mirror of
https://github.com/cjfranko/NTP-Timeturner.git
synced 2025-11-08 18:32:02 +00:00
Merge pull request #3 from Johnr24/update
double check upload of tested version
This commit is contained in:
GitHub
commit
aa453c30bc
6 changed files with 2344 additions and 624 deletions
1720
Cargo.lock
generated
Normal file
1720
Cargo.lock
generated
Normal file
File diff suppressed because it is too large
Load diff
138
src/config.rs
138
src/config.rs
|
|
@ -1,69 +1,69 @@
|
|||
// src/config.rs
|
||||
|
||||
use notify::{
|
||||
recommended_watcher, Event, EventKind, RecommendedWatcher, RecursiveMode, Result as NotifyResult,
|
||||
Watcher,
|
||||
};
|
||||
use serde::Deserialize;
|
||||
use std::{
|
||||
fs::File,
|
||||
io::Read,
|
||||
path::PathBuf,
|
||||
sync::{Arc, Mutex},
|
||||
};
|
||||
|
||||
#[derive(Deserialize)]
|
||||
pub struct Config {
|
||||
pub hardware_offset_ms: i64,
|
||||
}
|
||||
|
||||
impl Config {
|
||||
pub fn load(path: &PathBuf) -> Self {
|
||||
let mut file = match File::open(path) {
|
||||
Ok(f) => f,
|
||||
Err(_) => return Self { hardware_offset_ms: 0 },
|
||||
};
|
||||
let mut contents = String::new();
|
||||
if file.read_to_string(&mut contents).is_err() {
|
||||
return Self { hardware_offset_ms: 0 };
|
||||
}
|
||||
serde_json::from_str(&contents).unwrap_or(Self { hardware_offset_ms: 0 })
|
||||
}
|
||||
}
|
||||
|
||||
pub fn watch_config(path: &str) -> Arc<Mutex<i64>> {
|
||||
let initial = Config::load(&PathBuf::from(path)).hardware_offset_ms;
|
||||
let offset = Arc::new(Mutex::new(initial));
|
||||
|
||||
// Owned PathBuf for watch() call
|
||||
let watch_path = PathBuf::from(path);
|
||||
// Clone for moving into the closure
|
||||
let watch_path_for_cb = watch_path.clone();
|
||||
let offset_for_cb = Arc::clone(&offset);
|
||||
|
||||
std::thread::spawn(move || {
|
||||
// Move `watch_path_for_cb` into the callback
|
||||
let mut watcher: RecommendedWatcher = recommended_watcher(move |res: NotifyResult<Event>| {
|
||||
if let Ok(evt) = res {
|
||||
if matches!(evt.kind, EventKind::Modify(_)) {
|
||||
let new_cfg = Config::load(&watch_path_for_cb);
|
||||
let mut hw = offset_for_cb.lock().unwrap();
|
||||
*hw = new_cfg.hardware_offset_ms;
|
||||
eprintln!("🔄 Reloaded hardware_offset_ms = {}", *hw);
|
||||
}
|
||||
}
|
||||
})
|
||||
.expect("Failed to create file watcher");
|
||||
|
||||
// Use the original `watch_path` here
|
||||
watcher
|
||||
.watch(&watch_path, RecursiveMode::NonRecursive)
|
||||
.expect("Failed to watch config.json");
|
||||
|
||||
loop {
|
||||
std::thread::sleep(std::time::Duration::from_secs(60));
|
||||
}
|
||||
});
|
||||
|
||||
offset
|
||||
}
|
||||
// src/config.rs
|
||||
|
||||
use notify::{
|
||||
recommended_watcher, Event, EventKind, RecommendedWatcher, RecursiveMode, Result as NotifyResult,
|
||||
Watcher,
|
||||
};
|
||||
use serde::Deserialize;
|
||||
use std::{
|
||||
fs::File,
|
||||
io::Read,
|
||||
path::PathBuf,
|
||||
sync::{Arc, Mutex},
|
||||
};
|
||||
|
||||
#[derive(Deserialize)]
|
||||
pub struct Config {
|
||||
pub hardware_offset_ms: i64,
|
||||
}
|
||||
|
||||
impl Config {
|
||||
pub fn load(path: &PathBuf) -> Self {
|
||||
let mut file = match File::open(path) {
|
||||
Ok(f) => f,
|
||||
Err(_) => return Self { hardware_offset_ms: 0 },
|
||||
};
|
||||
let mut contents = String::new();
|
||||
if file.read_to_string(&mut contents).is_err() {
|
||||
return Self { hardware_offset_ms: 0 };
|
||||
}
|
||||
serde_json::from_str(&contents).unwrap_or(Self { hardware_offset_ms: 0 })
|
||||
}
|
||||
}
|
||||
|
||||
pub fn watch_config(path: &str) -> Arc<Mutex<i64>> {
|
||||
let initial = Config::load(&PathBuf::from(path)).hardware_offset_ms;
|
||||
let offset = Arc::new(Mutex::new(initial));
|
||||
|
||||
// Owned PathBuf for watch() call
|
||||
let watch_path = PathBuf::from(path);
|
||||
// Clone for moving into the closure
|
||||
let watch_path_for_cb = watch_path.clone();
|
||||
let offset_for_cb = Arc::clone(&offset);
|
||||
|
||||
std::thread::spawn(move || {
|
||||
// Move `watch_path_for_cb` into the callback
|
||||
let mut watcher: RecommendedWatcher = recommended_watcher(move |res: NotifyResult<Event>| {
|
||||
if let Ok(evt) = res {
|
||||
if matches!(evt.kind, EventKind::Modify(_)) {
|
||||
let new_cfg = Config::load(&watch_path_for_cb);
|
||||
let mut hw = offset_for_cb.lock().unwrap();
|
||||
*hw = new_cfg.hardware_offset_ms;
|
||||
eprintln!("🔄 Reloaded hardware_offset_ms = {}", *hw);
|
||||
}
|
||||
}
|
||||
})
|
||||
.expect("Failed to create file watcher");
|
||||
|
||||
// Use the original `watch_path` here
|
||||
watcher
|
||||
.watch(&watch_path, RecursiveMode::NonRecursive)
|
||||
.expect("Failed to watch config.json");
|
||||
|
||||
loop {
|
||||
std::thread::sleep(std::time::Duration::from_secs(60));
|
||||
}
|
||||
});
|
||||
|
||||
offset
|
||||
}
|
||||
|
|
|
|||
162
src/main.rs
162
src/main.rs
|
|
@ -1,81 +1,81 @@
|
|||
// src/main.rs
|
||||
|
||||
mod config;
|
||||
mod sync_logic;
|
||||
mod serial_input;
|
||||
mod ui;
|
||||
|
||||
use crate::config::watch_config;
|
||||
use crate::sync_logic::LtcState;
|
||||
use crate::serial_input::start_serial_thread;
|
||||
use crate::ui::start_ui;
|
||||
|
||||
use std::{
|
||||
fs,
|
||||
path::Path,
|
||||
sync::{Arc, Mutex, mpsc},
|
||||
thread,
|
||||
};
|
||||
|
||||
/// Embed the default config.json at compile time.
|
||||
const DEFAULT_CONFIG: &str = include_str!("../config.json");
|
||||
|
||||
/// If no `config.json` exists alongside the binary, write out the default.
|
||||
fn ensure_config() {
|
||||
let p = Path::new("config.json");
|
||||
if !p.exists() {
|
||||
fs::write(p, DEFAULT_CONFIG)
|
||||
.expect("Failed to write default config.json");
|
||||
eprintln!("⚙️ Emitted default config.json");
|
||||
}
|
||||
}
|
||||
|
||||
fn main() {
|
||||
// 🔄 Ensure there's always a config.json present
|
||||
ensure_config();
|
||||
|
||||
// 1️⃣ Start watching config.json for changes
|
||||
let hw_offset = watch_config("config.json");
|
||||
println!("🔧 Watching config.json (hardware_offset_ms)...");
|
||||
|
||||
// 2️⃣ Channel for raw LTC frames
|
||||
let (tx, rx) = mpsc::channel();
|
||||
println!("✅ Channel created");
|
||||
|
||||
// 3️⃣ Shared state for UI and serial reader
|
||||
let ltc_state = Arc::new(Mutex::new(LtcState::new()));
|
||||
println!("✅ State initialised");
|
||||
|
||||
// 4️⃣ Spawn the serial reader thread (no offset here)
|
||||
{
|
||||
let tx_clone = tx.clone();
|
||||
let state_clone = ltc_state.clone();
|
||||
thread::spawn(move || {
|
||||
println!("🚀 Serial thread launched");
|
||||
start_serial_thread(
|
||||
"/dev/ttyACM0",
|
||||
115200,
|
||||
tx_clone,
|
||||
state_clone,
|
||||
0, // ignored in serial path
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
// 5️⃣ Spawn the UI renderer thread, passing the live offset Arc
|
||||
{
|
||||
let ui_state = ltc_state.clone();
|
||||
let offset_clone = hw_offset.clone();
|
||||
let port = "/dev/ttyACM0".to_string();
|
||||
thread::spawn(move || {
|
||||
println!("🖥️ UI thread launched");
|
||||
start_ui(ui_state, port, offset_clone);
|
||||
});
|
||||
}
|
||||
|
||||
// 6️⃣ Keep main thread alive
|
||||
println!("📡 Main thread entering loop...");
|
||||
for _frame in rx {
|
||||
// no-op
|
||||
}
|
||||
}
|
||||
// src/main.rs
|
||||
|
||||
mod config;
|
||||
mod sync_logic;
|
||||
mod serial_input;
|
||||
mod ui;
|
||||
|
||||
use crate::config::watch_config;
|
||||
use crate::sync_logic::LtcState;
|
||||
use crate::serial_input::start_serial_thread;
|
||||
use crate::ui::start_ui;
|
||||
|
||||
use std::{
|
||||
fs,
|
||||
path::Path,
|
||||
sync::{Arc, Mutex, mpsc},
|
||||
thread,
|
||||
};
|
||||
|
||||
/// Embed the default config.json at compile time.
|
||||
const DEFAULT_CONFIG: &str = include_str!("../config.json");
|
||||
|
||||
/// If no `config.json` exists alongside the binary, write out the default.
|
||||
fn ensure_config() {
|
||||
let p = Path::new("config.json");
|
||||
if !p.exists() {
|
||||
fs::write(p, DEFAULT_CONFIG)
|
||||
.expect("Failed to write default config.json");
|
||||
eprintln!("⚙️ Emitted default config.json");
|
||||
}
|
||||
}
|
||||
|
||||
fn main() {
|
||||
// 🔄 Ensure there's always a config.json present
|
||||
ensure_config();
|
||||
|
||||
// 1️⃣ Start watching config.json for changes
|
||||
let hw_offset = watch_config("config.json");
|
||||
println!("🔧 Watching config.json (hardware_offset_ms)...");
|
||||
|
||||
// 2️⃣ Channel for raw LTC frames
|
||||
let (tx, rx) = mpsc::channel();
|
||||
println!("✅ Channel created");
|
||||
|
||||
// 3️⃣ Shared state for UI and serial reader
|
||||
let ltc_state = Arc::new(Mutex::new(LtcState::new()));
|
||||
println!("✅ State initialised");
|
||||
|
||||
// 4️⃣ Spawn the serial reader thread (no offset here)
|
||||
{
|
||||
let tx_clone = tx.clone();
|
||||
let state_clone = ltc_state.clone();
|
||||
thread::spawn(move || {
|
||||
println!("🚀 Serial thread launched");
|
||||
start_serial_thread(
|
||||
"/dev/ttyACM0",
|
||||
115200,
|
||||
tx_clone,
|
||||
state_clone,
|
||||
0, // ignored in serial path
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
// 5️⃣ Spawn the UI renderer thread, passing the live offset Arc
|
||||
{
|
||||
let ui_state = ltc_state.clone();
|
||||
let offset_clone = hw_offset.clone();
|
||||
let port = "/dev/ttyACM0".to_string();
|
||||
thread::spawn(move || {
|
||||
println!("🖥️ UI thread launched");
|
||||
start_ui(ui_state, port, offset_clone);
|
||||
});
|
||||
}
|
||||
|
||||
// 6️⃣ Keep main thread alive
|
||||
println!("📡 Main thread entering loop...");
|
||||
for _frame in rx {
|
||||
// no-op
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,56 +1,56 @@
|
|||
// src/serial_input.rs
|
||||
|
||||
use std::io::BufRead;
|
||||
use std::sync::{Arc, Mutex};
|
||||
use std::sync::mpsc::Sender;
|
||||
use chrono::Utc;
|
||||
use regex::Regex;
|
||||
use crate::sync_logic::{LtcFrame, LtcState};
|
||||
|
||||
pub fn start_serial_thread(
|
||||
port_path: &str,
|
||||
baud_rate: u32,
|
||||
sender: Sender<LtcFrame>,
|
||||
state: Arc<Mutex<LtcState>>,
|
||||
_hardware_offset_ms: i64, // no longer used here
|
||||
) {
|
||||
println!("📡 Opening serial port {} @ {} baud", port_path, baud_rate);
|
||||
|
||||
let port = match serialport::new(port_path, baud_rate)
|
||||
.timeout(std::time::Duration::from_millis(1000))
|
||||
.open()
|
||||
{
|
||||
Ok(p) => {
|
||||
println!("✅ Serial port opened");
|
||||
p
|
||||
}
|
||||
Err(e) => {
|
||||
eprintln!("❌ Serial open failed: {}", e);
|
||||
return;
|
||||
}
|
||||
};
|
||||
|
||||
let reader = std::io::BufReader::new(port);
|
||||
let re = Regex::new(
|
||||
r"\[(LOCK|FREE)\]\s+(\d{2}):(\d{2}):(\d{2})[:;](\d{2})\s+\|\s+([\d.]+)fps",
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
println!("🔄 Entering LTC read loop…");
|
||||
for line in reader.lines() {
|
||||
if let Ok(text) = line {
|
||||
if let Some(caps) = re.captures(&text) {
|
||||
let arrival = Utc::now();
|
||||
if let Some(frame) = LtcFrame::from_regex(&caps, arrival) {
|
||||
// update LOCK/FREE counts & timestamp
|
||||
{
|
||||
let mut st = state.lock().unwrap();
|
||||
st.update(frame.clone());
|
||||
}
|
||||
// forward raw frame
|
||||
let _ = sender.send(frame);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// src/serial_input.rs
|
||||
|
||||
use std::io::BufRead;
|
||||
use std::sync::{Arc, Mutex};
|
||||
use std::sync::mpsc::Sender;
|
||||
use chrono::Utc;
|
||||
use regex::Regex;
|
||||
use crate::sync_logic::{LtcFrame, LtcState};
|
||||
|
||||
pub fn start_serial_thread(
|
||||
port_path: &str,
|
||||
baud_rate: u32,
|
||||
sender: Sender<LtcFrame>,
|
||||
state: Arc<Mutex<LtcState>>,
|
||||
_hardware_offset_ms: i64, // no longer used here
|
||||
) {
|
||||
println!("📡 Opening serial port {} @ {} baud", port_path, baud_rate);
|
||||
|
||||
let port = match serialport::new(port_path, baud_rate)
|
||||
.timeout(std::time::Duration::from_millis(1000))
|
||||
.open()
|
||||
{
|
||||
Ok(p) => {
|
||||
println!("✅ Serial port opened");
|
||||
p
|
||||
}
|
||||
Err(e) => {
|
||||
eprintln!("❌ Serial open failed: {}", e);
|
||||
return;
|
||||
}
|
||||
};
|
||||
|
||||
let reader = std::io::BufReader::new(port);
|
||||
let re = Regex::new(
|
||||
r"\[(LOCK|FREE)\]\s+(\d{2}):(\d{2}):(\d{2})[:;](\d{2})\s+\|\s+([\d.]+)fps",
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
println!("🔄 Entering LTC read loop…");
|
||||
for line in reader.lines() {
|
||||
if let Ok(text) = line {
|
||||
if let Some(caps) = re.captures(&text) {
|
||||
let arrival = Utc::now();
|
||||
if let Some(frame) = LtcFrame::from_regex(&caps, arrival) {
|
||||
// update LOCK/FREE counts & timestamp
|
||||
{
|
||||
let mut st = state.lock().unwrap();
|
||||
st.update(frame.clone());
|
||||
}
|
||||
// forward raw frame
|
||||
let _ = sender.send(frame);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,206 +1,206 @@
|
|||
// src/sync_logic.rs
|
||||
|
||||
use chrono::{DateTime, Local, Timelike, Utc};
|
||||
use regex::Captures;
|
||||
use std::collections::VecDeque;
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct LtcFrame {
|
||||
pub status: String,
|
||||
pub hours: u32,
|
||||
pub minutes: u32,
|
||||
pub seconds: u32,
|
||||
pub frames: u32,
|
||||
pub frame_rate: f64,
|
||||
pub timestamp: DateTime<Utc>, // arrival stamp
|
||||
}
|
||||
|
||||
impl LtcFrame {
|
||||
pub fn from_regex(caps: &Captures, timestamp: DateTime<Utc>) -> Option<Self> {
|
||||
Some(Self {
|
||||
status: caps[1].to_string(),
|
||||
hours: caps[2].parse().ok()?,
|
||||
minutes: caps[3].parse().ok()?,
|
||||
seconds: caps[4].parse().ok()?,
|
||||
frames: caps[5].parse().ok()?,
|
||||
frame_rate: caps[6].parse().ok()?,
|
||||
timestamp,
|
||||
})
|
||||
}
|
||||
|
||||
/// Compare just HH:MM:SS against local time.
|
||||
pub fn matches_system_time(&self) -> bool {
|
||||
let local = Local::now();
|
||||
local.hour() == self.hours
|
||||
&& local.minute() == self.minutes
|
||||
&& local.second() == self.seconds
|
||||
}
|
||||
}
|
||||
|
||||
pub struct LtcState {
|
||||
pub latest: Option<LtcFrame>,
|
||||
pub lock_count: u32,
|
||||
pub free_count: u32,
|
||||
/// Stores the last up-to-20 raw offset measurements in ms.
|
||||
pub offset_history: VecDeque<i64>,
|
||||
pub last_match_status: String,
|
||||
pub last_match_check: i64,
|
||||
}
|
||||
|
||||
impl LtcState {
|
||||
pub fn new() -> Self {
|
||||
Self {
|
||||
latest: None,
|
||||
lock_count: 0,
|
||||
free_count: 0,
|
||||
offset_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.
|
||||
pub fn record_offset(&mut self, offset_ms: i64) {
|
||||
if self.offset_history.len() == 20 {
|
||||
self.offset_history.pop_front();
|
||||
}
|
||||
self.offset_history.push_back(offset_ms);
|
||||
}
|
||||
|
||||
/// Clear all stored offset measurements (e.g. on FREE-run).
|
||||
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.
|
||||
pub fn update(&mut self, frame: LtcFrame) {
|
||||
match frame.status.as_str() {
|
||||
"LOCK" => {
|
||||
self.lock_count += 1;
|
||||
|
||||
// Every 5 seconds, recompute whether HH:MM:SS matches local time
|
||||
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()
|
||||
} else {
|
||||
"OUT OF SYNC".into()
|
||||
};
|
||||
self.last_match_check = now_secs;
|
||||
}
|
||||
}
|
||||
"FREE" => {
|
||||
self.free_count += 1;
|
||||
self.clear_offsets();
|
||||
self.last_match_status = "UNKNOWN".into();
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
|
||||
self.latest = Some(frame);
|
||||
}
|
||||
|
||||
/// Average jitter over the stored history, in milliseconds.
|
||||
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)
|
||||
}
|
||||
}
|
||||
|
||||
/// Convert that 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;
|
||||
(self.average_jitter() as f64 / ms_per_frame).round() as i64
|
||||
} else {
|
||||
0
|
||||
}
|
||||
}
|
||||
|
||||
/// 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
|
||||
}
|
||||
}
|
||||
|
||||
/// Get the last computed timecode‐match status ("IN SYNC", "OUT OF SYNC", or "UNKNOWN").
|
||||
pub fn timecode_match(&self) -> &str {
|
||||
&self.last_match_status
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use chrono::{Local, Utc};
|
||||
|
||||
fn get_test_frame(status: &str, h: u32, m: u32, s: u32) -> LtcFrame {
|
||||
LtcFrame {
|
||||
status: status.to_string(),
|
||||
hours: h,
|
||||
minutes: m,
|
||||
seconds: s,
|
||||
frames: 0,
|
||||
frame_rate: 25.0,
|
||||
timestamp: Utc::now(),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_ltc_frame_matches_system_time() {
|
||||
let now = Local::now();
|
||||
let frame = get_test_frame("LOCK", now.hour(), now.minute(), now.second());
|
||||
assert!(frame.matches_system_time());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_ltc_frame_does_not_match_system_time() {
|
||||
let now = Local::now();
|
||||
// Create a time that is one hour ahead, wrapping around 23:00
|
||||
let different_hour = (now.hour() + 1) % 24;
|
||||
let frame = get_test_frame("LOCK", different_hour, now.minute(), now.second());
|
||||
assert!(!frame.matches_system_time());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_ltc_state_update_lock() {
|
||||
let mut state = LtcState::new();
|
||||
let frame = get_test_frame("LOCK", 10, 20, 30);
|
||||
state.update(frame);
|
||||
assert_eq!(state.lock_count, 1);
|
||||
assert_eq!(state.free_count, 0);
|
||||
assert!(state.latest.is_some());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_ltc_state_update_free() {
|
||||
let mut state = LtcState::new();
|
||||
state.record_offset(100);
|
||||
assert!(!state.offset_history.is_empty());
|
||||
|
||||
let frame = get_test_frame("FREE", 10, 20, 30);
|
||||
state.update(frame);
|
||||
assert_eq!(state.lock_count, 0);
|
||||
assert_eq!(state.free_count, 1);
|
||||
assert!(state.offset_history.is_empty()); // Offsets should be cleared
|
||||
assert_eq!(state.last_match_status, "UNKNOWN");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_offset_history_management() {
|
||||
let mut state = LtcState::new();
|
||||
for i in 0..25 {
|
||||
state.record_offset(i);
|
||||
}
|
||||
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);
|
||||
}
|
||||
}
|
||||
// src/sync_logic.rs
|
||||
|
||||
use chrono::{DateTime, Local, Timelike, Utc};
|
||||
use regex::Captures;
|
||||
use std::collections::VecDeque;
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct LtcFrame {
|
||||
pub status: String,
|
||||
pub hours: u32,
|
||||
pub minutes: u32,
|
||||
pub seconds: u32,
|
||||
pub frames: u32,
|
||||
pub frame_rate: f64,
|
||||
pub timestamp: DateTime<Utc>, // arrival stamp
|
||||
}
|
||||
|
||||
impl LtcFrame {
|
||||
pub fn from_regex(caps: &Captures, timestamp: DateTime<Utc>) -> Option<Self> {
|
||||
Some(Self {
|
||||
status: caps[1].to_string(),
|
||||
hours: caps[2].parse().ok()?,
|
||||
minutes: caps[3].parse().ok()?,
|
||||
seconds: caps[4].parse().ok()?,
|
||||
frames: caps[5].parse().ok()?,
|
||||
frame_rate: caps[6].parse().ok()?,
|
||||
timestamp,
|
||||
})
|
||||
}
|
||||
|
||||
/// Compare just HH:MM:SS against local time.
|
||||
pub fn matches_system_time(&self) -> bool {
|
||||
let local = Local::now();
|
||||
local.hour() == self.hours
|
||||
&& local.minute() == self.minutes
|
||||
&& local.second() == self.seconds
|
||||
}
|
||||
}
|
||||
|
||||
pub struct LtcState {
|
||||
pub latest: Option<LtcFrame>,
|
||||
pub lock_count: u32,
|
||||
pub free_count: u32,
|
||||
/// Stores the last up-to-20 raw offset measurements in ms.
|
||||
pub offset_history: VecDeque<i64>,
|
||||
pub last_match_status: String,
|
||||
pub last_match_check: i64,
|
||||
}
|
||||
|
||||
impl LtcState {
|
||||
pub fn new() -> Self {
|
||||
Self {
|
||||
latest: None,
|
||||
lock_count: 0,
|
||||
free_count: 0,
|
||||
offset_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.
|
||||
pub fn record_offset(&mut self, offset_ms: i64) {
|
||||
if self.offset_history.len() == 20 {
|
||||
self.offset_history.pop_front();
|
||||
}
|
||||
self.offset_history.push_back(offset_ms);
|
||||
}
|
||||
|
||||
/// Clear all stored offset measurements (e.g. on FREE-run).
|
||||
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.
|
||||
pub fn update(&mut self, frame: LtcFrame) {
|
||||
match frame.status.as_str() {
|
||||
"LOCK" => {
|
||||
self.lock_count += 1;
|
||||
}
|
||||
"FREE" => {
|
||||
self.free_count += 1;
|
||||
self.clear_offsets();
|
||||
self.last_match_status = "UNKNOWN".into();
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
|
||||
// Every 5 seconds, recompute whether HH:MM:SS matches local time
|
||||
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()
|
||||
} else {
|
||||
"OUT OF SYNC".into()
|
||||
};
|
||||
self.last_match_check = now_secs;
|
||||
}
|
||||
|
||||
self.latest = Some(frame);
|
||||
}
|
||||
|
||||
/// Average jitter over the stored history, in milliseconds.
|
||||
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)
|
||||
}
|
||||
}
|
||||
|
||||
/// Convert that 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;
|
||||
(self.average_jitter() as f64 / ms_per_frame).round() as i64
|
||||
} else {
|
||||
0
|
||||
}
|
||||
}
|
||||
|
||||
/// 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
|
||||
}
|
||||
}
|
||||
|
||||
/// Get the last computed timecode‐match status ("IN SYNC", "OUT OF SYNC", or "UNKNOWN").
|
||||
pub fn timecode_match(&self) -> &str {
|
||||
&self.last_match_status
|
||||
}
|
||||
}
|
||||
// This module provides the logic for handling LTC (Linear Timecode) frames and maintaining state.
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use chrono::{Local, Utc};
|
||||
|
||||
fn get_test_frame(status: &str, h: u32, m: u32, s: u32) -> LtcFrame {
|
||||
LtcFrame {
|
||||
status: status.to_string(),
|
||||
hours: h,
|
||||
minutes: m,
|
||||
seconds: s,
|
||||
frames: 0,
|
||||
frame_rate: 25.0,
|
||||
timestamp: Utc::now(),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_ltc_frame_matches_system_time() {
|
||||
let now = Local::now();
|
||||
let frame = get_test_frame("LOCK", now.hour(), now.minute(), now.second());
|
||||
assert!(frame.matches_system_time());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_ltc_frame_does_not_match_system_time() {
|
||||
let now = Local::now();
|
||||
// Create a time that is one hour ahead, wrapping around 23:00
|
||||
let different_hour = (now.hour() + 1) % 24;
|
||||
let frame = get_test_frame("LOCK", different_hour, now.minute(), now.second());
|
||||
assert!(!frame.matches_system_time());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_ltc_state_update_lock() {
|
||||
let mut state = LtcState::new();
|
||||
let frame = get_test_frame("LOCK", 10, 20, 30);
|
||||
state.update(frame);
|
||||
assert_eq!(state.lock_count, 1);
|
||||
assert_eq!(state.free_count, 0);
|
||||
assert!(state.latest.is_some());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_ltc_state_update_free() {
|
||||
let mut state = LtcState::new();
|
||||
state.record_offset(100);
|
||||
assert!(!state.offset_history.is_empty());
|
||||
|
||||
let frame = get_test_frame("FREE", 10, 20, 30);
|
||||
state.update(frame);
|
||||
assert_eq!(state.lock_count, 0);
|
||||
assert_eq!(state.free_count, 1);
|
||||
assert!(state.offset_history.is_empty()); // Offsets should be cleared
|
||||
assert_eq!(state.last_match_status, "OUT OF SYNC");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_offset_history_management() {
|
||||
let mut state = LtcState::new();
|
||||
for i in 0..25 {
|
||||
state.record_offset(i);
|
||||
}
|
||||
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);
|
||||
}
|
||||
}
|
||||
424
src/ui.rs
424
src/ui.rs
|
|
@ -1,212 +1,212 @@
|
|||
// src/ui.rs
|
||||
|
||||
use std::{
|
||||
io::{stdout, Write},
|
||||
process::{self, Command},
|
||||
sync::{Arc, Mutex},
|
||||
thread,
|
||||
time::Duration,
|
||||
};
|
||||
|
||||
use chrono::{Local, Timelike, Utc};
|
||||
use crossterm::{
|
||||
cursor::{Hide, MoveTo, Show},
|
||||
event::{poll, read, Event, KeyCode},
|
||||
execute, queue,
|
||||
style::{Color, Print, ResetColor, SetForegroundColor},
|
||||
terminal::{self, Clear, ClearType, EnterAlternateScreen, LeaveAlternateScreen},
|
||||
};
|
||||
|
||||
use crate::sync_logic::LtcState;
|
||||
|
||||
/// Launch the TUI; reads `offset` live from the file-watcher.
|
||||
pub fn start_ui(
|
||||
state: Arc<Mutex<LtcState>>,
|
||||
serial_port: String,
|
||||
offset: Arc<Mutex<i64>>,
|
||||
) {
|
||||
let mut stdout = stdout();
|
||||
execute!(stdout, EnterAlternateScreen).unwrap();
|
||||
terminal::enable_raw_mode().unwrap();
|
||||
|
||||
loop {
|
||||
// 1️⃣ Read current hardware offset
|
||||
let hw_offset_ms = *offset.lock().unwrap();
|
||||
|
||||
// 2️⃣ Measure & record jitter only when LOCKED; clear on FREE
|
||||
{
|
||||
let mut st = state.lock().unwrap();
|
||||
if let Some(frame) = &st.latest {
|
||||
if frame.status == "LOCK" {
|
||||
let now = Utc::now();
|
||||
let raw = (now - frame.timestamp).num_milliseconds();
|
||||
let measured = raw - hw_offset_ms;
|
||||
st.record_offset(measured);
|
||||
} else {
|
||||
st.clear_offsets();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 3️⃣ Draw static UI
|
||||
queue!(
|
||||
stdout,
|
||||
MoveTo(0, 0),
|
||||
Clear(ClearType::All),
|
||||
Hide,
|
||||
MoveTo(2, 1), Print("NTP Timeturner v2 - Rust Port"),
|
||||
MoveTo(2, 2), Print(format!("Using Serial Port: {}", serial_port)),
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
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}",
|
||||
frame.hours, frame.minutes, frame.seconds, frame.frames
|
||||
)),
|
||||
MoveTo(2, 6), 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 : …"),
|
||||
)
|
||||
.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()
|
||||
);
|
||||
queue!(
|
||||
stdout,
|
||||
MoveTo(2, 7),
|
||||
Print(format!("System Clock : {}", sys_str))
|
||||
)
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
// Footer
|
||||
queue!(
|
||||
stdout,
|
||||
MoveTo(2, 12),
|
||||
Print("[S] Set system clock to LTC [Q] Quit")
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
stdout.flush().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();
|
||||
|
||||
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();
|
||||
|
||||
let ratio = st.lock_ratio();
|
||||
queue!(
|
||||
stdout,
|
||||
MoveTo(2, 10),
|
||||
Print(format!("Lock Ratio : {:.1}% LOCK", ratio)),
|
||||
)
|
||||
.ok();
|
||||
|
||||
stdout.flush().ok();
|
||||
}
|
||||
|
||||
// 5️⃣ Handle keypress
|
||||
if poll(Duration::from_millis(0)).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);
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
thread::sleep(Duration::from_millis(50));
|
||||
}
|
||||
}
|
||||
// src/ui.rs
|
||||
|
||||
use std::{
|
||||
io::{stdout, Write},
|
||||
process::{self, Command},
|
||||
sync::{Arc, Mutex},
|
||||
thread,
|
||||
time::Duration,
|
||||
};
|
||||
|
||||
use chrono::{Local, Timelike, Utc};
|
||||
use crossterm::{
|
||||
cursor::{Hide, MoveTo, Show},
|
||||
event::{poll, read, Event, KeyCode},
|
||||
execute, queue,
|
||||
style::{Color, Print, ResetColor, SetForegroundColor},
|
||||
terminal::{self, Clear, ClearType, EnterAlternateScreen, LeaveAlternateScreen},
|
||||
};
|
||||
|
||||
use crate::sync_logic::LtcState;
|
||||
|
||||
/// Launch the TUI; reads `offset` live from the file-watcher.
|
||||
pub fn start_ui(
|
||||
state: Arc<Mutex<LtcState>>,
|
||||
serial_port: String,
|
||||
offset: Arc<Mutex<i64>>,
|
||||
) {
|
||||
let mut stdout = stdout();
|
||||
execute!(stdout, EnterAlternateScreen).unwrap();
|
||||
terminal::enable_raw_mode().unwrap();
|
||||
|
||||
loop {
|
||||
// 1️⃣ Read current hardware offset
|
||||
let hw_offset_ms = *offset.lock().unwrap();
|
||||
|
||||
// 2️⃣ Measure & record jitter only when LOCKED; clear on FREE
|
||||
{
|
||||
let mut st = state.lock().unwrap();
|
||||
if let Some(frame) = &st.latest {
|
||||
if frame.status == "LOCK" {
|
||||
let now = Utc::now();
|
||||
let raw = (now - frame.timestamp).num_milliseconds();
|
||||
let measured = raw - hw_offset_ms;
|
||||
st.record_offset(measured);
|
||||
} else {
|
||||
st.clear_offsets();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 3️⃣ Draw static UI
|
||||
queue!(
|
||||
stdout,
|
||||
MoveTo(0, 0),
|
||||
Clear(ClearType::All),
|
||||
Hide,
|
||||
MoveTo(2, 1), Print("NTP Timeturner v2 - Rust Port"),
|
||||
MoveTo(2, 2), Print(format!("Using Serial Port: {}", serial_port)),
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
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}",
|
||||
frame.hours, frame.minutes, frame.seconds, frame.frames
|
||||
)),
|
||||
MoveTo(2, 6), 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 : …"),
|
||||
)
|
||||
.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()
|
||||
);
|
||||
queue!(
|
||||
stdout,
|
||||
MoveTo(2, 7),
|
||||
Print(format!("System Clock : {}", sys_str))
|
||||
)
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
// Footer
|
||||
queue!(
|
||||
stdout,
|
||||
MoveTo(2, 12),
|
||||
Print("[S] Set system clock to LTC [Q] Quit")
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
stdout.flush().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();
|
||||
|
||||
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();
|
||||
|
||||
let ratio = st.lock_ratio();
|
||||
queue!(
|
||||
stdout,
|
||||
MoveTo(2, 10),
|
||||
Print(format!("Lock Ratio : {:.1}% LOCK", ratio)),
|
||||
)
|
||||
.ok();
|
||||
|
||||
stdout.flush().ok();
|
||||
}
|
||||
|
||||
// 5️⃣ Handle keypress
|
||||
if poll(Duration::from_millis(0)).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);
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
thread::sleep(Duration::from_millis(50));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue