Designs get shipped out and prototypes arrive, but that first power-on oftentimes requires a bed-of-nails fixture, instrument racks, and custom software. Building a test stack in-house can take weeks or months away from an engineering team’s busy schedule, making product validation a significant roadblock to quick iteration and turnaround.

Best-in-class test infrastructure is the key to accelerating hardware progress. Both Nominal and Fixturfab are working on this singular mission: accelerate test. Test should be safe, repeatable, automated, traceable, and seamless. Nominal and FixturFab are making this a reality.

FixturFab provides mechanical fixtures, turnkey test systems, and software support for sourcing, configuring, and designing tests. Nominal Connect provides the custom test applications and UIs to streamline read/write workflows and stream data to Nominal Core, our cloud-based timeseries database and analysis platform. In this post, we break down how engineers can use Nominal Connect together with FixturFabs’ products to accelerate test & validation.

FixturFab’s best-in-class circuit board test fixtures

FixturFab tackles the pain of testing head-on with an integrated platform for building & operating your hardware test stack:

1. Mechanical fixtures: FixturFab offers quick-turn development jigs for early boards, rugged production clamshells for high-volume lines, and a middle-ground “Dev Pro” option. All use laser-cut probe plates and alignment tooling, so you can simply drop a PCB in and start probing.

2. Turnkey test systems: Desktop or rack enclosures that bundle power supplies, DMMs, relay matrices, safety interlocks, and calibrated wiring.

3. Flexible software stack: Open-source Python libraries that handle instrument I/O, test sequencing, and real-time result logging. Scripts you write for prototypes can run unchanged on the production line.

4. FixturFab Studio: A web portal where you upload CAD or Gerbers, get automated test design feedback, configure fixture options, and track documentation. Streamline your hardware testing with one unified platform for sourcing any solution – from fixtures to turnkey systems – for prototypes through production. FixturFab is moving fast here – stay tuned for new updates!

Why this matters

• Speed – FixturFab claims its platform can cut test-development lead time by up to 80%. That can bring a multi-iteration consumer-electronics program to market months earlier, or let a hardware startup ship revision-B boards before the runway runs out.

• Consistency from proto to production – Using the same fixture geometry, instrumentation drivers, and test APIs across life-cycle stages eliminates “works-on-my-bench” surprises and simplifies ECO roll-outs.

• Lower total cost – Outsourcing only the probe plate still leaves you integrating power rails, relays, and code yourself. FixturFab’s all-in approach bundles those costs – and the risk – into a predictable line item.

Who’s using it?

Customers range from IoT startups flashing firmware on ten boards a week to large automotive suppliers running pneumatic clamshells on 24/7 conveyor lines. Because the mechanical footprint is standardized and the software is Python-centric, engineers can start small and scale without ripping up infrastructure allowing them to enjoy continuous integration, automated testing, and cloud analytics.

FixturFab brings velocity to PCB validation - in an industry where time-to-test is becoming the new time-to-market.

Nominal Connect + FixturFab

Manually probing every board with a DMM and scope would burn hours. So we paired FixturFab’s pogo‑pin fixture with Nominal Connect to create a reusable test‑app that runs PCB test suites in minutes. To test out the bed-of-nails, we used this FixturFab test PCB:

And we’ll run a suite of tests including, but not limited to:

• short detection

• voltage measurement

• GPIO functionality verification

• USB functionality verification

To do this, the bed of nails will probe the underside of our PCB at certain points and check path resistances, apply voltage and measure potentials, and verify communication protocols are all within spec. For example, to ensure the the 5V potential on the board is not shorted to ground, the device measures the continuity between the 5V probe and a GND probe: if there is no continuity, we’re in the clear.

The test logic lives on the FixturFab itself, while the configured Nominal Connect GUI displays the test results. To learn more about how to write a test suite and view your test results using FixturFab’s hardware, visit FixturFab documentation here.

Custom Nominal Connect app for FixturFab

The Nominal Connect App we built to test our circuit board poses as a configurable GUI connected to a python backend with test cases written by the user.

After a successful login, all test info and configured settings will appear - you can update the current profile with different test plans, admin status, and passwords using the “Update Profile” button. To log into a different profile, simply enter in the details in the login section and run “Login”. The bottom panel shows the current run. To start a run, simply enter the DUT Serial Number and click “Start Test”. As the test runs, the results of each test will appear on the right hand side.

In the Runner tab within Settings, you’ll see all the crucial connection details for your test runner including the Frontend, Backend, and Pytest‑container IP addresses so that you can pipe data in over WebSocket.

The Previous Runs panel at the bottom of the test app lets you review every run from the current session, then selectively download the ones you want to keep or wipe the ones you don’t.

Pass vs Fail

Now, testing the app on an actual piece of hardware, we get the following result:

In less than 30 seconds we were able to detect that something is wrong with our board - it’s not receiving power to the 5V rail… back to the drawing board!

After some debugging, we think we’ve solved the issue and we slide our PCB back into the tester.

Nice! We’ve got the board working now - onto the next one!

All of this data will be streamed, indexed, and stored in Nominal Core, where engineers can explore the data deeper, observe historical trends, and trace components through the entire development lifecycle.

Conclusion

By bridging FixturFab’s reliable hardware with Nominal Connect’s Python‑driven test runner, we collapsed board‑bring‑up time and killed the two biggest bottlenecks in functional testing: human error and poor traceability.

If your team is still juggling probes by hand, it’s time to let FixturFab and Nominal Connect do the probing while you get back to designing the next board.

Complex hardware systems are no longer static objects. They continuously adapt and evolve. Operational assets across aerospace, energy, robotics, and more can behave entirely differently, operate entirely differently, based on software updates. They are software-defined.

This is one of many reasons that hardware test has radically changed over the past year. Test is no longer a phase in development, it’s persistent process woven directly into operations. Every update generates new behaviors, data profiles, and learnings. As we like to say at Nominal: Every asset is a test stand. The fastest companies use their vast stores of operational data as the foundation for new development. Their testing is connected, from development through operations – and back.

This new reality is relevant from fleets of autonomous vehicles down to individual radio frequency signals – every update demands immediate validation in real-world conditions.

In this post, we explore one practical example of testing a software-defined system in Nominal.

RF spectral analysis in Nominal Connect

Countless industries and technologies depend on radio frequency (RF) signals. For the engineers building and testing these systems, it is critical to be able to collect, analyze, and visualize RF data in real time.

Nominal Connect provides RF engineers with a clean and intuitive software platform for ingesting and displaying RF data live. With a customizable and low-code UI/UX, engineers can command RF sensors, ingest signals, and display real-time data all in a single platform.

Read our post on antenna impedance characterization

Software-defined radio (SDR)

Traditionally, key radio components such as mixers, filters, amplifiers, and modulators/demodulators were implemented in specialized analog hardware. With advances in modern computing and analog-to-digital converters, many of these components can now be implemented and updated via software (AKA ‘Software-defined’). Migrating these components into software enables a single radio to receive and transmit a wide range of different waveforms without the need for custom hardware, making SDRs flexible, adaptable, and low-cost.

Using Nominal Connect to analyze RF data from an RTL-SDR

RTL-SDR is an ultra-low-cost commercial SDR capable of receiving frequencies ranging from 500 kHz to 1.75 GHz, depending on the particular model. With an SMA connector at the front-end and a USB interface, the RTL-SDR can be paired with an antenna and commanded from an external operating system. There are open source libraries for commanding the RTL-SDR and streaming live IQ data. Users can make use of Python wrappers to write simple scripts for interfacing with the RTL-SDR.

Connect offers several customizable widgets specifically for RF spectral analysis, such as a Power Spectral Density (PSD) plot and a Spectrogram. The video below is a screen capture of a Connect application built specifically for interfacing with an RTL-SDR and visualizing the received RF data in real time. In under 75 lines of code, the underlying Python script accepts user inputs to configure the SDR and returns live IQ data that is ingested by Connect to display the plots shown.

Accelerating hardware in a software-defined world

With simple, customizable interfaces for controlling & observing SDRs, engineers get clear feedback on every update. Rather than sifting through batched or unstructured data, engineers iterate in real-time and deploy their system to the next critical use-case.

Beyond this functionality, Nominal Connect also integrates seamlessly with Nominal Core for deeper analysis & historical comparisons. Data from every software update is stored, indexed, and queryable. With every version & iteration at their fingertips, engineers can quickly identify trends or out-of-family behavior. No matter how often your hardware updates, Nominal lets you adapt quickly – with confidence.

Robot Framework is one of the most versatile automation tools in the world. Over the past 20 years, it has served everyone from lone test engineers to enterprise‑scale teams.

Robot Framework is an open source Test Executive for acceptance testing, acceptance test driven development, behavior driven development, and robotic process automation – instead of developing test executives in-house or buying expensive off-the-shelf products. Robot Framework can be used in distributed, heterogenous environments where interfacing with many different technologies is necessary. At its core, it is an automated test runner that supports process and component validation.

How is Robot Framework different?

• Keyword-driven, tabular syntax – Tests are written in plain text tables rather than code, readable as executable specs. Easy readability makes Robot Framework quick for onboarding and iteration.

• Extensible library architecture – Robot Framework includes over 200 libraries covering most domains. Plus, anything the built‑in libraries don’t cover can be added via Python, Java, or .NET. A “batteries‐included plus easy to add more” ecosystem

• Integration & execution – Robot Framework keywords can call external tools, CLI commands, REST endpoints, UI drivers, or custom scripts in almost any programming language. This leads to extremely versatile execution.

• Cross‑platform – Robot Framework runs wherever Python does and can even orchestrate tests on remote hosts.

Common real‑world use cases

1. Web UI regression and End-to-End flows

SeleniumLibrary and the newer Browser library give teams the power to validate complex browser interactions across Chrome, Firefox, Safari, and mobile emulation.

2. API & micro‑service verification

Libraries such as RESTinstance, RequestsLibrary, and HTTP deal with REST/GraphQL/SOAP calls, enabling quick, data‑driven contract and integration tests that slot straight into nightly pipelines.

3. Mobile app testing

AppiumLibrary exposes Android and iOS devices (real or emulated) to the same keyword syntax, so a single test suite can drive both platforms with minimal duplication.

4. Robotic Process Automation

With the RPA Framework libraries, Robot Framework steps outside classic testing to automate Excel, PDFs, ERP systems, and web portals.

5. Hardware Acceptance Testing

Because keywords can call serial ports, SSH sessions, or proprietary tools, hardware teams use Robot Framework to validate firmware flashes, sensor data, or even RF measurements in continuous delivery setups.

A five‑line syntax example

*** Settings ***
Library    Browser    # Playwright‑powered browser lib

*** Test Cases ***
Login And See Dashboard
    New Browser    chromium
    New Page    <https://example.com>
    Click    text=Login
    Fill Text    id=username    johnsmith@example.com
    Fill Text    id=password    password
    Click    text=Submit
    Wait For Elements State    text=Dashboard    visible
    Should Contain    ${page.title}    Dashboard
    Close Browser

Even without much background, these test files are still easy to read.

Nominal Connect as UI for Robot Framework

Nominal Connect is our test application framework for real-time automation, analysis, and data capture at the edge. Engineers can easily create custom visualizations and control interfaces for their common tests, with seamless integrations with existing frameworks and libraries. It provides a high-performance, low-code UI to operationalize Robot Framework.

Let’s explore one application of this system in detail: Motor Response Validation.

By merging Nominal Connect and Robot Framework, we are able to both run validation tests and visualize the behavior of our devices. Our system, outlined graphically in Fig. 2, will attempt to connect a Laptop running Nominal Connect to both an Arduino UNO and a FLIPSKY ESC. The Laptop will proceed to send (pin HIGH/LOW) commands to the Arduino and test whether the messages are being sent and received (read HIGH/LOW state of pins). If successful, the Laptop will send actuation commands to the ESC and ensure that the motor spins using the built-in Hall sensors.

Figure 2: Wiring Diagram for the test suite. Pin D8 on the Arduino is the message send, Pin D9 is the interrupt, pin D6 checks for message send status, and pin D7 checks for message reception. When Pin 8 is high (message send) and Pin 9 is low (message interrupt), the MOSFET is on so both Pin 6 (check message send) and Pin 7 (check message received) are high. If both Pin 8 and 9 are high, then the MOSFET is off and Pin 7 reads low (Pin 6 stays high). Note that the motor controller and Arduino are configured to two different ports in Connect - the visual representation is a simplification.

The tests we are looking to run are the following:

1. Can we connect our system to an Arduino?

2. Can we connect our system to a VESC?

3. Can we send commands to the Arduino?

4. Can we read commands to the Arduino?

5. Can we see the motor spinning if we send an actuation input?

To do this we created the following Connect App where you can configure the test UI with a .yaml:

This app provides space for the user to define the Arduino and VESC connection ports and baud rates, as well as toggle switches to open the communication lines and inject data interruption. Once all the ports are configured and the switches set, the user can run the suite of Robot Framework tests to validate whether their system is working as expected.

Robot Framework turns every public method into a keyword whose name is the method name with underscores changed to spaces - test_arduino_connectivity → “Test Arduino Connectivity” is therefore mapped automatically.

At runtime, Robot will:

1. Start and run Setup Test Environment

2. Run through each test case by calling each function’s matching keyword

3. Assert whether the function result is True/False

4. Tear down the test environment, closing the ports

Now that we understand how the process works, we can look at a couple of test runs with different system conditions:

Test Runs:

No arduino or VESC connectivity:

Message interrupt:

Message sent, no VESC connectivity:

All tests passed:

Intuitive, scalable test automation

Robot Framework provides sophisticated test automation without the complication. Its plain‑text, keyword‑driven and expansive library ecosystem lets the same suite validate everything from web UIs to hardware‑in‑the‑loop rigs. Pair it with Nominal  Connect for a high‑performance, low-code UI on top of the test application.

Learn more about Nominal Connect

For more information about Robot Framework, visit here.

Antennas have become ubiquitous in modern technology, serving a vital role in the transmission and reception of RF signals across a diverse set of applications. Their influence ranges from the cell phones we carry in our pockets to the missile defense radars that line our coasts. They are therefore critical hardware components that require extensive test and validation campaigns.

Impedance matching is an important part of the antenna design and test process that ensures the antenna performs with maximum efficiency within the desired frequency ranges. For RF test engineers, antenna characterization can be an involved and difficult process, as it requires repeated calibrations, measurements, and analysis with benchtop instruments such as a Vector Network Analyzer (VNA). As antenna production continues to grow, test engineers are forced to perform tedious, critical testing – again and again and again.

To effectively operate and execute these tests, test engineers need first-class computer-based automation, extensive python script libraries, and an intuitive interface for executing and interpreting tests.

That’s where Nominal Connect comes in.

Nominal Connect: The platform for antenna benchtop instruments

Nominal Connect provides test engineers with a platform to calibrate and command benchtop instruments, gather measurements in real-time, and save sweep parameters. In particular, it unlocks value for test engineers by operationalizing python scripts for hardware.

Nominal Connect provides customizable Human-Machine Interface (HMI) framework on top of Python scripts. Without an HMI, these Python scripts are run directly on the command line, creating failures, inflexibility, and information siloes. With Connect’s Python-first SDK, engineers can take advantage of open-source instrumentation libraries such as PyVISA to easily communicate with numerous benchtop instruments.

In the case of impedance characterization, in less than 30 lines of Python code, an engineer can:

• Establish connection to a VNA

• Set sweep parameters (bandwidth, start/stop frequency, power level, point count)

• Run a frequency sweep

• Measure and return S-parameters of the device-under-test (DUT)

Nominal Connect’s real-time visualization and customizable GUIs unlock the extensive capabilities of python-based hardware engineering. Furthermore, Connect integrates with Nominal Core, which provides saved test sequences, cloud-based sharing of results across teams, and a timeseries database purpose-built for hardware engineering.

Setting parameters and running the sweep

Primary parameters for a VNA sweep include:

• Start frequency: the beginning frequency of the sweep

• Stop frequency: the final frequency of the sweep

• Point count: the number of discrete frequency steps within the sweep range

• Power level: the power level of the VNA source signal

• Bandwidth: the bandwidth of the intermediate frequency (IF) filter

With Connect’s framework, an engineer can build a simple and intuitive interface that allows users to input values for these parameters and send commands to configure the VNA accordingly. No need to rewrite messy config files every time you want to run a sweep, just input the desired values and click “Run Sweep.” Connect’s real-time visualization will show you the measurements and give results immediately.

Saving results

Once a run is complete, an engineer can easily save the collected measurements to a CSV or Touchstone file, documenting the results of the test and making the data accessible, queryable, and shareable.

Pre-designed Smith Chart widget pre-built into Nominal Connect UI, saving engineer time

Nominal Connect handles the data;
RF engineers focus on the mission

By building an application in Nominal Connect that streamlines much of the antenna impedance matching process, an RF test engineer can save several hours of time spent on debugging scripts or building a UI, and instead focus on collecting measurements, drawing insights, and sharing results – to build at scale, faster.

Modern robotic perception relies on integrated data. Today’s systems routinely combine camera feeds, LiDAR, IMUs, and GPS, all of which must be precisely aligned in both time and space. A single run can produce thousands of synchronized frames that need to be replayed, inspected, and understood within their operational context.

LiDAR point clouds are especially critical because they provide information that cannot be adequately expressed in video. They are essential for accurate object detection, SLAM, and other 3D perception workflows.

But point clouds and machine vision are hitting a breaking point. Hardware development cycles are accelerating, robotic fleets are growing, and engineers are struggling with massive, continuous streams of spatial data. Engineers require tools that support rapid iteration and immediate feedback rather than slow, outdated batch processing. They need to move faster than ever with more data than ever.

Without a system capable of efficiently ingesting and analyzing this data, progress stalls. Visualizations choke, engineers lose visibility and insights, and timelines slow across development, production, and operations.

With Nominal, robotics engineers finally have a solution that works for them:

• Nominal Core is purpose-built to handle this scale, enabling fast and organized access to years of multimodal sensor information.

• Nominal Connect now offers full support for time series point clouds, integrating them seamlessly alongside telemetry, video, and event data.

Nominal equips engineers to leverage high-resolution point clouds at scale – a critical capability to improve perception, validate performance, and de-bug autonomous systems with precision and context. Let’s dive in.

Scan of tree growth, toggled by different years

The unsolved problem with time series spatial measurements

1. The data floods in: A single high performance LiDAR sensor can generate gigabytes of 3D data every minute. That kind of firehose quickly overwhelms traditional tools.

2. It’s not like video: Point clouds don’t sit neatly on a grid like pixels. They’re scattered in space. Mostly empty, noisy, and lacking the structure most algorithms rely on. Efficient handling means thinking in sparse formats, not dense arrays.

3. Everything must align: Depth sensing is just one piece of the puzzle. To make sense of what a robot “saw,” you need to align 3D scans precisely with the camera feed, inertial measurements, and control logs. Even a few milliseconds of drift between sensors can throw everything off.

4. Speed matters: Whether you’re navigating live environments or replaying a test run, engineers expect responsive tools. Waiting minutes to load a single scan or scroll a timeline breaks the feedback loop.

5. No standard format: Point cloud data comes in a zoo of file types, LAS, PCD, E57, and more. Stitching them together requires significant effort, especially in a time series context. Most traditional databases weren’t designed to handle 3D geometry in motion.

These challenges strain the entire pipeline, from initial collection and storage to in-depth analysis. Without the right tools, engineers spend more time wrangling data than building systems. They’re bogged down in compute costs rather than delivering features.

Drone taking point cloud scan of warehouse

The solution: Nominal’s unified 4D sensor platform

Nominal now treats temporal scans as first class citizens, fully integrated into Connect, our edge platform. The system is purpose-built to operate at scale, starting with high throughput ingestion. Machine Vision sources can connect directly, with each scan automatically tagged, timestamped, and streamed into cloud storage, thereby eliminating the need for manual handling or custom scripts.

Time alignment

Once ingested, point clouds are precisely time aligned with other sensor streams, video feeds, actuator commands, encoder logs, and more. This synchronized timeline gives engineers a clear window into what the robot ‘experienced’ at any given moment, allowing them to correlate sensor input with behavior or decision-making.

Differentiated environments

To bring this data into context, Nominal supports visualization of URDF datasets. Point clouds are rendered within the robot’s own frame of reference, giving structure to what would otherwise be unstructured spatial data. Engineers can see exactly which part of the environment produced which cluster of points, making it easier to interpret scenes and validate system responses.

Flexible queries

The platform also supports rich, flexible queries. Users can search by timestamp, location, sensor, or even event tags, then run on demand analytics such as point density calculations, bounding box occlusion, or comparisons against known object positions. These tools surface insights immediately, without requiring offline post processing.

Performance at scale

All of this runs on infrastructure built for performance at scale. Whether you’re working with a brief test run or years of archived missions, Nominal’s indexing engine and parallel compute keep interactions responsive and data accessible. The result is a unified perception workflow that eliminates friction and keeps pace with the speed of development.

Querying & toggling massive datasets in real time

Supporting machine vision today

Nominal’s point cloud support is already transforming how teams interact with complex spatial data across industries.

Flight test engineers can now replay Structure from Motion (SfM) models side by side with inertial data, allowing them to precisely correlate visual reconstructions with real world motion and system behavior.

Robotics teams use Nominal to investigate failures in detail by inspecting the exact 3D environments their machines encountered. Either frame by frame or aggregated over time. This lets them compare what actually happened against known object positions or expected behaviors, improving both debugging and validation.

Fleet operators rely on continuous spatial streams to maintain and refine high precision maps. With Nominal, they can detect positional drift automatically and keep maps up to date without relying on slow, manual stitching or post processing workflows.

Enabling the future of autonomy

As autonomy systems grow more complex, sensor fusion must become repeatable, transparent, and collaborative. Nominal’s tooling helps bridge the last mile between rich data and reliable insight, turning sensor logs into something teams can leverage at scale. Helping both robots & engineers understand the world.

If you’re building robots or vehicles and want to explore how time series spatial data management can slot into your workflow, schedule a demo with us and send over your toughest point-cloud dataset.

This section explains CAN communication, along with an implemented example using a CAN line to read thermocouple data and display it using Nominal Connect. If you are already familiar with CAN bus and want to see how you can use Nominal Connect to intuitively view your data, skip to “Reading and Logging Thermocouple Data using Nominal Connect”

Controller Area Network (CAN) is a twisted-pair wire communication protocol that is widely used in the automotive and machinery industry due to being extremely robust, efficient, and versatile. Its prevalence in control systems make its attributes, advantages, and use cases critical to understand.

Instead of having hundreds of wires running from electronic control units (ECUs) to sensors and other ECUs all throughout the car, CAN allows messages to be both sent and received along a single “information highway” to which every module is connected. This works because every message is sent with a unique identifier: for example, a CAN message ID of 123 might be sending information about the engine temperature while a message with ID 482 might be relaying current front left tire pressure.

Having everything on a single “information highway” allows for components to be interconnected and listen for the information they need by querying with the IDs. This leads to less cable usage, allowing for weight and cost reductions.

Technical details

The many advantages CAN has over other communication protocols require a technical deep dive to be better understood. These topics include OSI layers, differential signaling, reflection mitigation, and frame composition – all explained below.

OSI layers

The Open Systems Interconnection (OSI) model is a reference model that provides a basis for standards of development in communication systems. There are 7 layers, with complexity increasing along with layer number. The layers also build atop one another, so layer 2 will live above and utilize layer 1. CAN works as a layer 2 communication protocol.

Physical layer (Layer 1)

Layer 1 represents the point-to-point physical medium used to connect two communication nodes. This connection can be copper (electrical signals), fiber optic cable (light signals), or WIFI (RF signals). Layer 1 sets the standards for transmitting and receiving signals such as: voltage level, timing rate, modulation, connectors, and (very important for CAN communication), baud rate, cable length, and termination. For successful communication, both nodes must agree on encoding and decoding.

Once you start dealing with multiple nodes, point-to-point connections get complicated, so it is useful to have a central hub that everything connects to and which can repeat the signal to the other nodes. Anything received at these hubs automatically gets sent to every other port, but this includes errors and collisions. This highlights the largest drawback of utilizing purely layer 1: there is no active signal detection preventing multiple nodes from sending a signal simultaneously which leads to signal corruption. Therefore, Layer 1 networks do not scale well, which is why we build up to layer 2.

Data-Link Layer (Layer 2)

The Data-Link Layer, as mentioned above, runs over Layer 1: a module using Layer 2 will “step down” its information, transmit it along layer 1, and then “step up” to Layer 2 at the receiving end. For simplicity, we can simply abstract Layer 1 away for now. Layer 2, instead of focusing on physical wavelengths, creates frames of information. Devices on Layer 2 also have unique MAC addresses (hexadecimal, not applicable to CAN which uses message IDs) which are assigned to pieces of hardware (have both a manufacturer and specific module component). You can think of a frame as a container for your information, which is divided into the sections shown below:

The improvements that Layer 2 provides over Layer 1 include: collision detection, error handling, and arbitration. Before sending a message, Layer 2 checks to see if there is currently a message on the line, and if so, will wait to send the message until the line is clear. If two signals end up being sent at exactly the same time, the collision detection will jam the signals on all devices which detected the collision and have a randomly set backoff time, after which the collisions will be mitigated. Layer 2 also provides non-destructive bitwise arbitration which helps manage CAN bus access and avoid collisions.

There are standardized CAN bus protocols that establish a common ground between manufacturers, some examples being SAE J1939, ARINC, and UAVCAN.

Differential signaling and reflection Mitigation

CAN communication is extremely resilient to outside noise because it uses differential signaling. Essentially, CAN messages are sent as the difference in voltage between two wires (CAN High: 2.5V-3.5V, CAN Low: 1.5V-2.5V) as opposed to the nominal value of a singular wire. This way, even if electromagnetic disturbance is present, it will affect both signals equally and their difference will thus remain equal. This is also why CAN wires are twisted: if one wire is constantly further from the disturbance it will create unequal disturbance between the wires.

CAN is also resilient against reflections. You can imagine electrical reflections as waves crashing against a wall - the energy from the wave is reflected back into the water which disturbs the incoming waves. This is a problem when dealing with electrical signals, because these reflections will distort and corrupt the signal, leaving the message a garbled mess. By including 120-ohm termination resistors at the nodes, we can implement impedance matching to provide consistent impedance and absorb signal energy. One caveat of using CAN is that you have to ensure that the wires/traces are length-matched so that the data signals obey the hold time requirements of the receiving chip: the data signals must remain within a certain relative timing window to the clock signal. There is also best practice guidance for maximum node length based off of bitrate: (1 Mbit/s: ~25m, 500kbit/s: ~100m, 250kbit/s: ~250m, 125kbit/s: ~500m)

Frame composition

When reading CAN messages, the displayed information will usually be as follows:

However, the standard CAN frame is composed of many other frame fields as shown below:

Where:

• SOF: This field indicates the beginning of the frame

• ID: This field contains the frame identifier, where lower numbers have higher priority

• RTR: Remote Transmission Request describes if a node is a data frame or remote request frame

• Control: The control field contains the ID extension bit along with a Data Length Code (DLC) which specifies the length of the Data field

• Data: The data field contains the actual meat of the message - sends the payload

• CRC: The Cycle Redundancy Check detects errors and ensures data integrity

• ACK: The acknowledgement field indicates whether the node has received the data correctly

• EOF: This field indicates the end of the frame

Message decoding and endianness

CAN data is not human-interpretable (not by me at least) unless you decode it. To do this, many companies will write their own encoding and decoding schemas (.dbc files) which will often look like this:

Where you can use the following as a dictionary to decode a message:

Where:

• Mnemonic: Unique Name Identifier

• Start: Start bit of the signal

• Length: Number of bits in signal

• BOM: Endianness → 0 = big, 1 = little

• Sign: Signed or Unsigned integers → + = unsigned, - = signed

• Factor: Multiplicative scale to decode signal

• Offset: Offset used to decode signal

• Min: Signal minimum value

• Max: Signal maximum value

• Unit: Signal units

Lets run through a decoding example using the following CAN message:

We first convert the message from hex to binary:

NOTE: One important interjection that must be made here is related to endianness. Endianness is a wider computer science concept which defines the order in which a computer stores a sequence of bytes (IMPORTANT: bytes not bits). The .dbc shows that the decoder uses little endianness - the least significant bytes are placed first and most significant bytes are placed last (1 2 3 4 5 → 5 4 3 2 1).

We convert the message to little endian:

Now we can split our message into the splices described in the .dbc - NOTE: we use the big endian indices (so CJ temp running from bits 0:7 means that it will now run from bits -8:-1)

Subsequently we convert from binary to base-10 and apply our scaling factors and offsets to ultimately decode the following from the CAN message:

Because the thermocouples were simply left in ambient air, the end result is quite boring (all temperatures are the same), but we have successfully decoded the CAN message!

Read & log thermocouple data using Nominal Connect

To demonstrate the process of using CAN to read data, we will take temperature data from four thermocouples and stream this to Nominal Connect. For this project we will use:

• Nominal Connect

• PEAK CAN to USB Adapter (PCAN - UCB)

• CANmod.temp: 4x Thermocouple-to-CAN temperature sensor

• 4 K-type Thermocouples

• Arduino UNO MINIMA (used as voltage source)

To connect to the D-sub 9-pin connectors on both the PCAN and CANmod, we will attach jumper cables as follows:

• Pin 1: 5V - Arduino (source) to CANmod

• Pin 2: CAN-H - CANmod to PCAN

• Pin 3: GND - Arduino (source) to CANmod

• Pin 7: CAN-L. - CANmod to PCAN

We will then connect our PCAN and Arduino USBs into our computer and end up with the following setup:

NOTE: Best practice is to use yellow for CAN-H 🟡 and green for CAN-L 🟢 (industry standard).

We can then use a python-can import (pip install python-can), read CAN messages from the CANmod module, and decode them using the associated .dbc file.

To easily visualize and log this data, we can use Nominal Connect. Nominal Connect is a real-time testing and automation platform that gives the user the freedom to create custom UIs to clearly visualize their data quickly! Connect also has integrated functionality with Nominal Core, allowing for simple, seamless data transfer and storage for future view and further analysis (to learn more about Nominal Connect, visit here). We can simply build an interface like the one shown below and stream the thermocouple CAN data to Connect.

With Nominal’s product suite, engineers can get real-time visibility into their CAN data, and store that data in Nominal Core’s flexible, queryable data warehouse. This means faster time-to-insight, constant data availability, and accelerated test programs.

References

1. Mahmoud, Walid. “OSI Model: Layer 2 — The Data Link Layer.” Medium, 28 July 2024, https://walid-mahmoud.medium.com/osi-model-layer-2-the-data-link-layer-c7513c701e81.

2. “CAN Bus Explained - A Simple Intro [2025].” CSS Electronics, https://www.csselectronics.com/pages/can-bus-simple-intro-tutorial. Accessed 5 June 2025.

3. “D-Subminiature (D-Sub) Connectors.” Mbedded.Ninja, https://blog.mbedded.ninja/electronics/components/connectors/d-subminiature-d-sub-connectors/. Accessed 5 June 2025.

The robot arm attempts to place a pen in a pan, but it falls over the edge.

A small, simple failure. The question is: why?

Diagnosing the root cause of a robot failure is difficult, especially for subtle errors like a slight misplacement or an incomplete task. There are many reasons why this task may have failed, but we can’t identify root cause by simply watching this video.

To improve reliability, engineers can’t just know what happened; they need to understand why.

The key is to see the world from the robot's perspective. This requires fusing and synchronizing all available data: video, robot models, depth perception, and algorithm outputs.

This article demonstrates how to use Nominal Connect to investigate this specific failure. We will systematically analyze the event by:

1. Verifying the robot's physical actions against its commands.

2. Examining its 3D environmental perception using point clouds.

3. Inspecting its object understanding with segmentation data.

Step 1: Verify execution – the robot followed its plan

👆 A replay and time scrubbing of the robot arm. By showing the commanded and measured joint angles and gripper state we can check how well the robot executed the plan.

The first step to diagnose robot misbehavior is to confirm its physical components followed the plan. Did the arm and gripper accurately execute their commands?

Within Nominal Connect, we start by loading all the recorded data from this test run. The platform provides a synchronized, multi-faceted replay:

• Synced video footage: We can re-watch the original camera views (external and wrist-mounted) to pinpoint the exact moment of failure.

• 3D scene with arm animation: Alongside the video, a 3D model of the robot arm (its URDF representation) precisely re-enacts its movements, driven by the recorded joint state data.

• Commanded actions vs. measured state: Nominal Connect allows us to overlay or plot the actions given to the robot (the commanded joint positions and gripper instructions) against the measured robot state (the actual data from its encoders and sensors).

By scrubbing the timeline to the critical moment – when the pen is released – we can meticulously compare:

• Was the arm at the commanded state (gripper) and orientation (joint angles) for the pickup and drop?

• Did the gripper close and open precisely when instructed?

• Are there any significant lags or deviations between the intended motion profile and the actual motion achieved by the robot?

The replay in Nominal Connect confirms the robot executed its commands faithfully. The commanded and measured joint angles, along with the gripper state, track each other closely. This means the problem is not a simple control error or mechanical fault.

The robot followed the plan. Next, we investigate the perception that created it.

Step 2: Check 3D perception – the world model is accurate

Since execution was correct, we now investigate perception: Did the robot "see" the world correctly when it formed its plan?

Nominal Connect allows us to overlay 3D point cloud data, derived from the robot's stereo cameras, directly into the synchronized 3D scene alongside the robot's 3D (URDF) model. This point cloud represents the robot's depth perception, its estimate of surfaces and distances in its surroundings.

👆 Overlaying the point cloud from the stereo camera into the 3D model lets us check for alignment. Here, the alignment is good.

As we replay the sequence in Connect, we observe that the portion of the point cloud corresponding to the robot's own arm segments (e.g., its gripper, forearm) closely aligns with the 3D URDF model of the arm.

This alignment confirms the robot's depth perception and localization are sound. The error is not in the general perception of the scene.

With execution and the world model ruled out, we now investigate step 3.

Step 3: Inspect object understanding – error in segmentation overlays

Execution and general perception seem correct. The final question is: did the robot correctly identify and track the specific objects in the scene?

Nominal Connect enables us to visualize the output of the robot's object segmentation algorithms. This can be shown as colored masks overlaid directly onto the synchronized camera footage, highlighting what the robot identifies as "pen," "pan," "table," etc. Each recognized object class or instance can be assigned a distinct color. As we scrub the timeline in Nominal Connect, we look for unstable object identification.

👆 Watch the segmentation mask on the pen. Its color flickers, indicating the robot’s perception system is losing a stable track of the object.

The replay reveals a potential issue: the segmentation mask for the pen flickers and changes color. The robot loses a persistent track of the pen it is holding.

This observation provides a strong clue. Unstable object tracking suggests the robot's plan could be based on an unreliable perception. The robot failed to drop the pen in the pan because the robot lost ‘sight’ of the pen during critical moments.

This 3-step investigation ruled out execution and general perception as root causes, instead identifying segmentation overlays as the culprit. These visualizations give engineers a clear direction for investigation: the object tracking algorithm.

Nominal Connect: See more, build better robots

The pen missed the pan not because of a mechanical fault or a bad world model, but likely because of a fleeting, unstable perception of the object it targeted. This root cause was not evident in the original video. Triaging subtle failures requires looking through the robot's eyes.

The systematic, three-step analysis shown here – verifying actions, then perception, then object understanding – is made possible by Nominal Connect. It transforms raw robotics data (joint states, camera feeds, depth, perception outputs) into a clear, interactive replay of a robot's behavior.

This synchronized, multi-modal view helps teams:

• Quickly find the root cause of elusive bugs.

• Validate and iterate on perception and control algorithms.

• Improve collaboration with a shared, system-level view.

Furthermore, test data can also be synced to Nominal Core, the analytics and data warehouse backbone of Nominal’s platform. This enables long-term data storage, traceability across serial numbers, software versions, cross-unit trend analysis, and seamless data sharing for engineering investigations.

By providing deep insight into individual failures and broad insight into long-term trends, Nominal equips engineers to build higher-quality robotic systems, reduce errors, and confidently advance automation.

Credits

• Robot demonstration data derived from the DROID dataset.

• Robot arm model (Franka Emika Panda) from public URDF.

Creating bespoke visualizations is time-consuming, resource-intensive, and demands rigorous validation for mission-critical precision. Compounding the challenge, few teams have the specialized engineering talent required to deliver high-performance 3D visualization, particularly in the browser. The result: a difficult tradeoff between building in-house or relying on off-the-shelf tools that lack flexibility, fidelity, or time-awareness.

Nominal Connect provides the answer – a Rust-based application framework for rapidly developing scientific visualization tools tailored to mission-grade satellite operations. It’s fast, high-resolution, time-aware, and engineered with precision for both web and native environments.

Real-time ephemeris in 3D

Nominal Connect can render satellite orbits in 3D using OEMs (Orbit Ephemeris Messages) and TLEs (Two-Line Elements). While TLEs are widely used for casual tracking, OEMs offer timestamped ground truth – essential for mission planning, historical replay, and validation workflows.

With Connect, you can:

• Load orbital state from real or simulated OEMs

• Scrub time forward or backward with millisecond precision

• Visualize orbital paths as they evolve with physics-informed realism

Every Connect application is powered by a declarative config file and Python scripts. The config file defines your scene – Earth, spacecraft models, sensors, stream colors, and more. The Python file connects your data to the visualization.

Connect works by opening a simple config file that describes your visualization:

scene:
  load_earth: true
  show_grid: false
  sensors:
  - iss_sensor:
      position:
        model: ISS
      orientation: nadir
      color: "#ffffff"
      shape: # Cone
        radius: 20000
        length: 408000
  models:
  - name: ISS
    path: ISS.glb
    scale: 0.1
    initial_altitude: 408000.0
    stream:
      id: iss
      color: "#00ff00"

Connect’s runtime handles everything else: initializing the scene, managing python scripts, spinning up a performant GUI, and streaming data in real-time using a simple, intuitive Python client. As you stream position and attitude data – whether simulated or loaded from real telemetry – Connect renders it immediately in 3D, without sacrificing spatial or temporal precision.

import connect_python, time, math

@connect_python.main
def stream_data(client):
    timestamp = 0.0
    while True:
        timestamp += 0.01

        # Simulate position data
        lat = math.sin(timestamp) * 20         # Latitude oscillates ±20°
        lon = math.degrees(timestamp) % 360    # Longitude wraps around Earth
        alt = 420_000 + math.sin(timestamp * 50) * 15  # Altitude in meters

        client.stream(
            "sat1", timestamp,
            names=["latitude", "longitude", "altitude"],
            values=[lat, lon, alt]
        )

        time.sleep(0.01)  # Send data every 10ms

Connect offers flexibility in visualization configuration, and the Python runtime yields flexibility for business logic covering a wide variety of scenarios. It’s perfect for:

• Replaying OEMs or TLEs

• Simulating maneuvers or coverage

• Driving real-time ops dashboards

Every Connect application can be packaged individually as a replay, making it useful for sharing with US government officials.

Precise time-syncing for precise missions

Every asset is synced with a global mission clock, because time isn’t just a parameter – it’s a constraint. Temporal precision affects everything: maneuver replay accuracy, sensor fusion, and decision-making clarity. Connect was built from the ground up to respect and preserve that fidelity. You can work in:

• UTC

• Relative mission time

• Custom clocks tied to your own data systems.

Time becomes a first-class control. Pause, slow down, or jump forward. Connect’s real-time trail rendering engine lets you see object paths evolve, colored dynamically by telemetry values like velocity, attitude, or your own custom fields. This isn’t just visual polish – it’s mission context.

When you need more than visuals, Connect’s built-in time-series widgets let you plot any mnemonic in side-by-side panels – no browser extensions, no extra tooling. Click on a point in the graph, and the 3D scene jumps to that timestamp. It’s a direct, intuitive link between your data and your decisions. In space, precision isn't optional –and your tools shouldn't compromise on it.

right_panel:
  width: 0.2
  tabs:
  - name: Mnemonics
    layout:
    - display: stream_value
      title: Altitude (km)
      units: km
      stream_id: iss
      channel: alt_km
		...

Accelerate mission-grade visualizations

Stand up rich, mission-grade visualization tools in less time with Connect. Launch confidently, when precision is table-stakes and timelines are tight.

With Nominal Connect, you can:

• Load OEMs, sensors, and telemetry with simple config files

• Stream real-time data with Python

• Scrub time, plot mnemonics, and render trails with precision

All in a system engineered for scientific fidelity, portability, and mission trust.

Learn More

What is OpenHTF?

OpenHTF is Google's open-source Python library built specifically for hardware testing. First shared at the 2016 Google Test Automation Conference by Joe Ethier and John Hawley, OpenHTF was born out of Google's Glass project, where traditional HITL software test frameworks fell short.

Why it exists

The Google Glass team needed something different: lightweight, adaptable, and agnostic towards hardware platforms. The result is a Python library designed expressly for hardware and electrical engineers, contract manufacturers, and suppliers.

Core features

• Python-first scripting: Integrates effortlessly with NumPy, pandas, and more.

• Modular design: Organized clearly into Phases (steps), Measurements (data capture), Plugs (hardware interaction), and Output Callbacks (result processing).

• Detailed logging: Easy debugging and complete traceability.

• Runs anywhere: Works seamlessly across Windows, macOS, and Linux; compatible with diverse hardware environments.

Using the power of a thriving community

From startups to multinational companies, OpenHTF has grown into a global community staple. It continues evolving on GitHub, driven by contributions from hardware engineers worldwide.

Check out the original GTAC 2016 presentation.

What is Nominal Connect?

Nominal Connect is a real-time testing and automation platform built specifically for hardware-in-the-loop (HITL) scenarios. Engineered for high-stakes environments, Nominal Connect provides clear visibility into your hardware’s real-time performance, leveraging the safety and speed of Rust.

Standout features

• Python-first SDK: Runs OpenHTF and any other Python scripts.

• Real-time visualization: Sensor data visualized at kilohertz speeds.

• Robust offline testing: Dependable, repeatable tests without internet.

• Custom GUIs: Tailored interfaces to simplify hardware control.

• Automated orchestration: Streamlined management of continuous testbeds.

• Simulation replays: Game-engine graphics for reviewing mission scenarios and historical tests.

• DAQ streaming: Real-time acquisition of high-frequency data from NI cDAQ, LabJack, and others.

• Edge-to-server integration: Effortlessly sync data between local devices and cloud servers for comprehensive storage and analysis.

Nominal Connect is already in action at aerospace launch pads, defense flight lines, and nuclear energy sites. Connect ensures reliability under pressure, delivering precise control for even the most demanding hardware tests.

OpenHTF + Nominal Connect:
Powerful stack for HITL test

These tools are most powerful in combination, when Nominal Connect directly runs Python-based OpenHTF scripts. With minimal effort, test engineers leverage nearly a decade of community-driven test scripts, visualizing and automating proven test sequences through custom Connect HMIs.

Here’s a simple example – measuring resistor values:

This script plots voltage measurements, calculates a line of best fit, and determines resistance (here, 0.67 Ω). Operationalizing UIs for the OpenHTF library is just a Python script away with Nominal Connect.

The next generation of HITL testing, available today

OpenHTF’s extensive coverage combines perfectly with Nominal Connect’s powerful performance. From initial development through mission-critical deployment, this stack ensures engineers test reliably, visualize clearly, and iterate confidently.

Learn more

A critical EOL verification is the drone's navigation system: its ability to determine its own position and movement. Onboard Visual Odometry (VO) often enables this, using cameras to perceive motion, particularly in GPS-denied environments.

However, VO’s sophistication introduces difficult complexity. It’s susceptible to subtle manufacturing or assembly errors, leading to inaccurate positioning, or 'drift'. Without dedicated motion capture, manufacturers must stitch together complex analyses to determine the VO performance. This process demands powerful, intuitive, and flexible interfaces for offline analysis.

Nominal Connect answers the call with a high-performance app built specifically for drone VO. Connect streamlines EOL for drone manufacturers, helping them scale and deploy their systems faster.

Let’s dive in.

Visual Odometry: How drones see the world

Think about how you navigate a room. As you move, you instinctively observe how objects around you shift in your field of view. Items closer to you appear to move faster than distant ones. By processing this constant stream of visual change, your brain estimates how far you've walked and in which direction.

Visual Odometry (VO) works similarly, using cameras and algorithms instead of eyes and a brain. Essentially, VO estimates ego-motion (the drone's own change in position and orientation) by analyzing sequential camera images. Here's a simplified breakdown:

1. Capture: The drone's camera captures a continuous stream of images (frames) as it moves.

2. Feature Detection: The algorithm identifies distinct, trackable features in images—corners, unique textures, or other salient points.

   

3. Feature Matching: The algorithm matches these detected features across sequential frames.

4. Motion Estimation: Analyzing the apparent motion of matched features between frames, and knowing camera intrinsics, allows the algorithm to calculate the camera's movement. As the camera is fixed to the drone, this reveals the drone's translation and rotation.

5. Integration: By continuously integrating these small, frame-to-frame movements, VO estimates the drone's complete trajectory over time.

VO's power comes from relying only on cameras, which are typically lightweight, low-power, and often already onboard for imaging. Using VO enables drones to navigate where GPS is unreliable or unavailable, such as indoors, underground, or near structures.

However, VO is not without its challenges. It's susceptible to accumulating errors (drift) and sensitive to poor lighting, fast motion (blur), or feature-poor environments (e.g., a plain white wall). Even subtle issues such as minor camera miscalibration, sensor misalignment during assembly, or slight lens distortion can cause VO estimates to deviate significantly from reality.

This brings us back to the production line. How can manufacturers ensure the VO system on each drone performs acceptably before it reaches the customer? This is where rigorous, reliable, and efficient EOL testing becomes paramount.

VO's complexity breeds errors: Catch them before you ship

Visual Odometry is a cornerstone of modern drone navigation. However, like any complex hardware/software system, issues can arise, especially during manufacturing and assembly. Common issues that EOL testing aims to catch include:

• Camera Calibration Errors: Inaccurate focal length, principal point, or lens distortion parameters lead to growing motion estimation errors.

• Sensor Misalignment: A camera not perfectly aligned with the drone's body axes (as software expects) skews motion estimates.

• IMU Miscalibration or Misalignment (for Visual-Inertial Systems): If the drone fuses visual data with an Inertial Measurement Unit (IMU), errors in the IMU's calibration or its alignment relative to the camera are critical sources of drift.

• Hardware Faults: Faulty cameras, poor processing units, or loose connections degrade VO performance.

• Software/Configuration Issues: Incorrect VO algorithm parameters hinder performance.

These aren't just theoretical problems. A slight calibration drift can cause significant positional deviation even during a short flight. This "drift" is the enemy of reliable navigation. For drones performing precise tasks, excessive drift is unacceptable and dangerous. Catching these issues pre-shipment saves manufacturers from costly recalls, warranty claims, and brand damage.

The Challenge: measuring VO performance objectively

How do manufacturers currently ensure VO performance? Methods vary:

• Basic Functional Checks: Verifying the VO system initializes and outputs something. This catches catastrophic failure, but often misses subtle, critical drift.

• Manual Test Flights: An operator subjectively assesses stability or path adherence during flight. This is operator-dependent and lacks quantitative rigor.

• Rudimentary Path Checks: Flying a predefined path and visually checking completion. This still lacks an objective measurement of the internal position estimate's accuracy.

The core challenge is objectivity and quantification. How do you know if the VO drift is 1 cm/meter or 10 cm/meter? Is that acceptable? Answering this requires comparing the drone's own position estimate against a known, highly accurate reference—often called "ground truth".

Defining "truth": MoCap precision vs offline VO

1. The gold standard: motion capture (MoCap)

In controlled settings like a factory test area, Motion Capture (MoCap) systems provide the most accurate ground truth. Similar to movie CGI systems, multiple specialized cameras track reflective markers on the drone, calculating its precise 3D pose (position and orientation) in real-time with millimeter-level accuracy.

• Pros: Extremely high accuracy, provides a truly independent reference.

• Cons: High setup and ongoing costs; dedicated, instrumented space needed; limited flight volume constrained by capture area; marker placement adds to preparation time.

With a MoCap system at an EOL station, the process is straightforward: fly the drone in the capture volume, record its onboard VO estimate and MoCap's ground truth, then compare trajectories. However, even with MoCap, comprehensive test flights might extend beyond camera coverage.

2. The powerful alternative: high-fidelity offline processing ("Best Truth")

What if a dedicated MoCap setup isn't feasible due to cost, space, or logistical constraints? Or what if test flights exceed MoCap coverage? A highly accurate reference path—often termed "best truth"—can still be generated by better leveraging the drone's own sensor data post-flight.

The key insight here is the difference between onboard (real-time) processing and offline (post-flight) processing:

• Onboard VO: Runs in real-time under the drone's tight computational (CPU/power) and memory limits. It often uses simplified, causal algorithms and may omit resource-intensive refinements like global optimization (e.g., loop closure, bundle adjustment).

• Offline Processing: Runs on powerful ground computers without the drone's real-time or resource constraints. Using the exact same flight-recorded sensor data (video, IMU), it employs more sophisticated, computationally intensive algorithms that might perform:

  • Full SLAM (Simultaneous Localization and Mapping): Building a map of the environment and using it to refine the trajectory globally.

  • Global Optimization: Techniques like bundle adjustment that optimize the entire trajectory and map simultaneously, minimizing errors across the whole flight.

  • Multi-pass Analysis: Processing the data forwards and backward to improve accuracy.

  • Sensor Fusion with Higher Fidelity Models: More complex fusion algorithms than might be feasible onboard.

These advanced offline techniques generate a trajectory estimate from the drone's own sensors that is far more accurate than its real-time onboard computation. This "best truth" trajectory is an excellent reference for evaluating the drone's actual onboard VO system performance.

This approach enables rigorous, quantitative VO QC using only the drone's flight data, no external MoCap needed. The crucial step is a system to ingest flight data, perform (or import) this high-fidelity processing, compare it to the drone's onboard estimate, and deliver a clear verdict.

Real-time pass/fail: Nominal Connect streamlines VO testing

We've discussed the importance of verifying VO performance and the need for a reliable reference trajectory. Now, let's see how Nominal Connect, our desktop application, transforms this critical EOL test into an efficient, interactive, and automated process, directly addressing the complexities of handling and interpreting sensor data.

Imagine the EOL test operator has just completed the drone's standardized test flight. Instead of juggling files and scripts, they turn to Nominal Connect. Here’s the streamlined workflow:

1. Initiate the Test: The operator selects the appropriate app within Connect and clicks "Run" (visible in the bottom panel of the screenshot).

2. Load Data & Generate Reference: Connect automatically loads raw sensor data (e.g., rosbag, MCAP). Leveraging Python and Rust, it interfaces with diverse data formats and can directly execute a sophisticated, high-fidelity VO algorithm. This algorithm runs on the operator's desktop, processing the drone's camera/IMU data to generate an accurate reference trajectory (our "best truth"). (Alternatively, if MoCap data is available, the Connect app uses that as the reference.)

3. Live Visualization and Monitoring: While Connect is processing, it provides rich, real-time feedback:

   • Camera Feed & Features: The left panels display the drone's camera view(s). Connect overlays the features being detected (green dots) and tracks how they move between frames (colored lines), offering insight into the visual input the VO algorithm is working with.

   • 3D Trajectory Comparison: A central 3D view dynamically plots the reference paths alongside the drone's onboard estimate, allowing visual inspection of drift.

   • Live Metrics: The plots on the right provide quantitative insights during the run:

     • Feature Health: The top graph ("Feature detection") shows detected/matched features over time. Drops can indicate challenging visual conditions for VO.

     • Error Accumulation: The bottom graph ("Path error...") shows position error (drift) compared to high-fidelity VO over time, showing when and how quickly error accumulates.

4. Automated Pass/Fail: Users pre-configure acceptable error thresholds (e.g., "Maximum path error" slider). After processing, Connect compares the calculated path error to this limit, displaying a clear "Pass" or "Fail".

5. Interactive Debugging: Beyond Pass/Fail, a timeline scrubber allows navigation to any flight point. This helps correlate events (e.g., error spikes) with camera footage, feature counts, and 3D position to understand causes like poor lighting, low texture, or rapid motion.

The example run above reveals systematic X-Y drift uncorrelated with feature count, offering engineers a clue to the cause.

Standardize and Accelerate VO EOL Tests with Nominal Connect

This entire process—data loading, complex analysis, multi-stream visualization, pass/fail judgment, and interactive debugging—occurs in one intuitive desktop application built on Nominal Connect. It replaces bespoke scripts and manual analysis with a standardized, repeatable, and efficient EOL verification. Its flexible Python/Rust backend makes Nominal Connect an adaptable application framework, not just a single tool. This allows it to interface with various data sources and custom analysis algorithms, enabling the creation of tailored testing applications like this VO example, or entirely different EOL quality control solutions.

Beyond the test bench:
New insights with Nominal Core

While Nominal Connect provides immediate local results, test data can also be synced to Nominal Core, the analytics and data warehouse backbone of the Nominal platform. This adds capabilities like:

• Long-term data storage

• Traceability across serial numbers

• Fleet-wide trend analysis

• Seamless data sharing for engineering investigation

Ship with confidence

Consistently verifying Visual Odometry (VO) performance at End-of-Line (EOL) is a critical quality hurdle for drone manufacturers. Ensuring pre-shipment navigation meets specifications is fundamental to reliability, safety, and customer satisfaction.

While traditional methods are often manual, time-consuming, and subjective, Nominal Connect, as an adaptable app framework, provides a streamlined solution for VO testing and potentially many other EOL verification needs. It transforms EOL VO testing by integrating data loading, powerful analysis (like executing high-fidelity VO algorithms), intuitive visualization (with 3D trajectory comparisons), and automated pass/fail checks—all on the operator's desktop.

The result is faster, more consistent, and objective QC, giving manufacturers confidence in each unit shipped and valuable insights from each test run.

Credits

The data used for the above footage is obtained from Computer Vision Group of the Technical University of Munich ( https://cvg.cit.tum.de/data/datasets/visual-inertial-dataset )

The VO algorithm used is OKVIS by the same group.

These datasets – terabytes per run – break legacy visualization tools. Instead of providing clarity, complex sims create hurdles to overcome. Test engineers are forced to down-sample, disregard metadata and context, or else risk crashing their systems.

Nominal Connect finally unlocks the power of modern CFD, seamlessly rendering large-scale, time-resolved data in real time. Its procedural streaming system deliver these capabilities to standard engineering workstations, minimizing complex server integration and failure points. It delivers a cohesive, interactive picture of your systems right to your workstation – no matter how complex the computations.

These unique capabilities come from careful, iterative design choices of our own. Nominal Connect was tailor-made for hardware test by former hardware engineers who feel the pain of a visualization crashing at 2am. Let’s break it down.

Full-rate CFD replay

In iterative design cycles, engineers must explore transient flow fields, pressure distributions, and turbulent structures. This poses a unique difficulty for visualization software. While volumetric replays visualize data changes on fixed geometry, CFD replays must handle both changing geometry and dynamic attributes –significantly increasing data complexity.

Nominal Connect’s procedural streaming system ensures smooth, real-time frame generation even for these massive datasets. Instead of preloading all data, the system dynamically loads only what is necessary, allowing for frame-by-frame inspection at full resolution.

Users can pause at any frame, triggering full-resolution data loading for in-depth examination and filtering. This enables precise inspection of simulation details without performance bottlenecks.

By streaming data directly from disk to the GPU as needed, Nominal Connect allows engineers to interact with extremely large models on standard engineering workstations – a breakthrough for industries handling complex simulations.

Real-time sim-reality comparisons

Wind Tunnels introduce design to reality. They are the critical infrastructure that determine the accuracy of their calculations, that validate that predictions and measurements match.

Nominal Connect introduces a powerful and convenient way to validate real world measurements against pre-computed physics simulations in real time. Connect users can author automatic validation logic across multiple channels, surfacing insights and empowering engineers to adapt on the fly to new data and results

Conclusion

Nominal Connect unlocks the full-rate, real-time power of modern CFD. Engineers can maintain a continuous, cohesive vision of their data – they can spend their time planning the next test rather than fighting their own tools.

Wind tunnels are the backbone of innovation across aerospace, automotive, and more. Their operators deserve better than outdated, brittle tools. Nominal Connect enables wind tunnel engineers to improve test cadence, ensure test conditions are met, and accelerate post-test reporting.

Accelerate test. Accelerate progress. Accelerate the future.

Learn more

We would like to thank Dr. Moritz for making FluidX3D, which was used to create the physics simulations above.

Simulation and spatial data capture have advanced dramatically – but visualization tools can’t handle the complexity. Next-gen datasets deliver models and measurements with unprecedented detail and scale that overwhelm viz tools. They’re too slow, too rigid, or simply overwhelmed by volume and complexity. The result? Bottlenecks, reduced fidelity, and wasted potential.

High-res simulations drive critical decisions from design and inspection to forecasting and optimization. But their potential is wasted. To fully harness modern sim, visualization must be reimagined.

Nominal Connect unlocks the power of modern sim

Nominal Connect enables real-time visualization of large-scale simulation data, from direct hardware measurements to massive volumetric datasets. Nominal Connect delivers continuous, actionable insights from data – no matter how complex.

No more waiting for offline renders. No more struggling with data bottlenecks. Just high-fidelity interaction with massive spatial data in real time.

This is only possible because Nominal was purpose-built for extreme scale and peak performance. Let’s break it down.

Overcoming memory constraints with procedural streaming

To render data, it must first be loaded into RAM and then transferred to VRAM for processing by the GPU. This presents a significant challenge, as spatial datasets often exceed available memory resources by orders of magnitude.

In response, traditional solutions either reduce data fidelity or accept poor performance. At Nominal, we prioritize full data availability while ensuring real-time interaction. To achieve this, we developed a procedural streaming system that dynamically loads data based on user interaction and camera perspective, significantly reducing hardware strain while maintaining high-resolution visualization.

In the video above, a Nominal Connect app renders a high-resolution 3D model consisting of hundreds of millions of pixels. Rendering this dataset naively would exceed standard VRAM limits. Our Bounding Volume Hierarchy (BVH) approach organizes these pixels into a tree-like structure, allowing efficient rendering based on camera position and proximity – minimizing memory usage without sacrificing detail. Nominal Connect loads only the pixels you need so that you never miss a single moment.

Note in particular the percentage of rendered nodes remains in fractions of percentages while allowing us to see the original pixels at any time. The view is split into coloring by pixel (left), and coloring by BVH node (right).

The following video shows this approach used on a large 3D point cloud scene.

High performance unlocks interactive volumetric replays

Nominal Connect enables the visualization of large volumetric replays on fixed geometric objects. For example, the following simulation models complex, overlapping resonance fields on a solid state machine tooled part.

The software provides a fully interactive experience, including real-time filtering and data modification for deeper analysis.

Custom, high-powered viz at your fingertips

Precision and speed are the lifeblood of innovation. Nominal Connect empowers engineers and researchers to break through the limitations of traditional visualization. Whether you’re designing next-generation vehicles, optimizing aerospace components, or pioneering new energy solutions, Nominal Connect puts you in full control of your data, enhances your insights, and accelerates your workflows.

Don’t let outdated tools slow you down. Make the most of your simulations. Explore how Nominal Connect can transform the way you see, analyze, and innovate.

Nominal’s mission: equip engineers to deploy capability at scale in the shortest time possible.

In order to scale mission-critical systems, organizations need to optimize their engineer:asset ratio. Operators need powerful tools to continuously monitor fleets of assets, whether their assets are deployed underwater, in air, or in space. For many of Nominal’s customers, that means 3D dashboards.

But traditional 3D dashboards have historically been expensive, inflexible, and ineffective. Teams often fill this need with outdated software, or else dedicate extensive resources to build bespoke internal tools. In both cases, these solutions are (1) ill-equipped to handle the complexity and data-scale of modern asset networks and (2) over-fitted to particular use-cases – inflexible in the face of new assets, behavior, or mission environments.

Nominal Connect is changing this historical reality.

Nominal Connect: Flexible 3D applications

Nominal Connect is building the most advanced 3d simulation, mission replay, and asset monitoring environment that has ever been available to Python engineers. This includes the ability to visualize an arbitrary number of physical assets, each with independent behavior. With Nominal Connect, one engineer can deploy a monitoring dashboard for a 7,000-satellite constellation – in a single afternoon.

Standing on the shoulders of recent advancements in Rust and wgpu, Connect is bringing a new era of 3d engineering visualization to the Python ecosystem. Unlike outdated or internal tools, Connect seamlessly scales to display thousands of assets in real-time without performance degradation. These displays can range from a few square meters to planetary (or multi-planetary) scale. Nominal’s customers can easily visualize all of their assets in one place, no matter what they are or where they might be.

This powerful performance is paired with modern, intuitive UI. We built Connect from the ground-up with interoperability and flexibility in mind. With its Python-based ecosystem, Connect seamlessly handles any data input format. If Python isn’t your language of choice, Connect can also orchestrate Rust scripts, bash scripts, LabVIEW VIs, or a polygot combination of each. And as an app-building framework, Connect dashboards can be quickly tailored and adapted to specific customer requirements.

Automated end-to-end monitoring

Nominal does more than just visualize assets – it provides the end-to-end solution engineers need to immediately act on real-time insights.

Connect integrates seamlessly with Nominal Core, the analytics and data warehouse backbone of the Nominal platform. Using Nominal’s automated checks & horizontally-scalable cloud compute, 3D dashboards can automatically highlight any anomalies based on pre-determined validation logic. Once the anomaly is flagged, operators can triage the issue, cross-reference historical performance data, and quickly pinpoint root causes, all within the same integrated ecosystem.

Monitoring fleets of thousands of assets is challenging. With Nominal, operators no longer need to choose between cumbersome legacy tools and costly internal development. Nominal delivers the powerful, automated, adaptable dashboards that equip engineers to operate complex systems at scale.

Spot anomalies in seconds. Diagnose in minutes. Correct-course before it’s too late.

Before component parts are integrated into aircraft and vehicles, they undergo extensive testing. It’s critical to ensure every circuit board or actuator is functioning properly before being installed in an aircraft.

Test coverage in manufacturing is scaling with the complexity of today’s hardware products. And with the low-cost of cloud data storage, manufacturers are automating more tests and collecting more test data. This test data is critical - it feeds into AI optimizations such as predictive maintenance, and it helps achieve market-unlocking certifications in highly-regulated industries. No one has ever been fired for collecting too much test data.

Nowadays, Hardware-in-the-Loop (HITL) tests are often written in Python because of Python’s excellent ecosystem for test and measurement instruments. Libraries such as pyserial, python-can, pyvisa, pytest, and unittest have made HITL test and measurement accessible, fast, and low-cost.

As HITL testing continues to accelerate, there are two primary challenges:

1. Python scripts run directly on command lines are failure-prone and inaccessible to anyone but the test engineer who wrote the script.

2. Resulting test data is siloed between facilities, product life-stages, and even different measurement instruments for the same asset.

HITL testing in Python

Nominal’s desktop product, Nominal Connect, is being used by vehicle and robotics manufacturers for component tests and end-of-line tests. One customer, for example, uses Nominal Connect to test their servo motors, as shown in the recording below. The motor must pass this test before being integrated into a quadruped arm downstream (a “quadruped” is a 4 legged robot).

In this example, Connect provides a highly customizable, ergonomic UI for Python HITL tests that interacts with the servo motor controller. With Connect, any technician or manufacturing line operator can run these Python HITL tests and understand their output. The test results are automatically synched with the Nominal platform, where they can be collaboratively analyzed, visualized, and triaged.

Nominal Connect provides the first customizable Human-Machine Interface (HMI) framework on top of Python HITL scripts.† Without an HMI, these Python scripts are run directly on the command line, creating failures, inflexibility, and information siloes. For the first time, Nominal Connect is operationalizing Python HITL tests with customizable HMIs for the manufacturing line.

† In addition to Python, Nominal Connect supports sequencing HITL tests in Bash, MATLAB, and Robot Framework.

Distributed, Continuous Manufacturing

Manufacturing test data captured in Nominal Connect automatically syncs with Nominal’s cloud (or on-premises) platform. This means that an entire organization can monitor, analyze, and triage manufacturing test results in realtime – no matter how far from the manufacturing site.

For example, nuclear reactor manufacturer Antares uses Nominal Connect at headquarters to monitor tests at their remote production facility (read the Mission Brief). Nominal Connect can even be deployed at 3rd-party contract manufacturers so that test data is automatically sent back to the OEM’s Nominal platform. Nominal is the only test and evaluation platform with this vertically-integrated, edge-to-server capability.

Critically, this connectivity does not end with manufacturing. On Nominal, the HITL test data from manufacturing is stored alongside the data from the vehicle’s field tests, operating lifetime, and retirement. Several years into a vehicle’s lifetime, a part’s original performance during manufacture should be retrievable to compare to its current or end-of-life performance. Nominal is the only end-to-end test & evaluation platform ushering in this future.

Manufacturing the future

Testing should be delightful, low-friction, collaborative, ubiquitous, and insightful at every stage. At Nominal, we’re building the test & evaluation platform for all stages of a hardware product’s lifecycle - research, manufacturing, deployment, long-term operations, and retirement.

As the US scales up its manufacture of complex hardware products, exponentially more test data will be generated to support their reliability and development. This data is multi-modal: images, audio, and video are increasingly captured with every HITL test. Nominal is empowering this future for some of the US’s most advanced hardware manufacturers and operators. If you’re interested, reach out to us to discuss your test & evaluation efforts at any stage of a product life cycle.

All manufacturing lines Nominal.

Critical aerospace, defense, and industrial systems rely on brittle scripts duct-taped to aging GUIs. Nominal’s founding team saw this firsthand in our work at companies like SpaceX, NASA, and Lockheed Martin: scripts that failed at 2 AM, missing calibration constants discovered only after costly wasted effort, and data buried across fragmented and legacy desktop tools. Status quo test & evaluation tools were designed in a pre-Internet era – not for the complex, cloud-dependent, and massive data reality of today.

Engineers must quickly build custom apps for hardware-in-the-loop (”HITL”) tests. Unfortunately, existing solutions lack the speed, reliability, interfaces, and edge-ready performance necessary for mission-critical deployments. Relatively new projects in this field such as Robot Framework and Google's OpenHTF have taken refreshing looks at the problem, but weren’t built for collaborative decision-making, capturing essential metadata, and first-class operator GUIs. Command-line tools are nearly impossible to operationalize in test environments without substantial additional software engineering.

Introducing Nominal Connect

Nominal Connect solves these problems: it's a modern hardware-in-the-loop test app framework built specifically for hardware engineers. Connect combines a straightforward, Python-first development experience with robust edge infrastructure designed explicitly for real-time hardware data processing. Engineers and technicians can quickly create custom interfaces, automate tests, and reliably monitor complex hardware systems – handling sensor data streams at kilohertz rates, faster than your display can refresh.

To drive this vision forward, we’ve brought Jack Parmer – founder and former CEO of Plotly – to Nominal. Jack built one of the most widely-used data visualization frameworks ever: Plotly has over 500 million downloads. And Dash, Plotly’s web-based data science framework, boasts nearly 75 million. Connect marks Jack’s return to his hardware engineering roots, and we’re excited about the powerful community he's already building here at Nominal.

Nominal Connect isn’t a future promise – it's actively powering test operations today. Teams currently run Connect-based apps at launch pads, airport tarmacs, laboratory test benches, and nuclear test sites. If you’re building the future and still wrestling with legacy tools like TestStand or LabVIEW, Connect is here, ready to help you move faster.

Architecture

We've enthusiastically joined the “rewrite it in Rust” movement, rethinking decades-old testing architectures to deliver unmatched performance, safety, and stability. Rust gives us the speed and memory efficiency of C++, combined with modern compile-time guarantees of safety. This combination enables rapid data handling and immediate-mode graphics performance that older web or desktop stacks simply can't match.

We're actively recruiting ambitious Rust engineers at the cutting edge of scientific graphics and real-time systems. Special thanks go to our friends at Foresight Spatial Labs and the Bevy Foundation, who've generously shared insights and laid invaluable groundwork for Connect’s development.

Critically, Nominal Connect integrates seamlessly into Nominal’s cloud and on-premises core product. With just one click, you can stream gigabytes of test data or video directly from a Connect app running on your test bench or tarmac into Nominal’s platform. Together, Nominal Connect and Nominal’s core platform form the industry’s first fully integrated edge-to-server solution for hardware test and evaluation.

The future

Nominal Connect is live, bringing the most advanced software technology directly to the field, test bench, and launch pad. Wherever hardware testing demands reliability, flexibility, and speed, Connect is ready. Over the coming months, we'll showcase real-world customer-built apps, share user stories, and dive deep into the tech behind Connect. We can’t wait to celebrate this launch with the engineering community—stay tuned!