Struct canadensis_data_types::reg::udral::service::actuator::common::sp::_0_1::_0

#[repr(C, packed)]
pub struct _0 {}

reg.udral.service.actuator.common.sp._.0.1

Fixed size 0 bytes

This is a collection of weakly-typed primitives used to control groups of actuators synchronously.

Actuators are expected to subscribe using the largest array type. Publishers would choose the array type depending on the number of actuators in the group. The actuators would be expecting the largest array type, where the missing elements will be zero-filled automatically by the protocol stack thanks to the Implicit Zero Extension Rule (refer to the Cyphal Specification for details).

The physical meaning of the values contained in the array is defined by the respective actuator service specification. If ratiometric control is used, then the range should be [-1, +1].

It follows that a standalone actuator (that is not a member of any group) is just a special case of a group of 1, where the setpoint type is a single scalar.

The Cyphal Specification might benefit from supporting flexible array fields to avoid having to deal with redundant similar types: https://en.wikipedia.org/wiki/Flexible_array_member, so that instead of having multiple types that differ only in size of the array fields, one could just say float16[0] value such that the size of zero indicates that the array is a flex array.

Implementations

impl _0

pub const EPSILON: f16 = _

The float epsilon defined for convenience. See https://en.wikipedia.org/wiki/Machine_epsilon.

Trait Implementations

impl AsBytes for _0

fn as_bytes(&self) -> &[u8]

Gets the bytes of this value.

fn as_bytes_mut(&mut self) -> &mut [u8]where Self: FromBytes,

Gets the bytes of this value mutably.

fn write_to<B>(&self, bytes: B) -> Option<()>where B: ByteSliceMut,

Writes a copy of self to bytes.

fn write_to_prefix<B>(&self, bytes: B) -> Option<()>where B: ByteSliceMut,

Writes a copy of self to the prefix of bytes.

fn write_to_suffix<B>(&self, bytes: B) -> Option<()>where B: ByteSliceMut,

Writes a copy of self to the suffix of bytes.

impl DataType for _0

const EXTENT_BYTES: Option<u32> = _

This type is delimited with an extent of 0 bytes.

impl Deserialize for _0

fn deserialize(cursor: &mut ReadCursor<'_>) -> Result<Self, DeserializeError>where Self: Sized,

Deserializes a value and returns it

fn deserialize_zero_copy(cursor: &mut ReadCursor<'_>) -> Selfwhere Self: Sized + AsBytes + FromBytes,

Deserializes a value from a slice of bytes and returns it

fn deserialize_from_bytes(bytes: &[u8]) -> Result<Self, DeserializeError>where Self: Sized,

A convenience function that creates a cursor around the provided bytes and calls deserialize

impl FromBytes for _0

fn read_from<B>(bytes: B) -> Option<Self>where B: ByteSlice, Self: Sized,

Reads a copy of Self from bytes.

fn read_from_prefix<B>(bytes: B) -> Option<Self>where B: ByteSlice, Self: Sized,

Reads a copy of Self from the prefix of bytes.

fn read_from_suffix<B>(bytes: B) -> Option<Self>where B: ByteSlice, Self: Sized,

Reads a copy of Self from the suffix of bytes.

fn new_zeroed() -> Selfwhere Self: Sized,

Creates an instance of Self from zeroed bytes.

impl Serialize for _0

fn size_bits(&self) -> usize

Returns the size of the encoded form of this value, in bits

fn serialize(&self, cursor: &mut WriteCursor<'_>)

Serializes this value into a buffer

fn serialize_to_bytes(&self, bytes: &mut [u8])

A convenience function that creates a cursor around the provided bytes and calls serialize

impl Message for _0