CanLover is a desktop application for analysing, decoding, and interacting with CAN bus networks. It supports live connections to physical hardware adapters as well as offline replay of recorded log files, and it provides a set of specialised windows for inspecting raw traffic, decoded signals, diagnostic trouble codes, network topology, and bus health.
| Platform | Status |
|---|---|
| Windows 10 / 11 (x64) | Fully supported |
| Linux (x86-64) | Fully supported |
| macOS | Experimental |
CanLover uses a dockable window layout. All windows can be freely repositioned, resized, tabbed, and undocked. The layout is preserved between sessions.
A session starts with the Bus Configuration window, where you select hardware channels, attach database files, and connect. Once connected (or a replay is loaded), the remaining windows populate with live data.
Some features require a valid license file. CanLover will load a license from the application data directory automatically on startup. See the Licensing section for details on which features require a license.
If you encounter a problem and need to contact support, use Help → Send Diagnostic Report… to send a report directly to the developer. The report includes your application version, operating system, CPU model, hardware fingerprint, license status, and the last 100 lines of the application log. A preview of the report is shown before sending so you can review its contents. The report is transmitted over HTTPS and requires an active internet connection.
The Bus Configuration window is the starting point for every session. Open it with the Configure… button in the main toolbar. It covers device discovery, channel setup, database attachment, and session management.
Click Refresh Devices to enumerate all connected CAN adapters. Detected hardware is displayed in a collapsible list grouped by device, showing the device type, serial number, and the number of available channels.
If a device does not appear, verify that the vendor driver is installed and the adapter is powered on before clicking Refresh.
Expand a device entry to reveal its individual channels. For each channel:
| Control | Description |
|---|---|
| Enable checkbox | Include this channel in the session |
| Bitrate | Select from 10k, 20k, 50k, 125k, 250k, 500k, 800k, or 1 Mbps |
| Auto-scan | Detect the bitrate automatically by listening for valid traffic |
Only channels with the enable checkbox ticked will be opened when you connect.
Each channel can have one or more database files attached for signal decoding:
A file browser opens to select the file. Multiple files can be attached to the same channel; signals from all files will be decoded concurrently.
When a DBC or SYM file containing J1939 messages is loaded, an additional J1939 section appears with options for BAM assembly, SPN decoding, and CSV-based SPN description lookup.
Once channels are configured and databases are attached, click Connect Active Channels. CanLover opens all enabled channels at the selected bitrates and begins capturing traffic.
A recording starts automatically when you connect. The status bar shows elapsed recording time.
To replay a previously recorded file instead of connecting to hardware:
| Control | Description |
|---|---|
| Play / Pause | Start or pause the replay |
| Timeline slider | Scrub to any position in the recording |
| Speed | Replay speed from 0.1× to 16× |
| Loop | Restart automatically at the end |
| Stop Replay | Exit replay mode and return Bus Configuration to its initial state |
Multiple files can be added and will be played in sequence as a single concatenated recording.
Clicking Stop Replay ends the replay session and restores the channel configuration to the state it was in before the replay started, allowing you to reconfigure channels, change bitrates, or connect to hardware immediately.
If the replay produced a recording that has not been saved yet, CanLover will ask whether to save it before stopping. Choose Save to export the recording, Discard to drop it, or Cancel to return to the replay without stopping.
Before disconnecting or connecting to a different device, CanLover offers to save the current session recording. The save dialog supports three formats:
| Format | Description |
|---|---|
| ASC | Peak/CANalyzer text format |
| TRC | Peak binary trace format |
| BLF | Vector Binary Logging Format |
Choose a format, set the output path, and click Save. Selecting Discard discards the in-memory recording without saving.
The Raw Trace window shows every CAN frame that passes through the session, in real time. It has two complementary view modes selectable via tabs at the top.
When a session is opened, the active view mode is chosen automatically: if at least one channel has a DBC or SYM file attached, the window opens in Unique mode so decoded signal data is immediately visible; otherwise it opens in Trace mode. You can switch modes freely at any time during the session.
Trace mode is a chronological log of all frames in the order they were received or transmitted, up to an internal buffer of approximately 16 000 entries.
| Column | Description |
|---|---|
| Time | Timestamp in seconds from session start |
| Dir | Direction — Rx (received) or Tx (transmitted) |
| Channel | Hardware channel index |
| ID | CAN identifier in hexadecimal or decimal |
| DLC | Data Length Code (number of data bytes) |
| Data | Raw data bytes in hexadecimal |
| Type | Decoded message name if a database is loaded, otherwise blank |
TX frames are highlighted with a subtle blue background to distinguish them from received traffic.
Click any column header to sort the visible rows by that column. Clicking the same header again reverses the order; a third click removes the sort and restores insertion order. The Data column cannot be sorted.
| Control | Description |
|---|---|
| Pause | Freeze the display without stopping capture |
| Clear | Discard all buffered frames |
| Hex / Dec | Toggle CAN ID display between hexadecimal and decimal |
| Filter | Text box — filter rows by message type name or CAN ID |
| Auto-scroll | Keep the view scrolled to the most recent frame |
Hovering over a frame row shows a tooltip with the decoded signal values for that frame, if a database is loaded.
Unique mode consolidates the stream into one row per CAN ID, showing only the most recent data for each message. This gives an at-a-glance view of all active messages on the bus.
| Column | Description |
|---|---|
| Time | Timestamp of the most recently received frame |
| Dir | Last observed direction |
| Ch | Channel |
| ID | CAN identifier |
| DLC | Data length |
| Data | Most recent data bytes |
| Count | Total number of frames received for this ID |
| Cycle | Last observed cycle time in milliseconds |
| Min / Max | Minimum and maximum observed cycle times |
Rows whose data changed within the last 500 ms are highlighted in amber, making it easy to spot active messages.
Click any column header to sort by that column (ascending → descending → none). The Data / Value and Unit columns cannot be sorted.
If a database is loaded, each row in Unique mode can be expanded (click the arrow) to reveal the decoded signals for that message. Multiplexed messages show a sub-level for each active multiplexer value.
The Signal Table window provides a real-time tabular view of every decoded signal value across all loaded databases. It requires at least one DBC or SYM file to be attached to an active channel.
License required: DBC/SYM signal decoding requires the DBC Decoder feature in the license.
Each row represents a single signal. Signals are grouped by their parent message name.
| Column | Description |
|---|---|
| Message | Name of the CAN message that contains this signal |
| Signal | Signal name as defined in the database |
| Value | Current physical value (scaled and offset-applied) |
| Unit | Engineering unit from the database (e.g. km/h,
°C, bar) |
| Source | Origin of the decoding rule — DBC, SYM, or
J1939 |
The total number of decoded signals is shown in the top-right corner of the window.
| Control | Description |
|---|---|
| Filter | Type any text to filter rows by message or signal name |
| Freeze | Pause value updates while keeping the current values visible |
| Clear | Remove all rows; they repopulate as new frames arrive |
Rows whose value changed within the last 500 ms are highlighted in green. This makes it easy to see which signals are currently active and changing, especially on a busy bus.
The Signal Plot window visualises signal values as time-series charts. Signals can be freely assigned to a configurable grid of plot panels.
License required: Signal plotting requires the Signal Plot feature in the license.
The left sidebar contains a hierarchical browser listing all decoded signals, organised by message name. Use the filter box at the top of the sidebar to search by message or signal name.
Drag a signal from the sidebar and drop it onto any panel in the plot canvas. Each panel accepts multiple signals and assigns a distinct colour automatically (up to eight colours before cycling).
To remove a signal, right-click anywhere on the panel and select Remove signal from the context menu.
The toolbar above the canvas contains a layout picker that sets the grid arrangement of panels:
| Option | Grid |
|---|---|
| 1×1 | Single panel (default) |
| 1×2 | Two panels side by side |
| 2×1 | Two panels stacked vertically |
| 2×2 | Four panels in a 2×2 grid |
| 3×1, 1×3, 3×2, 2×3 | Larger grids |
Changing the layout preserves existing signal assignments where possible.
Each panel supports two display modes, toggled from the right-click context menu:
The plot canvas is interactive:
In live mode the X axis spans a rolling history window. In replay mode it spans the full recording length, and a cursor marker shows the current playback position on every signal.
The toolbar contains a marker threshold setting (default 50). When the number of visible samples falls below this threshold (i.e., you are sufficiently zoomed in), individual sample markers appear on the plot lines to show the exact measurement points.
| Control | Description |
|---|---|
| Clear | Remove all signals from all panels |
| Layout picker | Change the panel grid arrangement |
| Marker threshold | Set the sample count below which markers are shown |
The DTC Panel displays active Diagnostic Trouble Codes (DTCs) reported by J1939 nodes on the network. It processes DM1 (active faults) and DM2 (previously active faults) messages as they arrive.
License required: The DTC Panel requires the DTC Panel feature in the license. Protocol requirement: A J1939 database must be loaded for SPN and FMI descriptions to appear.
The header shows the total count of active DTCs. The Clear button removes all entries from the list.
Each row in the table represents one DTC:
| Column | Description |
|---|---|
| Time | Session timestamp (seconds) when the DTC was first observed |
| Source | J1939 source address of the node reporting the fault (hexadecimal) |
| SPN | Suspect Parameter Number — identifies the system or component |
| FMI | Failure Mode Identifier — describes the type of fault |
| OC | Occurrence count reported by the node |
| Description | Human-readable text combining the SPN name and FMI meaning |
If the same SPN + FMI combination from the same source address is received more than once, the existing row is updated rather than creating a duplicate. The occurrence count reflects the latest value from the node.
The Freeze Frame window captures and displays J1939 DM25 (Expanded Freeze Frame) data — a snapshot of signal values recorded by an ECU at the moment a fault was triggered.
License required: Freeze Frame requires the Freeze Frame feature in the license. Protocol requirement: Requires J1939 and a loaded database with DM25 support.
The window is split into two panels.
Lists all freeze frame snapshots received during the session. Each entry shows:
Click a snapshot to select it and view its contents in the right panel.
Displays the contents of the selected snapshot:
| Field | Description |
|---|---|
| Source address | J1939 address of the node that reported the freeze frame |
| Trigger SPN | SPN that was active when the snapshot was taken |
| Trigger FMI | Failure Mode Identifier associated with the trigger SPN |
Below the header, a table lists all captured signals with their physical values at the time of the fault. These values are immutable — they represent the state of the system at the moment the fault was detected, not the current live values.
| Control | Description |
|---|---|
| Clear | Remove all snapshots from the list |
The J1939 Network window shows the nodes discovered on the J1939 network by listening for Address Claim (PGN 0xEE00) messages. It provides a quick topology overview of which ECUs are present on the bus.
Protocol requirement: Requires a J1939-enabled channel. Nodes only appear after they have transmitted an Address Claim message.
The header shows the total count of discovered nodes.
Each row in the table represents one network node:
| Column | Description |
|---|---|
| Address | J1939 source address of the node (hexadecimal, 0x00–0xFE) |
| Manufacturer | 11-bit manufacturer code from the NAME field (shown as 4-digit hex) |
| Function | 8-bit function code from the NAME field (shown as 2-digit hex) |
The Database Browser lets you inspect the contents of loaded DBC and SYM database files — message definitions, signal properties, and visual bit layouts — without needing an active CAN session.
License required: The Database Browser requires the Database Browser feature in the license.
If a database is already attached to an active channel via the Bus Configuration window, it is automatically shown in the browser. To browse a file independently of any session, click the Load button and select a DBC or SYM file.
If a session database is configured after an ad-hoc file is loaded, the session database takes priority and the ad-hoc file is dismissed.
The left panel shows a tree of channels, each with the count of messages defined in its database. Expand a channel to see its messages listed by CAN ID and name. Click a message to select it and view its details in the right panel.
The divider between the left and right panels can be dragged left or right to resize them. This is useful when message names are long and would otherwise be truncated.
The right panel has four tabs for the selected message.
A table of all signals defined in the message:
| Column | Description |
|---|---|
| Name | Signal name |
| Start Bit | Bit position of the LSB (Intel) or MSB (Motorola) |
| Length | Signal length in bits |
| Byte Order | Intel (little-endian) or Motorola (big-endian) |
| Factor | Scale factor applied to the raw value |
| Offset | Offset added after scaling |
| Unit | Engineering unit |
| Mux | Multiplexer role — Mux ID (selector signal) or the mux value this signal belongs to |
Hovering over a row shows a tooltip with any value descriptions (named enumeration values) defined for that signal in the database.
A colour-coded grid showing the physical bit positions occupied by each signal within the 8-byte CAN data field.
For multiplexed messages, a combo box above the grid selects the multiplexer value. The layout updates to show the signals valid for the selected mux value.
Shows the enumeration tables for signals that have named values defined in the database. Each such signal is listed by name; beneath it a two-column table maps each raw integer value to its human-readable description. Signals with no value table are omitted. If no signal in the message has a value table, the tab shows a note to that effect.
Analyses the message definition and reports potential problems. Issues are shown in a table with a severity indicator and a description.
| Severity | Meaning |
|---|---|
| Error | A definite problem — signal bit-length is zero, a signal exceeds the message DLC, or two signals occupy the same bit position |
| Warning | A likely problem — a signal uses a scale factor of zero (all decoded values would be zero) |
Overlapping bits between multiplexed signals that belong to different multiplexer values are not flagged, because those signals are never active at the same time. If no issues are found, the tab displays a confirmation that the message definition is valid.
The CAN Transmit window allows you to compose, schedule, and send CAN frames. It supports both raw frames with manually edited bytes and database-backed frames with per-signal value control and animated waveforms.
Use the toolbar buttons to add entries:
Entries can be removed by right-clicking the entry header and selecting Remove.
Each entry has two send modes:
| Control | Description |
|---|---|
| Send Once | Transmit the frame once immediately with the current signal values |
| Start Periodic | Begin transmitting the frame at the specified period (ms) |
| Stop Periodic | Halt periodic transmission |
The period field sets the interval in milliseconds between successive transmissions. When periodic transmission is active, the entry header displays the current period.
For frames added from a database, the entry expands to show a signal table:
| Column | Description |
|---|---|
| Signal [Unit] | Signal name and engineering unit |
| Value | Current physical value — editable input field or enum dropdown |
| Range | Min/max slider for quickly sweeping through the signal range |
| Behavior | Waveform animation mode (see below) |
| Period mult. | Waveform speed relative to the frame transmission period |
The Behavior column controls how the signal value changes on each periodic transmission:
| Behavior | Description |
|---|---|
| Fixed | Value stays constant at the manually entered value |
| Ramp Up | Value increments from min to max, then wraps back to min |
| Ramp Up-Down | Value ramps from min to max, then back to min (sawtooth) |
| Sine | Value follows a sine wave between min and max |
The Period mult. setting controls how many frame transmissions make up one full waveform cycle. The minimum effective cycle is 200 ms.
Animated signals (any mode other than Fixed) show the current animated value in the value column as read-only. Switch back to Fixed to regain manual control.
Signals with named value descriptions in the database show a dropdown instead of a numeric input or slider. Select a value by name from the dropdown.
Raw entries show a DLC selector and a row of byte fields. Each byte
is edited as a two-digit hexadecimal value
(00–FF). The raw bytes are sent as-is without
any database encoding.
The CAN Statistics window shows real-time bus health metrics for every active channel — bus load, traffic counters, error rates, and hardware status.
The window contains one collapsible section per active channel. The section header shows the channel index, device identifier, channel type (Physical, Virtual, or Replay), and configured bitrate.
A Reset button in the top-right corner of each physical channel header resets the hardware error counters on the adapter.
Replay channels display a “Statistics not available” message — metrics are not meaningful for file-based sessions.
Shows the current hardware error state reported by the adapter:
| State | Colour | Description |
|---|---|---|
| Error Active | Green | Normal operation |
| Warning | Yellow | Error counters are elevated but below the passive threshold |
| Error Passive | Orange | Error counter exceeded 127; the node is restricted |
| Bus-Off | Red | Error counter exceeded 255; the node has disconnected from the bus |
TEC (Transmit Error Count) and REC (Receive Error Count) are shown below the state when the hardware supports reading them. Values are colour-coded: green below 96, yellow up to 127, orange up to 255, red at bus-off threshold.
| Metric | Description |
|---|---|
| Now | Software-estimated bus utilisation over the most recent measurement window (%) |
| Avg | Rolling average load since the session started |
| Max | Peak load observed during the session |
A colour-coded progress bar provides an at-a-glance view: green below 50 %, yellow at 50 %, red above 50 %. Hardware load readings from the adapter are shown separately when available.
Counts of frames observed since the session started, broken down by frame type:
Received: Total, Extended ID, CAN FD, Remote
Transmitted: Total, Extended ID, CAN FD
Bytes: Total bytes received and transmitted
A breakdown of CAN error frames by error type:
| Type | Description |
|---|---|
| Bit | Bit error detected during transmission |
| Form | Frame format violation |
| Stuff | Bit stuffing rule violation |
| CRC | CRC mismatch |
| Ack | Missing acknowledge |
| Bus-Off | Bus-off events |
| Passive | Error passive transitions |
| Warning | Warning level transitions |
| Other | Errors not matching any specific category |
Error counts are colour-coded on a logarithmic scale: dimmed when zero, yellow for 1–9, orange for 10–999, red for 1 000 and above.
CanLover uses a feature-based licensing system. A subset of windows and capabilities requires a valid license file; the rest of the application runs without one.
The license is a JSON file placed in the CanLover application data directory. It is loaded automatically at startup. No manual import step is required — simply copy the license file to the correct location and restart the application.
The expected location on each platform:
| Platform | Path |
|---|---|
| Windows | %APPDATA%\CanLover\license.json |
| Linux | ~/.config/CanLover/license.json |
| macOS | ~/Library/Application Support/CanLover/license.json |
| Field | Description |
|---|---|
| Licensee | Name of the organisation or individual the license was issued to |
| Expiry | perpetual for a permanent license, or a date in
YYYY-MM-DD format |
| Features | Bitmask of enabled features (see table below) |
| Fingerprint | Hardware identifier — the license is bound to a specific machine |
A license with an expiry date will stop granting access to licensed features after the expiry date. The application continues to run with unlicensed features available.
| Feature | Description |
|---|---|
| DBC Decoder | Signal decoding from DBC and SYM files; enables the Signal Table window and decoded overlays in the Raw Trace |
| Signal Plot | Time-series signal plotting (Signal Plot window) |
| Node Logic | Visual scripting canvas — react to CAN events and automate frame transmission without writing code |
| J1939 Decoder | J1939 PGN/SPN decoding and the J1939 Network window |
| DTC Panel | J1939 DM1/DM2 diagnostic trouble code display |
| Freeze Frame | J1939 DM25 freeze frame viewer |
| Data Logger | Session recording and export to ASC, TRC, and BLF formats |
| Database Browser | DBC/SYM file inspector with bit layout visualisation |
Features not listed above (Raw Trace, CAN Statistics, CAN Transmit with raw frames, Bus Configuration) are available in all configurations without a license.
Contact the CanLover sales team to purchase a license. Provide your machine identifier, which can be found in the About dialog under Help → About. License files are issued per machine and cannot be transferred to a different computer.
CanLover verifies the license signature using an embedded Ed25519 public key on every startup. Tampered or incorrectly generated license files are rejected. The application also monitors system time integrity to prevent circumventing expiry dates by setting the clock back.
Workspaces let you save and restore the visual layout of the application — which windows are open, where they are docked, and how the dockspace is arranged. Each workspace is independent; switching between them instantly loads the saved layout without affecting the active bus session or any channel configuration.
A tab bar sits just below the toolbar. Each tab represents one saved workspace. Click a tab to switch to that layout.
| Action | How |
|---|---|
| Switch workspace | Click the tab |
| Add a workspace | Click the + button at the right end of the tab bar |
| Close a workspace | Click the × on the tab (visible when more than one workspace exists) |
| Rename a workspace | Right-click the tab → Rename |
| Remove a workspace | Right-click the tab → Remove, or click × |
When you add a new workspace you can choose:
Workspaces are saved automatically to workspaces.json in
the application configuration directory when the application exits, and
loaded again on the next startup. The last active workspace is
restored.
You can also save and load workspaces to arbitrary files via the File menu:
| Menu item | Description |
|---|---|
| File → Save Workspace | Captures the current layout and writes it to
workspaces.json immediately (without waiting for
exit). |
| File → Save Workspace to File… | Opens a save dialog and exports the current workspace to a
.json file you choose. |
| File → Load Workspace from File… | Opens a file dialog; the imported workspace is added as a new tab and activated. |
Exported workspace files are plain JSON and can be shared between machines or committed to version control alongside a project.
Each workspace stores:
The following are not part of a workspace and are shared across all workspaces:
Workspaces are persisted in the platform-specific configuration
directory alongside canlover_settings.json:
| Platform | Path |
|---|---|
| Windows | %APPDATA%\CanLover\workspaces.json |
| Linux | $XDG_CONFIG_HOME/canlover/workspaces.json (default:
~/.config/canlover/) |
| macOS | ~/Library/Application Support/CanLover/workspaces.json |
Node Logic is a visual programming environment built into CanLover. Wire together event, logic, data, and action nodes on a canvas to create scripts that react to live CAN traffic — no code required.
License required: Node Logic requires the Node Logic feature in the license.
Open the Node Logic window from Windows → Node Logic in the main menu bar. The window contains a toolbar at the top, a log panel, and the node canvas below.
| Button | Description |
|---|---|
| Run | Validate the graph and start execution. Any errors are printed to the log; the graph stays stopped until all errors are resolved. |
| Stop | Halt execution and unregister all event handlers. Editing resumes immediately. |
| New | Clear the canvas and start a fresh unnamed graph. You are prompted to save any unsaved changes first. |
| Load | Open a named graph from the graph library. A dropdown lists all previously saved graphs. |
| Save As… | Save the current graph under a name. Once named, subsequent autosaves use that name. |
The current graph name is shown in the toolbar next to the separator when a named graph is loaded. While the graph is running, node and link editing is locked — the canvas is read-only until you press Stop.
Execution always starts at an event node. When the node’s condition fires, the graph traverses the exec chain connected to that node’s exec output.
| Node | Fires when… |
|---|---|
| OnMessageReceived | A CAN frame with the configured CAN ID arrives on the bus |
| OnDBCMessageReceived | A DBC-decoded message with the configured name arrives on the configured channel; exposes named signal values as Float outputs |
| OnSignalChanged | A decoded signal value changes from its previous value |
| OnTimer | A configurable interval elapses (frame-rate-driven; minimum ≈ 16 ms at 60 FPS) |
| OnSessionStart | The graph is started via the Run button |
| OnSessionStop | The graph is stopped via the Stop button |
Exec nodes control the flow of execution.
| Node | Behaviour |
|---|---|
| Branch | Evaluates a Bool condition; routes execution to the True or False output |
| Sequence | Fires each exec output pin in order — the idiomatic fan-out node |
| Gate | Passes execution only when the Enable pin is true |
| DoOnce | Fires once, then blocks until the Reset exec input is triggered |
| DoNTimes | Loops N times, exposing a per-iteration Index output; fires a Done exec output when finished |
| Counter | Increments an internal counter on Execute; Reset sets it to zero; outputs the current count |
Data nodes compute values. They are evaluated lazily when an exec node reads their output, and the result is memoised for the duration of a single event firing.
| Node | Output |
|---|---|
| Constant | A fixed literal — Bool, Int, Float, or String |
| Compare | Comparison of two values using ==, !=,
<, <=, >,
>=; outputs a Bool |
| MathOp | Arithmetic on two floats: Add, Subtract, Multiply, Divide |
| Clamp | Clamps a Float to a configurable [Min, Max] range |
| MapRange | Linearly remaps a value from one range to another |
| BoolAND / BoolOR / BoolNOT | Boolean logic gates |
| Reroute | Pass-through wire — a cosmetic routing helper |
| GetVariable | Reads a named variable from the graph’s shared variable store |
| GetSignalValue | Returns the latest physical value of a decoded signal, looked up by message name and signal name |
| GetMessageByte | Extracts one byte at a given index from a raw CAN frame byte array |
| SequenceValue | Steps through a numeric range (Min → Max in configurable Step increments) each time it is evaluated; wrap mode cycles back to Min after reaching Max, bounce mode reverses direction at each edge |
Action nodes interact with the CAN session. They require an open CAN library to be loaded; the validator blocks the graph from starting if action nodes are present but no hardware (or virtual) session is active.
| Node | Action |
|---|---|
| SetVariable | Stores a value in the graph’s named variable store |
| SendFrame | Transmits a raw CAN frame with the configured CAN ID, DLC, channel, and data bytes |
| SendSignal | Encodes a physical signal value into a DBC message and transmits the resulting frame |
| SendDBCMessage | Encodes a complete DBC message by name, with one Float input pin per configured signal, and transmits it. Requires DBC support. |
| SendDBCMessagePeriodic | Same as Send DBC Message but driven by an internal timer (configurable interval in ms) — no exec pins required. Starts automatically when the graph runs and stops when the graph stops. Requires DBC support. |
| StartPeriodic | Registers a periodic TX task with the CAN scheduler at the configured period; outputs the task ID |
| StopPeriodic | Removes a periodic TX task by its task ID |
| LogMessage | Prints a labelled value to the Node Logic log panel |
| Type | Colour | Description |
|---|---|---|
| Exec | White | Control-flow wire — defines execution order |
| Bool | Yellow | Boolean true / false |
| Int | Cyan | 64-bit signed integer |
| Float | Green | Double-precision floating-point number |
| String | Purple | UTF-8 text |
| Bytes | Orange | Raw byte array |
Numeric types (Bool, Int, Float) accept each other with automatic coercion: a Float connected to an Int pin truncates to integer; a Bool connected to a Float pin yields 0.0 or 1.0.
The validator runs automatically when you press Run. Common errors:
| Error | Cause |
|---|---|
| No event nodes | The graph contains no node that can initiate execution |
| Library required but absent | A SendFrame / SendDBCMessage / StartPeriodic node exists but no CAN hardware session is open |
| Interval ≤ 0 | An OnTimer node has a zero or negative interval |
| Empty CAN ID | A SendFrame or OnMessageReceived node has no CAN ID configured |
| Empty signal name | A signal-bound node has no message or signal name configured |
| Empty message name | A DBC node (OnDBCMessageReceived, SendDBCMessage, SendDBCMessagePeriodic) has no message name configured |
Warnings (non-blocking) are shown for disconnected event nodes and unreachable subgraphs.
drain() and therefore see fully decoded signal values for
the current frame batch.tick() on each rendered frame; it fires independently of
any event chain.Graphs are stored as JSON files in a graphs/ folder
inside the application configuration directory. The Save
As… button saves under a user-chosen name;
Load lists all named graphs in a dropdown.
The most recently used graph is saved automatically to
node_graph.json (the autosave slot) whenever the Node Logic
window is closed or a different graph is loaded. It is restored
automatically when the window is next opened. To include the graph in a
workspace, use File → Save Workspace.