Struct TelemetryCollector 

pub struct TelemetryCollector<T: Transcendental, const BUF_SIZE: usize, const QUEUE_CAP: usize> { /* private fields */ }

Non-real-time consumer of telemetry frames from a shared SpscQueue.

Runs on the control thread (or any non-RT context). Drains available frames from the ring buffer and delivers them to a user-supplied callback.

Example

use std::sync::Arc;
use rill_core::queues::spsc::SpscQueue;
use rill_core::queues::TelemetryBlock;
use rill_telemetry::collector::TelemetryCollector;

let queue = Arc::new(SpscQueue::<TelemetryBlock<f32, 64>, 8>::new());
let mut collector = TelemetryCollector::new(queue, |frame| {
    println!("peak={} rms={} dc={}", frame.peak, frame.rms, frame.dc_offset);
});
collector.poll();  // drain available frames

Implementations

impl<T: Transcendental, const BUF_SIZE: usize, const QUEUE_CAP: usize> TelemetryCollector<T, BUF_SIZE, QUEUE_CAP>

pub fn new( queue: Arc<SpscQueue<TelemetryBlock<T, BUF_SIZE>, QUEUE_CAP>>, callback: impl FnMut(TelemetryBlock<T, BUF_SIZE>) + 'static, ) -> Self

Create a new collector backed by the shared ring buffer.

The callback is invoked for every frame drained from the queue.

pub fn poll(&mut self) -> usize

Drain all available telemetry frames from the ring buffer.

Returns the number of frames processed.

pub fn poll_n(&mut self, max: usize) -> usize

Drain at most max frames from the ring buffer.

Useful when you want to bound processing time per tick.

pub fn available(&self) -> usize

Number of frames currently available in the ring buffer (approximate).

pub fn into_queue( self, ) -> Arc<SpscQueue<TelemetryBlock<T, BUF_SIZE>, QUEUE_CAP>>

Consume the collector and return the underlying queue Arc.