Skip to content

Quick Start Guide

This guide will help you get up and running with V2X development in under 30 minutes. We'll set up a basic V2X development environment and create a simple application.

Prerequisites

Before you begin, ensure you have:

  • Python 3.8 or higher
  • Git
  • A modern web browser
  • Basic knowledge of Python programming

Step 1: Clone the Repository

git clone https://github.com/your-org/v2x-documentation.git
cd v2x-documentation

Step 2: Set Up Virtual Environment

# Create virtual environment
python -m venv venv

# Activate virtual environment
# On Windows:
venv\Scripts\activate
# On macOS/Linux:
source venv/bin/activate

Step 3: Install Dependencies

pip install -r requirements.txt

If you don't have a requirements.txt file yet, install the basic dependencies:

pip install mkdocs mkdocs-material pymdown-extensions

Step 4: Verify Installation

# Check if MkDocs is installed correctly
mkdocs --version

# Start the development server
mkdocs serve

Open your browser and navigate to http://127.0.0.1:8000 to see your documentation site.

Step 5: Create Your First V2X Application

Let's create a simple V2X message simulator:

# v2x_simulator.py
import json
import time
from datetime import datetime

class V2XMessage:
    def __init__(self, message_type, sender_id, data):
        self.message_type = message_type
        self.sender_id = sender_id
        self.data = data
        self.timestamp = datetime.now().isoformat()

    def to_json(self):
        return {
            "message_type": self.message_type,
            "sender_id": self.sender_id,
            "data": self.data,
            "timestamp": self.timestamp
        }

class V2XSimulator:
    def __init__(self):
        self.vehicles = {}
        self.messages = []

    def add_vehicle(self, vehicle_id, position, speed):
        self.vehicles[vehicle_id] = {
            "position": position,
            "speed": speed,
            "last_update": datetime.now()
        }

    def send_message(self, sender_id, message_type, data):
        message = V2XMessage(message_type, sender_id, data)
        self.messages.append(message)
        return message

    def get_vehicle_status(self, vehicle_id):
        return self.vehicles.get(vehicle_id)

    def simulate_traffic(self, duration=60):
        """Simulate V2X traffic for specified duration"""
        start_time = time.time()

        while time.time() - start_time < duration:
            # Simulate vehicle movement
            for vehicle_id, vehicle in self.vehicles.items():
                # Update position based on speed
                x, y = vehicle["position"]
                speed = vehicle["speed"]

                # Simple movement simulation
                new_x = x + speed * 0.1
                vehicle["position"] = (new_x, y)
                vehicle["last_update"] = datetime.now()

                # Send position update
                self.send_message(
                    vehicle_id,
                    "position_update",
                    {"position": vehicle["position"], "speed": speed}
                )

            time.sleep(1)  # Update every second

# Example usage
if __name__ == "__main__":
    simulator = V2XSimulator()

    # Add some vehicles
    simulator.add_vehicle("V001", (0, 0), 30)  # 30 km/h
    simulator.add_vehicle("V002", (100, 0), 25)  # 25 km/h

    print("Starting V2X simulation...")
    simulator.simulate_traffic(duration=10)  # Run for 10 seconds

    print(f"Generated {len(simulator.messages)} messages")

    # Display last few messages
    for message in simulator.messages[-5:]:
        print(json.dumps(message.to_json(), indent=2))

Step 6: Test Your Application

Run the simulator:

python v2x_simulator.py

You should see output similar to:

Starting V2X simulation...
Generated 20 messages
{
  "message_type": "position_update",
  "sender_id": "V001",
  "data": {
    "position": [3.0, 0],
    "speed": 30
  },
  "timestamp": "2024-01-15T10:30:45.123456"
}

Step 7: Explore the Documentation

Now that you have a basic setup, explore the documentation:

  1. V2X Technology: Learn about communication types and standards
  2. Implementation: Understand system architecture and requirements
  3. Use Cases: Explore real-world applications
  4. Development: Access API references and SDK documentation

Next Steps

After completing this quick start:

  1. Read the Installation Guide for detailed setup instructions
  2. Explore V2X Technology Overview for deeper understanding
  3. Check Implementation Guidelines for system design
  4. Review Best Practices for production deployment

Troubleshooting

Common Issues

MkDocs not found: Ensure you've activated your virtual environment and installed dependencies.

Port already in use: Change the port with mkdocs serve -a localhost:8001

Python version issues: Ensure you're using Python 3.8+ and have the correct virtual environment activated.

Getting Help

This quick start guide provides the foundation for V2X development. For more advanced topics, explore the detailed documentation sections.