Struct canadensis_data_types::reg::udral::service::battery::_0_1::_0

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

reg.udral.service.battery._.0.1

Fixed size 0 bytes

This is the smart battery monitoring service. A smart battery is required to publish on the following subjects:

SUBJECT TYPE TYP. RATE [Hz] energy_source reg.udral.physics.electricity.SourceTs 1…100 status reg.udral.service.battery.Status ~1 parameters reg.udral.service.battery.Parameters ~0.2

Observe that only the first subject can be used for estimating the endurance of the power source. The other subjects are designed for monitoring, diagnostics, and maintenance.

Optionally, the battery service can subscribe to a readiness control subject (see reg.udral.service.common.Readiness), which enables the following two optional capabilities:

• SLEEP mode: when the readiness subject commands the sleep state, the battery management system may enter a low power consumption state, possibly deactivating some of its capabilities.

• STANDBY mode: the battery management system may implement additional safety protections that may otherwise interfere with the normal operation of the vehicle. For example, the traction battery may limit the maximum load current and the depth of discharge unless the commanded state is ENGAGED. By doing so, the battery can protect itself and the supplied high-voltage DC network from accidental damage while the vehicle is parked. Limiting the output power or discharge of the traction battery might lead to catastrophic consequences in an aerial vehicle, hence such safety checks are to be disabled once the battery is commanded into the ENGAGED state.

If readiness state selection is not supported, the battery may not subscribe to the readiness control subject, in which case it should permanently report its state as ENGAGED unless the battery is unfit for use (e.g., due to degradation or a failure).

By convention, positive current flows from the DC network into the battery. Therefore, the current is negative when the battery powers the system, and positive when it is being charged.

Systems that leverage multiple battery packs simultaneously should be configured to publish the status of each pack on a separate subject.

Published quantities should be low-pass filtered to avoid aliasing effects. Publishers should strive to sample all parameters atomically.

The reported quantities are focused on the amount of energy that can be reclaimed from the battery. In a simplified view, this can be seen as the amount of energy that is “stored” in the battery; however, this interpretation is not strictly correct because the amount of retrievable energy may be dependent on external factors such as the temperature of the battery or the load current. Energy estimation is hard and requires accurate modeling of the state of the battery, which may be impossible to do without precise tracking of each charging cycle. Despite the complications, this is considered to be a superior approach compared to the commonly used alternative where the state estimation is focused on the electric charge, because the latter cannot be used directly to predict the endurance of the system.

The methods of energy estimation are implementation-defined.

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