Struct BitBang 

pub struct BitBang<P, D> { /* private fields */ }

A 1-Wire controller bit-banged over one open-drain pin and a delay.

The pin must drive the line low when set low and release it when set high, with a pull-up resistor (4.7 kΩ is the datasheet value) raising the released line, and it must read back the line’s level. On a microcontroller that is an open-drain output that can be read, or a pin switched between output and input.

Examples

use pamoja_hal::digital::PinState::{High, Low};
use pamoja_hal::onewire::{BitBang, OneWireBus};
use pamoja_hal::script::{DelayLog, PinScript};

// The scripted pin answers the presence sample low: a device is there.
let pin = PinScript::new([Low]);
let mut bus = BitBang::new(pin, DelayLog::new());
assert!(bus.reset()?);

let (pin, delay) = bus.into_parts();
assert_eq!(pin.driven(), [Low, High]);
assert_eq!(delay.total_micros(), 980);

Implementations

impl<P, D> BitBang<P, D>

pub fn new(pin: P, delay: D) -> BitBang<P, D>

Creates a controller over pin, timed by delay.

Arguments

• pin - the open-drain line, driven low to signal and released to listen.
• delay - the microsecond timer that paces the slots.

Returns

The controller, with the line released.

pub fn into_parts(self) -> (P, D)

Gives back the pin and the delay.

Returns

The pin and delay the controller was built from.

Trait Implementations

impl<P: Debug, D: Debug> Debug for BitBang<P, D>

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

Formats the value using the given formatter.

impl<P: OutputPin + InputPin, D: DelayNs> OneWireBus for BitBang<P, D>

type Error = <P as ErrorType>::Error

The error the controller underneath reports.

fn reset(&mut self) -> Result<bool, Self::Error>

Sends a reset pulse and reports whether any device answered with presence.

fn write_bit(&mut self, bit: bool) -> Result<(), Self::Error>

Sends one bit in a write slot.

fn read_bit(&mut self) -> Result<bool, Self::Error>

Samples one bit in a read slot.

fn write_byte(&mut self, byte: u8) -> Result<(), Self::Error>

Sends one byte, least significant bit first, as the bus requires.

fn read_byte(&mut self) -> Result<u8, Self::Error>

Reads one byte, least significant bit first.

fn write_bytes(&mut self, bytes: &[u8]) -> Result<(), Self::Error>

Sends every byte of bytes in order.

fn read_bytes(&mut self, buffer: &mut [u8]) -> Result<(), Self::Error>

Fills buffer with bytes read in order.

fn skip_rom(&mut self) -> Result<(), OneWireError<Self::Error>>

Resets the bus and addresses every device at once with SKIP_ROM.

fn match_rom(&mut self, rom: &RomCode) -> Result<(), OneWireError<Self::Error>>

Resets the bus and addresses one device by its ROM code with MATCH_ROM.

fn read_rom(&mut self) -> Result<RomCode, OneWireError<Self::Error>>

Resets the bus and reads the ROM code of the only device on it.