Struct svd_rs::peripheral::PeripheralInfo

#[non_exhaustive]
pub struct PeripheralInfo {

    pub name: String,
    pub display_name: Option<String>,
    pub version: Option<String>,
    pub description: Option<String>,
    pub alternate_peripheral: Option<String>,
    pub group_name: Option<String>,
    pub prepend_to_name: Option<String>,
    pub append_to_name: Option<String>,
    pub header_struct_name: Option<String>,
    pub base_address: u64,
    pub default_register_properties: RegisterProperties,
    pub address_block: Option<Vec<AddressBlock>>,
    pub interrupt: Vec<Interrupt>,
    pub registers: Option<Vec<RegisterCluster>>,
    pub derived_from: Option<String>,
}

A description of a peripheral in the device, describing, for example, the memory mappings.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

name: String

The string identifies the peripheral. Peripheral names are required to be unique for a device

display_name: Option<String>

Specifies a register name without the restrictions of an ANSI C identifier.

version: Option<String>

The string specifies the version of this peripheral description

description: Option<String>

The string provides an overview of the purpose and functionality of the peripheral

alternate_peripheral: Option<String>

Specifies peripheral assigned to the same address blocks

group_name: Option<String>

Assigns this peripheral to a group of peripherals. This is only used bye the System View

prepend_to_name: Option<String>

Define a string as prefix. All register names of this peripheral get this prefix

append_to_name: Option<String>

Define a string as suffix. All register names of this peripheral get this suffix

header_struct_name: Option<String>

Specify the struct type name created in the device header file

base_address: u64

Lowest address reserved or used by the peripheral

default_register_properties: RegisterProperties

Default properties for all registers

address_block: Option<Vec<AddressBlock>>

Specify an address range uniquely mapped to this peripheral

interrupt: Vec<Interrupt>

A peripheral can have multiple associated interrupts

registers: Option<Vec<RegisterCluster>>

Group to enclose register definitions. None indicates that the <registers> node is not present

derived_from: Option<String>

Specify the peripheral name from which to inherit data. Elements specified subsequently override inherited values

Implementations

impl PeripheralInfo

pub fn builder() -> PeripheralInfoBuilder

Make a builder for PeripheralInfo

pub const fn single(self) -> Peripheral

Construct single Peripheral

pub const fn array(self, dim: DimElement) -> Peripheral

Construct Peripheral array

pub fn maybe_array(self, dim: Option<DimElement>) -> Peripheral

Construct single Peripheral or array

pub fn modify_from( &mut self, builder: PeripheralInfoBuilder, lvl: ValidateLevel ) -> Result<(), SvdError>

Modify an existing Peripheral based on a builder.

pub fn validate(&self, lvl: ValidateLevel) -> Result<(), SvdError>

Validate the PeripheralInfo

pub fn validate_all(&self, lvl: ValidateLevel) -> Result<(), SvdError>

Validate the PeripheralInfo recursively

pub fn registers(&self) -> RegisterIter<'_>

Returns iterator over child registers

pub fn registers_mut(&mut self) -> RegisterIterMut<'_>

Returns mutable iterator over child registers

pub fn clusters(&self) -> ClusterIter<'_>

Returns iterator over child clusters

pub fn clusters_mut(&mut self) -> ClusterIterMut<'_>

Returns mutable iterator over child clusters

pub fn reg_iter(&self) -> AllRegistersIter<'_>

👎Deprecated since 0.12.1: Please use all_registers instead

Returns iterator over all descendant registers

pub fn all_registers(&self) -> AllRegistersIter<'_>

Returns iterator over all descendant registers

pub fn reg_iter_mut(&mut self) -> AllRegistersIterMut<'_>

👎Deprecated since 0.12.1: Please use all_registers_mut instead

Returns mutable iterator over all descendant registers

pub fn all_registers_mut(&mut self) -> AllRegistersIterMut<'_>

Returns mutable iterator over all descendant registers

pub fn get_register(&self, name: &str) -> Option<&Register>

Get register by name

pub fn get_mut_register(&mut self, name: &str) -> Option<&mut Register>

Get mutable register by name

pub fn get_cluster(&self, name: &str) -> Option<&Cluster>

Get cluster by name

pub fn get_mut_cluster(&mut self, name: &str) -> Option<&mut Cluster>

Get mutable cluster by name

pub fn get_interrupt(&self, name: &str) -> Option<&Interrupt>

Get interrupt by name

pub fn get_mut_interrupt(&mut self, name: &str) -> Option<&mut Interrupt>

Get mutable enumeratedValue by name

Trait Implementations

impl Clone for PeripheralInfo

fn clone(&self) -> PeripheralInfo

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for PeripheralInfo

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

Formats the value using the given formatter.

impl Description for PeripheralInfo

fn description(&self) -> Option<&str>

Get description

impl From<PeripheralInfo> for PeripheralInfoBuilder

fn from(p: PeripheralInfo) -> Self

Converts to this type from the input type.

impl Name for PeripheralInfo

fn name(&self) -> &str

Get name

impl PartialEq for PeripheralInfo

fn eq(&self, other: &PeripheralInfo) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for PeripheralInfo