Struct stabilizer::hardware::signal_generator::BasicConfig

pub struct BasicConfig {
    pub signal: Signal,
    pub frequency: f32,
    pub symmetry: f32,
    pub amplitude: f32,
    pub phase: f32,
}

Basic configuration for a generated signal.

Miniconf

{"signal": <signal>, "frequency", 1000.0, "symmetry": 0.5, "amplitude": 1.0}

Where <signal> may be any of Signal variants, frequency specifies the signal frequency in Hertz, symmetry specifies the normalized signal symmetry which ranges from 0 - 1.0, and amplitude specifies the signal amplitude in Volts.

Fields

signal: Signal

The signal type that should be generated. See Signal variants.

frequency: f32

The frequency of the generated signal in Hertz.

symmetry: f32

The normalized symmetry of the signal. At 0% symmetry, the duration of the first half oscillation is minimal. At 25% symmetry, the first half oscillation lasts for 25% of the signal period. For square wave output this symmetry is the duty cycle.

amplitude: f32

The amplitude of the output signal in volts.

phase: f32

The phase of the output signal in turns.

Implementations

impl BasicConfig

pub fn try_into_config( self, sample_period: f32, full_scale: f32 ) -> Result<Config, Error>

Convert configuration into signal generator values.

Args

• sample_period - The time in seconds between samples.
• full_scale - The full scale output voltage.

Trait Implementations

impl Clone for BasicConfig

fn clone(&self) -> BasicConfig

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BasicConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for BasicConfig

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for BasicConfig

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl KeyLookup for BasicConfig

const LEN: usize = 5usize

The number of top-level nodes.

const NAMES: &'static [&'static str] = _

Field names.

fn name_to_index(value: &str) -> Option<usize>

Convert a top level node name to a node index.

impl Serialize for BasicConfig

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TreeAny for BasicConfig

fn ref_any_by_key<K>(&self, keys: K) -> Result<&dyn Any, Traversal>

where K: Keys,

Obtain a reference to a dyn Any trait object for a leaf node.

fn mut_any_by_key<K>(&mut self, keys: K) -> Result<&mut dyn Any, Traversal>

where K: Keys,

Obtain a mutable reference to a dyn Any trait object for a leaf node.

fn ref_by_key<T, K>(&self, keys: K) -> Result<&T, Traversal>

where T: Any, K: IntoKeys,

Obtain a reference to a leaf of known type by key.

fn mut_by_key<T, K>(&mut self, keys: K) -> Result<&mut T, Traversal>

where T: Any, K: IntoKeys,

Obtain a mutable reference to a leaf of known type by key.

impl<'de> TreeDeserialize<'de> for BasicConfig

fn deserialize_by_key<K, D>( &mut self, keys: K, de: D ) -> Result<usize, Error<D::Error>>

where K: Keys, D: Deserializer<'de>,

Deserialize a leaf node by its keys.

impl TreeKey for BasicConfig

fn metadata() -> Metadata

Compute metadata about all paths.

fn traverse_by_key<K, F, E>(keys: K, func: F) -> Result<usize, Error<E>>

where K: Keys, F: FnMut(usize, Option<&'static str>, usize) -> Result<(), E>,

Traverse from the root to a leaf and call a function for each node.

fn path<K, P>(keys: K, path: P, separator: &str) -> Result<usize, Error<Error>>

where K: IntoKeys, P: Write,

Convert keys to path.

fn json_path<K, P>(keys: K, path: P) -> Result<usize, Error<Error>>

where K: IntoKeys, P: Write,

Return the keys formatted as a normalized JSON path.

fn indices<K>(keys: K) -> Result<([usize; Y], usize), Traversal>

where K: IntoKeys,

Convert keys to indices.

fn packed<K>(keys: K) -> Result<(Packed, usize), Error<()>>

where K: IntoKeys,

Convert keys to packed usize bitfield representation.

fn iter_paths<P>(separator: &str) -> PathIter<'_, Self, Y, P, Y>

where P: Write + Default,

Create an iterator of all possible leaf paths.

fn iter_indices() -> IndexIter<Self, Y, Y>

Create an iterator of all possible leaf indices.

fn iter_packed() -> PackedIter<Self, Y, Y>

Create an iterator of all packed leaf indices.

impl TreeSerialize for BasicConfig

fn serialize_by_key<K, S>( &self, keys: K, ser: S ) -> Result<usize, Error<S::Error>>

where K: Keys, S: Serializer,

Serialize a node by keys.

impl Copy for BasicConfig