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.

Zbigniew Kluczkowski

Z wykształcenia menedżer motoryzacji i informatyk, z zamiłowania historyk techniki i pasjonat starej motoryzacji. Maniak nowoczesnych technologii. Podobno zdolny autor tekstów (m.in. dla Continental Polska i Allegro). Czasem bloger i nauczyciel blogowania. Człowiek renesansu. Nauczyciel w zduńskowolskim „Elektroniku”.

Share this...

Facebook

Twitter

Linkedin

Whatsapp

Email

Print