Struct probe_rs::probe::MasterProbe

pub struct MasterProbe { /* fields omitted */ }

The MasterProbe struct is a generic wrapper over the different probes supported.

Examples

Open the first probe found

The list_all and from_probe_info functions can be used to create a new MasterProbe::

use probe_rs::probe::MasterProbe;

let probe_list = MasterProbe::list_all();
let probe = MasterProbe::from_probe_info(&probe_list[0]);

Methods

impl MasterProbe

pub fn list_all() -> Vec<DebugProbeInfo>

Get a list of all debug probes found. This can be used to select the debug probe which should be used.

pub fn from_probe_info(info: &DebugProbeInfo) -> Result<Self, DebugProbeError>

Create a MasterProbe from DebugProbeInfo. Use the MasterProbe::list_all() function to get the information about all probes available.

pub fn from_specific_probe(probe: Box<dyn DebugProbe>) -> Self

pub fn target_reset(&mut self) -> Result<(), DebugProbeError>

pub fn read_register_dp(&mut self, offset: u16) -> Result<u32, DebugProbeError>

pub fn write_register_dp(
    &mut self,
    offset: u16,
    val: u32
) -> Result<(), DebugProbeError>

pub fn nrf_recover(&mut self) -> Result<(), DebugProbeError>

Tries to mass erase a locked nRF52 chip, this process may timeout, if it does, the chip might be unlocked or not, it is advised to try again if flashing fails

Trait Implementations

impl<REGISTER> APAccess<GenericAP, REGISTER> for MasterProbe where
    REGISTER: APRegister<GenericAP>, 

type Error = DebugProbeError

fn read_ap_register(
    &mut self,
    port: GenericAP,
    register: REGISTER
) -> Result<REGISTER, Self::Error>

fn write_ap_register(
    &mut self,
    port: GenericAP,
    register: REGISTER
) -> Result<(), Self::Error>

fn write_ap_register_repeated(
    &mut self,
    port: GenericAP,
    register: REGISTER,
    values: &[u32]
) -> Result<(), Self::Error>

Write a register using a block transfer. This can be used to write multiple values to the same register.

fn read_ap_register_repeated(
    &mut self,
    port: GenericAP,
    register: REGISTER,
    values: &mut [u32]
) -> Result<(), Self::Error>

Read a register using a block transfer. This can be used to read multiple values from the same register.

impl<REGISTER> APAccess<MemoryAP, REGISTER> for MasterProbe where
    REGISTER: APRegister<MemoryAP>, 

type Error = DebugProbeError

fn read_ap_register(
    &mut self,
    port: MemoryAP,
    register: REGISTER
) -> Result<REGISTER, Self::Error>

fn write_ap_register(
    &mut self,
    port: MemoryAP,
    register: REGISTER
) -> Result<(), Self::Error>

fn write_ap_register_repeated(
    &mut self,
    port: MemoryAP,
    register: REGISTER,
    values: &[u32]
) -> Result<(), Self::Error>

Write a register using a block transfer. This can be used to write multiple values to the same register.

fn read_ap_register_repeated(
    &mut self,
    port: MemoryAP,
    register: REGISTER,
    values: &mut [u32]
) -> Result<(), Self::Error>

Read a register using a block transfer. This can be used to read multiple values from the same register.

impl MI for MasterProbe

fn read32(&mut self, address: u32) -> Result<u32, AccessPortError>

Read a 32bit word of at addr.

fn read8(&mut self, address: u32) -> Result<u8, AccessPortError>

Read an 8bit word of at addr.

fn read_block32(
    &mut self,
    address: u32,
    data: &mut [u32]
) -> Result<(), AccessPortError>

Read a block of 32bit words at addr.

fn read_block8(
    &mut self,
    address: u32,
    data: &mut [u8]
) -> Result<(), AccessPortError>

Read a block of 8bit words at addr.

fn write32(&mut self, addr: u32, data: u32) -> Result<(), AccessPortError>

Write a 32bit word at addr.

fn write8(&mut self, addr: u32, data: u8) -> Result<(), AccessPortError>

Write an 8bit word at addr.

fn write_block32(
    &mut self,
    addr: u32,
    data: &[u32]
) -> Result<(), AccessPortError>

Write a block of 32bit words at addr.

fn write_block8(
    &mut self,
    addr: u32,
    data: &[u8]
) -> Result<(), AccessPortError>

Write a block of 8bit words at addr.