Struct ieee802154::mac::frame::Header

pub struct Header {
    pub frame_type: FrameType,
    pub security: Security,
    pub frame_pending: bool,
    pub ack_request: bool,
    pub pan_id_compress: bool,
    pub version: FrameVersion,
    pub destination: Address,
    pub source: Address,
    pub seq: u8,
}

MAC frame header

Fields

frame_type: FrameType

Frame Type

security: Security

Auxiliary Security header

frame_pending: bool

Frame Pending

ack_request: bool

Acknowledgement Request

pan_id_compress: bool

PAN ID Compress

version: FrameVersion

Frame version

destination: Address

Destination Address

source: Address

Source Address

seq: u8

Sequence Number

Methods

impl Header

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

Decodes a header from a byte buffer

This method is used by Frame::decode to decode the frame header. Unless you decide to write your own code for decoding frames, there should be no reason to call this method directly.

Errors

This function returns an error, if the bytes either don't encode a valid IEEE 802.15.4 frame header, or encode a frame header that is not fully supported by this implementation. Please refer to DecodeError for details.

Example

use ieee802154::mac::{
    Address,
    ShortAddress,
    FrameType,
    Header,
    PanId,
    Security,
};

// Construct a simple header.
let bytes = [
    0x01, 0x98,             // frame control
    0x00,                   // sequence number
    0x12, 0x34, 0x56, 0x78, // PAN identifier and address of destination
    0x12, 0x34, 0x9a, 0xbc, // PAN identifier and address of source
];

let (header, num_bytes) = Header::decode(&bytes)?;

assert_eq!(num_bytes, bytes.len());

assert_eq!(header.seq,             0x00);
assert_eq!(header.frame_type,      FrameType::Data);
assert_eq!(header.security,        Security::None);
assert_eq!(header.frame_pending,   false);
assert_eq!(header.ack_request,     false);
assert_eq!(header.pan_id_compress, false);

assert_eq!(
    header.destination,
    Address::Short(PanId(0x3412), ShortAddress(0x7856))
);
assert_eq!(
    header.source,
    Address::Short(PanId(0x3412), ShortAddress(0xbc9a))
);

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

Encodes the header into a buffer

Returns the number of bytes written to the buffer.

Panics

Panics, if the buffer is not long enough to hold the header. If you believe that this behavior is inappropriate, please leave your feedback on the issue tracker. Will also panic if the destination PAN identifier differs from the source PAN identifier when using PAN identifier compress.

The header length depends on the options chosen and varies between 3 and 30 octets.

Example

use ieee802154::mac::{
    Address,
    ShortAddress,
    FrameType,
    FrameVersion,
    Header,
    PanId,
    Security,
};

let header = Header {
    seq:             0x00,
    frame_type:      FrameType::Data,
    security:        Security::None,
    frame_pending:   false,
    ack_request:     false,
    pan_id_compress: false,
    version:         FrameVersion::Ieee802154_2006,

    destination: Address::Short(PanId(0x1234), ShortAddress(0x5678)),
    source:      Address::Short(PanId(0x1234), ShortAddress(0x9abc)),
};

let mut bytes = [0u8; 11];

header.encode(&mut bytes);

let expected_bytes = [
    0x01, 0x98,             // frame control
    0x00,                   // sequence number
    0x34, 0x12, 0x78, 0x56, // PAN identifier and address of destination
    0x34, 0x12, 0xbc, 0x9a, // PAN identifier and address of source
];
assert_eq!(bytes[..expected_bytes.len()], expected_bytes[..]);

Trait Implementations

impl PartialEq<Header> for Header

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

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

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

This method tests for !=.

impl Eq for Header

impl Clone for Header

fn clone(&self) -> Header

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for Header

impl Debug for Header

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

Formats the value using the given formatter.

impl Hash for Header

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, 

Feeds a slice of this type into the given [Hasher].