Struct IndividualAddress 

pub struct IndividualAddress { /* private fields */ }

KNX Individual Address (Area.Line.Device)

Used to identify physical devices on the KNX bus.

Examples

use knx_pico::IndividualAddress;

// Create from components
let addr = IndividualAddress::new(1, 1, 5).unwrap();
assert_eq!(addr.to_string(), "1.1.5");

// Create from raw u16
let addr = IndividualAddress::from(0x1105u16);
assert_eq!(addr.area(), 1);
assert_eq!(addr.line(), 1);
assert_eq!(addr.device(), 5);

// Parse from string
let addr: IndividualAddress = "1.1.5".parse().unwrap();
assert_eq!(u16::from(addr), 0x1105);

Implementations

impl IndividualAddress

pub const MAX_AREA: u8 = 15u8

Maximum area value (4 bits)

pub const MAX_LINE: u8 = 15u8

Maximum line value (4 bits)

pub const MAX_DEVICE: u8 = 255u8

Maximum device value (8 bits)

pub fn new(area: u8, line: u8, device: u8) -> Result<Self>

Create a new Individual Address from components.

Arguments

• area - Area (0-15)
• line - Line (0-15)
• device - Device (0-255)

Errors

Returns KnxError::AddressOutOfRange if any component is out of range.

Examples

use knx_pico::IndividualAddress;

let addr = IndividualAddress::new(1, 1, 5)?;
assert_eq!(addr.to_string(), "1.1.5");

pub fn from_array(parts: [u8; 3]) -> Result<Self>

Create from a 3-element array [area, line, device].

Convenient for creating addresses from array literals.

Examples

use knx_pico::IndividualAddress;

let addr = IndividualAddress::from_array([1, 1, 5])?;
assert_eq!(addr.to_string(), "1.1.5");

pub const fn raw(self) -> u16

Get the raw u16 representation of the address.

pub const fn area(self) -> u8

Get the area component (0-15).

pub const fn line(self) -> u8

Get the line component (0-15).

pub const fn device(self) -> u8

Get the device component (0-255).

pub fn encode(&self, buf: &mut [u8]) -> Result<usize>

Encode the address into a byte buffer (big-endian).

Arguments

• buf - Buffer to write to (must be at least 2 bytes)

Errors

Returns KnxError::BufferTooSmall if buffer is too small.

pub fn decode(buf: &[u8]) -> Result<Self>

Decode an address from a byte buffer (big-endian).

Arguments

• buf - Buffer to read from (must be at least 2 bytes)

Errors

Returns KnxError::BufferTooSmall if buffer is too small.

Trait Implementations

impl Clone for IndividualAddress

fn clone(&self) -> IndividualAddress

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for IndividualAddress

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

Formats the value using the given formatter.

impl Display for IndividualAddress

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

Formats the value using the given formatter.

impl Format for IndividualAddress

fn format(&self, f: Formatter<'_>)

Writes the defmt representation of self to fmt.

impl From<IndividualAddress> for u16

fn from(addr: IndividualAddress) -> u16

Converts to this type from the input type.

impl From<u16> for IndividualAddress

fn from(raw: u16) -> Self

Converts to this type from the input type.

impl FromStr for IndividualAddress

type Err = KnxError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self>

Parses a string s to return a value of this type.

impl Hash for IndividualAddress

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for IndividualAddress

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Copy for IndividualAddress

impl Eq for IndividualAddress

impl StructuralPartialEq for IndividualAddress