Generating CAN Traffic to Test Devices with Komodo CAN Duo Interface

Developing and validating CAN systems often requires generating controlled communication scenarios to test behavior, verify performance, and troubleshoot issues, especially before fully built hardware environments are available. With the Komodo CAN Duo Interface, engineers can reliably generate and send CAN messages in a controlled, automated and scalable way.

Komodo CAN Duo Interface sending CAN messages to display text on the CAN/I2C Activity Board Pro LCD display

How CAN Traffic Generation Helps Test and Validate CAN Devices

Generating and transmitting CAN traffic allows engineers to recreate communication between nodes on a network without requiring a fully developed system. This makes development faster, safer, and more flexible in CAN-based applications, including automotive, industrial, medical, and aerospace systems. Common reasons engineers generate CAN traffic include:

• Accelerating development before hardware is fully ready: Waiting for every component of different subsystems to be physically available can slow progress. By simulating CAN messages, engineers can replicate missing CAN devices and maintain consistent development and testing.
• Debugging unexpected system behavior: Generating controlled CAN traffic allows engineers to reproduce specific scenarios, such as unexpected message data, unusual timing sequences, or missing messages, and observe how a device responds.
• Regression testing: After implementing hardware or firmware updates, engineers must verify that the change does not cause any new communication issues to arise. By repeatedly simulating CAN messages after any new updates, they can confirm that bus behavior remains consistent and is performing as expected.
• Stress testing: Before a product goes to market, engineers generate high bus loads and large and dense CAN message traffic to evaluate device limits and overall reliability by pushing the system beyond its normal operating conditions.

How the Komodo CAN Duo Interface Debugs CAN Systems

The Komodo CAN Duo Interface is a powerful two-channel USB-to-CAN adapter and CAN bus analyzer that allows users to send and receive CAN data, capture raw CAN frames, detect bus errors, and verify timing. Users can actively transmit on one channel while passively monitoring traffic on the other, or use both channels to simultaneously capture CAN traffic from two separate buses. The interface also features 8 configurable GPIOs, independent galvanic isolation per CAN channel, and supports Fault Tolerant (125 kbps) and High Speed (1 Mbps) CAN.

The Komodo CAN Duo Interface is compatible with a variety of software, including:

• Komodo GUI Software for sending and receiving CAN data, batch scripting, data capture playback, and simulating CAN traffic
• Data Center Software for real-time non-intrusive CAN bus monitoring
• Komodo Software API for creating custom programs
• CANtrace for decoding J1939 and CANopen

Total Phase Komodo CAN Duo Interface

Sending CAN Frames in General CAN Mode with the Komodo GUI Software

General CAN Mode in the Komodo GUI Software allows users to send and receive arbitrary data on a CAN bus. Messages can be transmitted at defined time intervals to create consistent, periodic traffic.

When the Active CAN Node is disabled, the Komodo CAN Duo operates in listen-only mode and passively monitors the CAN bus. When enabled, CAN Control becomes available, allowing engineers to simulate traffic by transmitting customized CAN packets.

By default, CAN Control displays the packet destination node ID in the CAN ID field.

In the Data Length Code (DLC) field, users can specify the number of data bytes in each message. This is important for accurately simulating real-world CAN traffic, since different messages on the bus will often vary in payload size.

Users can enable the “Remote Request” option to send a remote frame instead of a standard data frame. In this mode, no data payload is transmitted. While Remote Request frames are less commonly used for simulation, they can be useful for validating how devices respond to data requests.

Enabling Extended ID allows the use of 29-bit identifiers instead of standard 11-bit IDs.

If one-shot is enabled, the Komodo CAN Duo Interface attempts to transmit the CAN packet only once and does not retry if the transmission is unsuccessful. When disabled, the Komodo interface reflects typical CAN controller behavior by automatically retrying transmission until successful or until a 10 ms timeout is reached.

The GPIO Settings allows users to configure pins as either inputs or outputs for interaction with external hardware. Input pins can detect changes in external signals and log these events in real time, enabling synchronization between CAN traffic and external system behavior. Output pins can be used to trigger external tools, such as oscilloscopes or logic analyzers, when specific CAN events occur.

This capability is especially useful when simulating CAN traffic in more complex test environments, where engineers need to correlate bus activity with physical signals or coordinate testing across multiple systems.

Automating CAN Messages in Batch Mode

Batch Mode in the Komodo GUI Software is designed for creating and executing automated batch scripts to transmit sequences of arbitrary CAN packets. In this mode, the application monitors the CAN bus and displays CAN packets, events, and errors in the Transaction log.

Users can automatically generate a batch script from captured data by clicking the “Create Batch Script” button. The batch script language is based on Python which allows for the use of local variables and control structures such as if/else and for/while looping.

The Batch Mode Application includes several components for creating and executing scripts, including:

• Output Window: displays all output generated from the script.
• Execute/Stop Buttons: allows users to start and stop script execution.
• Batch Script Editor: uses Python syntax, allowing users to define variables, implement control structures, and include comments using the hash character (#).
• Save/Load Batch File Buttons: allows users to save a current script or load a script from file.

With Batch Mode, engineers can automate complex or repetitive message sequences, ensuring consistent and repeatable testing when simulating large volumes of CAN traffic.

Observing CAN Device Responses in the Transaction Log

The Transaction log, available in General CAN Mode and Batch Mode, plays a central role in streamlining CAN testing workflows by providing real-time visibility into direct responses from devices under test. It displays CAN packets, events, and errors, including start and stop indicators.

Through the Transaction log, engineers gain insight into a live feedback loop, allowing them to send frames and instantly verify behavior, timing, and format. This makes it easy to reproduce specific conditions and quickly isolate unexpected behavior.

The log captures key information about bus activity, including the following fields:

• Timestamp
• ID (CAN Identifier)
• RTR (Remote Transmission Request)
• DLC (Data Length Code)
• Data

Batch scripts can also be created from captured CAN data either in the General CAN Transaction Log or within Batch Mode using the “Create Batch Script” option. These scripts can then be used to replay CAN traffic for testing and message generation, enabling more repeatable and scalable validation.

Testing Against Known-Good CAN Devices with Activity Board Mode

Activity Board Mode in the Komodo GUI Software is designed specifically for the CAN/I2C Activity Board Pro, which provides known-good target devices that can operate as CAN nodes or I2C slaves. This allows developers to test and debug systems using reliable, preconfigured hardware. Additionally, in this mode, the application polls the CAN devices on the board and updates the GUI through its graphical widgets and the Transaction log.

Inputs include:

• Polling Interval: Defines how frequently (in milliseconds) the application polls the board for sensor updates (e.g., light, temperature).
• Display: Sets the text to display on the CAN/I2C Activity Board Pro LCD screen.
• LEDs: Toggles user-configurable LEDs on or off.

Outputs include:

• Light: Displays light intensity detected by the onboard sensor. The more yellow bars, the higher the light intensity.
• Temperature: Shows ambient temperature readings, as detected by the CAN/I2C Activity Board Pro temperature sensor. The more filled the temperature bar, the higher the temperature.
• Joystick: Indicates the position of the CAN/I2C Activity Board Pro 8-way hat switch (joystick). Filled green arrows show the direction of the joystick. A filled green center indicates that the joystick is being pressed into the board.
• Motion: Displays the 3-axis movement of the CAN/I2C Activity Board Pro. Motion is represented via X, Y and Z axis bars and a visual representation of the board.

Targets on the board include:

• Digital-to-Analog Converter (DAC)
• Motion Sensor
• Light Sensor
• Port Expander #1
• Joystick, LEDs, and Port Expander #2
• Analog-to-Digital Converter (ADC)
• LCD Display
• Temperature Sensor

Activity Board Mode allows engineers to interact with real sensors and peripherals that generate dynamic CAN data, enabling more realistic simulation scenarios. Because the board includes multiple device types, users can generate concurrent CAN traffic from different sources and observe how their system responds to multiple inputs and outputs in real time.

This helps validate communication logic, timing, and system behavior under more real-world conditions, bridging the gap between basic message-level testing and higher-level system integration testing. This is especially useful during prototyping and firmware development for CAN-based systems.

CAN Playback: Replaying Captured CAN Traffic

Using the Komodo CAN Duo Interface’s two independent CAN channels, engineers can record CAN traffic on one channel and replay it on the other. This makes it possible to capture real-world communication from a CAN bus and then reproduce it for validation, debugging, and regression testing.

In our example workflow, this is achieved using both Data Center Software and Komodo GUI Software. One channel in Data Center Software records and logs live bus activity, which can then be exported as a .kba file, while the second channel in Komodo GUI Software replays the captured data in Batch Mode. This enables real-world CAN communication to be reproduced exactly as recorded, helping engineers validate system behavior, reproduce intermittent issues, and perform consistent regression testing under realistic conditions.

For a closer look at this process, check out our blog, Monitor and Transmit CAN Traffic Using the Komodo CAN Duo Interface or our demo video, for a more in-depth walk-through showing how to record and playback CAN traffic.

Automating CAN Traffic with the Komodo Software API

The Komodo Can Duo Interface can also be used with the free Komodo Software API,  allowing users to create customized applications. Supported programming languages include C#, C Python, .NET, VB.NET, and VB6.

Using the API is especially valuable for generating CAN traffic in more advanced or complex test environments. Engineers can build custom applications that transmit CAN messages through API calls rather than the GUI, allowing message content to be defined and modified based on test conditions, loop logic, or external inputs. This enables CAN messages to be generated as part of test scripts or automated workflows, using asynchronous packet submission and collection functions to manage transmission and responses. This level of flexibility enables scalable testing setups beyond what can be accomplished with Total Phase GUIs alone.

By combining GUI-based tools, scripting capabilities, and real-time analysis, the Komodo CAN Duo Interface provides a flexible platform for simulating, testing, and validating CAN communication at every stage of development.

For more information, please email us at sales@totalphase.com or request a demo.