CoreUnit

Your whole bench,
on the network.

CoreUnit gives your team remote access to a hardware-in-the-loop (HIL) test bench. It drives your debug probe and bench power supply, and talks to your board over UART, RS-485, CAN and GPIO. One cable to your network, reachable from the browser, your CI or an AI agent.

The CoreUnit: a small black box with a terminal block, an Ethernet socket and USB-C.

Watch the 4-minute demo

Everything your device under test needs.
In one place on the network.

Most benches grow one adapter at a time: a USB hub, two serial dongles, a CAN interface and a power supply someone has to switch by hand. CoreUnit is one maintained appliance in their place: the same box on every bench, with the buses built in, so the board can be tested by anyone, from anywhere, at any hour.

4USB ports

For your debug probe, a USB-serial device and the board itself.

1 GbEthernet

One cable to your network, and the bench is online.

3serial buses

UART with flow control, RS-485 and CAN.

3 + 3GPIO

Inputs and outputs for status pins, reset and boot lines.

Speaks every bus
your firmware does.

A debug UART tells you the firmware booted. It does not tell you the board works on the bus it ships on. CoreUnit puts the real links next to the console, so your tests talk to the board the way the field will.

Serial console, WisentWire 22Live
115200 8N1, RTS/CTS on
  1. 10:42:01.112TXAT+VERSION\r\n
  2. 10:42:01.118RXFW 2.4.1 build 8f3c2a
  3. 10:42:01.240TXBOOT ENTERinto the bootloader
  4. 10:42:01.252RXREADY 0x08000000
  5. 10:42:01.260TXblock 1/96, 256 BCTS high, sending
  6. 10:42:01.284RXACK
  7. 10:42:01.301TXblock 2/96, 256 BCTS low, waiting
  8. 10:42:01.329RXACK

UART, with flow control. RTS and CTS keep fast links and bootloaders behaving exactly the way they do in production.

RS-485, with termination you switch. Test a node at the end of the line and one in the middle of it, without reaching for a jumper.

CAN, on the same box. Automotive, industrial and robotics firmware, tested over the bus it actually ships on.

Bring your own hardware.

No new lab to buy. The gear on your bench today stays there, and the whole team can use it from anywhere.

Plug in your J‑Link, ST‑LINK, CMSIS‑DAP or Atmel‑ICE.

Hook up your Rigol, Siglent or KORAD supply, and many more.

CoreUnit puts them both on the network.

Generic USB probes work too. Using something else? Ask us and we will check it.

A CoreUnit on a desk with its status lights on, cabled to a debug probe and a bench power supply, with a fan under test behind it.

Keep the gear you trust. No new hardware to qualify and no toolchain to replace. The probe and the supply on your desk are the ones on the bench.

One bench, a whole team. Engineers book the unit instead of passing the probe around the office or posting it to another site.

Flash the exact build you test. A CI job flashes the binary it just built, so a result always belongs to a known commit.

Remote firmware flashing and reset, from the dashboard, a CI job or an AI agent.

Supported brands

  • STMicroelectronicsSTM32
  • AtmelAVR and SAM
  • EspressifESP32
  • Texas InstrumentsMSP430
  • ArmCortex-M
  • Nordic SemiconductornRF52 and nRF53
  • NXPLPC and Kinetis
  • KORADBench supply
  • OWONBench supply
  • RIGOLBench supply
  • ROHDE&SCHWARZBench supply
  • SIGLENTBench supply

Debug it like
it’s on your desk.

When a test fails, you do not need the board in your hands. Use remote GDB debugging through the probe on the bench, or read the firmware’s RTT log as it runs, from wherever you are.

GDB, remote session
  1. $ arm-none-eabi-gdb build/robot.elf
  2. (gdb) target extended-remote ww-22.lab:21377
  3. Remote debugging using ww-22.lab:21377
  4. (gdb) load
  5. Loading section .text, size 0x6c40 ... done.
  6. (gdb) break motor_stop
  7. Breakpoint 1 at 0x8002f1c: file src/motor.c, line 88.
  8. (gdb) continue
  9. Breakpoint 1, motor_stop (reason=EDGE_DETECTED) at src/motor.c:88
  10. (gdb) print ir_level
  11. $1 = 1873
RTT, channel 0Live
  1. 00:00.004boot: fw 2.4.1 (8f3c2a)
  2. 00:00.019clock: 72 MHz, HSE ok
  3. 00:00.120ir: calibrated, threshold 1800
  4. 00:01.532motor: start, 1000 rpm
  5. 00:03.411ir: 1873 > 1800, edge detected
  6. 00:03.412motor: stop, reason EDGE_DETECTED
  7. 00:03.415test: stop-check PASS in 3 ms

A full GDB session, remotely. Load, set breakpoints, step, read registers and memory. Use the command line, VS Code or the IDE you already debug with.

RTT logs without a spare UART. Read printf-style output straight from target memory through the probe, fast and with minimal impact on timing.

Logs that stay with the run. RTT output is saved next to the serial log and the power trace, so a failed test comes with its own story.

A power cycle is now
an API call.

The bugs that reach customers often start at power-up: a slow rail, a brown-out, a board that does not come back after a cut. Those are the tests nobody runs by hand twice. CoreUnit puts the bench supply under software control, so they run on every commit.

Switching a board on, setting its voltage and watching what it draws, from the dashboard.

Switch it off. Switch it on. Cold-boot the board the way a customer would, as often as a test needs, without anyone in the lab.

Set the voltage per test. Presets for 3.3, 5 and 6 V, or any value in range. Run at the low end of the battery before your users do.

Settings hold while it runs. Voltage and current limit lock while the supply is on, so nothing changes in the middle of a test.

Voltage and current of a board under test over a few minutes, with a readout of 7.400 V and 0.981 A.

Every milliamp, on record.

Voltage and current are logged while the test runs. Look at the last five minutes, the last half hour or the whole session, and hover any point for the exact reading.

Power becomes a test result. A board that suddenly draws more in sleep fails the build like any other regression, with the trace attached.

A short trips the limit, not the prototype.

Set a current limit for every test. A wiring mistake or a stuck pin hits the limit instead of burning the only board you have.

CoreUnit drives a programmable bench power supply over USB. Tested with Rigol DP832, KORAD and Siglent SPD1000X.

Hold BOOT low.

Press reset.

Read the LED that says it passed.

Three inputs with pull-up, pull-down or no pull, and three outputs for reset, boot and enable lines. The pins nobody wants to touch by hand, wired once.

GPIO

Hardware CI: one commit,
one run on real hardware.

Here is what happens when a pull request triggers a hardware test. GitLab CI, GitHub Actions or any other CI drives it through the API, so the runner does not need to be wired to the board. Nobody walks to the lab, and nothing depends on whose desk the board is on.

  1. Reserve the unitBookingNo one else can touch the board until the run ends.
  2. Flash the buildDebug probe over USBThe binary from this commit, nothing else.
  3. Power it upBench supplyAt the voltage the test asks for, with the current limit set.
  4. Hold BOOT, release resetGPIOInto application mode, the same way every time.
  5. Talk to itUART, RS-485, CANSend the commands, read the replies, check every byte.
  6. Measure and judgePower and GPIOCurrent draw and status pins checked against the limits.
  7. ReportCIPass or fail, with the logs and the power trace attached.

The same run can be started from the dashboard, from pytest on a laptop, or by an AI agent over MCP.

One cable to your network.
An appliance, not a project.

CoreUnit is a maintained appliance: the same box on every bench, with the buses built in and nothing to assemble or script. Plug it into Ethernet and choose where the software runs.

Cloud. Reach every bench from anywhere. We host the dashboard and keep it up to date.

On-premise. The full app on your own servers, with roles and an audit log.

Self-hosted. Free and feature-limited: the CLI, the Python SDK and the MCP server on one machine, for a single user, without the web dashboard.

Made for the whole team
around the board.

A board on the network changes the day of everyone who depends on it, not only the person who wired it.

An engineer typing next to a development board wired to a breadboard.

Firmware engineers

Flash, debug and test on the real board from wherever you work, instead of waiting for your turn at the bench.

Hands wiring a microcontroller on a breadboard.

Hardware engineers

Validate every new board revision yourself, without waiting for a firmware engineer to write the test.

An engineer working on a laptop inside a test lab.

Test engineers

Run the same hardware tests on every commit and every unit, with the logs and power trace of each run kept as evidence.

An engineer standing in an electronics lab.

Engineering managers

Share a handful of prototypes across sites and time zones, without buying a bench for every engineer.

Add extensions
when a test needs them.

Both modules stack on a CoreUnit and appear in the same dashboard. Start without them and add one when a test calls for it.

Which setup is right for you?

Cloud

€649 per CoreUnit, one-time, uses bench-days from a paid plan

We host the dashboard. Professional support in building test setups.

Buy now
  • Dashboard, API, CI and MCP on every cloud plan
  • 5 bench-days a month on Free; 45, 210 or 600 on Plus, Pro or Ultimate
  • Hands-on onboarding and rig design help
  • Direct channel to our engineers

On-premise

Quoted for your setup

The full app on your own servers.

Get a quote
  • Everything in Cloud
  • Roles and audit log
  • Help with ISO/IEC 27001 and GDPR

Self-hosted

Free software, feature-limited

The CLI, Python SDK and MCP server on one machine.

Buy now
  • Single user, no web dashboard
  • Flash, serial and power from the command line
  • The CoreUnit itself: €649 one-time

CoreUnit or CraftWisent?

Both are benches in the same dashboard and draw on the same bench-days, and a CoreUnit needs a paid plan. CraftWisent is software for the Linux PC already on your bench. CoreUnit is the box for what a PC cannot do.

CoreUnit

€649 one-time, uses bench-days from a paid plan

A maintained appliance on your network.

Buy now
  • GPIO, PWM, DAC and signal generation
  • UART with flow control, RS-485 and CAN built in
  • The only base for SensorHub and SensorSim
  • The same box on every bench, nothing to assemble

CraftWisent

Free to start Launching 1 December · Linux only

Bring the setup you already have.

Start free
  • Control of the power supply already on your bench
  • Serial and CAN through your USB dongles
  • Flashing and debugging through your debug probe
  • Bench reservations, log retention, SDK and MCP server

SensorHub and SensorSim stack on a CoreUnit and do not attach to CraftWisent benches. Explore CraftWisent

Tech specs

USB

Ports
4

Serial buses

UART
TX, RX, RTS, CTS
RS-485
Termination switched from software

GPIO

Inputs
3, pull-up / pull-down / none
Outputs
3

Programmers

Debug probes
Market-leading and generic USB probes
Targets
STM32, AVR and SAM, ESP32, MSP430, and more

Debugging

GDB
Remote session through the probe on the bench
RTT
Live log, saved with every run
Toolchains
probe-rs, OpenOCD, J-Link. RTT currently via OpenOCD or J-Link.

Power control

Supply
Programmable bench supply: Rigol DP832, KORAD, Siglent SPD1000X
Control
On, off, voltage, current limit
Measurement
Voltage and current over time

Network

Ethernet
Gigabit
Deployment
Cloud, on-premise or self-hosted (CLI)

Software

Dashboard
Web, included
Automation
API, Python SDK, MCP server

Physical

Expansion
Stacks with SensorHub and SensorSim

CoreUnit questions

Anything else? Email the team.

How long does the setup really take?

Under 30 minutes for a first board: connect the CoreUnit, wire up the target, and it shows up ready to power and flash.

Which programmers and boards are supported?

Our own demos run on STM32 and MSP430. Other targets, such as AVR and SAM or ESP32, go through probe-rs, OpenOCD or J-Link with the probe you already use: J-Link, ST-LINK, CMSIS-DAP, Atmel-ICE or a generic USB probe. Using something else? Ask us and we will check it.

Do I need a CoreUnit, or is CraftWisent enough?

CraftWisent is enough when your tests need power control, serial or CAN through USB dongles, flashing and debugging: it runs on the Linux PC already on your bench and launches on 1 December. You need a CoreUnit for GPIO, PWM, DAC and signal generation, and as the base for SensorHub and SensorSim.

Do we have to use your cloud?

No. On-premise runs the full app on your own servers, with roles and an audit log, and is quoted for your setup. Self-hosted is free and feature-limited: the CLI, the Python SDK and the MCP server on one machine, for a single user, without the web dashboard.

Can an AI coding agent use it?

Yes. WisentWire ships with an MCP server, so Claude, Cursor and other agents can flash firmware, switch power and run tests on real hardware.