WattStep Group

Desktop application · Windows

Watch the bus move.

AmpTrace plots a live CAN bus in real time. Point it at your DBC file and every signal in it becomes a named, engineering-unit trace you can zoom, cursor and compare while the hardware is still running.

Rust logoWritten in Rust
Desktop monitor displaying WattStep AmpTrace

What it does

A scope for your CAN bus, not a frame dumper.

Most CAN tools show you frames and leave the interpretation to you. AmpTrace decodes every frame against your DBC the moment it arrives and puts the physical values on a plot.

Real-time plotting

The trace grows as the frames land. Nothing to refresh, nothing to wait for.

  • Stacked axes per signal, or overlaid on one scale
  • Zoom to a millisecond while the capture keeps running

Receive and transmit

AmpTrace is not a listener. Command the target and watch it answer on the same screen.

  • Received frames arrive already scaled to Nm, A, rpm
  • Encode frames in engineering units, AmpTrace builds and sends the frame

Signals find themselves

No channel list to build or maintain. Load the DBC and the signals are already there.

  • Every signal named the way your DBC names it
  • Drop any signal on any axis, regroup them mid-run

From bus to plot

Four steps, and you are looking at data.

01

Load the DBC

The file you already maintain for the vehicle or drive. No second definition to keep in sync.

02

Connect to the bus

A USB CAN adapter between the laptop and the hardware. One click to go live.

03

Frames decode

Each frame is matched, scaled and timestamped as it lands, raw bytes become physical units.

04

Plot, probe, export

Watch it live, cursor through it afterwards, or write the whole capture out to disk.

Beyond the live view

Analysis that stays in the same window.

XY plots

Put one signal against another, current against speed or torque against angle, to see the shape of a relationship instead of two lines that happen to move together.

FFT

Take any captured signal into the frequency domain to chase an oscillation back to its source: a switching artefact, a resonance, a control loop hunting. All in real time.

Compare two runs

Load a saved capture alongside a second one and hold them on the same axes. Export a session to disk and bring it back later, or hand it to a colleague.

Built-in test runner

Script the bus, or prove the product works.

Every copy of AmpTrace includes a test runner. It scales with what you are trying to do: the same sequence that saves you from clicking through a start-up procedure by hand is also, once you add assertions to it, a hardware-in-the-loop test you can put in front of an auditor.

Scripting a stimulus

A list of frames to send and how long to wait between them. Press run and the bus is driven for you: a start-up sequence, a sweep through operating points, a fault you need to reproduce for the tenth time today.

Verifying the response

Add the checks and the same sequence becomes a real test. Wait for a signal to settle, assert it lands in tolerance, hold it there to prove it stays. Each step returns a verdict with the captured trace behind it. Setup brings the target to a known state, and teardown runs whatever happens.

Suites are plain files that live in version control beside the firmware they test, so the same scenario runs identically on every bench and on every revision of the product.

Performance

Built in Rust, so the hardware sets the pace.

A viewer that stutters makes you doubt the measurement instead of the machine. AmpTrace is a native desktop application with a Rust core, so a busy bus never turns into a laggy window. What you are watching is the drive's behaviour, never the tool's.

Decoding never blocks the view

Frames are received and decoded on their own asynchronous tasks. A busy bus slows the bus, not the window you are looking at.

Only the new samples move

The display asks for what has arrived since it last drew, not the whole capture again. Long recordings cost the same per frame as short ones.

Drawn on the GPU

Traces render through WebGL, so hundreds of thousands of points stay interactive. Zooming into a millisecond of a long run is instant.

Interface

USB CAN adapter

Definitions

Standard DBC files

Platform

Native Windows desktop app

Built with

Rust · Tauri · WebGL charts

Drive software

Get everything your motor can give.

Our motor control software is already tuned for every WattStep motor and inverter. You get a drive that works from day one, written in Rust.

Talk to us about your drive
Motors
4
Inverter hardwares
2
Application protocols
3

[ For customers ]

What must your machine do, and by when?

With a shelf inverter you buy a box and a tuning job. With us you buy a drive that already works on your motor.

  • Tuning is done for you

    Your engineers do not spend months on it.

  • It fits your system

    We adapt to your controller and protocol.

  • Changes are quick

    We own the source, so a change never waits on a vendor roadmap.

  • Your own motor works too

    No datasheet needed. Our test rig extracts the motor parameters automatically and we calibrate the software to them.

[ Why Rust ]

Motor control firmware in the language the industry is moving to.

Rust catches memory errors before the firmware ever runs. Microsoft, Google, Volvo and the Linux kernel are all moving to it. Our firmware has been Rust from the first line.

What Google measured in Android

Lower memory safety vulnerability density in Rust than in C and C++2
1000×
Lower rollback rate than C++ for medium and large changes2
~4×
Less time in code review than C++ changes2
~25%
Memory safety share of Android vulnerabilities in 2025, down from 76% in 20193
<20%

What this means in our firmware

  • We started here

    Our motor control code has been Rust since its first line. The firmware holds no C or C++, so there is nothing to migrate.

  • The compiler guards memory

    Our core control library contains no unsafe code, and the compiler rejects any attempt to add it.

  • Physical units are checked

    Every quantity carries its unit in its type, so adding a voltage to a current does not compile. NASA lost the Mars Climate Orbiter in 1999 over a unit mismatch.

  • Concurrency without fear

    The RTIC framework checks at compile time that shared data is safely locked, so tasks from the current loop to communication cannot race or deadlock.

Figures come from large software projects, not motor drives. Control behavior is verified in simulation, hardware in the loop tests and on our test rig.

[ Sources ]
  1. Microsoft Security Response Center, We need a safer systems programming language, July 18, 2019.
  2. Jeff Vander Stoep, Google, Rust in Android: move fast and fix things, November 13, 2025.
  3. Google, Eliminating Memory Safety Vulnerabilities at the Source, September 25, 2024.
  4. Thomas Claburn, The Register, Microsoft is busy rewriting core Windows code in memory-safe Rust, April 27, 2023.
  5. Tweede golf, Rust is rolling off the Volvo assembly line, October 7, 2024.
  6. CISA, New Guidance Released for Reducing Memory-Related Vulnerabilities, June 24, 2025.
  7. Miguel Ojeda, rust: conclude the Rust experiment, Linux kernel mailing list, December 12, 2025.
  8. eeNews Europe, report on Ferrocene 26.02.0, March 19, 2026.
  9. NASA, Mars Climate Orbiter Mishap Investigation Board Phase I Report, November 10, 1999.
Erik Strigén, Business Developer at WattStep

[ FIRST CONVERSATION ]

Book a meeting

Erik Strigén, Business Developer, takes the first conversation about your drivetrain, timeline and requirements. Pick a slot directly in his calendar.

Book a meeting with Erik