Struct profirust::dp::DpMaster

pub struct DpMaster<'a> { /* private fields */ }

The DP master

Currently only implements a subset of DP-V0.

The DP master holds all peripherals that we interact with. To get access, use the PeripheralHandle that you get when calling dp_master.add().

When constructing the DP master, you need to pass a storage for peripherals. This can either be a fixed-size storage (slice or array) or, if alloc/std is available, a Vec<> that will be dynamically grown to house the peripherals.

The DP master starts in the Stop state. To communicate with peripherals, you first need to move it into the Operate state using the dp_master.enter_operate() method.

Example

use profirust::dp;
let buffer: [dp::PeripheralStorage; 4] = Default::default();
let mut dp_master = dp::DpMaster::new(buffer);
// or with `std`:
// let mut dp_master = dp::DpMaster::new(Vec::new());

// Let's add a peripheral.
let remoteio_address = 7;
let remoteio_options = dp::PeripheralOptions {
    // ...
    // best generated using `gsdtool`
    // ...
    ..Default::default()
};
let mut buffer_inputs = [0u8; 8];
let mut buffer_outputs = [0u8; 4];

let remoteio = dp_master.add(dp::Peripheral::new(
    remoteio_address,
    remoteio_options,
    &mut buffer_inputs,
    &mut buffer_outputs,
));

dp_master.enter_operate();

Implementations

impl<'a> DpMaster<'a>

pub fn new<S>(storage: S) -> Self

where S: Into<ManagedSlice<'a, PeripheralStorage<'a>>>,

pub fn add(&mut self, peripheral: Peripheral<'a>) -> PeripheralHandle

Add a peripheral to the set, and return its handle.

Panics

This function panics if the storage is fixed-size (not a Vec) and is full.

pub fn get_mut(&mut self, handle: PeripheralHandle) -> &mut Peripheral<'a>

Get a peripheral from the set by its handle, as mutable.

Panics

This function may panic if the handle does not belong to this peripheral set.

pub fn iter_mut( &mut self ) -> impl Iterator<Item = (PeripheralHandle, &mut Peripheral<'a>)>

pub fn iter(&self) -> impl Iterator<Item = (PeripheralHandle, &Peripheral<'a>)>

pub fn operating_state(&self) -> OperatingState

pub fn enter_state(&mut self, state: OperatingState)

pub fn enter_stop(&mut self)

Enter the Stop operating state.

This is equivalent to calling .enter_state(OperatingState::Stop).

pub fn enter_clear(&mut self)

Enter the Clear operating state.

This is equivalent to calling .enter_state(OperatingState::Clear).

pub fn enter_operate(&mut self)

Enter the Operate operating state.

This is equivalent to calling .enter_state(OperatingState::Operate).

Trait Implementations

impl<'a> FdlApplication for DpMaster<'a>

type Events = DpEvents

fn transmit_telegram( &mut self, now: Instant, fdl: &FdlMaster, tx: TelegramTx<'_>, high_prio_only: bool ) -> (Option<TelegramTxResponse>, Self::Events)

Possibly transmit a telegram.

fn receive_reply( &mut self, now: Instant, fdl: &FdlMaster, addr: u8, telegram: Telegram<'_> ) -> Self::Events

Receive the reply for the telegram that was last transmitted.

fn handle_timeout(&mut self, now: Instant, fdl: &FdlMaster, addr: u8)

Handle a timeout while waiting for a reply from the given address.