CAN Bus Ethernet Interface: Stream via USB, LAN, WiFi, LTE
What if your CAN bus interface worked from anywhere?
Most engineers know the classic CAN-USB interface: Plug it into your PC, open your software and stream CAN data. It works - but it is bound by the USB cable.
In this article, Martin Falch shows how the CANsub combines that familiar plug & play simplicity with the flexibility of Ethernet - enabling real-time send/receive CAN bus access via USB, LAN, WiFi or even remote LTE - from any PC, tablet or phone.
In particular, Martin covers 5 practical showcases to go from a basic USB test bench
- to
streaming live vehicle data from a moving car via LTE!
Read on to expand how you think about CAN interfaces.
In this article
We'll provide awesome practical showcases of using the CANsub for streaming CAN data from/to anywhere!
Why CAN via Ethernet - and key challenges
A classic CAN-USB interface is a great bench tool - and we've used them as such for 10+ years. But USB is not ideal for physical distance, multiple users or remote CAN buses. Below are example situations where CAN-USB streaming is impractical:
Out of physical reach
The CAN connector is inside a (moving) vehicle, an electrical cabinet, in another room - or even just 10 meters away from your laptop
Multiple devices/users
In e.g. test labs, a team of engineers may need ad hoc access to many CAN buses in many locations - USB makes this impossible
Remote deployments
Prototype vehicles, customer machines, field equipment: The CAN bus you need to access is often hours (or continents) away from your location
Installation issues
Installing a CAN-USB interface typically involves drivers, COM ports, OS quirks and IT restrictions - while tablets / phones are ruled out entirely
As we'll show, these USB limitations can be solved via a CAN-Ethernet interface. However, doing this well comes with 4 key challenges:
Latency vs. timing
Once CAN frames travel a network with latency, PC-based timestamping / transmission is unreliable - and multi-device setups add sync challenges
Cyber security
A networked CAN bus interface can read/write from/to critical operational CAN buses - making data encryption and access control vital
Where is it?
Finding a network device can be difficult - i.e. 'what is the IP'? And in multi-device setups across a wide area this can quickly become a real problem
Any-device access
To leverage the full flexibility of Ethernet, any authorized PC, tablet or phone on the network should be able to access the CAN data with zero installation
The solution: CANsub - one CAN interface, any distance
The CANsub is a pro specs CAN bus interface with 2-4 CAN FD channels - and both a USB and Ethernet port.
Critically, it does not have a 'USB mode' and 'Ethernet mode'. Instead, the device serves the same HTTPS interface and open REST/WebSocket API regardless of how you connect.
This means that you can 'start simple' and use the CANsub as a regular CAN-USB interface. Then, when your deployment requirements change, you can use the same device, software/API and workflows via LAN, WiFi or remote/LTE access.
Several CAN-Ethernet gateways exist on the market - but they generally focus on tunneling CAN between fixed points (e.g. bridging two buses across a plant) or feeding CAN into automation systems. They are configured once and deployed permanently - rarely offering the interactive streaming experience of a CAN-USB interface.
The result is two separate devices: Plug & play USB interfaces for interactive work, gateways for fixed deployments.
However, the CANsub deliberately spans both: You can use it as a plug & play CAN-USB interface at the bench or as a secure network interface - with the exact same workflows. This lets you start with the familiar USB connection and expand to networked deployments if your needs grow.
Why the CANsub is ideal for CAN-Ethernet streaming
Below we outline key CANsub functionality that addresses the challenges from before:
1: Hardware timestamps, transmit sequences and PTP
Network latency must not affect your CAN data quality. The CANsub therefore timestamps every RX/TX frame at 1 µs resolution 'at the edge'. Whether CAN frames then travel 1 ms (LAN) or 100 ms (LTE) to reach your PC has no impact on timestamps.
Further, transmit sequences can be deployed as jobs on the device, achieving 10 µs edge-based inter-frame precision - independent of host and network latency.
And for multi-device setups in e.g. end-of-line testing, the CANsub supports the Precision Time Protocol (PTP) to enable a cross-device time sync precision of 10 µs.
2: E2E security via TLS/mTLS
The CANsub encrypts all communication via TLS out-of-the-box. Further, for Ethernet deployments you can optionally enable mTLS (TLS Mutual Authentication) so that only clients holding a valid certificate can reach the device - even if the network itself is compromised. For details, see our secure CAN interface article.
3: Instant device discovery
On boot, the CANsub's LCD shows the device URL/IP for intuitive access. Further, you can bookmark the URL (e.g. [DEVICE-ID]-eth.local) to later access the device in one click.
The CANsub also advertises itself via mDNS, letting tools like python-can (or AI agents) auto-discover all devices/channels on the network - ideal in multi-device setups.
4: Access your CAN data from any device
The webCAN app is served by the CANsub itself: Enter the device URL in any browser to stream, DBC decode, plot and transmit CAN data. No installation, no internet required. It runs on Windows, macOS, Linux, ChromeOS, iOS and Android alike.
As a result, any authorized engineer can instantly access any CAN bus in their browser - with no installation required. Further, connecting the CANsub to a WiFi router even enables the use of tablets/phones to access your CAN data.
How to get started
A core feature of the CANsub's connectivity is that you can adopt it one step at a time:
- Start with USB: Connect the CANsub to your PC, enter the URL from the LCD in your browser - and start streaming CAN data via webCAN in seconds
- Go LAN: Power the CANsub via a USB charger (or PoE adapter) and connect it to your router - you can now access the device from any PC on the network
- Go WiFi: Connect the CANsub's Ethernet port to a WiFi router at the asset to access the device wirelessly from your laptop, tablet or phone
- Go remote: For mobile assets, connect the CANsub to a VPN-enabled LTE router - and access the CAN bus from anywhere via the internet
The CANsub Intro provides step-by-step guidance for each of the above setups.
The CANsub and the CANedge complement each other. The CANsub is a streaming interface using a 'pull' model: A client (browser, script or app) connects to the device to receive and transmit CAN data in real-time - ideal for interactive diagnostics, development and test automation.
The CANedge is a standalone CAN logger using a 'push' model: It records data to an SD card and can automatically upload it via WiFi or LTE to your own server - with no client connection required. This makes it ideal for continuous logging and telematics across e.g. vehicle fleets.
Technical: CAN RX/TX considerations for high-latency networks
If you deploy the CANsub in a high-latency setup (e.g. via LTE), it is important to understand the implications:
RX: Timestamps are OK - but frame loss risk
All CAN frames are edge-timestamped by the CANsub at 1 µs resolution. Latency may delay when frames arrive at your PC (e.g. a live plot may briefly jitter via LTE) - but the timestamps remain valid: Your data is equally precise over LTE vs USB.
In our tests, an office VPN showed 10-20 ms latency, while LTE showed 80-120 ms with spikes of 400+ ms. As a practical consequence, streaming high frame rates (1K+ frames/second) over a spiky high-latency connection can overflow the device buffer, causing frame loss. This can be alleviated by configuring hardware filters so only relevant frames hit the network.
TX: On-device sequences beat host-controlled
Remote access use cases often require the CANsub to transmit CAN frames - e.g. for cyclic OBD/UDS requests or ECU calibration. If your PC schedules each frame (e.g. a python-can script sending every 150 ms), every frame inherits the network's jitter. On LTE this can result in significant variation in the inter-frame spacing.
As visualized, it may still be possible to achieve 'sufficient' host-controlled TX timing precision for some remote use cases. However, when possible, it is recommended to leverage the CANsub's edge-based 'transmit sequences'. These enable 10 µs precision, no matter how laggy the connection - ideal for cyclical requests or simple ECU configurations / calibrations.
The two also combine: In python-can you can e.g. run an XCP seed/key exchange host-side then switch to a transmit sequence.
5 x showcases: From USB bench to remote LTE streaming
To illustrate the CANsub's connectivity I'll run 5 practical showcases - from basic USB streaming to advanced LTE deployments.
As part of the showcases, I sometimes use Claude Code to work with my CANsub devices. For this purpose I have provided the CANsub LLM-friendly documentation and created a simple skill as explained in the CANsub Intro. This effectively just lets me talk to my CANsub devices - enabling rapid deployment changes such as firmware updates, mTLS deployment, config changes, custom ad hoc app creation and more. The REST/WebSocket API of the CANsub makes it uniquely suited for agentic workflows.
1: CAN-USB bench streaming in 1 min
Let's start with a simple CAN-USB desk setup:
- I connect my CANsub.2 via USB to my PC (powering it up)
- Next, I connect CAN1 to a CANmod.input (analog-to-CAN)
- I type my device URL from the LCD in my browser
- In webCAN I load the DBC and assign it to CAN1
- Finally, I click 'connect' to start streaming
As per the video, this lets me stream the raw CAN frames and DBC decoded signals in seconds - with zero installation.
To transmit data, I can use webCAN's 'Transmit Sequences' panel to send custom CAN frames onto the bus with edge precision - visible instantly in the trace view alongside the received traffic.
This should be familiar if you've used other CAN-USB interfaces!
(maybe except the edge TX precision, awesome LCD display and the 100% free on-device webCAN software).
But wait, there's more...
2: 8 x CAN on LAN + python-can + PTP
Ok let's take it up a notch:
Now I'll deploy 2 x CANsub.4 via LAN - i.e. 8 x CAN in total, a common use case in e.g. end-of-line/automation/test setups.
In contrast to USB, I now have practically unlimited deployment flexibility. For example, I could connect the CANsubs to switches in separate rooms - or wire up a device 50 meters away.
Today, however, I'll just connect both units to an office switch.
I power each unit through our PoE adapter, so a single Ethernet cable carries both power and data - simplifying my installation.
To check my setup, I open webCAN for each device in my browser - and bookmark the device URLs for ease-of-access.
If you start deploying many CANsub devices on the network, bookmarking the URLs can quickly become tedious and inefficient. In practice I simply tell Claude Code which devices I want to interact with and how. Claude will use the python-can-cansub discovery function (via mDNS) to list all CAN channels across all CANsub devices. Based on my context it'll then quickly identify the relevant devices - e.g. based on the number of CAN channels or by using REST to check the actively set bit rates, frames recorded, etc.
Cyber security: Enabling mTLS
Right now the rest of my team can also access my CANsubs via the same URLs - and screw up my showcase!
To avoid this I'll enable mTLS (mutual TLS authentication) on the 2 devices with a CA-signed certificate, authorizing only my PC to access the devices. The steps are described in the CANsub Docs, but I'm lazy so I ask Claude to set it up - which it does in 3 min.
Test lab simulation (python-can)
Next I want to create a simulated test lab. To stay pragmatic I cheat a bit: I'll use a CANsub.2 as my simulator and use some cable hacks to chain together all 1 + 8 CAN channels on a single bus. The output from my CANsub.2 CAN1 now gets duplicated onto all 8 x CAN channels across my two CANsub.4 devices.
I use python-can to set up the CANsub.2 to simulate CAN data for recording by my 2 x CANsub.4 (details below).
To visualize this TX/RX simulation script, I also add a 'test lab dashboard' which shows how these fictive test runs perform across the 8 x CAN buses - and basic functionality for storing the raw/decoded data streams as log files locally and in S3.
As evident, the video shows a common practical challenge for multi-device setups: The independent device clocks drift apart - eventually resulting in problematic timestamp deviations.
Luckily, this is where the CANsub's PTP support comes in.
The simulator is a small python-can script: It encodes 'physical' signal values (sine waves, random walks, ...) into CAN frames via a DBC file (using cantools) and transmits them through the CANsub.2 at fixed periods per message. Roughly 1 in 5 test runs deliberately injects an outlier that pushes one signal beyond its threshold band - giving the evaluation logic real failures to catch and plot.
The consumer app opens 8 python-can buses across the two CANsub.4 units and DBC decodes the frames on the fly to drive the live dashboard and tests. Importantly, the code doesn't care where the devices sit: A CAN channel is just a hostname / IP, so the same script works via USB, on the office LAN - or from home via VPN.
CAN frame timing is critical for test lab setups. The app therefore evaluates this for each 'test run'. Every CANsub RX/TX CAN frame is hardware-timestamped. This lets the app do two test evaluations: First, it checks if the interframe spacing within each CAN bus matches the expected transmit period. Second, it compares the timestamps across CAN channels for the same physical frames (CANsub.2 TX ACK vs. CANsub.4 RX) to test if the cross-device clock drift goes beyond the specified threshold.
Our end users often want to 'log data to a backend' (e.g. local disk, database, data lake, ...) while simultaneously being able to 'view the data in true real-time dashboards'. This example does exactly that: As long as the python-can app is running, the CANsub devices will actively stream data - and the script will store the data as defined. In this case, I store the raw data as CSV files locally, while the DBC decoded data is stored as Parquet files in an S3 bucket - similar to e.g. our Grafana-Athena workflow for our CANedge devices.
It is important to note that if your goal is to run a setup like this 24/7, you will need a host (e.g. a Raspberry Pi, virtual machine, ...) that is continuously online - and your scripting logic must be resilient against various logging challenges - such as network outages, glitches, disconnects, script memory leaks etc. Further, if there is even just a transient network outage/glitch, you may experience data loss.
If your use case demands 100% reliable data logging, I recommend using the CANsub for your real-time streaming needs - and a CANedge for logging the data reliably to an SD (or via WiFi/LTE to your own server). However, if logging is more of a secondary 'nice to have' functionality, you can achieve both with a CANsub.
10 µs cross-device clock sync via PTP
When a CANsub is initialized e.g. via webCAN or python-can, the client will 'PUT' the PC time to the device - serving as a baseline for the hardware based timestamping. But over time this clock will 'drift'. This is typically irrelevant in single-device setups - but can be a problem if you need to monitor e.g. 8 x CAN with perfect cross-channel synchronization.
To solve this, we set up one of our office Linux PCs to act as a 'PTP master' on the network. On boot, the CANsub.4 units immediately start PTP-syncing their clocks - and as a result our test simulation no longer exhibits interframe spacing failures. Instead, we're seeing a perfect cross-device sync of < 10 µs.
As another way of visualizing the impact of PTP, we hook up the 2 x CANsub.4 to a CANmod.input producing a continuous signal onto all 8 x CAN. In SavvyCAN we can connect CAN1 of both CANsub.4 devices and plot the signal from both channel sources.
As evident, PTP ensures that the signal plots from the two devices align perfectly (lower half), in contrast to the default setup without PTP (upper half).
In this scenario we use an office Linux PC as the PTP master, running this in 'software'. While a very basic/simple setup, it gives a 99.9%+ reduction in the cross-device sync error (from 10-50 milliseconds to 5-10 microseconds). You can also deploy a dedicated hardware-based PTP master to achieve even better cross-device sync, as well as absolute timestamp precision. Via REST you can poll PTP-related information from each CANsub, which we display in separate panels in the test lab dashboard app, which can be useful in evaluating/adjusting the setup.
3: Vehicle CAN-WiFi access from 50 m
What if you could stream your CAN data via WiFi?
For this showcase I'll leave the office and instead install the CANsub.2 in my Kia EV6 via an OBD2-DB9 adapter. I connect the CANsub's Ethernet port to a small RUT200 WiFi/LTE router. The RUT200 is powered via a cigarette-receptacle adapter, while my CANsub.2 is powered via USB from my car.
With my car idling, I connect to the RUT200 WiFi via my laptop. I open webCAN, where I've loaded the Kia EV6 DBC file. I also add a transmit sequence to perform a 5 Hz multi-frame UDS request for BMS data. I start the TX sequence, plot the decoded signals in real-time - and start walking away with my laptop.
At 50+ m from my EV6, I am still streaming CAN data via WiFi.
Oh, and since we're on WiFi I can also use my iPad to stream data via webCAN. This may seem like a gimmick, but it means that your team can e.g. hang an iPad on your wall and instantly create a real-time dashboard of your test lab CAN buses.
The ability to stream data via WiFi is extremely useful e.g. for technicians who need to troubleshoot vehicle/assets in the field - without obstructing the operator. Or, simply for cases where the CANsub may be permanently deployed in hard-to-reach locations. As before, mTLS can be used to restrict access.
4: Lab CAN data from home via VPN
How about working from home?
As an engineer you may need to connect to a CAN bus test bench - but you're working from home or another office. Or, maybe you need inputs from a colleague in another country.
With the CANsub, you can easily do this: Simply connect the device via LAN - and access your network remotely by VPN.
To show this in action, I use OpenVPN to connect to our office network from home - and access my CANsubs from showcase 2.
In fact, I used this setup extensively in writing the 2nd showcase, with Claude finalizing/testing the python-can script via VPN while I worked from home - with full access to the office CANsubs.
5: LTE streaming from a moving car
Let's combine things - and really stretch the CANsub reach!
In this showcase, I'll re-use the Kia EV6 setup from showcase 3, but now I'll stream CAN data via LTE - while the car is driving!
Warning: Only do this with VPN, mTLS and if you know what you're doing. Use listen-only mode when possible.
To do this, I follow our CANsub Intro step-by-step guide, in which we use plug & play scripts to deploy an Amazon Lightsail VPN server and configure the RUT200 as a VPN client. This takes ~30 min to deploy and Lightsail costs ~5$/month. The setup scales to fleets of devices and multiple users.
I also want to add some GPS data, so I connect a CANedge2 incl. GPS to the 2nd port of my CANsub.2 and configure the CANedge to output the internal GPS data onto the CAN bus.
Next, I activate my WireGuard VPN client and confirm that I can access my CANsub via webCAN over the internet and that I can stream both the UDS EV6 data and the GPS data - great!
In order to produce GPS data for my CANsub, I could have simply used a CANmod.gps. However, the setup I use can be relevant in many deployments when you want to combine reliable CAN logging with real-time streaming. As mentioned previously, I believe the best way to do this is to deploy both a CANedge and a CANsub.
This specific setup uses a CANedge2 incl. GPS, which allows me to leverage the RUT200 LTE connection to auto-push all my data from the CANedge2 to an S3 bucket (if I want to collect all of it). However, I can also just use the CANedge2 as an 'offline blackbox' with cyclic logging with the web server interface enabled. This way, if I want to pull specific logs to e.g. investigate a historical issue, I can simply leverage the VPN connection to access the CANedge2 SD card contents via WiFi and selectively pull the data relevant to me - thus minimizing the LTE transfer costs.
Creating the custom EV6 dashboard web app
To properly visualize the data, I want to do a bit of custom stuff. For example, I want to be able to visualize the car's GPS position on a map, which webCAN does not support. Further, I want to provide users with the ability to interactively request parameters from the car within the custom app.
The simplest way is to again use python-can as in showcase 2. However, the app then relies on Python running in the background - making it harder to share with others.
Instead, I'll use our Javascript/Typescript libraries to build a pure web app, leveraging the CANsub's REST/WebSocket API. I ask Claude Code to do this with a few prompts (~10 min of effort, zero coding). The result is an HTML file I can use locally or host on a web server (no backend).
With the app, any user with VPN + mTLS access can now track the EV6 in real-time while it is on-the-road - with sub-second latency. The app auto-initializes an edge transmit sequence on the CANsub to cyclically request UDS data from the EV6. In addition, the app also lets me click a button to trigger specific UDS requests for updated tire data ad hoc via host-controlled TX.
While not an obvious feature, the fact that the CANsub exposes a network interface with REST/WebSocket APIs makes it uniquely able to interface directly with pure web apps. In contrast, classic CAN-USB interfaces would require some middleware such as python-can to achieve this - adding a cumbersome backend to the setup.
During development, it's a neat bonus that you can seamlessly switch between USB and Ethernet with no impact on the code, enabling agnostic apps and simpler testing.
In this case, the app not only serves to visualize incoming data streams - it also performs device configuration via REST and enables host-controlled transmission. This last part is also subtle, but important: The on-device transmit sequences offer powerful edge precision - but have limits on e.g. the number of frames per sequence. For advanced use cases like ECU calibration/flashing, remote configuration, seed & key authentication and more it may be necessary to use host-controlled TX instead. As per our technical deep dive on latency, you should evaluate the limitations of LTE for your specific use case if you embark on deploying host-controlled TX in your apps, however.
The web app libraries are available on-request for CANsub users and let you skip all the 'hard work' to instantly create custom web apps for the CANsub. Contact us for details.
For the interested reader, below is my initial starting prompt for Claude Code when building the app. I always use 'plan mode', review/edit the plan and then I evaluate the 1st draft. In this case I had a few modifications (mainly on the layout/visuals), but the overall tweaks were minimal. A useful trick is to give Claude Code access to your CANsub via USB and chain CAN1-CAN2 with a DB9-2xDB9 splitter and a terminal resistor. This lets Claude test out the app 'live' by replaying a CSV (as in my case) or just simulating data between CAN channels - as well as verifying the REST configuration changes like the transmit sequence.
Example use cases
Below we outline example use cases for CAN-Ethernet streaming with the CANsub:
Test labs with many CAN buses - and one network
Need to monitor multiple CAN buses across a lab from any PC?
Connect each CANsub in your test lab to the network via Ethernet, optionally powered through the PoE adapter for single-cable wiring. Every engineer can open any device via its bookmarked URL - streaming, DBC decoding and transmitting via webCAN with zero installation. Adding a rig is a one-click operation: Save the device configuration as JSON and reload it on the next CANsub. With PTP enabled, data from all devices shares one time base - ideal for correlating signals across rigs.
Wireless diagnostics on vehicles in the field
Need to troubleshoot a vehicle without interrupting its operator?
Connect the CANsub via Ethernet to a WiFi router on e.g. heavy-duty vehicles or machinery. Field technicians can then open webCAN wirelessly from a laptop or tablet - streaming live J1939 data or running extensive diagnostic request sequences with 10 µs on-device scheduling, all without entering the cab or halting operation. With mTLS enabled, only authorized technicians can connect - even if the WiFi is compromised.
Remote wind turbine diagnostics via LTE
Need to troubleshoot a wind turbine - without sending a technician up?
Wind turbines are stationary, but far from the people who maintain them - and a site visit is costly, especially offshore. Permanently deploy a CANsub + LTE router in the turbine and connect both to a VPN: Engineers can now stream the turbine's CAN data (e.g. CANopen-based pitch/yaw systems) on demand and run diagnostic requests via on-device transmit sequences - dispatching a technician only when the data says so. Hardware filters keep the stream (and SIM cost) lean - and VPN + mTLS restrict access.
OEM end-of-line testing: From USB to Ethernet
Need a CAN interface for automated EOL test benches?
Since the CANsub registers as a standard python-can interface, it drops straight into existing test automation - receiving responses and transmitting test frames with no rewrite of your test logic. This also lets you upgrade EOL setups from USB to Ethernet connectivity: Test stations reach each device across the production network, with optional mTLS ensuring only authorized stations connect to each unit.
Key takeaways
I hope this article makes you think 'hey, does that mean I can do ... ?'
- and with the CANsub, the
answer is probably 'yes, easily!'
- Same device, any distance: The CANsub serves the same webCAN app and APIs via USB, LAN, WiFi and VPN/LTE - you can start at the bench and scale when you need to
- Any client: Zero-install browser access and open REST/WebSocket APIs mean the client can be a PC, tablet, phone, server or script - on any OS
- Timing survives the network: 1 µs edge-based timestamps, 10 µs on-device transmit sequences and PTP multi-device sync keep your data precise regardless of latency
- Secure by default: Uniquely, the CANsub encrypts all communication via TLS out-of-the-box - and mTLS lets you control exactly who can access each device
- Know the limits: Remote deployments - in particular in mobile assets via LTE - should consider safety, cyber security and latency
If you found this useful please share it in your community!
You are also welcome to contact me if you have any questions on the CANsub!
Ready to stream CAN data from anywhere?
Get your CANsub today!
