automotive-v2x

Automotive V2X

Cv2X 5G Integration

C-V2X and 5G Integration

Overview

C-V2X (Cellular V2X) integration with 5G networks including PC5 sidelink communication modes, network slicing, Multi-access Edge Computing (MEC), Ultra-Reliable Low-Latency Communication (URLLC), and 5G NR V2X features.

C-V2X Communication Modes

Mode 3 vs Mode 4 Comparison

Feature	Mode 3 (Network Scheduled)	Mode 4 (Autonomous/D2D)
Infrastructure Required	Yes (eNodeB/gNodeB)	No (direct sidelink)
Resource Allocation	Network-scheduled (centralized)	Distributed sensing
Coverage Dependency	Requires cellular coverage	Works without network
Typical Latency	20-50 ms (via network)	10-20 ms (direct)
QoS Guarantee	Network-enforced QoS	Best-effort coordination
Ideal Use Case	Urban with good coverage	Rural, tunnels, emergencies
Handover	Network-managed	Autonomous
Power Consumption	Higher (constant network sync)	Lower (periodic only)

5G NR-V2X Physical Layer

Frequency Bands:

5.9 GHz ITS Band:
- 5.855-5.925 GHz (US, EU, Asia harmonized)
- Channel bandwidth: 10/20 MHz
- Supports both DSRC coexistence and C-V2X

Licensed Spectrum:
- Band n78 (3.5 GHz): High capacity urban
- Band n79 (4.7 GHz): Regional deployments
- Mmwave (28/39 GHz): Ultra-high data rate applications

Numerology:

Subcarrier spacing: 15/30/60 kHz
- 15 kHz: Long range, low mobility
- 30 kHz: Standard V2X (recommended)
- 60 kHz: High mobility scenarios

Symbol duration: 66.7/33.3/16.7 μs
Cyclic prefix: 4.7/2.3/1.2 μs

Network Slicing for V2X

Slice Configuration

# network_slicing.py
"""
5G Network slicing for differentiated V2X services.
"""

from dataclasses import dataclass
from enum import Enum
from typing import List

class SliceServiceType(Enum):
    """Service and Slice Differentiator (SST)"""
    URLLC = 1  # Ultra-reliable low-latency
    EMBB = 2   # Enhanced mobile broadband
    MMTC = 3   # Massive machine-type communications

@dataclass
class NetworkSliceDescriptor:
    """5G Network Slice Selection Assistance Information (NSSAI)"""
    sst: SliceServiceType  # Slice/Service Type
    sd: int  # Slice Differentiator (24 bits)

    # Performance KPIs
    target_latency_ms: int
    reliability_percent: float
    max_data_rate_mbps: int
    connection_density_per_km2: int

    # Resource allocation
    guaranteed_bit_rate_mbps: int
    priority_level: int  # 1 (highest) to 15 (lowest)

# V2V Safety Communications Slice
SLICE_V2V_SAFETY = NetworkSliceDescriptor(
    sst=SliceServiceType.URLLC,
    sd=0x000001,  # V2V safety specific
    target_latency_ms=5,
    reliability_percent=99.9999,  # Six nines
    max_data_rate_mbps=10,
    connection_density_per_km2=10000,
    guaranteed_bit_rate_mbps=2,
    priority_level=1
)

# V2I Traffic Management Slice
SLICE_V2I_TRAFFIC = NetworkSliceDescriptor(
    sst=SliceServiceType.URLLC,
    sd=0x000002,
    target_latency_ms=20,
    reliability_percent=99.99,
    max_data_rate_mbps=5,
    connection_density_per_km2=5000,
    guaranteed_bit_rate_mbps=1,
    priority_level=3
)

# V2N Infotainment Slice
SLICE_V2N_INFOTAINMENT = NetworkSliceDescriptor(
    sst=SliceServiceType.EMBB,
    sd=0x000003,
    target_latency_ms=100,
    reliability_percent=99.0,
    max_data_rate_mbps=100,
    connection_density_per_km2=1000,
    guaranteed_bit_rate_mbps=10,
    priority_level=10
)

class NetworkSliceManager:
    """Manage network slice selection for V2X traffic."""

    def __init__(self):
        self.available_slices = [
            SLICE_V2V_SAFETY,
            SLICE_V2I_TRAFFIC,
            SLICE_V2N_INFOTAINMENT
        ]
        self.current_slice = None

    def select_slice_for_message(self, message_type: str, qos_requirement: str) -> NetworkSliceDescriptor:
        """
        Select appropriate network slice based on message type and QoS.

        Args:
            message_type: "BSM", "DENM", "CAM", "SPaT", "MAP", etc.
            qos_requirement: "critical", "high", "medium", "low"

        Returns:
            NetworkSliceDescriptor
        """
        # Safety-critical messages
        if message_type in ["BSM", "CAM", "DENM", "EEBL"] or qos_requirement == "critical":
            return SLICE_V2V_SAFETY

        # Infrastructure messages
        elif message_type in ["SPaT", "MAP", "TIM"] or qos_requirement == "high":
            return SLICE_V2I_TRAFFIC

        # Non-critical services
        else:
            return SLICE_V2N_INFOTAINMENT

    def request_slice_activation(self, nssai: NetworkSliceDescriptor) -> bool:
        """
        Request slice activation from 5G core.

        In production: NGAP signaling to AMF (Access and Mobility Management Function)
        """
        print(f"Requesting slice activation:")
        print(f"  SST: {nssai.sst.name}")
        print(f"  SD: {nssai.sd:#08x}")
        print(f"  Latency: {nssai.target_latency_ms} ms")
        print(f"  Reliability: {nssai.reliability_percent}%")

        # Simulate AMF response
        self.current_slice = nssai
        return True