Istny MontyPython czyli zastosowanie języka Python w technice samochodowej

Dziś nietypowo, bo chcę zawodowo i praktycznie.

Informatyka w samochodach to dziś bardzo rozwinięta gałęź przemysłu. Dla potrzeb automotive programy pisze wielu programistów. Co ciekawe, większość kodu, który obsługuje podstawowe funkcje pojazdów pisze się w językach niższego rzędu – C, C++ lub C#. Python ma zupełnie inne zastosowanie – służy inteligentnym systemom wsparcia. Jakim? Podzieliliśmy to na kilka kategorii.

1. Testowanie i symulacje
   • Automatyzacja testów oprogramowania sterowników ECU (Electronic Control Unit).
   • Symulacje zachowań pojazdu, czujników, systemów wspomagania kierowcy.
2. Analiza danych i diagnostyka
   • Przetwarzanie danych z czujników (np. z CAN bus).
   • Analiza i wizualizacja danych diagnostycznych, predykcja usterek.
   • Tworzenie narzędzi do monitorowania parametrów samochodu.
3. Systemy infotainment i interfejsy użytkownika
   • Prototypowanie i rozwijanie GUI (np. dashboardów, systemów multimedialnych).
   • Integracja z aplikacjami smartfonów lub chmurą.
4. Autonomiczne pojazdy i systemy wspomagające
   • Programowanie algorytmów uczenia maszynowego i przetwarzania obrazu (np. rozpoznawanie znaków, wykrywanie przeszkód).
   • Budowa systemów nawigacyjnych i planowania trasy.
5. Prototypy i narzędzia deweloperskie
   • Python jest często używany do szybkiego tworzenia prototypów funkcji lub narzędzi do analizy oprogramowania pojazdu.

Bardziej konkretnie? Wystarczy uruchomić kod oprogramowania Tesli czy Waymo. W jakim języku zostały napisane? Oczywiście w Pythonie. Python ma proste biblioteki do obsługi uczenia maszynowego. Baza danych i interfejs w Python GUI stosowane są do gromadzenia danych z czujników służących samodzielnej jeździe autonomicznej. Interfejsy diagnostyczne do większości marek również są napisane w Pythonie.

Poniżej przykład kodu, którego zadaniem jest zbieranie danych:

import random

import time

import matplotlib.pyplot as plt

# Symulacja odczytów z czujników samochodu

def get_speed():

 # prędkość w km/h, losowa zmienna w zakresie 0-120

  return random.uniform(0, 120)

def get_engine_temp():

# temperatura silnika w stopniach C, zwykle 70-100

   return random.uniform(70, 100)

# Zbieranie danych przez 60 sekund

speed_data = []

temp_data = []

time_data = []

start_time = time.time()

while time.time() - start_time < 60:

 speed = get_speed()

 temp = get_engine_temp()

 current_time = time.time() - start_time

 speed_data.append(speed)

 temp_data.append(temp)

 time_data.append(current_time)

print(f"Czas: {current_time:.1f}s | Prędkość: {speed:.1f} km/h | Temp. silnika: {temp:.1f} °C")

time.sleep(1)

# Prosta analiza - średnia prędkość i temperatura

avg_speed = sum(speed_data) / len(speed_data)

avg_temp = sum(temp_data) / len(temp_data)

print(f"\nŚrednia prędkość: {avg_speed:.1f} km/h")

print(f"Średnia temperatura silnika: {avg_temp:.1f} °C")

# Wizualizacja danych

plt.figure(figsize=(10,5))

plt.subplot(2,1,1)

plt.plot(time_data, speed_data, label="Prędkość (km/h)")

plt.legend()

plt.subplot(2,1,2)

plt.plot(time_data, temp_data, label="Temperatura silnika (°C)", color="red")

plt.legend()

plt.xlabel("Czas [s]")

plt.show()

Co otrzymaliśmy? Prosty skrypt, który zbiera i analizuje dane. Dane są przedstawione w postaci posortowanej kolekcji. Dane są zapisywane z dokładnością do sekundy. Zwykle jest tak, że dane można odczytać za pomocą programu z GUI (graficznym interfejsem użytkownika) – programu, który odbiera dane i przedstawia je na wykresie. Zanim to nastąpi strumień danych może wyglądać jak na zdjęciu. Przed Wami widok danych w konsoli środowiska programistycznego.

Efekt działania kodu

Źródło: PyCharmEdu

Skąd pochodzą te dane? Czujniki i gniazdo ODB-2 lub pochodnych standardów. Prezentowanie danych odbywa się przez GUI w postaci tabel, wykresów lub w prostszej formie jako aktualizowana lista. Oto przykład prostego GUI, które co sekundę pokazuje dane odczytane z czujników i ODB-2. To oczywiście jedynie symulacja.

Kod aplikacji do czujnika z GUI

import tkinter as tk
import random

class VehicleMonitor:
    def __init__(self, root):
        self.root = root
        self.root.title("Monitor Pojazdu")
        self.root.geometry("400x250")
        self.root.configure(bg="#1c1c1c")

        # Etykiety
        self.speed_label = tk.Label(root, text="Prędkość: 0 km/h", font=("Arial", 16), fg="white", bg="#1c1c1c")
        self.temp_label = tk.Label(root, text="Temp. silnika: 0 °C", font=("Arial", 16), fg="white", bg="#1c1c1c")
        self.fuel_label = tk.Label(root, text="Zużycie paliwa: 0 l/100km", font=("Arial", 16), fg="white", bg="#1c1c1c")

        # Pozycjonowanie
        self.speed_label.pack(pady=20)
        self.temp_label.pack(pady=20)
        self.fuel_label.pack(pady=20)

        # Uruchom cykliczne odświeżanie
        self.update_data()

    def update_data(self):
        # Symulacja danych
        speed = random.randint(0, 180)
        temperature = random.randint(70, 120)
        fuel_usage = round(random.uniform(3, 15), 1)

        # Aktualizacja etykiet
        self.speed_label.config(text=f"Prędkość: {speed} km/h")
        self.temp_label.config(text=f"Temp. silnika: {temperature} °C")
        self.fuel_label.config(text=f"Zużycie paliwa: {fuel_usage} l/100km")

        # Odświeżanie co 1 sekundę
        self.root.after(1000, self.update_data)

# Uruchomienie programu
if __name__ == "__main__":
    root = tk.Tk()
    app = VehicleMonitor(root)
    root.mainloop()

Widok danych na ekranie w najprostszej postaci wygląda tak jak na zdjęciu poniżej. Oczywiście wygląd GUI może się różnić w zależności od ilości pozyskanych danych.

Prosta aplikacja do czujnika z GUI

Źródło: PyCharm

Python zawsze będzie potrzebny tam, gdzie trzeba diagnozować przyczyny awarii i wypadków. Odczyt setek czy tysięcy linii danych pozwala na ustalenie źródła problemu, z którym muszą zmierzyć się mechanicy czy śledczy. Napisanie prostego kontrolera przy użyciu sztucznej inteligencji nie wymaga specjalistycznej wiedzy. To daje możliwość personalizacji rozwiązań diagnostycznych. Zastosowanie Pythona znacząco ułatwia ten proces.