Real-Time Systems

use r4w_core::rt_scheduler::{
    RealTimeScheduler, ClockSource
};
use std::time::Duration;

let scheduler = RealTimeScheduler::builder()
    .clock_source(ClockSource::System)
    .tx_rx_turnaround(Duration::from_micros(100))
    .rx_tx_turnaround(Duration::from_micros(100))
    .deadline_tolerance(Duration::from_micros(500))
    .build()?;

use r4w_core::rt_scheduler::{ScheduledEvent, EventAction};

// Single event
let event = ScheduledEvent::new(
    scheduler.now_ns() + 10_000_000,  // 10ms from now
    EventAction::StartTx,
);
scheduler.schedule(event);

// Atomic batch
scheduler.schedule_batch(vec![
    ScheduledEvent::new(100_000_000, EventAction::StartTx),
    ScheduledEvent::new(110_000_000, EventAction::StopTx),
]);

let event = ScheduledEvent::new(
    scheduler.now_ns() + 1_000_000,
    EventAction::StartTx,
)
.with_guard(|state| state.can_transmit())
.with_priority(0);  // Highest priority

// Non-blocking: process all due events
let results = scheduler.process();

for result in results {
    match result {
        Ok(event) => println!("Executed: {:?}", event.action),
        Err(e) => eprintln!("Failed: {}", e),
    }
}

// Or run continuously in dedicated thread
std::thread::spawn(move || {
    scheduler.run().unwrap();
});

let (start_id, stop_id) = scheduler.schedule_tx_burst(
    scheduler.now_ns() + 5_000_000,  // Start in 5ms
    Duration::from_millis(10),        // Duration
);

// Cancel if needed
scheduler.cancel(start_id);

let (start_id, stop_id) = scheduler.schedule_rx_window(
    scheduler.now_ns() + 1_000_000,  // Start in 1ms
    Duration::from_millis(50),        // Window duration
);

let hop_sequence = vec![915.0e6, 916.0e6, 917.0e6, 918.0e6];
let dwell_time = Duration::from_millis(10);

for (i, &freq) in hop_sequence.iter().enumerate() {
    let hop_time = scheduler.now_ns()
        + (i as u64) * dwell_time.as_nanos() as u64;

    scheduler.schedule(ScheduledEvent::new(
        hop_time,
        EventAction::SetFrequency(freq),
    ).with_priority(0));  // High priority
}

let slot_duration = Duration::from_millis(5);
let my_slot = 3;  // Assigned slot number

loop {
    let frame_start = scheduler.next_frame_start();
    let my_slot_time = frame_start
        + my_slot * slot_duration.as_nanos() as u64;

    // TX only in assigned slot
    scheduler.schedule_tx_burst(
        my_slot_time,
        slot_duration - GUARD_TIME,
    );
}

use r4w_core::tick_scheduler::TickScheduler;

let mut scheduler = TickScheduler::new();

// Schedule in virtual ticks
scheduler.schedule(10, |_| println!("Tick 10!"));
scheduler.schedule(20, |_| println!("Tick 20!"));

// Advance time manually
scheduler.advance_to(25);  // Executes both events

use r4w_core::rt::RingBuffer;

// SPSC lock-free queue
let buffer: RingBuffer<IQSample> = RingBuffer::new(1024);

// Producer (no locks)
buffer.push(sample)?;

// Consumer (no locks)
if let Some(sample) = buffer.pop() {
    process(sample);
}

use r4w_core::rt::LockedBuffer;

// Allocate and lock memory
let buffer = LockedBuffer::<IQSample>::new(4096)?;

// Guaranteed no page faults
for sample in buffer.iter() {
    process_sample(sample);
}

use r4w_core::rt::RtThreadConfig;

let config = RtThreadConfig {
    priority: 80,           // SCHED_FIFO priority
    cpu_affinity: Some(vec![0]),  // Pin to CPU 0
    lock_memory: true,      // mlockall
};

let handle = config.spawn(|| {
    // Real-time processing loop
    scheduler.run()
})?;

let event = ScheduledEvent::new(deadline, action)
    .with_deadline_tolerance(Duration::from_micros(100));

// If > 100us late:
// - Event is logged as missed
// - Optional callback for recovery
// - Metrics updated

let stats = scheduler.get_stats();

println!("Events scheduled: {}", stats.total_scheduled);
println!("Events executed: {}", stats.total_executed);
println!("Missed deadlines: {}", stats.missed_deadlines);
println!("Max latency: {} ns", stats.max_latency_ns);
println!("Avg latency: {} ns", stats.avg_latency_ns);

scheduler.set_error_handler(|error| {
    match error {
        SchedulerError::MissedDeadline(event) => {
            log::warn!("Missed: {:?}", event);
            // Attempt recovery
        }
        SchedulerError::InvalidTransition(from, to) => {
            log::error!("Invalid: {} -> {}", from, to);
            // Reset state machine
        }
    }
});

let mut scheduler = RealTimeScheduler::builder()
    .clock_source(ClockSource::Gps)
    .build()?;

// Generate hop sequence
for (i, freq) in hop_sequence.iter().enumerate() {
    scheduler.schedule(ScheduledEvent::new(
        start + i * dwell,
        EventAction::SetFrequency(*freq),
    ));

    // TX burst each hop
    scheduler.schedule_tx_burst(
        start + i * dwell + SETTLE_TIME,
        Duration::from_micros(800),
    );
}

scheduler.run()?;