Struct TelemetryProbe 

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

Passive telemetry probe that passes audio through while periodically capturing block data + metrics into a shared ring buffer.

Type Parameters

• T — sample type (f32/f64)
• BUF_SIZE — signal block size
• QUEUE_CAP — capacity of the telemetry ring buffer (must be power of two)

Design

• 1 audio input → 1 audio output (passthrough, zero-latency)
• Every interval blocks, computes peak/RMS/DC and pushes into the queue
• Queue is SpscQueue with overwrite-oldest policy (default)
• Non-blocking: if the queue is full, old entries are overwritten

Implementations

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

pub fn new( queue: Arc<SpscQueue<TelemetryBlock<T, BUF_SIZE>, QUEUE_CAP>>, interval: u32, channel: u32, node_name: &str, ) -> Self

Create a new telemetry probe.

Arguments

• queue — shared SpscQueue for telemetry output
• interval — send telemetry every N blocks (1 = every block)
• channel — channel index to report in telemetry frames
• node_name — human-readable node name for metadata

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

Get a reference to the shared telemetry queue.

Trait Implementations

impl<T: Transcendental, const BUF_SIZE: usize, const QUEUE_CAP: usize> Node<T, BUF_SIZE> for TelemetryProbe<T, BUF_SIZE, QUEUE_CAP>

fn metadata(&self) -> NodeMetadata

Get node metadata

fn init(&mut self, sample_rate: f32)

Initialize the node with a sample rate

fn reset(&mut self)

Reset the node to its initial state

fn get_parameter(&self, _id: &ParameterId) -> Option<ParamValue>

Get the value of a parameter

fn set_parameter( &mut self, _id: &ParameterId, _value: ParamValue, ) -> ProcessResult<()>

Set the value of a parameter

fn id(&self) -> NodeId

Get node ID

fn set_id(&mut self, id: NodeId)

Set node ID

fn input_port(&self, index: usize) -> Option<&Port<T, BUF_SIZE>>

Get input port by index

fn input_port_mut(&mut self, index: usize) -> Option<&mut Port<T, BUF_SIZE>>

Get mutable input port by index

fn output_port(&self, index: usize) -> Option<&Port<T, BUF_SIZE>>

Get output port by index

fn output_port_mut(&mut self, index: usize) -> Option<&mut Port<T, BUF_SIZE>>

Get mutable output port by index

fn control_port(&self, _index: usize) -> Option<&Port<T, BUF_SIZE>>

Get control port by index

fn control_port_mut(&mut self, _index: usize) -> Option<&mut Port<T, BUF_SIZE>>

Get mutable control port by index

fn num_signal_inputs(&self) -> usize

Number of signal input ports

fn num_signal_outputs(&self) -> usize

Number of signal output ports

fn num_control_inputs(&self) -> usize

Number of control input ports

fn num_control_outputs(&self) -> usize

Number of control output ports

fn state(&self) -> &NodeState<T, BUF_SIZE>

Get node state

fn state_mut(&mut self) -> &mut NodeState<T, BUF_SIZE>

Get mutable node state

fn node_type_id(&self) -> NodeTypeId

where Self: Sized + 'static,

Get the node’s type ID

fn apply_set_parameter( &mut self, cmd: &SetParameter, ) -> Result<(), ProcessError>

Apply a SetParameter command to this node.

fn resolve_resources(&mut self, _resources: &mut ResourceRegistry<T>)

Resolve named shared resources (tape loops, etc.) from the registry, acquiring the capability handle matching this node’s role.

fn num_clock_inputs(&self) -> usize

Number of clock input ports

fn num_clock_outputs(&self) -> usize

Number of clock output ports

fn num_feedback_ports(&self) -> usize

Number of feedback ports

fn num_inputs(&self) -> usize

Total number of input ports

fn num_outputs(&self) -> usize

Total number of output ports

impl<T: Transcendental, const BUF_SIZE: usize, const QUEUE_CAP: usize> Processor<T, BUF_SIZE> for TelemetryProbe<T, BUF_SIZE, QUEUE_CAP>

fn process( &mut self, _ctx: &RenderContext, signal_inputs: &[&[T; BUF_SIZE]], _control_inputs: &[T], _clock_inputs: &[RenderContext], _feedback_inputs: &[&[T; BUF_SIZE]], ) -> ProcessResult<()>

Process a block of signal

fn latency(&self) -> usize

Latency in samples (for delay compensation)