automotive-expert

What this skill does

# Automotive Expert

Expert guidance for automotive systems, connected vehicles, fleet management, telematics, advanced driver assistance systems (ADAS), and automotive software development.

## Core Concepts

### Automotive Systems
- Telematics and fleet management
- Connected car platforms
- Advanced Driver Assistance Systems (ADAS)
- Electric Vehicle (EV) management
- Vehicle-to-Everything (V2X) communication
- Infotainment systems
- Diagnostic systems (OBD-II)

### Technologies
- CAN bus and automotive networks
- AUTOSAR architecture
- Over-the-air (OTA) updates
- Autonomous driving systems
- Battery management systems
- Computer vision for ADAS
- Edge computing in vehicles

### Standards and Protocols
- ISO 26262 (functional safety)
- AUTOSAR (automotive software architecture)
- J1939 (heavy-duty vehicle communication)
- UDS (Unified Diagnostic Services)
- SOME/IP (service-oriented middleware)
- MQTT for telematics
- CAN, LIN, FlexRay protocols

## Fleet Management System

```python
from dataclasses import dataclass
from datetime import datetime, timedelta
from typing import List, Optional
from decimal import Decimal
from enum import Enum
import numpy as np

class VehicleStatus(Enum):
    ACTIVE = "active"
    IDLE = "idle"
    MAINTENANCE = "maintenance"
    OUT_OF_SERVICE = "out_of_service"

class FuelType(Enum):
    GASOLINE = "gasoline"
    DIESEL = "diesel"
    ELECTRIC = "electric"
    HYBRID = "hybrid"
    CNG = "cng"

@dataclass
class Vehicle:
    """Fleet vehicle information"""
    vehicle_id: str
    vin: str  # Vehicle Identification Number
    make: str
    model: str
    year: int
    license_plate: str
    fuel_type: FuelType
    status: VehicleStatus
    odometer_km: int
    last_service_km: int
    next_service_km: int
    assigned_driver_id: Optional[str]
    location: tuple  # (latitude, longitude)
    fuel_level_percent: float

@dataclass
class Trip:
    """Vehicle trip record"""
    trip_id: str
    vehicle_id: str
    driver_id: str
    start_time: datetime
    end_time: Optional[datetime]
    start_location: tuple
    end_location: Optional[tuple]
    distance_km: float
    fuel_consumed_liters: float
    average_speed_kmh: float
    max_speed_kmh: float
    harsh_braking_count: int
    harsh_acceleration_count: int

class FleetManagementSystem:
    """Fleet management and telematics system"""

    def __init__(self):
        self.vehicles = {}
        self.trips = []
        self.maintenance_schedules = []

    def track_vehicle_location(self, vehicle_id: str) -> dict:
        """Track real-time vehicle location"""
        vehicle = self.vehicles.get(vehicle_id)
        if not vehicle:
            return {'error': 'Vehicle not found'}

        # Get GPS data from telematics device
        location = self._get_gps_location(vehicle_id)
        speed = self._get_current_speed(vehicle_id)
        heading = self._get_heading(vehicle_id)

        vehicle.location = location

        return {
            'vehicle_id': vehicle_id,
            'location': {
                'latitude': location[0],
                'longitude': location[1]
            },
            'speed_kmh': speed,
            'heading': heading,
            'timestamp': datetime.now().isoformat(),
            'status': vehicle.status.value
        }

    def start_trip(self, vehicle_id: str, driver_id: str) -> Trip:
        """Start a new trip"""
        vehicle = self.vehicles.get(vehicle_id)
        if not vehicle:
            raise ValueError("Vehicle not found")

        trip = Trip(
            trip_id=self._generate_trip_id(),
            vehicle_id=vehicle_id,
            driver_id=driver_id,
            start_time=datetime.now(),
            end_time=None,
            start_location=vehicle.location,
            end_location=None,
            distance_km=0.0,
            fuel_consumed_liters=0.0,
            average_speed_kmh=0.0,
            max_speed_kmh=0.0,
            harsh_braking_count=0,
            harsh_acceleration_count=0
        )

        vehicle.status = VehicleStatus.ACTIVE
        self.trips.append(trip)

        return trip

    def end_trip(self, trip_id: str) -> dict:
        """End trip and calculate metrics"""
        trip = next((t for t in self.trips if t.trip_id == trip_id), None)
        if not trip:
            return {'error': 'Trip not found'}

        vehicle = self.vehicles.get(trip.vehicle_id)

        trip.end_time = datetime.now()
        trip.end_location = vehicle.location

        # Calculate trip metrics
        duration_hours = (trip.end_time - trip.start_time).total_seconds() / 3600
        trip.average_speed_kmh = trip.distance_km / duration_hours if duration_hours > 0 else 0

        # Calculate fuel efficiency
        fuel_efficiency = trip.distance_km / trip.fuel_consumed_liters if trip.fuel_consumed_liters > 0 else 0

        # Calculate driver score
        driver_score = self._calculate_driver_score(trip)

        vehicle.status = VehicleStatus.IDLE

        return {
            'trip_id': trip_id,
            'duration_hours': duration_hours,
            'distance_km': trip.distance_km,
            'fuel_consumed': trip.fuel_consumed_liters,
            'fuel_efficiency_km_per_liter': fuel_efficiency,
            'average_speed': trip.average_speed_kmh,
            'max_speed': trip.max_speed_kmh,
            'harsh_events': trip.harsh_braking_count + trip.harsh_acceleration_count,
            'driver_score': driver_score
        }

    def _calculate_driver_score(self, trip: Trip) -> float:
        """Calculate driver safety score"""
        score = 100.0

        # Penalize harsh events
        score -= trip.harsh_braking_count * 5
        score -= trip.harsh_acceleration_count * 5

        # Penalize speeding
        if trip.max_speed_kmh > 120:
            score -= (trip.max_speed_kmh - 120) * 0.5

        # Penalize low fuel efficiency
        # Implementation would compare to vehicle baseline

        return max(0.0, min(100.0, score))

    def schedule_maintenance(self, vehicle_id: str) -> dict:
        """Schedule vehicle maintenance"""
        vehicle = self.vehicles.get(vehicle_id)
        if not vehicle:
            return {'error': 'Vehicle not found'}

        # Check if maintenance is due
        km_since_service = vehicle.odometer_km - vehicle.last_service_km
        km_until_service = vehicle.next_service_km - vehicle.odometer_km

        if km_until_service <= 1000:  # Within 1000km of service
            maintenance_type = self._determine_maintenance_type(km_since_service)

            schedule = {
                'vehicle_id': vehicle_id,
                'maintenance_type': maintenance_type,
                'current_odometer': vehicle.odometer_km,
                'recommended_by_odometer': vehicle.next_service_km,
                'urgency': 'high' if km_until_service <= 500 else 'medium',
                'estimated_cost': self._estimate_maintenance_cost(maintenance_type)
            }

            self.maintenance_schedules.append(schedule)

            return schedule

        return {
            'vehicle_id': vehicle_id,
            'maintenance_required': False,
            'km_until_service': km_until_service
        }

    def optimize_routes(self, deliveries: List[dict]) -> dict:
        """Optimize delivery routes for fleet"""
        # Simplified route optimization
        # In production, would use sophisticated algorithms (TSP, VRP)

        available_vehicles = [
            v for v in self.vehicles.values()
            if v.status == VehicleStatus.IDLE
        ]

        if not available_vehicles:
            return {'error': 'No available vehicles'}

        # Assign deliveries to vehicles
        assignments = []
        for i, delivery in enumerate(deliveries):
            vehicle = available_vehicles[i % len(available_vehicles)]

            route = self._calculate_route(
                vehicle.location,
                delivery['destination']
            )