--> AutoPi CAN-FD Pro: Dual-channel J1939 & CAN-FD data logger built on Raspberry Pi Compute Module 4.
Hardware NEW

Our NEW
AutoPi CAN-FD Pro

Dual-channel CAN-FD and J1939 data logger built on Raspberry Pi Compute Module 4. Captures both CAN-FD channels simultaneously at >3,000 frames/sec, decodes frames on-device using DBC files, and pushes raw or decoded data to AWS S3, local eMMC or an external USB drive — without any server-side processing. Native J1939 PGN/SPN support covers trucks, excavators and heavy construction machinery out of the box.

AutoPi CAN-FD Pro
Dual-channel can0/can1 — >3,000 frames/sec each
On-device DBC decoding with J1939 PGN/SPN
Local-first storage + AWS S3 sync with rollover
Tailscale VPN + NXP SE051 hardware crypto
Docker · Python · SocketCAN · SaltStack on CM4
Plug-and-play in any 12V or 24V vehicle
In stock - ships tomorrow
AutoPi CAN-FD Pro
Dual CAN-FD

can0 + can1

Up to 5 Mbps per channel. >3,000 frames/sec. Independent config.

J1939 Native

PGN / SPN

29-bit identifiers. DBC decoding. Active query engine. 12–35V DC.

Edge Compute

CM4 · Docker

Full Linux. SocketCAN. SaltStack. Run containerized applications.

Storage & Upload

32 GB + S3

eMMC + USB expansion. AWS S3 sync. Local-first with auto-resume.

Security

NXP SE051

Hardware crypto signing. Tailscale SSH. Tamper-evident logging.

Cloud + API

Included free

Full REST API parity. OTA updates. Fleet templates. No subscriptions.

New

Engineering-grade datalogging in a compact device

The AutoPi CAN-FD Pro is built around the Raspberry Pi Compute Module 4 running a hardened Raspbian OS with AutoPi Core - an open-source stack based on Linux, SocketCAN, Python and SaltStack. Both CAN-FD channels are independent and configurable per-bus, supporting classic CAN (up to 1 Mbps) and CAN-FD (up to 5 Mbps data phase). J1939 (PGNs/SPNs), OBD-II and ISO 15765-2 are handled natively, with mixed 11-bit and 29-bit identifiers on the same bus. Tailscale VPN provides secure SSH access to any deployed device without opening firewall ports.

AutoPi CAN-FD Pro with antenna kit

Ships with a 4-in-1 antenna kit (2× 4G/LTE, 1× GPS, 1× WiFi/BLE) - ports are labeled for error-free field installation.

4 GB LPDDR4 RAM and 32 GB eMMC storage, expandable via USB drive for continuous long-duration field logging.

AutoPi Core OS pre-installed: SocketCAN, Python, SaltStack and Docker runtime ready out-of-the-box.

Processor

Broadcom BCM2711 Quad-core Cortex-A72 (ARM v8) 64-bit SoC @ 1.5GHz (RPi CM4)

Memory

4GB LPDDR4 SDRAM

Storage

32GB on board eMMC (expandable with USB flash drive)

Modem

Integrated 4G/LTE Cat 4 connection (3G/EDGE fallback) (150Mbit DL / 50Mbit UL) (Global connectivity in a single device)

Secure Element

NXP SE051 hardware security element - cryptographic data signing and hardware-accelerated encryption for tamper-evident logging pipelines.

GPS/GNSS

Integrated GPS + A-GPS (GPS/GLONASS/BeiDou/Galileo/QZSS)

Power

12–35V DC input. Supports 12V (passenger vehicles), 24V (trucks and buses) and up to 35V (heavy machinery). Single hardware variant covers all vehicle types.

Expansion

2 x USB, Gigabit Ethernet and HAT

Wireless

Bluetooth: Bluetooth 5.0 + Bluetooth Low Energy (BLE)

WiFi: 2.4GHz and 5GHz IEEE 802.11.b/g/n/ac wireless LAN

Accelerometer

3-Axis accelerometer

Gyroscope

Built in 3-axis gyroscope

Automotive Interface

2× independent CAN-FD channels - classic CAN up to 1 Mbps, CAN-FD data phase up to 5 Mbps. Capture rate >3,000 frames/sec per channel. Native J1939 (PGN/SPN), OBD-II (SAE J1979) and ISO 15765-2 support. Mixed 11-bit and 29-bit frame IDs on the same bus. Hardware pass/block filters per frame ID. Configurable bus termination and auto-detection per interface.

Input Slots

SIM Card: Nano SIM - (SIM subscription purchased separately)

Audio

Built-in speakers

Video Out

mini HDMI @ 1080p60 Video Output

Operating System

Raspbian OS with preconfigured AutoPi Core software

CAN Logging Engine

Dedicated can0/can1 logging stack with optional external dump process for high-throughput workloads. Worker interval, startup delay, output rollover, and disk housekeeper behavior are configurable in AutoPi Cloud advanced settings. Runtime health can be inspected with logger.status.

Decoder Engines

Two onboard decoder pipelines: Standard decoder (CSV, JSONL, LOG) for higher throughput and ASAM decoder (MDF4) for measurement workflows. DBC collections are imported from cloud and executed locally on-device. Recommended J1939 Frame ID mask: 1FFFFF00.

Query Engine

Native OBD-II PID, J1939 PGN and raw CAN query types. Configure interval, run-at policy, start delay, loop count, response verification, pass filters and result formulas. Queries can trigger workflow returners for immediate integration with backend systems.

Event Automation

Frame listeners and event reactors support rule-based automation from live CAN traffic. Match by ID, mask, frame payload or Python expression, then trigger custom workflows (handler, converter, trigger, filter, enricher, returner). Example event tags include vehicle/bus/can0/autodetected and system/disk_housekeeper/critical_purge.

Technical Capabilities

Everything runs on the edge

Decoding, filtering, enrichment and export all execute on the CM4 processor - no cloud compute required between capture and storage.

CAN0 · CAN1 · simultaneous

Dual CAN-FD Capture

Both channels log simultaneously and independently. Classic CAN up to 1 Mbps and CAN-FD data phase up to 5 Mbps. Capture rate exceeds 3,000 frames/sec per channel. Bitrate, bus termination and auto-detection configurable per interface remotely from AutoPi Cloud.

J1939 · OBD-II · ISO 15765-2

Protocol Support

Native J1939 PGN and SPN logging for trucks, excavators and heavy machinery. OBD-II PID queries over ISO 15765-2. Mixed 11-bit and 29-bit frame IDs on the same bus. Hardware pass/block filters per frame ID reduce CPU load and storage footprint on dense J1939 buses.

DBC → JSON / MDF4 / CSV

On-Device DBC Decoding

Upload proprietary DBC files via AutoPi Cloud. Decoding runs on the CM4 edge processor - raw frame bytes become named signals before upload. Output in JSON, MDF4 or CSV. No server-side decoding pipeline needed between the vehicle and your data store.

AWS S3 · SFTP · eMMC · USB

Flexible Data Export

Continuous upload to Amazon AWS S3 over 4G/LTE or WiFi. Pull files via SFTP/SCP over Tailscale VPN. Store on 32 GB internal eMMC or attach a USB drive for long-duration field logging. The device buffers locally when connectivity is lost and resumes upload automatically.

Docker · Python · SocketCAN · SaltStack

Edge Computing

Deploy containerized applications directly on the Raspberry Pi CM4. Use SocketCAN and Python to interact with live CAN buses in custom logic. Run protocol translation, lightweight ML inference or data fusion on-device - Docker images versioned and updated remotely via AutoPi Cloud.

Tailscale · NXP SE051 · OTA

Remote Access & Security

Tailscale VPN provides SSH access to any field-deployed device without opening firewall ports. NXP SE051 hardware security element enables cryptographic data signing for tamper-evident logging. OTA firmware and Docker image updates via AutoPi Cloud with rollback support.

Platform vs logger

More than a data logger.

On-device execution

DBC decoding runs on the CM4

Import DBC files via AutoPi Cloud. Frames are decoded to named signals locally before upload - no server-side processing pipeline between vehicle and storage. Output in JSON, MDF4 or CSV.

Compute platform

Docker containers alongside logging

Deploy containerized applications to the same device capturing CAN data. Containers access SocketCAN directly - enabling protocol translation, local ML inference or custom signal processing without external hardware.

Event automation

Frame listeners and workflow hooks

Define frame listeners with ID/mask filters. Bind event reactors and workflow hooks (handler, converter, trigger, filter, enricher, returner) to execute targeted logic on specific CAN frame matches - without polling or cloud round-trips.

Fleet control plane

SaltStack-managed configuration at scale

AutoPi Cloud applies configuration changes to individual devices, groups or full projects via SaltStack. Channel setup, logger templates, DBC deployments and OTA firmware are all managed from one interface - or via the REST API at api.autopi.io.

Your data. Your server. Zero lock-in.

Open stack. Open API. Open platform.

  • Push to your own AWS S3 bucket - not a vendor-managed server
  • Full REST API at api.autopi.io - same operations as the Cloud UI
  • AutoPi Core is open-source - Linux, SocketCAN, Python, SaltStack
  • Install your own OS or custom Docker images on the CM4
  • AutoPi Cloud included free - no per-device subscription fees
  • CE, FCC and RoHS certified. Designed and produced in Denmark
Extendable

Extend the AutoPi CAN-FD Pro to any vehicle or machinery

Our extension and adapter cables provide a simple way to connect AutoPi devices to a wide range of vehicles and machinery. The heavy-duty adapters support common J1939 connectors used in trucks and industrial equipment, while the standard adapter range includes OBD-II extensions, power cables, splitters, and vehicle-specific adapters. Together, they ensure flexible installation, reliable data access, and compatibility with both light-duty and heavy-duty systems.

See all adapters

Female CAN Bus cable with open wires

Female CAN Bus cable with open wires

OBD-II to dual DB9 adapter

OBD-II to dual DB9 adapter

Cummins-Komatsu Truck 12 PIN J1939 to 16 PIN OBD-II Adapter

Cummins-Komatsu Truck 12 PIN J1939 to 16 PIN OBD-II Adapter

Cummins 9 PIN J1939 (J1708) to 16 PIN OBD-II Adapter Cable

Cummins 9 PIN J1939 (J1708) to 16 PIN OBD-II Adapter Cable

Caterpillar (538-5051) Truck 9 PIN J1939 to 16 PIN OBD-II Adapter

Caterpillar (538-5051) Truck 9 PIN J1939 to 16 PIN OBD-II Adapter

AutoPi CAN-FD Pro

AutoPi Cloud Control Plane for CAN-FD Pro

Use AutoPi Cloud to orchestrate channel setup, logger lifecycles, decoder pipelines and output handlers across your entire deployment. Configure can0/can1 bitrate strategies (autodetect or fixed), hardware termination, pass/block filters, DBC decoding and output routing from one interface. Define raw and decoded file rollover policies, S3 sync intervals and retry behavior, then monitor execution via live status and event streams.

AutoPi Cloud is included with all our devices. 100% free with the CAN-FD Pro device.

View more Open User Guide
AutoPi TMU CM4
CAN bus logging from dual interface.
Configure independent loggers for each CAN-FD channel from AutoPi Cloud. Set bitrate, termination, auto-detection and hardware filters per bus. J1939 PGN subscriptions and OBD-II PID requests are configured in the same interface - no SSH or command-line access to the device required.
Configure storage endpoints.
Define where logged data is delivered - Amazon AWS S3 buckets, local 32 GB eMMC, or an attached USB drive. Failover between endpoints is configurable: the device buffers data locally when connectivity is lost and resumes upload automatically when the link recovers.
Configure CAN bus decoding.
Upload DBC files through AutoPi Cloud and the device decodes CAN frames to named signals locally. Output format is selectable - JSON, MDF4 or CSV. Decoding runs on the CM4 processor, not on cloud infrastructure, cutting latency and eliminating external processing costs.
Remote live debugging.
Use Tailscale to SSH into any deployed CAN-FD Pro and interact with live CAN buses via SocketCAN tools (candump, cansend, canplayer). Deploy and update Docker containers remotely. Inspect logs, trigger captures and restart services from any network without VPN client configuration on the vehicle side.
Setup advanced CAN bus filters.
Configure hardware-level pass and block filters per CAN frame ID on each interface. Filter unwanted traffic before it reaches the processor - essential for high-density J1939 buses where hundreds of PGNs are broadcast simultaneously. Reduces storage usage and upload bandwidth proportionally.
Setup mix-in of additional data and encryption.
Fuse CAN data with GPS position (GPS/GLONASS/Galileo/BeiDou), 3-axis accelerometer and 3-axis gyroscope readings on-device. Sign data packages with the NXP SE051 hardware security element - cryptographic proof of origin and tamper evidence for audit-sensitive deployments.
Use cases

Where the CAN-FD Pro gets deployed

Heavy machinery

J1939 data logging on trucks and excavators

Connect via Cummins, Caterpillar or Komatsu J1939 adapter cables. Log PGNs for engine load, fuel rate, coolant temperature, RPM and hours-of-operation. Decode on-device using a J1939 DBC and push MDF4 files directly to S3 or an on-premise server via 4G/LTE.

protocol: J1939   |  output: mdf4

R&D and test engineering

Dual-bus capture for protocol analysis and DBC development

Capture raw CAN-FD frames simultaneously on can0 and can1 at >3,000 frames/sec per channel. Export JSONL or binary for offline analysis in Python, MATLAB or Vector Analyzer. Use the ASAM decoder to validate DBC files and compare raw vs decoded signal output before production deployment.

can0 + can1  |  >3000 fps  |  raw JSONL + MDF4

Predictive maintenance

On-device anomaly detection with frame listeners

Define frame listeners with ID/mask filters targeting fault-indicating PGNs. Bind event reactors to trigger immediate alerts, log snapshots or custom workflow hooks when threshold conditions are matched - without round-tripping to cloud infrastructure for the decision.

frame listener → enricher → returner → alert

Fleet telematics

Template-driven fleet configuration at scale

Define a single device template in AutoPi Cloud covering channel setup, logger configuration, DBC assignment and upload policy. Apply it to a project or vehicle group - SaltStack propagates the configuration on next device connection. Manage firmware and Docker image rollouts with per-device progress tracking.

template → group/project → SaltStack → device

Custom edge applications

Protocol translation and on-device ML inference

Deploy Docker containers alongside the CAN logging stack on the same CM4 hardware. Containers access SocketCAN interfaces (can0, can1) directly - enabling custom protocol adapters, lightweight signal classifiers or real-time data fusion pipelines that run entirely on-device without additional compute nodes.

Docker → SocketCAN → custom logic → output

Audit and compliance

Tamper-evident logging with hardware-signed data

The NXP SE051 hardware security element signs logged data packages cryptographically on the device before upload. Combined with GPS position and IMU data fusion, this creates a verifiable, tamper-evident record of vehicle behavior and location - suitable for legal, insurance and regulatory audit workflows.

NXP SE051 sign → GPS + IMU fused → S3 upload
Operational Workflow

From unboxing to production logging

Every step is documented in the Pro User Guide and configurable via AutoPi Cloud or REST API.

01 Connect

Connect and power

Connect can0 and/or can1 via the appropriate adapter cable - OBD-II, J1939 9-pin or J1939 12-pin. Apply 12–35V DC. The labeled 4-in-1 antenna kit (4G×2 + GPS + WiFi) installs in seconds. Device boots AutoPi Core and appears in AutoPi Cloud within minutes.

# device online event
system/device/online
power: 24V  |  modem: 4G/LTE
02 Detect

Detect the bus

Run the autodetect strategy from AutoPi Cloud - Any (passive), OBD (active SAE J1979) or J1939 (active PGN scan). The detected bitrate and protocol are confirmed via event tag. Lock the bitrate, configure per-channel termination and set send/receive mode.

# autodetect result
vehicle/bus/can0/autodetected
bitrate: 250000  |  J1939
03 Log

Configure the logger

Create named loggers per channel with pass/block ID filters. Select Standard (CSV/JSONL/LOG) or ASAM (MDF4) decoder, import your DBC file, choose signals and set rollover size. Configure output workers - local eMMC, USB and/or S3 with sync interval and retry count.

# logger writing
vehicle/bus/can0/logger/raw/writing
decoder: asam  |  output: mdf4
04 Monitor

Monitor and validate

Query runtime logger status, inspect fps per channel, verify S3 sync completion events and monitor the event stream in AutoPi Cloud. Tailscale SSH gives direct shell access to the device for live candump captures or Docker container inspection from any network.

# s3 sync confirmed
vehicle/bus/can0/logger/<name>/s3_sync/completed
// contact

Still have questions?

Get in touch with us - we're ready to answer any and all questions.

// send a message
We'll get back to you shortly

* Mandatory fields

Contact our engineers ↑