Vehicle Simulator with J1939 CAN Support¶

Overview¶

The Vehicle Simulator (gva-qt6-vehicle-sim) is a comprehensive testing and development tool for the GVA (Generic Vehicle Architecture) platform. It provides realistic vehicle dynamics simulation with integrated J1939 CAN bus message generation, enabling hardware-in-the-loop testing without requiring physical vehicle hardware.

Quick Start¶

1. Build the Simulator¶

cd /home/newman/repos/ldm/build
cmake ..
make gva-qt6-vehicle-sim -j $(nproc)

2. Setup Virtual CAN Interface¶

# Load kernel module
sudo modprobe vcan

# Create and activate vcan0
sudo ip link add dev vcan0 type vcan
sudo ip link set vcan0 up

# Verify interface
ip link show vcan0

Or use the provided script:

sudo scripts/test/j1939/setup-vcan.sh

3. Launch with Map¶

./build/bin/gva-qt6-vehicle-sim \
  --domain=0 \
  --map=data/opendrive/ZalaZONE_full.xodr

4. Start J1939 Gateway (Optional)¶

Bridge CAN to DDS for monitoring:

./build/bin/gva-j1939-gateway \
  --domain=0 \
  --interface=vcan0

5. Monitor with LDMX¶

./build/bin/ldmx
# Navigate to J1939 tab to see live parameters

Benefits of J1939 Simulation¶

🎯 Development & Testing Advantages¶

1. Hardware-Independent Development
2. Develop and test GVA applications without physical CAN hardware
3. No need for expensive vehicle ECUs or test benches

4. Parallel development across multiple teams

5. Realistic Vehicle Behavior

6. Generates authentic J1939 Parameter Group Numbers (PGNs) and Suspect Parameter Numbers (SPNs)
7. Simulates realistic vehicle dynamics (speed, RPM, gear changes, braking)

8. Provides time-synchronized sensor data

9. Cost Reduction

10. Eliminates need for physical test vehicles in early development
11. Virtual CAN interface (vcan0) enables testing on any Linux workstation

12. Reduces wear and tear on physical hardware

13. Rapid Prototyping

14. Instant feedback loop for algorithm development
15. Easy scenario creation and replay

16. Configurable message rates and data patterns

17. Integration Testing

18. Validate J1939 gateway functionality
19. Test data flow from CAN to DDS topics

20. Verify HMI responsiveness to vehicle parameters

21. Reproducible Testing

22. Deterministic vehicle behavior
23. Repeatable test scenarios
24. Consistent baseline for regression testing

J1939 Message Support¶

✅ Fully Supported PGNs (15 Active)¶

The vehicle simulator actively generates the following J1939 messages over CAN:

Total: 33 SPNs (Suspect Parameter Numbers) actively simulated

Detailed SPN List¶

J1939 to DDS Gateway Architecture¶

Data Flow Explanation¶

1. Message Generation Phase
2. Vehicle Simulator calculates realistic vehicle parameters based on driver inputs and physics
3. Encodes parameters into J1939 CAN frames with proper PGN/SPN structure

4. Transmits to virtual CAN interface (vcan0)

5. CAN Reception Phase

6. SocketCanReader Qt thread continuously reads from CAN interface

7. Validates CAN frame format (29-bit extended ID)

8. J1939 Decode Phase

9. J1939Decoder extracts PGN, source address, priority from CAN ID
10. Decodes SPNs using bit position, scale, offset

11. Applies engineering units

12. DDS Publishing Phase

13. Gateway publishes C_Parameter_Group_Definition (PGN metadata)
14. For each SPN: creates C_Parameter with value, timestamp, status

15. Publishes to DDS topics

16. Consumption Phase

17. GVA applications subscribe to J1939 DDS topics
18. Update UI elements (speedometer, tachometer, gear display)

Vehicle Controls¶

Keyboard (Default)¶

Logitech G29 Racing Wheel¶

When detected, G29 automatically overrides keyboard:

• Steering Wheel: Vehicle steering with force feedback
• Gas Pedal: Throttle (0-100%)
• Brake Pedal: Brake pressure (0-100%)
• Clutch Pedal: Clutch engagement
• Paddle Shifters: Quick up/down shift

OpenDRIVE Road Networks¶

ZalaZONE Proving Ground¶

The simulator includes the ZalaZONE proving ground (Hungary):

• 579 roads (451 junction connecting roads)
• 76 junctions
• Lane-accurate positioning
• Traffic signs & signals - Speed limits, stop signs
• Road markings - Solid/dashed lines, crosswalks
• GPS origin: 46.8780°N, 16.8439°E, 175m altitude

Camera Modes¶

Cycle through perspectives with C key:

1. Third-Person Chase Cam - Follow vehicle from behind
2. Top-Down Strategic View - Overhead tactical perspective
3. Drive-Along Side View - Parallel tracking camera
4. First-Person Driver View - Cockpit perspective (planned)

Command Line Options¶

gva-qt6-vehicle-sim [OPTIONS]

Options:
  -h, --help               Display help
  --version                Display version
  -d, --domain <id>        DDS domain ID (default: 0)
  -m, --map <filepath>     OpenDRIVE (.xodr) map file
  -f, --fullscreen         Start in fullscreen mode
  --device <path>          G29 input device path

Usage Examples¶

# Launch with ZalaZONE map
./gva-qt6-vehicle-sim --domain=0 --map=data/opendrive/ZalaZONE_full.xodr

# Fullscreen mode
./gva-qt6-vehicle-sim --fullscreen --map=data/opendrive/ZalaZONE_full.xodr

# Custom G29 device
./gva-qt6-vehicle-sim --device=/dev/input/event5

Integration Examples¶

1. Monitor CAN Bus¶

# Terminal 1: Run simulator
./gva-qt6-vehicle-sim --domain=0

# Terminal 2: Monitor CAN traffic
candump vcan0 -t A

# Output:
#  (000.123)  vcan0  18F00400   [8]  00 7D 7D 20 19 FF FF FF  # EEC1: 800 RPM
#  (000.223)  vcan0  18FEF100   [8]  FF 00 00 C0 FF FF FF FF  # CCVS: 0 km/h

2. Subscribe to DDS Parameters¶

// Subscribe to vehicle speed in your HMI
auto subscriber = std::make_unique<QtDdsSubscriberCParameter>(
    domainId, "J1939_Automotive__Parameter");

connect(subscriber.get(), &QtDdsSubscriberCParameter::OnSampleReceived,
    [](const P_J1939_Automotive_PSM::C_Parameter& param) {
        if (param.A_suspectParameterNumber() == 84) {  // SPN 84 = Vehicle Speed
            double speedKmh = param.A_value();
            updateSpeedometer(speedKmh);
        }
    });

3. Automated Testing¶

#!/bin/bash
# Start simulator in background
./gva-qt6-vehicle-sim --domain=0 --headless &
SIM_PID=$!

# Wait for initialization
sleep 2

# Start gateway
./gva-j1939-gateway --domain=0 --interface=vcan0 &
GW_PID=$!

# Run test suite
python3 scripts/test/validate_j1939_output.py

# Cleanup
kill $SIM_PID $GW_PID

Use Cases¶

1. HMI Development¶

• Develop vehicle dashboard without physical vehicle
• Test instrument cluster rendering
• Validate warning/alarm thresholds

2. Algorithm Testing¶

• Test eco-driving algorithms
• Validate predictive maintenance logic
• Test autonomous driving decision-making

3. Integration Validation¶

• Verify CAN → DDS → Application flow
• Test gateway performance under load
• Validate subsystem synchronization

4. Training & Education¶

• Safe operator training environment
• Customer demonstrations
• Teaching tool for GVA architecture

Performance¶

Troubleshooting¶

Simulator Won't Start¶

# Check Qt6
pkg-config --modversion Qt6Core

# Verify OpenGL
glxinfo | grep "OpenGL version"

# Check libraries
ldd ./build/bin/gva-qt6-vehicle-sim

No CAN Output¶

# Verify vcan0
ip link show vcan0

# Recreate if needed
sudo ip link delete vcan0
sudo ip link add dev vcan0 type vcan
sudo ip link set vcan0 up

G29 Not Detected¶

# List input devices
ls -l /dev/input/by-id/ | grep Logitech

# Check permissions
sudo chmod 666 /dev/input/event*

# Test with evtest
sudo evtest /dev/input/event5

Low Frame Rate¶

• Use smaller OpenDRIVE files
• Disable advanced features (shadows, reflections)
• Lower resolution (1280x720)
• Update graphics drivers

Related Documentation¶

• J1939 Gateway Service
• Vehicle Simulator Product Page
• GVA HMI Guide
• Debugging with LdmX

References¶

• SAE J1939 Standard: Digital Annex of Serial Control and Communications Heavy Duty Vehicle Network
• OpenDRIVE Standard: ASAM OpenDRIVE 1.8.1
• J1939 Automotive PSM: ldm/UK/GVA/v2/J1939_Automotive/IDL/
• Source Code: src/qt6/gva-vehicle-sim/

Last Updated: January 31, 2026