Struct PinScanner 

pub struct PinScanner { /* private fields */ }

Basic structure for doing boundary scanning. Expects a fixed chain of devices.

Implementations

impl PinScanner

pub fn tap_count(&self) -> usize

Count of TAPs on the chain.

pub fn tap_infos(&self) -> &[TapInfo]

Information for TAPs on the chain.

pub fn get_tap_info(&self, i: usize) -> Result<TapInfo, Error>

TapInfo of a TAP; the index is of Self::tap_infos.

pub fn get_tap_state(&self, i: usize) -> Result<TapState, Error>

Current state of a TAP; the index is of Self::tap_infos.

pub fn set_tap_state( &mut self, i: usize, new_state: TapState, ) -> Result<(), Error>

Switches the state of a TAP with index i; the index can be determined by finding in Self::tap_infos.

pub fn pin_ids_for_tap(&self, i_tap: usize) -> Result<PinIdIter, Error>

Iterates through all PinIds for a TAP in the chain. i_tap can be determined by finding in Self::tap_infos.

pub fn get_pin_id(&self, i_tap: usize, pin_name: &str) -> Result<PinId, Error>

Gets a pin identifier by its port name in the BSDL file. i_tap can be determined by finding in Self::tap_infos.

For a pin in a bus port, pin_name should be “PORT_NAME(i)”.

pub fn get_pin_state(&self, pin_id: &PinId) -> Result<PinState, Error>

Gets the pin state at the timepoint before the last Self::update call applied newly set pin states.

pub fn set_pin_state( &mut self, pin_id: &PinId, new_state: Option<bool>, ) -> Result<(), Error>

Sets the new pin state that will be applyed on the next Self::update call. Only for setting pins with output cell in EXTEST mode.

If new_state is Some(state), state will be set in the output cell, and true will be set in the output enable cell if the pin is tristated.

If new_state is None, false will be set in the output enable cell if the pin is tristated, otherwise an error is returned.

pub fn update(&mut self) -> Result<(), Error>

Applies Self::set_pin_state calls since last Self::update and refreshes the capture buffer for later Self::get_pin_state calls with the values before setting new pin states.

pub fn write_update(&mut self) -> Result<(), Error>

Applies Self::set_pin_state calls and then does Self::update, so that later Self::get_pin_state calls will be influenced by the newly set values. This makes no sense if no TAP is in EXTEST mode.

pub fn release(&mut self) -> Result<(), Error>

Switches all TAPs to BYPASS state.

impl PinScanner

pub fn batch( &mut self, count: usize, writer: impl FnMut(usize, &mut BsrEdit<'_, '_>) -> Result<(), Error>, reader: impl FnMut(usize, &BsrView<'_, '_>) -> Result<(), Error>, ) -> Result<(), Error>

Executes queued read + write operations for count times.

This can be used to speed up a group of transfers if each item in the group does not depend on the result of the previous item.

writer and reader will both be called for count times. The cycle counter counts towards count starting from 0. On startup, the current BSR output buffer is copied as the buffer for writer.

At the beginning of each cycle, writer is called with the output buffer and the cycle counter value; any change to the buffer made by writer will be captured and queued for writing to the device, and preserved for the next writer call. When it is actually executed, the captured states before this write is passed to the corresponding call to reader, along with the same cycle counter value.

Returns successfully when the last write is finished; before returning, the output buffer (possibly modified by the last writer call) is applied back to self, and Self::update is called.

let pins = [
    "PB0", "PB1", "PB5", "PB6", "PB7", "PB8", "PB9", "PB10", "PB11", "PB12", "PB13", "PB14",
    "PB15", "PC13", "PC14", "PC15",
];
let pins: Vec<_> = pins
    .iter()
    .map(|n| scanner.get_pin_id(i_c6t6, *n).unwrap())
    .collect();

scanner.set_tap_state(i_c6t6, TapState::Extest)?;
scanner.batch(
    65536,
    |i, edit| {
        // sets value `i` to the 16-bit "bus".
        for (i_pin, pin) in pins.iter().enumerate() {
            let val = ((i >> i_pin) & 1) == 1;
            edit.set(pin, Some(val))?;
        }
        Ok(())
    },
    |i, view| {
        let i_prev = if i > 0 {
            i - 1
        } else {
            return Ok(());
        };
        // `view` provides pin states before the `i`th edit is applied,
        // which equals the values set in `i - 1`th edit.
        let mut val = 0;
        for (i_pin, pin) in pins.iter().enumerate() {
            if view.get(pin)?.input().unwrap() {
                val |= 1 << i_pin;
            }
        }
        assert_eq!(val, i_prev);
        Ok(())
    },
)?;

Trait Implementations

impl Drop for PinScanner

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.