Struct avr_oxide::util::datatypes::BitField

#[repr(C)]
pub struct BitField(/* private fields */);

Helper newtype to represent a packed bitfield structure.

Implementations

impl BitField

Configuration of various translation/usability options for the serial port device.

Option	Effect
flush_on_eol	Automatically flush when an end-of-line is transmitted
cr_to_crlf	Translate sent CRs to CRLF
lf_to_crlf	Translate sent LFs to CRLF
interactive	This is an interactive terminal, reading from the device will automatically flush the transmit buffer first
echo	Echo all characters received back on the transmit line. If interactive is set, will also flush after each.
blocking_read	Calls to read() should block until data is available
read_to_eol	Blocking read()s will immediately return when a CR or LF (‘\r’ or ‘\n’) is received
read_to_eot	Blocking read()s will immediately return when an EOT character is received

pub fn set_flush_on_eol(&mut self, flag: bool)

Indicate that the device should automatically flush when an end-of-line (CR or LF) character is sent is sent.

pub fn flush_on_eol(self) -> bool

True iff the device should automatically flush when an LF character is sent.

pub fn set_cr_to_crlf(&mut self, flag: bool)

Indicate that CR should be translated to CRLF automatically

pub fn cr_to_crlf(&self) -> bool

True iff the device should automatically translate CR to CRLF.

pub fn set_lf_to_crlf(&mut self, flag: bool)

Indicate that LF should be translated to CRLF automatically

pub fn lf_to_crlf(&self) -> bool

True iff the device should automatically translate LF to CRLF.

pub fn set_interactive(&mut self, flag: bool)

Indicate that this is an interactive terminal. Effects:

• A call to read() will automatically flush the transmit buffer

pub fn interactive(&self) -> bool

True iff this is an interative terminal

pub fn set_echo(&mut self, flag: bool)

Indicate that we should echo received characters back. If the device is also set to interactive, then we will flush() after each echoed character as well.

pub fn echo(&self) -> bool

True iff we should echo everything we receive back on transmit

pub fn set_blocking_read(&mut self, flag: bool)

Indicate that calls to read() should block until data is available

pub fn blocking_read(&self) -> bool

True iff read()s should block until data is available

pub fn set_read_to_eol(&mut self, flag: bool)

Stop blocking read()s as soon as a linefeed (\n) is received

pub fn read_to_eol(&self) -> bool

True iff blocking reads will complete when a linefeed (\n) is received

pub fn set_read_to_eot(&mut self, flag: bool)

Stop blocking read()s as soon as an EOT is received

pub fn read_to_eot(&self) -> bool

True iff blocking reads will complete when an EOT is received

pub fn disable_translations(&mut self)

Clear all settings that result in the data being translated in any way (e.g. CR to CRLF type translations.) Use this to ensure a serial port is ‘clean’ for sending/receiving binary data.

impl BitField

pub const fn with_initial(vals: u8) -> Self

Create a BitField initialised to the given values (big-endian)

pub fn with_bits_set(bits: &[BitIndex]) -> Self

Create a BitField where all bits are clear except the ones passed in the initialisation array.

pub const fn all_clr() -> Self

An instance of BitField with all bits cleared

pub const fn all_set() -> Self

An instance of BitField with all bits set

Trait Implementations

impl BitAnd<u8> for BitField

type Output = u8

The resulting type after applying the & operator.

fn bitand(self, rhs: u8) -> Self::Output

Performs the & operation.

impl BitFieldAccess for BitField

fn read_byte(&self) -> u8

fn write_byte(&mut self, val: u8)

fn is_set(&self, bit: BitIndex) -> bool

True IFF the bit at the given index is set

fn is_all_set<B: BitMaskable + Copy>(&self, bits: B) -> bool

True IFF all the bits at the given index/range are set

fn is_any_set<B: BitMaskable + Copy>(&self, bits: B) -> bool

True IFF any of the bits at the given index/range are set

fn is_all_clr<B: BitMaskable + Copy>(&self, bits: B) -> bool

True IFF none of the bits at the given index/range are set

fn is_clr(&self, bit: BitIndex) -> bool

True IFF the bit at the given index is clear

fn set_isolated<B: BitMaskable + Copy>(&mut self, _isotoken: Isolated, bits: B)

Set the bit(s) at the given index/range

fn set<B: BitMaskable + Copy>(&mut self, bits: B)

Set the bit(s) at the given index/range

fn set_all(&mut self)

Set all bits of the bitmask to 1

fn clr_all(&mut self)

Set all bits of the bitmask to 0

fn exc_set<B: BitMaskable + Copy>(&mut self, bits: B)

Set the bit(s) at the given index/range and clear all others

fn clr_isolated<B: BitMaskable + Copy>(&mut self, _isotoken: Isolated, bits: B)

Clear the bit(s) at the given index/range

fn clr<B: BitMaskable + Copy>(&mut self, bits: B)

Clear the bit at the given index

fn exc_clr<B: BitMaskable + Copy>(&mut self, bits: B)

Clear the bit at the given index and set all others

fn set_or_clr<B: BitMaskable + Copy>(&mut self, bits: B, set: bool)

Set or clear the bit(s) at the given index/range depending on the set parameter (true = set the bit, false = clear it.)

fn set_to<B: BitMaskable + Copy>(&mut self, bits: B, value: u8)

Set the bit(s) at the given index/range to the bitwise value given.

fn set_to_isolated<B: BitMaskable + Copy>( &mut self, _isotoken: Isolated, bits: B, value: u8 )

Set the bit(s) at the given index/range to the bitwise value given.

fn get_val<B: BitMaskable + Copy>(&self, bits: B) -> u8

Return the bit(s) at the given index/range as a binary value.

impl BitOr<u8> for BitField

type Output = u8

The resulting type after applying the | operator.

fn bitor(self, rhs: u8) -> Self::Output

Performs the | operation.

impl Clone for BitField

fn clone(&self) -> BitField

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for BitField

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

Formats the value using the given formatter.

impl PartialEq for BitField

fn eq(&self, other: &BitField) -> 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 Copy for BitField

impl Eq for BitField

impl StructuralPartialEq for BitField