Struct Config 

pub struct Config { /* private fields */ }

Implementations

impl Config

pub const WORD_COUNT: usize = 64

pub fn new() -> Self

pub fn from_words(words: [u16; 64]) -> Self

pub fn words(&self) -> &[u16; 64]

pub fn vericomm_clock_high_delay(&self) -> u16

pub fn set_vericomm_clock_high_delay(&mut self, delay: u16)

pub fn vericomm_clock_low_delay(&self) -> u16

pub fn set_vericomm_clock_low_delay(&mut self, delay: u16)

pub fn vericomm_isv(&self) -> u8

pub fn set_vericomm_isv(&mut self, value: u8)

pub fn vericomm_clock_check_enabled(&self) -> bool

pub fn set_vericomm_clock_check_enabled(&mut self, enabled: bool)

pub fn veri_sdk_channel_selector(&self) -> u8

pub fn set_veri_sdk_channel_selector(&mut self, channel: u8)

pub fn mode_selector(&self) -> u8

pub fn set_mode_selector(&mut self, mode: u8)

pub fn flash_begin_block_addr(&self) -> u16

pub fn set_flash_begin_block_addr(&mut self, addr: u16)

pub fn flash_begin_cluster_addr(&self) -> u16

pub fn set_flash_begin_cluster_addr(&mut self, addr: u16)

pub fn flash_read_end_block_addr(&self) -> u16

pub fn set_flash_read_end_block_addr(&mut self, addr: u16)

pub fn flash_read_end_cluster_addr(&self) -> u16

pub fn set_flash_read_end_cluster_addr(&mut self, addr: u16)

pub fn licence_key(&self) -> u16

pub fn security_key(&self) -> u16

The hardware exposes the security key through the same configuration word used for the active license key.

pub fn set_licence_key(&mut self, key: u16)

pub fn smims_version_raw(&self) -> u16

Examples found in repository

examples/stress_abort.rs (line 62)

fn real_main() -> Result<(), Box<dyn Error>> {
    let mut iterations = 10usize;
    let mut words = 512usize;
    let mut window = 4usize;
    let mut clock_high = 4u16;
    let mut clock_low = 4u16;
    let mut settle_ms = 0u64;

    let mut args = env::args().skip(1);
    while let Some(flag) = args.next() {
        match flag.as_str() {
            "--iterations" => {
                iterations = args
                    .next()
                    .ok_or("missing value for --iterations")?
                    .parse()?
            }
            "--words" => words = args.next().ok_or("missing value for --words")?.parse()?,
            "--window" => window = args.next().ok_or("missing value for --window")?.parse()?,
            "--clock-high" => {
                clock_high = args
                    .next()
                    .ok_or("missing value for --clock-high")?
                    .parse()?
            }
            "--clock-low" => {
                clock_low = args
                    .next()
                    .ok_or("missing value for --clock-low")?
                    .parse()?
            }
            "--settle-ms" => {
                settle_ms = args
                    .next()
                    .ok_or("missing value for --settle-ms")?
                    .parse()?
            }
            other => return Err(format!("unknown flag `{other}`").into()),
        }
    }

    let tx = vec![0x1234u16; words];

    for iteration in 0..iterations {
        println!("iter={iteration} phase=open");
        let mut board = Board::open()?;
        println!(
            "iter={iteration} config programmed={} fifo_words={} version=0x{:04x}",
            board.config().is_programmed(),
            board.config().fifo_size_words(),
            board.config().smims_version_raw()
        );

        let mut io = board.configure_io(&IoConfig {
            clock_high_delay: clock_high,
            clock_low_delay: clock_low,
            ..IoConfig::default()
        })?;

        {
            let mut rolling = io.transfer_window(words, window)?;
            for submit_index in 0..window {
                rolling.submit(&tx)?;
                println!("iter={iteration} submit={submit_index}");
            }
            if settle_ms > 0 {
                thread::sleep(Duration::from_millis(settle_ms));
            }
        }

        io.finish()?;
        board.close()?;

        println!("iter={iteration} phase=reopen");
        let reopened = Board::open()?;
        println!(
            "iter={iteration} reopened programmed={} fifo_words={} version=0x{:04x}",
            reopened.config().is_programmed(),
            reopened.config().fifo_size_words(),
            reopened.config().smims_version_raw()
        );
        reopened.close()?;
    }

    Ok(())
}

pub fn smims_major_version(&self) -> u8

pub fn smims_sub_version(&self) -> u8

pub fn smims_patch_version(&self) -> u8

pub fn fifo_size_words(&self) -> u16

Returns the FIFO capacity in 16-bit words.

This matches the legacy C++ implementation, where CFG[33] is passed directly to SMIMS_FIFO_Write / SMIMS_FIFO_Read as a word count.

Examples found in repository

examples/bench_transfer.rs (line 149)

fn run_device_bench(options: &Options) -> Result<(), Box<dyn Error>> {
    let mut board = Board::open_with_transport(options.transport)?;
    let max_cycles_per_transfer = usize::from(board.config().fifo_size_words()) / WORDS_PER_CYCLE;
    let mut io = board.configure_io(&IoConfig {
        clock_high_delay: options.clock_high_delay,
        clock_low_delay: options.clock_low_delay,
        ..IoConfig::default()
    })?;

    if options.window == 0 {
        return Err("window must be at least 1".into());
    }

    let template = vec![0x1234u16; options.words];
    let mut rx = vec![0u16; options.words];
    let mut outputs = vec![vec![0u16; options.words]; options.window];
    let mut stage_profile = TransferStageProfile::default();

    let started = Instant::now();
    if options.window == 1 {
        if options.profile_stages {
            for _ in 0..options.iterations {
                let profile = io.transfer_profiled_into(&template, &mut rx)?;
                stage_profile.merge(&profile);
            }
        } else {
            for _ in 0..options.iterations {
                io.transfer(&template, &mut rx)?;
            }
        }
    } else {
        let mut window = io.transfer_window(options.words, options.window)?;
        let initial = options.iterations.min(options.window);
        for _ in 0..initial {
            if options.profile_stages {
                let profile = window.submit_profiled(&template)?;
                stage_profile.merge(&profile);
            } else {
                window.submit(&template)?;
            }
        }

        let mut submitted = initial;
        let mut completed = 0usize;
        while completed < options.iterations {
            let output = outputs[completed % options.window].as_mut_slice();
            if options.profile_stages {
                let profile = window.receive_into_profiled(output)?;
                stage_profile.merge(&profile);
            } else {
                window.receive_into(output)?;
            }
            completed += 1;

            if submitted < options.iterations {
                if options.profile_stages {
                    let profile = window.submit_profiled(&template)?;
                    stage_profile.merge(&profile);
                } else {
                    window.submit(&template)?;
                }
                submitted += 1;
            }
        }
    }
    let elapsed = started.elapsed();
    io.finish()?;

    print_summary(
        "device",
        options.words,
        options.iterations,
        elapsed,
        Some(max_cycles_per_transfer),
    );
    if options.profile_stages {
        print_stage_profile(&stage_profile, elapsed);
    }
    Ok(())
}

examples/stress_abort.rs (line 61)

fn real_main() -> Result<(), Box<dyn Error>> {
    let mut iterations = 10usize;
    let mut words = 512usize;
    let mut window = 4usize;
    let mut clock_high = 4u16;
    let mut clock_low = 4u16;
    let mut settle_ms = 0u64;

    let mut args = env::args().skip(1);
    while let Some(flag) = args.next() {
        match flag.as_str() {
            "--iterations" => {
                iterations = args
                    .next()
                    .ok_or("missing value for --iterations")?
                    .parse()?
            }
            "--words" => words = args.next().ok_or("missing value for --words")?.parse()?,
            "--window" => window = args.next().ok_or("missing value for --window")?.parse()?,
            "--clock-high" => {
                clock_high = args
                    .next()
                    .ok_or("missing value for --clock-high")?
                    .parse()?
            }
            "--clock-low" => {
                clock_low = args
                    .next()
                    .ok_or("missing value for --clock-low")?
                    .parse()?
            }
            "--settle-ms" => {
                settle_ms = args
                    .next()
                    .ok_or("missing value for --settle-ms")?
                    .parse()?
            }
            other => return Err(format!("unknown flag `{other}`").into()),
        }
    }

    let tx = vec![0x1234u16; words];

    for iteration in 0..iterations {
        println!("iter={iteration} phase=open");
        let mut board = Board::open()?;
        println!(
            "iter={iteration} config programmed={} fifo_words={} version=0x{:04x}",
            board.config().is_programmed(),
            board.config().fifo_size_words(),
            board.config().smims_version_raw()
        );

        let mut io = board.configure_io(&IoConfig {
            clock_high_delay: clock_high,
            clock_low_delay: clock_low,
            ..IoConfig::default()
        })?;

        {
            let mut rolling = io.transfer_window(words, window)?;
            for submit_index in 0..window {
                rolling.submit(&tx)?;
                println!("iter={iteration} submit={submit_index}");
            }
            if settle_ms > 0 {
                thread::sleep(Duration::from_millis(settle_ms));
            }
        }

        io.finish()?;
        board.close()?;

        println!("iter={iteration} phase=reopen");
        let reopened = Board::open()?;
        println!(
            "iter={iteration} reopened programmed={} fifo_words={} version=0x{:04x}",
            reopened.config().is_programmed(),
            reopened.config().fifo_size_words(),
            reopened.config().smims_version_raw()
        );
        reopened.close()?;
    }

    Ok(())
}

pub fn fifo_size(&self) -> u16

Legacy alias for Self::fifo_size_words.

pub fn flash_total_block(&self) -> u16

pub fn flash_block_size(&self) -> u16

pub fn flash_cluster_size(&self) -> u16

pub fn vericomm_ability(&self) -> bool

pub fn veri_instrument_ability(&self) -> bool

pub fn veri_link_ability(&self) -> bool

pub fn veri_soc_ability(&self) -> bool

pub fn vericomm_pro_ability(&self) -> bool

pub fn veri_sdk_ability(&self) -> bool

pub fn is_programmed(&self) -> bool

Examples found in repository

examples/stress_abort.rs (line 60)

fn real_main() -> Result<(), Box<dyn Error>> {
    let mut iterations = 10usize;
    let mut words = 512usize;
    let mut window = 4usize;
    let mut clock_high = 4u16;
    let mut clock_low = 4u16;
    let mut settle_ms = 0u64;

    let mut args = env::args().skip(1);
    while let Some(flag) = args.next() {
        match flag.as_str() {
            "--iterations" => {
                iterations = args
                    .next()
                    .ok_or("missing value for --iterations")?
                    .parse()?
            }
            "--words" => words = args.next().ok_or("missing value for --words")?.parse()?,
            "--window" => window = args.next().ok_or("missing value for --window")?.parse()?,
            "--clock-high" => {
                clock_high = args
                    .next()
                    .ok_or("missing value for --clock-high")?
                    .parse()?
            }
            "--clock-low" => {
                clock_low = args
                    .next()
                    .ok_or("missing value for --clock-low")?
                    .parse()?
            }
            "--settle-ms" => {
                settle_ms = args
                    .next()
                    .ok_or("missing value for --settle-ms")?
                    .parse()?
            }
            other => return Err(format!("unknown flag `{other}`").into()),
        }
    }

    let tx = vec![0x1234u16; words];

    for iteration in 0..iterations {
        println!("iter={iteration} phase=open");
        let mut board = Board::open()?;
        println!(
            "iter={iteration} config programmed={} fifo_words={} version=0x{:04x}",
            board.config().is_programmed(),
            board.config().fifo_size_words(),
            board.config().smims_version_raw()
        );

        let mut io = board.configure_io(&IoConfig {
            clock_high_delay: clock_high,
            clock_low_delay: clock_low,
            ..IoConfig::default()
        })?;

        {
            let mut rolling = io.transfer_window(words, window)?;
            for submit_index in 0..window {
                rolling.submit(&tx)?;
                println!("iter={iteration} submit={submit_index}");
            }
            if settle_ms > 0 {
                thread::sleep(Duration::from_millis(settle_ms));
            }
        }

        io.finish()?;
        board.close()?;

        println!("iter={iteration} phase=reopen");
        let reopened = Board::open()?;
        println!(
            "iter={iteration} reopened programmed={} fifo_words={} version=0x{:04x}",
            reopened.config().is_programmed(),
            reopened.config().fifo_size_words(),
            reopened.config().smims_version_raw()
        );
        reopened.close()?;
    }

    Ok(())
}

pub fn is_pcb_connected(&self) -> bool

pub fn vericomm_clock_continues(&self) -> bool

Trait Implementations

impl Clone for Config

fn clone(&self) -> Config

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Config

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

Formats the value using the given formatter.

impl Default for Config

fn default() -> Self

Returns the “default value” for a type.

impl Eq for Config

impl PartialEq for Config

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