Struct MicrogridClientHandle 

pub struct MicrogridClientHandle { /* private fields */ }

A handle to the microgrid client connection.

This handle can be cloned as many times as needed, and each clone will share the same underlying connection to the microgrid API.

Implementations

impl MicrogridClientHandle

pub async fn try_new(url: impl Into<String>) -> Result<Self, Error>

Creates a new MicrogridClientHandle that connects to the microgrid API at the specified URL.

pub fn new_from_client(client: impl MicrogridApiClient) -> Self

pub async fn receive_electrical_component_telemetry_stream( &self, electrical_component_id: u64, ) -> Result<Receiver<ElectricalComponentTelemetry>, Error>

Returns a telemetry stream from an electrical component with a given ID.

When a connection to the API service is lost, reconnecting is handled automatically, and the receiver will resume receiving data from the component once the connection is re-established.

pub async fn list_electrical_components( &self, electrical_component_ids: Vec<u64>, electrical_component_categories: Vec<ElectricalComponentCategory>, ) -> Result<Vec<ElectricalComponent>, Error>

Lists the electrical components in the local microgrid.

If provided, the filters for component IDs and categories have an AND relationship with one another, meaning that they are applied serially, but the elements within a single filter list have an OR relationship with each other.

For example, if ids = [1, 2, 3], and categories = [ ComponentCategory::COMPONENT_CATEGORY_INVERTER, ComponentCategory::COMPONENT_CATEGORY_BATTERY ], then the results will consist of elements that have the IDs 1, OR 2, OR 3, AND are of the categories ComponentCategory::COMPONENT_CATEGORY_INVERTER OR ComponentCategory::COMPONENT_CATEGORY_BATTERY.

If a filter list is empty, then that filter is not applied.

pub async fn list_electrical_component_connections( &self, source_electrical_component_ids: Vec<u64>, destination_electrical_component_ids: Vec<u64>, ) -> Result<Vec<ElectricalComponentConnection>, Error>

Lists the connections between the electrical components in a microgrid, denoted by (start, end).

The direction of a connection is always away from the grid endpoint, i.e. aligned with the direction of positive current according to the passive sign convention: https://en.wikipedia.org/wiki/Passive_sign_convention

If provided, the start and end filters have an AND relationship between each other, meaning that they are applied serially, but an OR relationship with other elements in the same list. For example, if start = [1, 2, 3], and end = [4, 5, 6], then the result should have all the connections where

• each start component ID is either 1, 2, OR 3, AND
• each end component ID is either 4, 5, OR 6.

pub async fn augment_electrical_component_bounds<M, I>( &self, electrical_component_id: u64, target_metric: M, bounds: Vec<I>, request_lifetime: Option<TimeDelta>, ) -> Result<Option<DateTime<Utc>>, Error>

where M: Metric, Bounds<M::QuantityType>: Into<PbBounds>, I: Into<Bounds<M::QuantityType>>,

Augments the overall bounds for a given metric of a given electrical component with the provided bounds. Returns the UTC time at which the provided bounds will expire and its effects will no longer be visible in the overall bounds for the given metric.

The request parameters allows users to select a duration until which the bounds will stay in effect. If no duration is provided, then the bounds will be removed after a default duration of 5 seconds.

Inclusion bounds give the range that the system will try to keep the metric within. If the metric goes outside of these bounds, the system will try to bring it back within the bounds. If the bounds for a metric are [`lower_1, upper_1], [lower_2, upper_2](<lower_1, upper_1], [lower_2, upper_2>), then this metric's valueneeds to comply with the constraintslower_1 <= value <= upper_1ORlower_2 <= value <= upper_2`.

If multiple inclusion bounds have been provided for a metric, then the overlapping bounds are merged into a single bound, and non-overlapping bounds are kept separate. E.g. if the bounds are [0, 10], [5, 15], 20, 30, then the resulting bounds will be [0, 15], 20, 30.

The following diagram illustrates how bounds are applied:

 lower_1  upper_1
<----|========|--------|========|-------->
                   lower_2  upper_2

The bounds in this example are [[lower_1, upper_1], [lower_2, upper_2]]. –– values here are considered out of range. ==== values here are considered within range.

Note that for power metrics, regardless of the bounds, 0W is always allowed.

Trait Implementations

impl Clone for MicrogridClientHandle

fn clone(&self) -> MicrogridClientHandle

Returns a duplicate of the value.

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

Performs copy-assignment from source.