Instruments · Software · Open source

Where code meets hardware

Instruments for embedded development, and the open-source software behind them.

draft Copy not yet read by Marketing and PM. Board renders follow.

Portwright, the B153 board, three-quarter view
FIG. 1B153 Portwright

01Products

Hardware for the bench

Three tools for bring-up, debugging and test, each with a Rust driver, a CLI and a GUI.

Portwright, the B153 board, three-quarter view
FIG. 2B153 Portwright

Portwright Coming Q1–Q2 2027

A USB-C dongle with a USB 2.0 hub, a VBUS switch with a power meter, and UART, I2C and SWD on the plug's sideband pins.

Hub
USB 2.0 Hi-Speed
SBU
UART, I2C, SWD, FDCAN
VBUS
switch to 20 V, 5 A + meter
Pinsmith board, three-quarter view
FIG. 3B200 Pinsmith

Pinsmith In development

Digital and analog I/O over USB. No programming needed.

Link
USB
Digital
USART, SPI, I2C, 1-Wire
Levels
selectable
USB to isolated CAN FD bridge, three-quarter view
FIG. 4B135 USB to CAN FD

CAN line In development

USB and Ethernet bridges to isolated CAN FD, with SD card logging, and the adapters around them.

Bus
CAN FD, isolated
Host
USB or Ethernet
Connector
DB-9

02Portwright · B153

One cable to your board

Portwright sits between your computer and a device with a USB-C port. One cable carries USB, the device's sideband pins and power you can switch and measure.

  1. Hub and sideband pins in one plug

    A USB 2.0 Hi-Speed hub, and UART, I2C, SWD, FDCAN, GPIO and ADC on the plug's SBU pins. The cable orientation is a setting: a flipped cable is one command, not re-plugging.

  2. Power under control

    A VBUS switch up to 20 V and 5 A, off at power-up, a power meter, and a switch on the device's USB data lines. Guards in the firmware cut VBUS at a voltage, current or power limit.

  3. Scriptable

    A CLI, pw, with a Rust library and a Python wheel behind it, and a CMSIS-DAP debug probe for probe-rs, OpenOCD and pyOCD.

For bring-up, debugging, flashing and production test of devices with a USB-C port.

03Software

See what your device says

IOWeaver plots what your device says. RockFace debugs the firmware that says it. WireWeaver keeps both sides speaking the same API.

IOWeaver

Protocol analyzer and grapher. Record, decode, plot and send. It ships with Pinsmith and Portwright.

RockFace draft

Firmware debugger: logs, stack and CPU use, zero-cost profiling, logs from a fleet. Commercial release: TBD.

WireWeaver

One API definition for device and host: RPC, streams and properties, backwards and forwards compatible. Open source.

Screens, terminal runs and code on the software page

04From the lab

Selected work

Four pieces from VHRD's own bench: Ethernet and USB to CAN FD, a laser scanner and a firmware debugger.

B125 Ethernet to two isolated CAN FD bridge, three-quarter view
FIG. 5B125

Ethernet to CAN FD In development

Ethernet to two isolated CAN FD buses, with SD card logging.

Bus
2× CAN FD, DB-9
Power
PoE, bus or USB
Logging
SD card
B135 USB to isolated CAN FD bridge, top view
FIG. 6B135

USB to CAN FD In development

USB High Speed to isolated CAN FD, with SD card logging.

Bus
CAN FD, DB-9
Host
USB HS
Logging
SD card
A circuit board held between the scanner's linear rails and carriages
FIG. 7AOI

3D laser scanner

Optical inspection of solder paste and placed parts with a scanning green laser line.

Resolution
15 µm
Optics
F-Theta, telecentric
Stage
2× CoreXY
RockFace timeline view: sleep spans and events of a running firmware over time
FIG. 8RockFace

RockFace draft

A firmware debugger for running systems. Commercial release: TBD.

Logs
from a fleet
Graphs
stack, CPU use
Profiling
zero-cost

More work

05Open source

From register to GUI

The products stand on open crates, all Rust: the API and its wire format, units checked at compile time, and a bare-metal firmware template.

  1. ProductsPortwright · Pinsmith · CAN line · IOWeaver · RockFace
  2. API
  3. Wire format
  4. Units
  5. Firmware

    embedded_bedrock

    not on crates.io yet

    A bare-metal firmware template with ruggedizing, debugging and logging built in, and optional embassy, RTIC and HAL support. The template is an agent skill that generates a firmware for a chip, with its errata notes, blink codes on the status LED when it cannot start, and a clock a host keeps in step across boards. Most STM32s and a few MCUs from other vendors are covered.

    use bedrock_led::code::*;
    use bedrock_sync::{Config, Sync};
    use cortex_m::asm::delay;
    
    // A firmware that will not start
    // says why on its status LED, then
    // waits in the ROM bootloader.
    if !guard.runs_board() {
        let pause = |n| delay(n * KHZ);
        blink(Code::UnknownRework,
              led, pause);
        reboot_into_rom_bootloader();
    }
    
    // One clock on all boards, steered
    // by the host over WireWeaver:
    // Acquiring, Locked within 2 ms.
    // `ww sync` locks the boards in
    // 1.2-1.6 s. On Portwright it costs
    // about 1.5 KB of flash.
    static SYNC: Sync =
        Sync::new(Config::DEFAULT);
    
    // clock.steer, once a second
    let r = SYNC.with(|clock, now| {
        server.steer(clock, now, &p)
    });
    
    // all boards act at the same µs
    SYNC.wait_until_shared(t).await?;
    use bedrock_led::code::*;
    use bedrock_sync::{Config, Sync};
    use cortex_m::asm::delay;
    
    // A firmware that will not start says why on its status LED, then
    // waits in the ROM bootloader.
    if !guard.runs_board() {
        let pause = |n| delay(n * KHZ);
        blink(Code::UnknownRework, led, pause);
        reboot_into_rom_bootloader();
    }
    
    // One clock on all boards, steered by the host over WireWeaver:
    // Acquiring, Locked within 2 ms. `ww sync` locks the boards in
    // 1.2-1.6 s. On Portwright it costs about 1.5 KB of flash.
    static SYNC: Sync = Sync::new(Config::DEFAULT);
    
    // clock.steer, once a second
    let r = SYNC.with(|clock, now| { server.steer(clock, now, &p) });
    
    // all boards act at the same µs
    SYNC.wait_until_shared(t).await?;
  6. Firmware

    When logging is not an option, count. Each count statement gets its own counter in a RAM array, through a linker trick like defmt's, without a critical section, so it is safe in any interrupt; on Cortex-M3 and up a counter shared with an interrupt never loses an update. The cnt tool reads the counters over the debug probe, once, as a watch or in a TUI, with the defmt log beside them.

    // one RAM counter per call site,
    // no critical section, safe in an IRQ
    fn high_frequency_irq() {
        let r = do_something();
        cnt::cnt_if!(r.is_err(),
                     unpack_errors: u64);
    }
    
    fn process_packet() {
        cnt::cnt!(packet_count: u32);
    }
    
    // on the PC, over the debug probe:
    // $ cnt tui --chip STM32H533RE
    // one RAM counter per call site,
    // no critical section, safe in an IRQ
    fn high_frequency_irq() {
        let r = do_something();
        cnt::cnt_if!(r.is_err(), unpack_errors: u64);
    }
    
    fn process_packet() {
        cnt::cnt!(packet_count: u32);
    }
    
    // on the PC, over the debug probe:
    // $ cnt tui --chip STM32H533RE

All open-source crates

06Stay in the loop

Hear when Portwright launches

Portwright launches on Crowd Supply. Leave your address and you hear first, when the campaign opens. draft

Check your mail. If the address is new, a mail to confirm it is on its way. Nothing goes on the list until you press its button.

Rather send a mail? Write to portwright at vhrd.tech. What Portwright is

Contact

Questions about the boards, the software or a project of your own: contact at vhrd.tech.

Engineering services are rare right now. What I do and how I work