Docs

• 1: Dokumentacja
• 2: Praca w zespole
• 2.1: Cele tygodniowe
• 2.2: Sprzątanie
• 3: Oprogramowanie i narzędzia
• 3.1: Logowanie się do platformy Nextcloud
• 3.2: Szlaban Bot
• 3.3: Sekcja Informatyki
• 3.3.1: Spotkania Sekcji IT
• 3.3.2: Przydatne strony
• 3.3.3: Wytyczne projektowe
• 3.3.4: Poradniki
• 3.3.5: Projekty
• 3.3.5.1: Generator stopek
• 3.3.5.2: PRT-Hub
• 3.3.5.3: Przykładowy projekt
• 3.3.5.4: SzlabanBot
• 3.3.5.5: Projekt serwera
• 3.3.5.6: Serwer testowy
• 3.3.5.7: Symulator silnika
• 3.3.5.8:
• 3.3.6: Zaplanowane projekty
• 3.3.6.1: Agregator Webhook
• 3.3.6.2: Bot Discord
• 4: Bolid Autonomiczny
• 4.1: Zbiór wiedzy do Matlaba i Simulinka
• 4.2: Dokumentacja Symulatora Okrążenia
• 4.2.1: paramtery akumulatora
• 4.2.2: paramtery akumulatora
• 4.2.3: calculateSteeringData
• 4.2.4: Inicjalizacja powtórki symulacji
• 4.2.5: Inicjowanie Opon do symulacji
• 4.2.6: paramtery układu napędowego
• 4.2.7: Linia Krzywa 2D
• 4.2.8: Linia Znormalizowana 2D
• 4.2.9: Maksymalna prędkość na łuku
• 4.2.10: Manadżer symulacji
• 4.2.11: Parametry opon, poślizgi i siły
• 4.2.12: Generowanie parametrów startowych
• 4.2.13: Pliki .mat i .csv
• 4.2.14: oddziaływanie sił
• 4.2.15: Presety
• 4.2.16: Wykresy sił na oponach
• 4.2.17: catstruct.m
• 4.2.18: Logi
• 4.2.19: Renderowanie Trasy
• 4.2.20: TirFiles
• 4.3: Regulamin Autonomiczny
• 4.3.1: Bolid autonomiczny - regulamin (ENG)
• 4.3.2: Bolid autonomiczny - regulamin (PL)
• 5: PMT-05
• 5.1: Sekcja Elektroniki
• 5.1.1: Projekty
• 6: PMT-04
• 6.1: Sekcja Elektroniki
• 6.1.1: Projekty
• 6.1.1.1: Battery Management System
• 6.2: Sekcja Informatyki
• 7: PMT-03
• 7.1: Rama
• 7.1.1: Główne założenia
• 7.1.2: Projekt geometrii

1 - Dokumentacja

Dokumentacja jest projektem mającym na celu stworzenie jednego portalu, który będzie skarbnicą wiedzy zespołu PRz-Racing Team.

W tym miejscu, znajdziecie zasady, regulaminy, instrukcje użycia, a także dokumenty odnośnie designów i projektów prowadzonych pod skrzydłem naszego zespołu.

Jeżeli masz jakiekolwiek pytania odnośnie systemu dokumentacji, lub chciałby/aś coś dodać od siebie, skontaktuj się z liderem Sekcji Informatyki.

2 - Praca w zespole

2.1 - Cele tygodniowe

Cele tygodniowe - jest to zbiór zadań, nad którymi będziemy pracowac w określonym tygodniu.

Są one publikowane na zespołowym kanale “Announcements” dostępnym na platformie Telegram.

2.2 - Sprzątanie

Wstęp

Jak wszystko na tym świecie, rzeczy się brudzą, a tym bardziej na naszym warsztacie ;)

W związku z tym, wymagane jest jego regularne sprzątanie - co u nas przypada na raz w każdym tygodniu, przed konkretną sekcje której w tym tygodniu wypada tura.

Tury sprzątań

Co tydzień przypada rotacja zgodnie z niżej podaną kolejnością:

• Sekcja …
• Sekcja …

Lista czynności

Niżej zostały podane podstawowe rzeczy które wymagają poświęcania uwagi w trakcie sprzątania warsztatu przez zespół:

1. Podłogi

Zamiecenie

Zaczniemy od zamiecienia podłóg za pomocą zmiotek znajdujących się zazwyczaj w toalecie, ale mogą być też porozrzucone po części warsztatowej.

Należy zamieć:

• w części czystej
• w części warsztatowej

Umycie podłóg

• w części czystej
• w części warsztatowej

3. Posprzatanie ze stołów w strefie czystej

4. Naczynia

Należy umyć różnego rodzaju naczynia, m.in:

• kubki
• sztućce
• itp. A następnie poukładać je w części czystej na suszarce.

5. Przetarcie kurzów w strefie czystej

• stoły i biurka (te dostepne)
• półki ( te dostępne

6. Toaleta

Należy też wysprzątać toalete, m.in:

• prysznic
• umywalkę
• kompakt WC
• zamieść WC
• zamieć podłogę
• wymyc podłogę
• uzupełnić papiery w pojemnikach (jak są to nie)

7. Narzędzia

Jeżeli nikt nie używa narzędzi, należy odłożyć je na swoje odpowiednie miejsce w warsztacie.

8. Wyrzucenie śmieci

Po zakończeniu całego sprzątania, należy wynieść śmieci do śmietników, a następnie wymienić worki w koszach. Worki możemy znaleźć na półce w toalecie.

TODO:

Dodać zdjęcia zmiotek, myjki itp

3 - Oprogramowanie i narzędzia

3.1 - Logowanie się do platformy Nextcloud

Czym jest Nextcloud?

Nextcloud - jest to platforma służąca do hostowania plików, coś w stylu Google Drive’a - w naszym przypadku, służy ona do trzymania plików związanych z pracą w zespole, a więc różnego rodzaju dokumenty, zdjęcia, video, szablony, itp.

Jak się na nią dostać?

Aby wejść na naszą stronę Nextcloud’a, należy się udać pod adres:

• https://www.nextcloud.przracing.pl

Gdzie nastepnie, jeżeli nie logowaliśmy się wcześniej, zostaniemy poproszeni o dane dostępowe do platformy. Nasze dane dostępowe, podane są w formie:

• Nazwa użytkownika: 1 litera imienia, a potem nazwisko bez polskich znaków (np. Jan Kowalski -> jkowalski)
• Hasło: losowo wygenerowane bezpieczne hasło podane przez administratora platformy, bądź hasło które zmieniłeś po otrzymaniu konta.

Organizacja plików

Pliki na platformie Nextcloud są grupowane według bolidów przy których dane pliki zostały wykorzystane. Przykładowo, jeżeli chcielibyśmy znaleźć pliki designów Sekcji Aerodynamiki bolidu PMT-03, będziemy się kierować folderami:

• PMT-03 Sekcja Aerodynamika …

3.2 - Szlaban Bot

Opis

“Szlaban Bot” to bot na platformie Telegram pozwalający cżłonkom zespołu otwierać szlaban przy wjeździe do parkingu przy warsztacie PRz-Racing Team.

Jak korzystać?

Aby korzystac z bota, należy spełniać dwa warunki:

Kontakt

W celu jakichkolwiek informacji odnośnie działania i problemów w związku z Szlaban Botem, proszę kontaktować się z:

• Gabriel Olszewski

3.3 - Sekcja Informatyki

Wstęp

Sekcja Informatyki jest sekcją techniczną zespołu PRz-Racing Team, mająca na celu rozwijanie możliwosci drużyny o różnego rodzaju rozwiązania informatyczne.

Nasza historia zaczęła się jako odłam Sekcji Elektroniki, gdzie spośród osób mających doświadczenie z szeroko pojętą informatyką, realizowaliśmy oprogramowanie dla naszej drużyny.

Obecnie zajmujemy się tworzeniem oprogramowania oraz rozwiązań informatycznych, mającego wspomóc działanie drużyny, są to m.in:

• System zbierania danych z bolidu wyścigowego
• Obsługa danych i wyświetlanie zbieranych danych telemetrycznych
• Budowa i utrzymanie serwera głównego zespołu
• Wewnętrzny system wspomagania drużyny (IMS) - PRT-Hub

Będąc członkiem naszej sekcji, będziesz miał omżliwość pracy z naszymi obecnymi rozwiązaniami, korzystać z nich, utrzymywać i rozwijać je o kompletnie nowe możliwości.

Od naszych członków oczekujemy pisania czystego, funkcjonalnego kodu, który spełnia wszystkie standardy obowiązujące projekty wykorzystywanych w produkcji, nie odbiegając od projektów tworzonych pod skrzydłami dużych firm programistycznych.

Korzyści z pracy w sekcji

Wykonując projekty w zakresie Sekcji, będziesz miał możliwość nauki wielu zawansowanych technologii oraz technik, które są stosowane w przemyśle IT.

Jeżeli bierzesz udział w zajęciach związanych z informatyką, w zakresie których realizowany jest projekt, dostępna jest możliwość rozmowy z prowadząconym przedmiotu w celu wybrania tematu projektu jako ten, który realizujesz w zakresie Sekcji Informatyki. Z doświadczenia, większość prowadzących chętnie akceptują taką propozycje. W razie pytań, proszę o kontaktowanie się z Liderem Sekcji.

Organizacja pracy

Pracując w Sekcji Informatyki będziesz zoobligowany do korzystania z narzędzi które pozwolą Tobie jak i reszcie zespołu na łatwiejszą współprace, dzieląc się wynikami swojej pracy przy użyciu platform takich jak Github, Trello, Telegram na których nasza drużyna posiada odpowiednie zarządzane zespoły.

Kod

W celu realizacji naszych zadań, korzystamy z narzędzi które pozwalają nam na współprace przy bazach kodu, jak i niezawodne sposobu trzymanie naszych projektów w jednym miejscu, nie obawiając się o utratę danych i dostępność - w celu zaspokojenia tych potrzeb, sekcja korzysta z technologii git, a konkretnie z platformy Github

Nasz zespół posiada swoją własną organizację dostępną na tej platformie, dostepną pod linkiem https://github.com/PRz-Racing-Team

Narzędzia pracy

• Gitkraken - oprogramowanie wspomagające korzystanie z technologi Git, pozwala na wizualne zarządzanie repozytoriami, usuwając potrzebe korzystania konsoli w czasie zarządzania kodem. Dostępny na stronie https://www.gitkraken.com}

• Postman - program ułatwiający korzystanie, oraz testowanie z różnego rodzaju API. Pozwala on także na tworzenie symulacji natłoku zapytań REST w celu testowania endpointów naszych usług internetowych. Dostępny na stronie https://www.postman.com

• Pakiet Jetbrains - paczka narzędzi programistycznych typu IDE\footnote{Integrated Development Environment - zintegrowane środowisko deweloperskie} ułatwiających pisanie kodu poprzez zaawansowane, wbudowane narzędzia typu debuggery, type checkery, które działają bezpośrednio z edytora kodu. W skład tych narzędzi wchodzą m.in:

  • IntelliJ IDEA - środowisko programistyczne dla języka Java
  • Clion - edytor kodu dla języków typu C, C++, RUST
  • Webstorm - środowisko dla programistów stron internetowych, zawiera wsparcie dla HTML, CSS, JS i frameworków typu React bądź Angular.
  • Pycharm - środowisko dla języka Python
  • Goland - edytor dla języka programowania Go

  Wszystkie powyższe edytory możemy znaleźć na stronie: https://www.jetbrains.com/

Licencja na narzędzia Jetbrains

Trzeba wspomnieć, że tylko część z narzedzi firmy Jetbrains jest dostępna za darmo, resztę możemy uzyskać odpłatnie - bądź, korzystając z specjalnej licencji Jetbrains dla studentów, uzyskać dostęp do nich za darmo. Licencja obowiązuje jedynie na projekty nie-komercyjne (nie przynoszące dochodu).

Licencja dla studentów na pakiet Jetbrains jest możliwa do uzyskania na stronie:

https://www.jetbrains.com/community/education/#students}

3.3.1 - Spotkania Sekcji IT

Spotkanie 08.03.2023

• Typ spotkania: stacjonarne
• Ilość osób obecnych: 10

Tematy do poruszenia

• Sprzątanie:

  Spotkamy się aby posprzątać 09.03.2023 o godz. 18:00 przed spotkaniem zespołu.

• Omówienie projektów, nowe projekty:

  • Projekt Bot Discord: rozwój bota na nasz serwer Discordowy
  • Projekt Aggregator Webhook: rozwój modułu (Java Springboot) przechwytujące podłączone webhooki i umieszczające je w bazie danych w celu korzystania przez inne usługi

• Serwer testowy:

  Został postawiony serwer testowy, do testowania różnego rodzaju projektów i rozwiązań, bez obawy przed uwaleniem serwera głównego.

• Inicjatywa Webhook:

  rozpoczęcie robienia regularnych commitów na repozytorium, w celu testów systemu CI/CD Jenkins/Gitlab.

• Plany na przyszły tydzień:

  • Przetestowanie system logowania na serwerze testowym
  • Próby implementacji logowania w PRTHub
  • Jeżeli uda się postawić stabilny system logowania -> migracja Nextcloud do Nextcloud AIO

Spotkanie 01.03.2023

• Typ spotkania: stacjonarne
• Ilość osób obecnych: 8

Tematy do poruszenia

• Inicjatywa “One Login For All” - obejmuje wprowadzenie systemu logowania SSO (Single Sign-On) do następujących usług:

  • E-mail (służący również jako główny sposób logowania się użytkowników)
  • Dokumentacja
  • Gitlab
  • Nextcloud
  • OpenVPN
  • Customowe usługi, typu PRTHub oraz mikroserwisy

  System ten będzie oparty na podstawie Keycloak: https://www.keycloak.org oraz posiadał integrację z platformą Telegram i kontami Google, wraz z udostępnionym panelem zarządzania użytkownikami.

• Kolejny meetup: https://www.meetup.com/rzeszow-cloud-native-group/events/291021181
  Temat: “Delivering good development experience” 15 marca 19:00 Apart Hotel 12

• Sprawdzenie postępu projektów

• Zadanie domowe: Wprowadzenie do korzystania z dokumentacji: https://github.com/PRz-Racing-Team/prt-docs

  Wejdźcie na repozytorium https://github.com/PRz-Racing-Team/prt-docs i pobierzcie sobie projekt, następnie spróbujcie według instrukcji w README go odpalić. Będziecie potrzebowali do tego Hugo oraz Golang, które są podlinkowane w README.

  Jak wam się to uda, to dodajcie w folderze jak na screenshocie, plik odnośnie waszego tworzonego projektu, na podstawie pliku przykladowa_dokumentacja_projektu.md w którym po krótka opisujecie co się w nim dzieje.

  Następnie, zróbcie commita, po czym wrzućcie merge request na repozytorium, w razie jakichkolwiek problemów, w starej dokumentacji PDF są poradniki z Gita.

W razie jakichkolwiek problemów, przy budowaniu projektu albo czymkolwiek, dajcie znać 😄

• Przypomnienie o uzupełnienie dyspocyzyjności na event https://docs.google.com/spreadsheets/d/1Cga25YVIx1rlewaD2AcGBO0iwqflEUdQEXfvqM-b3NM/edit#gid=1767985861
• Nowe zadania:
  • Przygotowanie generatora stopek mailowych dla naszego zespołu. Projekt obejmuje stworzenie serwisu z formularzem, który przyjmuje zdjęcie, mail, stanowisko, imie i nazwisko, a następnie generuje podgląd dokumentu HTML w przeglądarce. Kod stopki będzie dostępny na grupie Telegram.

Spotkanie 22.02.2023

• Typ spotkania: zdalne
• Ilość osób obecnych: 10

Tematy do poruszenia odnośnie Sekcji

• Wprowadzenie do nowego systemu dokumentacji:

  • https://www.docs.przracing.pl
  • Cotygodniowy skrót spotkań
  • Przykładowa dokumentacja projektowa
  • Pokazanie jak edytować stronę dokumentacji w plikach markdown

• Ustalenie potencjalnego nowego terminu spotkań sekcji

  https://www.when2meet.com/?18913916-jYZdR

• Przejrzenie produktów potencjalnego partnera CSI)

  • https://csi.pl/
  • Rzeczy z kategorii:
    • Routery
    • UPS
    • Części do serwera (Dyski, RAM, etc.)
    • Mini-komputery (np. z terminale z ekranem dotykowym do telemetrii)

• Bitrix:

  • PRT-Tools
  • Magazyn

• Rzeczy na ASAP

  • Serwer:
    • Aktualizacja do najnowszej wersji Nextclouda (i sprawdzenie czy błędy z wrzucaniem plików przestaną występować)

• Możliwość wzięcia udział w wydarzeniu Nvidii

• Możliwość wzięcia udziału w spotkania programistów:

  • 18:30 23.02.2023
  • Rzeszowskie Piwnice - interaktywna instytucja kultury Rynek 26 · Rzeszów
  • https://www.meetup.com/rg-dev/events/291557961/

Tematy ogólne

• Rekrutacja specjalistyczna: jakie stanowiska potrzebujemy?

• Wpisanie się w harmonogram eventu (IX Salon Edukacji 02.03.2023 CKZ Rzeszów 8:00- 13:00): https://docs.google.com/spreadsheets/d/1Cga25YVIx1rlewaD2AcGBO0iwqflEUdQEXfvqM-b3NM/edit#gid=1767985861

• Powrót do celów tygodniowych (PRz-Racing Team Announcements)

Spotkanie XX.XX.20XX

• Typ spotkania: zdalne/stacjonarne
• Ilość osób obecnych: X

Tematy do poruszenia

• A
• B
• C
• D

3.3.2 - Przydatne strony

Narzędzia WEB

Poniżej znajdziesz różnego rodzaju przydatne narzędzia działającego w przeglądarce.

Tworzenie grafik

• Diagrams - tworzenie grafik wektorowych
• Photopea - prosty webowy Photoshop

Tworzenie Favicon

• https://favicon.io
• https://cthedot.de/icongen

Analizatory i testery

• JSON Size Analyzer
• Regex Tester
• Mockaroo - Random Data Generation

Symulatory

• Wokwi - symulator mikrokontrolerów i urządzeń IoT

Dokumentacje

Poniżej zostały podane różnego rodzaju dokumentacje, ściągi i zbiory przydatnych informacji.

• Google Material Design

Cheat sheets

• Git Cheat Sheet
• Markdown Cheat Sheet
• Markdown Emoji Cheat Sheet

Edytowanie strony dokumentacji

Jeżeli pragniesz modyfikować szablon tej strony, bądź dodać nowy content - polecam skorzystać z dokumentacji tego szablonu pod linkiem:

• https://www.docsy.dev/docs/get-started

Awesome Sites

Zbiór kompediów wiedzy z Githuba, na różnego rodzaje tematów:

• https://github.com/chubin/awesome-console-services
• https://github.com/kylelobo/The-Documentation-Compendium
• https://github.com/dastergon/awesome-chaos-engineering
• https://github.com/ChromeDevTools/awesome-chrome-devtools
• https://github.com/BruceDone/awesome-crawler
• https://github.com/Vedenin/useful-java-links
• https://github.com/atinfo/awesome-test-automation
• https://github.com/awesome-lists/awesome-bash
• https://github.com/chrissimpkins/codeface
• https://github.com/meirwah/awesome-incident-response
• https://github.com/pingcap/awesome-database-learning
• https://github.com/grpc-ecosystem/awesome-grpc
• https://github.com/detailyang/awesome-cheatsheet
• https://github.com/LappleApple/awesome-leading-and-managing
• https://github.com/paralax/awesome-honeypots
• https://github.com/yzhao062/anomaly-detection-resources
• https://github.com/rossant/awesome-math
• https://github.com/alexandresanlim/Badges4-README.md-Profile
• https://github.com/aalhour/awesome-compilers
• https://github.com/webpro/awesome-dotfiles
• https://github.com/davidsonfellipe/awesome-wpo
• https://github.com/Kristories/awesome-guidelines
• https://github.com/TonnyL/Awesome_APIs
• https://github.com/thibmaek/awesome-raspberry-pi
• https://github.com/phanan/htaccess
• https://github.com/RunaCapital/awesome-oss-alternatives
• https://github.com/ujjwalkarn/Machine-Learning-Tutorials
• https://github.com/EthicalML/awesome-production-machine-learning
• https://github.com/keon/awesome-nlp
• https://github.com/dipakkr/A-to-Z-Resources-for-Students
• https://github.com/dexteryy/spellbook-of-modern-webdev
• https://github.com/awesome-foss/awesome-sysadmin
• https://github.com/kuchin/awesome-cto
• https://github.com/sdras/awesome-actions
• https://github.com/akullpp/awesome-java

Front-end

• https://github.com/dypsilon/frontend-dev-bookmarks
• https://github.com/rehooks/awesome-react-hooks
• https://github.com/brillout/awesome-react-components
• https://github.com/AllThingsSmitty/css-protips
• https://github.com/sindresorhus/awesome-electron
• https://github.com/AllThingsSmitty/must-watch-css
• https://github.com/goabstract/Awesome-Design-Tools
• https://github.com/terkelg/awesome-creative-coding
• https://github.com/neutraltone/awesome-stock-resources
• https://github.com/gztchan/awesome-design

Scaling & Automations & System administration

• https://github.com/veggiemonk/awesome-docker
• https://github.com/binhnguyennus/awesome-scalability
• https://github.com/awesome-selfhosted/awesome-selfhosted
• https://github.com/sottlmarek/DevSecOps
• https://github.com/shuaibiyy/awesome-terraform
• https://github.com/dzharii/awesome-elasticsearch

Cyber-security

• https://github.com/carpedm20/awesome-hacking
• https://github.com/Hack-with-Github/Awesome-Hacking
• https://github.com/pluja/awesome-privacy
• https://github.com/Lissy93/personal-security-checklist

Teoria

• https://github.com/trimstray/the-book-of-secret-knowledge
• https://github.com/kdeldycke/awesome-falsehood
• https://github.com/mfornos/awesome-microservices
• https://github.com/mhadidg/software-architecture-books
• https://github.com/DovAmir/awesome-design-patterns

Inne

• https://github.com/sindresorhus/awesome
• https://github.com/prakhar1989/awesome-courses
• https://github.com/papers-we-love/papers-we-love
• https://github.com/MunGell/awesome-for-beginners
• https://github.com/DopplerHQ/awesome-interview-questions
• https://github.com/tiimgreen/github-cheat-sheet
• https://github.com/mezod/awesome-indie
• https://github.com/rShetty/awesome-podcasts
• https://github.com/bnb/awesome-developer-streams
• https://github.com/abhisheknaiidu/awesome-github-profile-readme
• https://github.com/posquit0/Awesome-CV
• https://github.com/kitspace/awesome-electronics
• https://github.com/lukasz-madon/awesome-remote-job
• https://github.com/alebcay/awesome-shell
• https://github.com/jakejarvis/awesome-shodan-queries

3.3.3 - Wytyczne projektowe

WIP .

3.3.4 - Poradniki

Programowanie

Python

• Podstawy Python - youtube.com [PL]

• Korzystanie z REST API w Pythonie - youtube.com [PL]

• Łączenie z zewnętrznym API w Pythonie - youtube.com [PL]

• Obsługa baz danych w Python - youtube.com [PL]

C++

• Playlista z poradnikami C++ - youtube.com [PL]

Protokoły

Poradniki związane z protokołami komunikacyjnymi.

SocketCAN

• SocketCAN - wikipedia.org [EN]
• Omówienie SocketCAN - kernel.org [EN]

SPI

• Krótkie wprowadzenie do SPI - arduino.cc [EN]

Mikrokontrolery

Materiały odnośnie mikrokontrolerów, mini-komputerowych i podobnych.

• Omówienie ESP32 - youtube.com [EN]

Git

Obsługa systemu kontroli źródła Git

• Git od podstaw - youtube.com [PL]
• Korzystanie z Gitkrakena - youtube.com [EN]

Autonomiczność

Materiały zwiazane z rozwijaniem rozwiązań autonomicznych

• Zastrzyk teorii co do ROS’a - youtube.com [EN]
• Wprowadzenie praktyczne działania z ROS’em - youtube.com [EN]
• Programowanie ROS w Python - youtube.com [EN]
• Kanał poświęcony robotyce i projektom w ROS - youtube.com [EN]

Regulaminy Formuly Student

• Regulamin FSG - formulastudent.de [EN]

3.3.5 - Projekty

Miejsce w którym znajdują się pliki dokumentacje odnośnie projektów Sekcji Informatyki.

3.3.5.1 - Generator stopek

Generator stopek

Projekt służy do szybkiego stworzenia szablonu stopek do maili. Jest to backend dla jednej z wielu funkcjonalności projektu PRTHub.

Osoby odpowiedzialne:

• Sebastian Samulak

Gdzie można znaleźć ten projekt? Projekt znajduje się na naszym formułowym serwerze.

Jak z niego korzystac?

Aby skorzystać z projektu należy wejść w zakładkę generatora stopek na pasku nawigacyjnym PRT-Hub. Wymagane jest uzupełnienie formularza podając wkazane w nim dane. Po wciśnięciu przycisku Wygeneruj/Wyślij zostanie utworzona stopka do maili, którą należy skopiować i wkleić w odpowiednie miejsce w każdym z maili.

Część techniczna

Projekt obejmuje część backendową utworzoną w ASP.NET Core Web API. Znajdują się w nim modele domenowe. Warstwą prezentacji jest WebAPI, w której znajduje się kontroler odpowiedzialny za zapytania typu POST. Istnieje możliwosć gromadzenia danych, lecz w chwili obecnej jest wyłaczona.

Linki do repozytorium

• https://github.com/PRz-Racing-Team/FooterAPI

Cele

• Microserwis (Realizuje ściśle określoną funkcję tworzenia stopek do maili)
• Wydajność (Użyto w momencie tworzenia projektu najnowszą wersję framworku .NET)
• Dostępność (Możliwość korzystania z projektu dla każdego członka zespołu)

Założenia projektowe

Backend zostanie postawiony na formułowym serwerze, aby każdy z członków miał możliwość pozyskiwania sponsorów oraz promocji zespołu. Finalnie będzie posiadał zabezpieczenia przed użytkownikami z zewnątrz poprzez wymianę tokenu pomiędzy użytkownikiem a serwerem.

Użyte technologie

• Język programowania C#
• Platforma ASP.NET Core Web API
• Framework .NET 7.0

Napotkane problemy

Automapper

Warto zwrócić tutaj uwage na kłopotliwość związaną z skonfigurowaniem AutoMappera, który został ostatecznie usunięty z projektu, gdyż dane nie są gromadzone. Pomimo zgodności mapowanych danych wyskakiwał błąd kończący pracę serwera. Wedle wierzeń programistów należy napisać Automaper w sposób “ręczny” co minimalizuje ryzyko depresji z nim związanej.

3.3.5.2 - PRT-Hub

PRT-Hub

Projekt PRTHub, jest stroną internetową postawioną na naszym formułowym serwerze, która służy do zgromadzenia funkcji ułatwiających członkom zespołu pracę na warsztacie. Poza przydatnymi informacjami na stronie głównej, która jest dostępna po zalogowaniu się, możemy zauważyć m.in. generatory do ofert oraz stopek do maili. Strona jest ciągle rozbudowywana o nowe funkcje.

Osoby odpowiedzialne:

• Wiktoria Czech

Gdzie można znaleźć ten projekt?

Projekt znajduje się na stronie internetowej, wymagane jest zalogowanie się: PRT-Hub

Jak z niego korzystać?

Po wejściu w adres strony internetowej klikamy w bolid lub z przycisk w prawym górnym rogu żeby się zalogować. Podajemy swoje dane i logujemy się.

Zostajemy przekierowani na stronę główną gdzie możemy zobaczyć czas pozostały do nadchodzących zawodów w tym sezonie oraz kalendarz z informacją o sprzątaniu dla danej sekcji. 3 przyciski pod kalendarzem przeniosą nas na strony opisane na przyciskach.

Po lewej stronie widzimy granatowy pasek nawigacji, dzięki któremu możemy przejść na interesujące nas podstrony.

Tworzenie ofert oraz generator stopek

Oba projekty wymagają uzupełnienia formularza, który pojawia się gdy wejdziemy w odpowiednią zakładkę na pasku nawigacji. Pola wymagane oznaczono czerwoną gwiazdką i podano też przykładowe dane w okienkach. Po naciśnięciu przycisku Wygeneruj/Wyślij dostajemy informację zwrotną w formie pola z informacją czy nasze żądanie powiodło się.

Dla generatora stopek po najechaniu na słowo POCZTA lub naciśnięciu któregokolwiek z kolorowych przycisków w formularzu wyświetlona zostaje lista z popularnymi serwisami pocztowymi. Należy wybrać swoją pocztę i kliknąć w nią. Pojawi się lista kroków jak dodać wygenerowaną stopkę. Wytłuszczony przycisk TUTAJ otwiera w nowym oknie link z instrukcją w razie problemów.

Panel sponsorów

Wchodząc w panel sponsorów widzimy 4 karty, które sortują naszych aktualnych sponsorów na kategorie. Wchodząc w interesującą nas kartę widzimy listę sponsorów z danej kategorii. Reszta funkcji widoczna w oknie nawigacji będzie programowana i uzupełniana na bieżąco.

Część Techniczna

Wyżej opisany projekt obejmuje część frontendową pisaną w frameworku REACT na Node.js w wersji 18.12.1. Zainstalowany poprzez komendę npm i antd layout ant-designu został w różnych częściach projektu zaimplementowany w celu ukrócenia sobie męki programowania „koła” na nowo.

Każda podstrona bądź znacząca część strony została wydzielona do osobnych folderów, zawierających komponent javascriptowy z css’em do niego w celu zachowania jakiejkolwiek przejrzystości kodu. Przy programowaniu każdej części strony ogarnięto responsywność ale nie była ona testowana na każdym telefonie. W celu nadpisania defaultowego wyglądu niektórych komponentów antd wrzucono „!important” w css.

Cele

• Skalowalność: możliwość dodania nowych funkcji
• Ułatwienie dostępu: Generowanie prawidłowych pdf do zakupu części bolidowych, wyszukiwarka
• ALL in ONE: dużo przydatnych funkcji zebranych w jednym miejscu

Założenia projektowe

Do projektu nie mogą mieć dostępu osoby niezalogowane. Funkcjonalność ponad wygląd ale to nie znaczy , że strona ma wyglądać beznadziejnie. Przyjazne UI.

Użyte technologie

• Framework: React ^ 18.2.0
• Oprogramowanie: Node.js ^ 18.12.1

Biblioteki:

• Ant-design-icons ^ 5.0.1
• Antd ^ 5.2.3
• History ^ 5.3.0

Napotkane problemy

Kalendarz:

W celu wykonania jakiejkolwiek operacji na kalendarzu antd nie odwoływać się do zmiennych w obiekcie – są prywatne. Wszystkie prywatne zmienne oznaczone są „_” przed nazwą zmiennej.

3.3.5.3 - Przykładowy projekt

Nazwa projektu

Opis w bardzo prostych słowach, na temat tego do czego służy ten projekt i co on robi.

Max. 5 zdań.

Osoby odpowiedzialne:

• Jan Kowalski
• etc

Gdzie można znaleźć ten projekt? Opisać gdzie ten projekt się znaduje, czy np. jest to na jakiejś stronie internetowej, czy w miejscu na formule bądź bolidzie.

Jak z niego korzystac?

Jeżeli twój projekt został zrealizowany dla wszystkich w formule, w tym miejscu powinna znaleźć się dokładna instrukcja jak korzystać z danego rozwiązania. Np. dla kreatora dokumentów ofertowych, powinien być opis jak to wyklikać, co się kiedy dzieje, itp.

Część techniczna

Część przeznaczona dla osób z Sekcji Informatyki bądź elektroniki, bądź zainteresowanych szczegółami projektu.

Linki do repozytorium

• https://github.com/PRz-Racing-Team/przyklad

Cele

Opis tego jakie cele chcielibyśmy uzyskać i jakie projekt powinien spełniać cechy Przykładowo, jeżeli mielibysmy projekt internetowego włącznika do światła, to byłoby to:

• Dostępność (Łatwo wejść na strone i przełączyć światło)
• Skalowalność ( proste dodawanie kolejnych guzików żeby móc pstrykać więcej lampek)
• Wydajność (mając podłączonych 1000 lampek do systemu, po kliknięciu przełączą sie one i tak w 1 sekundę )

Założenia projektowe

Przykładowo, założeniem projektowym są odgórne limity i wymagania które projekt musi spełnić, np. ograniczeniem telemetrii jest układ STM32, albo to że projekt strony internetowej będzie postawiony na AWS i musi być możliwość szybkiego deploy’a na tą platformę.

Użyte technologie

• Języki programowania
• Biblioteki
• Usługi np. AWS, Retool

W jaki sposób działa ten projekt?

Bardziej szczegółowy opis, na ten moment zostawiam stosunkową dowolność.

Napotkane problemy

W tym miejscu, powinny znajdować się duże problemy, które sprawiły nam problem przez dłuższy okres czasu i warto wrzucić tutaj informacje na jego temat, w celu protego znalezienia rozwiązania, bądź ogólnej przestrogi, na przyszłość, jak dla siebie jak i dla innych osób które mogą rozwinać ten dany projekt.

Jeżeli jakiś problem pojawił się z powodu źle popełnionej decyzji, taka informacja też jest bardzo wartościowa - zwłaszcza na designach!

Problem XYZ

Napotkałe/am problem […] w czasie […], naprawiony został poprzez […]

3.3.5.4 - SzlabanBot

SzlabanBot

Projekt został stworzony w celu ułatwienia dostępu na parking warsztatu poprzez aplikację Telegram.

Osoby odpowiedzialne:

• Gabriel Olszewski

Gdzie można znaleźć ten projekt? Projekt jest podzielony na trzy skrypty oraz bazę danych. Skrypt pierwszy jest zainstalowany na ESP8266 znajdującym się w puszcze po prawej stronie od wejścia. Baza danych i dwa pozostałe skrypty są uruchomione na serwerze.

Jak z niego korzystac?

Jeżeli twój projekt został zrealizowany dla wszystkich w formule, w tym miejscu powinna znaleźć się dokładna instrukcja jak korzystać z danego rozwiązania. Np. dla kreatora dokumentów ofertowych, powinien być opis jak to wyklikać, co się kiedy dzieje, itp.

Część techniczna

Część przeznaczona dla osób z Sekcji Informatyki bądź elektroniki, bądź zainteresowanych szczegółami projektu.

Linki do repozytorium

• https://github.com/PRz-Racing-Team/przyklad

Cele

Opis tego jakie cele chcielibyśmy uzyskać i jakie projekt powinien spełniać cechy Przykładowo, jeżeli mielibysmy projekt internetowego włącznika do światła, to byłoby to:

• Dostępność (Łatwo wejść na strone i przełączyć światło)
• Skalowalność ( proste dodawanie kolejnych guzików żeby móc pstrykać więcej lampek)
• Wydajność (mając podłączonych 1000 lampek do systemu, po kliknięciu przełączą sie one i tak w 1 sekundę )

Założenia projektowe

Przykładowo, założeniem projektowym są odgórne limity i wymagania które projekt musi spełnić, np. ograniczeniem telemetrii jest układ STM32, albo to że projekt strony internetowej będzie postawiony na AWS i musi być możliwość szybkiego deploy’a na tą platformę.

Użyte technologie

• Python, C
• Docker
• JWT, SHA256

W jaki sposób działa ten projekt?

Bardziej szczegółowy opis, na ten moment zostawiam stosunkową dowolność.

Napotkane problemy

W tym miejscu, powinny znajdować się duże problemy, które sprawiły nam problem przez dłuższy okres czasu i warto wrzucić tutaj informacje na jego temat, w celu protego znalezienia rozwiązania, bądź ogólnej przestrogi, na przyszłość, jak dla siebie jak i dla innych osób które mogą rozwinać ten dany projekt.

Jeżeli jakiś problem pojawił się z powodu źle popełnionej decyzji, taka informacja też jest bardzo wartościowa - zwłaszcza na designach!

Problem XYZ

Napotkałe/am problem […] w czasie […], naprawiony został poprzez […]

3.3.5.5 - Projekt serwera

Wstęp

Projekt majacy na celu stworzenie drużynowego serwera w celu hostowania własnego oprogramowania oraz przetrzymywania danych długoterminowo.

Hardware serwera

Komputer służacy jako serwer został złożony z następujących części:

• Płyta główna - ASRock B460M Steel Legend
• Procesor - Intel Core i5-10400
• Pamieć RAM - GOODRAM 16GB (2x8GB) 3200MHz CL16 IRDM X Black
• Zasilacz - be quiet! Pure Power 11 400W 80 Plus Gold
• Dysk systemowy - ADATA 256GB M.2 PCIe NVMe XPG SX6000 Pro
• Dyski - Seagate IRONWOLF CMR 4TB 5900obr. 64MB - 3 sztuki

Osoby odpowiedzialne za serwer

• Wiktor Jezioro
• Patryk Kępa

3.3.5.6 - Serwer testowy

Wstęp

Serwer testowy, to lokalnie zahostowany serwer w warsztacie, służący do testowania różnego rodzaju rozwiązań w środowisku gdzie, w razie usterki, nie wpłynie to na działanie żadnych systemów wykorzystywanych przez zespół.

Korzystanie z serwera

W celu skorzystania z serwera, należy będąc podłączonym do sieci Wi-Fi zespołu, bądź będąc podłączonym do VPN’a, skorzystać z połączenia SSH.

Aby to dokonać, będziemy musieli skorzystać z klienta ssh, przykładowo - Termius bądź PuTTY (przestarzały).

Następnie, korzystając z klienta ssh, logujemy się za pomocą niżej podanych danych dostępowych.

• Adres IP: 192.168.1.143
• Nazwa użytkownika: prztest
• Hasło: turbocebra600

{{ % alert title=“Uwaga!” color=“warning” % }} Każde połączenie i wywołane komendy są logowane przez administratora, jakiekolwiek próby uszkodzenia bądź zniszczenia konfiguracji dla zabawy są jawne i przypisane do osób korzystających z serwera.

Jakiekolwiek przykłady takiego zachowania będą karane.

3.3.5.7 - Symulator silnika

Symulacja pracy silnika spalinowego

Celem projektu jest sprawdzenie skuteczności dostępnego publicznie oprogramowania, które umożliwia symulację pracy dowolnego silnika spalinowego w czasie rzeczywistym. Głównym celem jest utworzenie w przyszłości projektu silnika z bolidu PMT-04 i porównanie wyników symulatora z prawdziwą telemetrią.

Osoby odpowiedzialne:

• Michał Surówka

Gdzie można znaleźć ten projekt?

Oprogramowanie dostępne jest w serwisie GitHub pod tym linkiem: TUTAJ Znajduje się nie tylko sam program, ale z tej witryny można przejść bezpośrednio do bazy gotowych już silników utworzonych przez społeczność. Docelowo w naszym repozytorium znajdzie się plik zawierający model silnika z bolidu PMT-04.

Jak z niego korzystac?

Przechodząc do lokalizacji ‘\engine-sim-buildWERSJA\bin’ otwieramy plik ‘engine-sim-app.exe’. Otworzy się wtedy program z załadowanym ostatnio używanym modelem silnika. Tam wedle dołączonej na w.w. GitHubie można badać jego zachowanie (prędkość maksymalną, zużycie paliwa, ciśnienie w kolektorze etc.). Możemy też zmienić model silnika za pomocą opcji ‘Load Engine’.

Część techniczna

Budowa oprogramowania oraz modeli silnika oparta jest na języku Piranha, który jest językiem opartym na C stworzonym specjalnie na potrzeby tego programu. Dzięki temu kod jest na tyle zoptymalizowany, że umożliwia monitorowanie silnika przy ponad 25 tysiącach odświeżeń stanu na sekundę, jednakże jest to bardzo zależne od mocy obliczeniowej komputera oraz złożoności modelu. Warto wspomnieć, że program jest w fazie Alpha, więc nie wszystkie modele działają poprawnie, są liczne problemy z wydajnością przy bardziej skomplikowanych modelach silników, niektóre modele często z niewiadomych przyczyn wcale się nie kompilują w programie.

Cele

• Wydajność
• Dokładność
• Niezawodność
• Skalowalność

Założenia projektowe

Główne założenie to zbadanie budowy modelu silnika w języku Piranha i sprawdzenie jego możliwości. Celem końcowym jest odtworzenie silnika z bolidu PMT-04 w symulatorze z jak największą dokładnością. Jeżeli twórca udostępni taką funkcjonalność, to w przyszłości może być możliwe badanie pracy silnika elektrycznego.

Użyte technologie

• Języki programowania (Piranha)
• Biblioteki
• Społecznościowe modele silnika

W jaki sposób działa ten projekt?

Program czytając plik modelu silnika jest w stanie w czasie rzeczywistym odtwarzać jego pracę, dźwięk i zachowanie w określonych warunkach. Na ten moment możliwe jest badanie silnika spalinowego (bez turbosprężarki ani kompresora) w różnych układach cylindrów (V8, W12, Y9 itp.) a także silnika Wankla. Plik z modelem silnika zawiera w sobie node’y, gdzie każdy z nich dokładnie opisuje cechy charakterystyczne danego elementu silnika i skrzyni biegów. Możliwości jak na fazę Alpha są bardzo duże a edycja/tworzenie modeli jest intuicyjne.

Bardzo ważne jest, aby przed przystąpieniem do jakiejkolwiek symulacji przygotować program przez ustawienie odpowiedniej częstotliwości pracy. Ustawienie zbyt dużej częstotliwości będzie skutkować niedokładną symulacją i bardzo wolnym działaniem programu (spadki nawet do 10 klatek na sekundę), natomiast zbyt niska częstotliwość obniża stabilność modelu, przez co przy rozpoczęciu testów model może zwyczajnie się zepsuć. Wtedy należy go załadować ponownie i dostosować częstotliwość.

Napotkane problemy

Główne problemy to stabilność modeli. Wiele modeli posiada błędy wynikające podczas symulacji, np: silnik zawieszający się po osiągnięciu określonych obrotów lub brak reakcji na zapłon. W większości przypadków ciężko jest określić czy wina leży po stronie modelu czy po stronie symulatora. Dodatkowy problem to działanie symulacji przy skomplikowanych modelach. Podczas gdy modele o prostszej budowie, np: silniki motocyklowe można badać w częstotliwości 20-25kHz, tak bardziej skomplikowane modele, np: wysokobrotowe V10 lub V12 zaczyna sprawiać problemy przy 8-9kHz (może to wynikać ze słabej skalowalności programu, gdyż testy przeprowadzane były na komputerach o dużej mocy obliczeniowej).

Ostatni problem to język w jakim napisany jest program i modele z których korzysta. Konieczne jest zapoznanie się ze składnią całkowicie nowego języka, który nie jest używany nigdzie poza tym symulatorem, gdyż specjalnie na jego potrzeby został utworzony.

Problem z błędami w symulacji

Podczas przeprowadzania symulacji niejednokrotnie model po prostu się “wysypuje”, bądź od początku działa nieprawidłowo. Przykładowo model silnika Renault RS25 nie może przekroczyć bariery 3000RPM oraz nie może pracować samoczynnie (po wyłączeniu startera silnik gaśnie). Podobny problem występuje w modelu silnika Triumph Race T-Plane 3, który nie przebija 4500RPM i gaśnie od razu po wysprzęgleniu na jakimkolwiek biegu.

3.3.5.8 -

3.3.6 - Zaplanowane projekty

Wstęp

W tym miejscu, znajdują się projekty które są WIP bądź są zaplanowane na przyszłość.

3.3.6.1 - Agregator Webhook

Wstęp

Celem projektu, jest stworzenia modułu mającego na celu wystawienie endpoint’a REST API, który będzie przechwytywał webhook’i z różnego rodzaju serwisów, na początek będzie to serwis Github. Usługa zostanie później dołączona jako podpanel, do projektu PRTHub’a w celu szybkiego podglądu np. postępu projektów na Githubie.

Opis techniczny

Przykładowo, w celu odbierania naszych webhooków, będziemy chcieli wystawić POST API, na adresie:

https://api.przracing.pl/webhooks/github

na którym nasza usługa będzie przyjmować JSON’a z informacjami odnośnie wydarzenia które powstało na Githubie. Następnie, całą naszą odebraną wiadomość, będziemy zapisywać w bazie danych:

• MongoDB - będzie ona łatwiejsza do implementacji, z powodu jej natywnego wsparcia dla obiektów JSON (każdy rekord w tej bazie danych to tak naprawdę ramka formatu JSON)
• MySQL - korzystając z obiektu w formacie JSON (może być troszeczkę trudniej)

Ważnym elementem jest próba automatyzacji tego w taki sposób, byśmy nie musieli tworzyć rozbudowanego rekordu w bazie MySQL samemu, dla każdej usługi format Webhook’ów może być inny i ponowne definiowanie ich w bazie danych, w momencie kiedy chcemy dodać jakaś usługę, byłoby bardzo męczące i problematyczne.

Przydatne materiały

• https://www.baeldung.com/cs/webhooks-polling-real-time-information
• https://www.oodlestechnologies.com/blogs/how-to-implement-webhook-in-spring-webapplication./
• https://dreamix.eu/blog/java/webhook-with-spring-boot-and-h2-database
• https://www.codeproject.com/Articles/576278/Webhooks-webhook-URLs-and-a-sample-implementation
• https://github.com/IntuitDeveloper/SampleApp-Webhooks-Java - Uwaga! dosyć stary materiał
• https://www.digitalocean.com/community/tutorials/working-with-json-in-mysql

Przykłady

Poniżej znajduje się przykładowa ramka, z webhook’a Github’a.

{
  "action": "completed",
  "check_suite": {
    "id": 11474097815,
    "node_id": "CS_kwDOJFq9ec8AAAACq-jWlw",
    "head_branch": "master",
    "head_sha": "da8013944471bf7ad65c6739a9efde9770c70571",
    "status": "completed",
    "conclusion": "success",
    "url": "https://api.github.com/repos/PRz-Racing-Team/PRTHub-front/check-suites/11474097815",
    "before": "91546e32d360a235474921cf5dd7ea6d0a8d8aa0",
    "after": "da8013944471bf7ad65c6739a9efde9770c70571",
    "pull_requests": [

    ],
    "app": {
      "id": 85455,
      "slug": "cloudflare-pages",
      "node_id": "MDM6QXBwODU0NTU=",
      "owner": {
        "login": "cloudflare",
        "id": 314135,
        "node_id": "MDEyOk9yZ2FuaXphdGlvbjMxNDEzNQ==",
        "avatar_url": "https://avatars.githubusercontent.com/u/314135?v=4",
        "gravatar_id": "",
        "url": "https://api.github.com/users/cloudflare",
        "html_url": "https://github.com/cloudflare",
        "followers_url": "https://api.github.com/users/cloudflare/followers",
        "following_url": "https://api.github.com/users/cloudflare/following{/other_user}",
        "gists_url": "https://api.github.com/users/cloudflare/gists{/gist_id}",
        "starred_url": "https://api.github.com/users/cloudflare/starred{/owner}{/repo}",
        "subscriptions_url": "https://api.github.com/users/cloudflare/subscriptions",
        "organizations_url": "https://api.github.com/users/cloudflare/orgs",
        "repos_url": "https://api.github.com/users/cloudflare/repos",
        "events_url": "https://api.github.com/users/cloudflare/events{/privacy}",
        "received_events_url": "https://api.github.com/users/cloudflare/received_events",
        "type": "Organization",
        "site_admin": false
      },
      "name": "Cloudflare Pages",
      "description": "",
      "external_url": "https://pages.cloudflare.com/",
      "html_url": "https://github.com/apps/cloudflare-pages",
      "created_at": "2020-10-19T20:23:00Z",
      "updated_at": "2021-01-12T18:19:30Z",
      "permissions": {
        "checks": "write",
        "contents": "read",
        "deployments": "write",
        "metadata": "read",
        "pull_requests": "write"
      },
      "events": [
        "pull_request",
        "push"
      ]
    },
    "created_at": "2023-03-10T08:05:39Z",
    "updated_at": "2023-03-10T08:07:46Z",
    "rerequestable": true,
    "runs_rerequestable": true,
    "latest_check_runs_count": 1,
    "check_runs_url": "https://api.github.com/repos/PRz-Racing-Team/PRTHub-front/check-suites/11474097815/check-runs",
    "head_commit": {
      "id": "da8013944471bf7ad65c6739a9efde9770c70571",
      "tree_id": "6837da45883ed6cbbcd31ae8bc38ff768eb34169",
      "message": "Added layout with cards to sponsors panel.",
      "timestamp": "2023-03-09T00:12:44Z",
      "author": {
        "name": "WiktoriaCzech",
        "email": "czech.wiktoria1@gmail.com"
      },
      "committer": {
        "name": "WiktoriaCzech",
        "email": "czech.wiktoria1@gmail.com"
      }
    }
  },
  "repository": {
    "id": 609926521,
    "node_id": "R_kgDOJFq9eQ",
    "name": "PRTHub-front",
    "full_name": "PRz-Racing-Team/PRTHub-front",
    "private": true,
    "owner": {
      "login": "PRz-Racing-Team",
      "id": 64755388,
      "node_id": "MDEyOk9yZ2FuaXphdGlvbjY0NzU1Mzg4",
      "avatar_url": "https://avatars.githubusercontent.com/u/64755388?v=4",
      "gravatar_id": "",
      "url": "https://api.github.com/users/PRz-Racing-Team",
      "html_url": "https://github.com/PRz-Racing-Team",
      "followers_url": "https://api.github.com/users/PRz-Racing-Team/followers",
      "following_url": "https://api.github.com/users/PRz-Racing-Team/following{/other_user}",
      "gists_url": "https://api.github.com/users/PRz-Racing-Team/gists{/gist_id}",
      "starred_url": "https://api.github.com/users/PRz-Racing-Team/starred{/owner}{/repo}",
      "subscriptions_url": "https://api.github.com/users/PRz-Racing-Team/subscriptions",
      "organizations_url": "https://api.github.com/users/PRz-Racing-Team/orgs",
      "repos_url": "https://api.github.com/users/PRz-Racing-Team/repos",
      "events_url": "https://api.github.com/users/PRz-Racing-Team/events{/privacy}",
      "received_events_url": "https://api.github.com/users/PRz-Racing-Team/received_events",
      "type": "Organization",
      "site_admin": false
    },
    "html_url": "https://github.com/PRz-Racing-Team/PRTHub-front",
    "description": "Frontend do projektu PRTHub ",
    "fork": false,
    "url": "https://api.github.com/repos/PRz-Racing-Team/PRTHub-front",
    "forks_url": "https://api.github.com/repos/PRz-Racing-Team/PRTHub-front/forks",
    "keys_url": "https://api.github.com/repos/PRz-Racing-Team/PRTHub-front/keys{/key_id}",
    "collaborators_url": "https://api.github.com/repos/PRz-Racing-Team/PRTHub-front/collaborators{/collaborator}",
    "teams_url": "https://api.github.com/repos/PRz-Racing-Team/PRTHub-front/teams",
    "hooks_url": "https://api.github.com/repos/PRz-Racing-Team/PRTHub-front/hooks",
    "issue_events_url": "https://api.github.com/repos/PRz-Racing-Team/PRTHub-front/issues/events{/number}",
    "events_url": "https://api.github.com/repos/PRz-Racing-Team/PRTHub-front/events",
    "assignees_url": "https://api.github.com/repos/PRz-Racing-Team/PRTHub-front/assignees{/user}",
    "branches_url": "https://api.github.com/repos/PRz-Racing-Team/PRTHub-front/branches{/branch}",
    "tags_url": "https://api.github.com/repos/PRz-Racing-Team/PRTHub-front/tags",
    "blobs_url": "https://api.github.com/repos/PRz-Racing-Team/PRTHub-front/git/blobs{/sha}",
    "git_tags_url": "https://api.github.com/repos/PRz-Racing-Team/PRTHub-front/git/tags{/sha}",
    "git_refs_url": "https://api.github.com/repos/PRz-Racing-Team/PRTHub-front/git/refs{/sha}",
    "trees_url": "https://api.github.com/repos/PRz-Racing-Team/PRTHub-front/git/trees{/sha}",
    "statuses_url": "https://api.github.com/repos/PRz-Racing-Team/PRTHub-front/statuses/{sha}",
    "languages_url": "https://api.github.com/repos/PRz-Racing-Team/PRTHub-front/languages",
    "stargazers_url": "https://api.github.com/repos/PRz-Racing-Team/PRTHub-front/stargazers",
    "contributors_url": "https://api.github.com/repos/PRz-Racing-Team/PRTHub-front/contributors",
    "subscribers_url": "https://api.github.com/repos/PRz-Racing-Team/PRTHub-front/subscribers",
    "subscription_url": "https://api.github.com/repos/PRz-Racing-Team/PRTHub-front/subscription",
    "commits_url": "https://api.github.com/repos/PRz-Racing-Team/PRTHub-front/commits{/sha}",
    "git_commits_url": "https://api.github.com/repos/PRz-Racing-Team/PRTHub-front/git/commits{/sha}",
    "comments_url": "https://api.github.com/repos/PRz-Racing-Team/PRTHub-front/comments{/number}",
    "issue_comment_url": "https://api.github.com/repos/PRz-Racing-Team/PRTHub-front/issues/comments{/number}",
    "contents_url": "https://api.github.com/repos/PRz-Racing-Team/PRTHub-front/contents/{+path}",
    "compare_url": "https://api.github.com/repos/PRz-Racing-Team/PRTHub-front/compare/{base}...{head}",
    "merges_url": "https://api.github.com/repos/PRz-Racing-Team/PRTHub-front/merges",
    "archive_url": "https://api.github.com/repos/PRz-Racing-Team/PRTHub-front/{archive_format}{/ref}",
    "downloads_url": "https://api.github.com/repos/PRz-Racing-Team/PRTHub-front/downloads",
    "issues_url": "https://api.github.com/repos/PRz-Racing-Team/PRTHub-front/issues{/number}",
    "pulls_url": "https://api.github.com/repos/PRz-Racing-Team/PRTHub-front/pulls{/number}",
    "milestones_url": "https://api.github.com/repos/PRz-Racing-Team/PRTHub-front/milestones{/number}",
    "notifications_url": "https://api.github.com/repos/PRz-Racing-Team/PRTHub-front/notifications{?since,all,participating}",
    "labels_url": "https://api.github.com/repos/PRz-Racing-Team/PRTHub-front/labels{/name}",
    "releases_url": "https://api.github.com/repos/PRz-Racing-Team/PRTHub-front/releases{/id}",
    "deployments_url": "https://api.github.com/repos/PRz-Racing-Team/PRTHub-front/deployments",
    "created_at": "2023-03-05T16:45:00Z",
    "updated_at": "2023-03-05T16:52:09Z",
    "pushed_at": "2023-03-10T08:05:38Z",
    "git_url": "git://github.com/PRz-Racing-Team/PRTHub-front.git",
    "ssh_url": "git@github.com:PRz-Racing-Team/PRTHub-front.git",
    "clone_url": "https://github.com/PRz-Racing-Team/PRTHub-front.git",
    "svn_url": "https://github.com/PRz-Racing-Team/PRTHub-front",
    "homepage": null,
    "size": 26755,
    "stargazers_count": 0,
    "watchers_count": 0,
    "language": "JavaScript",
    "has_issues": true,
    "has_projects": true,
    "has_downloads": true,
    "has_wiki": false,
    "has_pages": false,
    "has_discussions": false,
    "forks_count": 0,
    "mirror_url": null,
    "archived": false,
    "disabled": false,
    "open_issues_count": 0,
    "license": null,
    "allow_forking": false,
    "is_template": false,
    "web_commit_signoff_required": false,
    "topics": [

    ],
    "visibility": "private",
    "forks": 0,
    "open_issues": 0,
    "watchers": 0,
    "default_branch": "master"
  },
  "organization": {
    "login": "PRz-Racing-Team",
    "id": 64755388,
    "node_id": "MDEyOk9yZ2FuaXphdGlvbjY0NzU1Mzg4",
    "url": "https://api.github.com/orgs/PRz-Racing-Team",
    "repos_url": "https://api.github.com/orgs/PRz-Racing-Team/repos",
    "events_url": "https://api.github.com/orgs/PRz-Racing-Team/events",
    "hooks_url": "https://api.github.com/orgs/PRz-Racing-Team/hooks",
    "issues_url": "https://api.github.com/orgs/PRz-Racing-Team/issues",
    "members_url": "https://api.github.com/orgs/PRz-Racing-Team/members{/member}",
    "public_members_url": "https://api.github.com/orgs/PRz-Racing-Team/public_members{/member}",
    "avatar_url": "https://avatars.githubusercontent.com/u/64755388?v=4",
    "description": ""
  },
  "sender": {
    "login": "WiktoriaCzech",
    "id": 103213435,
    "node_id": "U_kgDOBibpew",
    "avatar_url": "https://avatars.githubusercontent.com/u/103213435?v=4",
    "gravatar_id": "",
    "url": "https://api.github.com/users/WiktoriaCzech",
    "html_url": "https://github.com/WiktoriaCzech",
    "followers_url": "https://api.github.com/users/WiktoriaCzech/followers",
    "following_url": "https://api.github.com/users/WiktoriaCzech/following{/other_user}",
    "gists_url": "https://api.github.com/users/WiktoriaCzech/gists{/gist_id}",
    "starred_url": "https://api.github.com/users/WiktoriaCzech/starred{/owner}{/repo}",
    "subscriptions_url": "https://api.github.com/users/WiktoriaCzech/subscriptions",
    "organizations_url": "https://api.github.com/users/WiktoriaCzech/orgs",
    "repos_url": "https://api.github.com/users/WiktoriaCzech/repos",
    "events_url": "https://api.github.com/users/WiktoriaCzech/events{/privacy}",
    "received_events_url": "https://api.github.com/users/WiktoriaCzech/received_events",
    "type": "User",
    "site_admin": false
  }
}

3.3.6.2 - Bot Discord

Wstęp

Heavily WIP.

Projekt zawiera stworzenie bota zespołowego na platformę Discord.

Przykładowe funkcje

• “Feature parity” z botem na Telegram.
• Po dołączeniu:
  • Autoustawianie rangi członka po dołączeniu
  • Informacja dla użytkownika na temat zmiany nazwy na imię i nazwisko na serwerze
  • Informacje na temat regulaminu korzystania z serwera
• Dodanie szybkich skrotów do np.
  • Napisanie wiadomości do wszystkich członków w Sekcji w celu przypomnienia o spotkaniu
  • Planowanie spotkań na DS i przypominanie o nich 15 minut wcześniej w formie wiadomości prywatnej itp.

4 - Bolid Autonomiczny

4.1 - Zbiór wiedzy do Matlaba i Simulinka

Matlab & Simulink

W tym miejscu znajdziesz wszystkie poradniki i “gotowce”, które mogą się okazać przydatne podczas nauki i pracy z Matlabem i Simulinkiem.

Słowo wstępu

Na początku zanim przystąpisz do pracy w Matlabie i/lub Simulinku musisz się zaopatrzyć w sam program i licencję. Jako student PRz masz dostęp do licencji akademickiej, która udostępnia Ci wszystkie najpotrzebniejsze apki do Matlaba. Poradnik jak aktywować taką licencję znajdziesz w linku poniżej. Jeśli chodzi o apki wybierane podczas instalacji, to głównie będziesz korzystał ze wszystkiego powiązanego z Simulinkiem, bibliotek Simscape i blocksetów (np: Powertrain Blockset). Najbezpieczniej jednak będzie podczas instalacji samego Matlaba zaznaczyć wszystkie apki, kto wie co jeszcze może okazać się przydatne ;). Jeśli okaże się, że jakiejś apki brakuje, można ją doinstalować z poziomu samego Matlaba.

Licencja, Instalacja Matlaba i modułów

• Aktywacja licencji akademickiej
• Instalacja Matlab’a
• Instalacja apek/modułów wewnątrz Matlab’a

Oficjalne tutoriale, dokumentacje i zapisy webinarów

• (WAŻNE) “How to” with Matlab & Simulink
• (WAŻNE) Self-Paced Courses
• (WAŻNE) Tutorial jak się zabrać do autonomika autorstwa FSG
• Design, Simulate, and Test Automated Driving Systems with MATLAB and Simulink
• Modeling and Control of a Dual Active Bridge (DAB) for Electric Vehicle and Battery Charging Applications
• (Webinar) Vehicle Dynamics Simulation and Visualization for Student Competitions
• (Webinar) Electric Vehicle Powertrain Sizing and Optimization for Student Competitions
• (Webinar) Code Generation with Matlab and Simulink for Student Competitions
• (Webinar) Overview of MathWorks ADAS and Automated Driving Tools for Student Competitions
• Simulating Longitudinal and Lateral Vehicle Dynamics
• Automated Driving System Design and Simulation
• Complete Vehicle Model in Simulink
• Automated Driving Toolbox Documentation
• Get Started with Automated Driving Toolbox
• Get Started with the Virtual Vehicle Composer
• Getting started with YOLOv2
• Making Vehicles and Robots See: Getting Started with Perception for Students
• Path Planning for Formula Student Driverless Cars Using Delaunay Triangulation
• Communicating with CAN Networks Using Vehicle Network Toolbox for Student Competitions
• Automated Parking Valet with ROS in Simulink
• Code Generation for ARM Cortex-M and ARM Cortex-A Processors
• Electric Vehicle Assembly using Simulink Automotive

Oficjalne presety, modele i repozytoria.

• (Repozytorium) Simscape-Essentials-for-Automotive-Student-Teams
• Generowanie Skidpada
• Code Generation for Student Competitions
• Matlab&Simulink Vehicle Simulation Dynamics

Tutoriale społecznościowe

• Objaśnienie Algorytmu SLAM według studentów MIT
• Algorytm SLAM - objaśnienie po polsku
• Autonomous Driving System Design for Formula Student Driverless Racecar
• Autonomous Driving System Design for Formula Racing

4.2 - Dokumentacja Symulatora Okrążenia

Wstęp

W wypisanych poniżej podstronach znajdują się elementy dokumentacji zawierające informacje o poszczególnych jej elementach, ułożone wedle elementu bolidu (opony, układ napędowy etc.). Symulacja NIE jest naszego autorstwa, oryginalni autorzy to zespół Baltic Racing.

Linki do repozytorium:
Oryginał: Repozytorium Baltic Racing

Wraz z postępem prac dokumentacja będzie aktualizowana.

4.2.1 - paramtery akumulatora

Wstęp

calculateAccumulatorData.m - jest to opisywany plik

DZIAŁANIE PLIKU

1. pierwsze 4 linie służą do ładowania danych z plików MAT do zmiennych w skrypcie.

2. Następnie zapisane są funkcje, które służą do liczenia poszczególnych danych.

Accumulator.V_i(i) = sum(Accumulator.Voltage_Cellpack(:,i)); - Oblicza sumę napięć wszystkich ogniw w akumulatorze dla danego punktu czasowego (i), przechowuje tę wartość w Accumulator.V_i(i).

Accumulator.A_accu_cell(i) = P_el(i) / Accumulator.V_i(i) / setup.nZellen_Parallel; - Oblicza prąd akumulatora dla danego punktu czasowego (i) korzystając z mocy elektrycznej (P_el), napięcia (Accumulator.V_i(i)) i liczby ogniw równoległych (setup.nZellen_Parallel).

Accumulator.Current_Cellpack_Pointer(i) - Określa wskaźnik aktualnego prądu dla pakietu ogniw w 0,1A na podstawie mocy elektrycznej i napięcia.

Warunki “if” sprawdzają i ograniczają wartość Accumulator.Current_Cellpack_Pointer(i) w określonym zakresie.

Accumulator.VirtualCurrent_Cellpack(i) - Oblicza wirtualny prąd dla pakietu ogniw na podstawie skorygowanych danych rozładowania.

Accumulator.Energy_Cellpack(i) - Oblicza zużycie energii dla pakietu ogniw w jednostkach Ah na podstawie wirtualnego prądu i czasu.

Accumulator.Energy_Cellpack_Total(i+1) - Sumuje całkowite zużycie energii do tego punktu czasowego.

Accumulator.Capacity_Cellpack(1:131,i+1) - Aktualizuje pojemność pakietu ogniw na podstawie zużycia energii.

Accumulator.SOC_Cellpack(1:131,i+1) - Oblicza stan naładowania (SOC) pakietu ogniw na podstawie aktualnej i początkowej pojemności.

Accumulator.SOC_Pointer(1:131,i+1) - Określa wskaźnik SOC w milicentylach na podstawie obliczonego SOC.

Accumulator.Current_Cellpack_Pointer_Voltage(1,i+1) - Określa wskaźnik napięcia pakietu ogniw na podstawie obliczonego wskaźnika prądu.

Kolejne dwa warunki if ograniczają wartości wskaźnika napięcia i SOC do dopuszczalnego zakresu.

W bloku try-catch jest próba dostępu do danych napięcia pakietu ogniw na podstawie obliczonych wskaźników prądu i SOC. Jeśli operacja się nie powiedzie, kod nie rzuca błędem.

4.2.2 - paramtery akumulatora

Wstęp

Interfejs i jego oddziaływanie poszczególnych danych. Dany plik zaprojektowany jest w App Designer i jest podzielony na Design View oraz Code View

Działanie

1. Uruchomienie aplikacji:

Gdy aplikacja zostaje uruchomiona, jej konstruktor “Accumulator” jest wywoływany. Tworzy on interfejs użytkownika poprzez wywołanie metody createComponents. Następnie uruchamiana jest funkcja startupFcn, która inicjuje działanie aplikacji poprzez załadowanie danych, obliczenie i wyświetlenie pojemności akumulatora oraz zmianę schematu kolorów interfejsu.

AccumulatorSetupUIFigure: Główne okno aplikacji.

AccumulatorPanel: Panel zawierający wszystkie komponenty interfejsu użytkownika związane z akumulatorem.

Przyciski: SaveButton, ResetButton, DeleteCellButton, SaveCellButton.

Pola edycji numerycznej: NominalVoltageVEditField, CellCapacitymAhEditField, CellsInParallelEditField, CellsInRowEditField, itp.

Etykiety: OverallCapacityLabel, NumberofCellsLabel, OverallCellWeightLabel, AccumulatorVoltageLabel, itp.

SelectCellDropDown: Lista rozwijana umożliwiająca wybór typu ogniwa.

CellDataPanel: Panel zawierający dane dotyczące pojedynczego ogniwa.

app.CallingApp = mainapp;

loadData(app) – Wczytuje dane z aplikacji głównej

updateCapacity(app) – aktualizuje całkowitą pojemność akumulatora

changeColorScheme(app) – wiele zmiennych obsługujących zmiane kolorów interfejsu

2. Zamykanie aplikacji:

Gdy użytkownik próbuje zamknąć aplikację, wywoływana jest funkcja zwrotna AccumulatorSetupUIFigureCloseRequest, która zapisuje dane i usuwa aplikację.

3. Wprowadzanie danych:

Wartości wprowadzone przez użytkownika, takie jak pojemność ogniwa, liczba ogniw w rzędzie i równolegle, są automatycznie aktualizowane poprzez funkcje zwrotne, takie jak CellCapacitymAhEditFieldValueChanged czy CellsinrowEditFieldValueChanged. Po zmianie tych danych, wywoływana jest funkcja updateCapacity, która aktualizuje wyświetlane wartości związane z pojemnością akumulatora.

4. Podsumowanie

Interfejs umożliwia użytkownikwi prowadzanie danych dotyczących akumulatora, ich zapisywanie, resetowanie oraz prezentuje obliczone wartości. Dodatkowo, interfejs jest dostosowywany do zdefiniowanego schematu kolorów.

4.2.3 - calculateSteeringData

Opisany plik: calculateSteeringData.m

Wywoływanie funkcji i wartości które zwraca

Funkcja przyjmuje 16 parametrów:

wheelbase - rozstaw osi
R - promień łuku
lr - odległość tylnej osi od środka masy
lf - odległość przedniej osi od środka masy
vV - prędkość bolidu
FWZ_fl, FWZ_rl, FWZ_fr, FWZ_rr - nacisk na poszczególne opony (nieużywane)
track_f - szerokość toru
cZ_fl, cZ_fr, cZ_rl, cZ_rr - interpolowane sztywności poszczególnych opon (nieużywane)
alpha_f - kąt poślizgu przedniej osi
alpha_r - kąt poślizgu tylnej osi

Funkcja zwraca 14 parametrów:

delta - kąt skrętu
beta - kąt odchylenia (Schwimmwinkel)
psi1 - obrót odchylenia (Gierrate)
alpha_f, alpha_r - kąty poślizgu osi
alpha_fr, alpha_fl, alpha_rr, alpha_rl - kąty poślizgu poszczególnych opon
delta_fl - kąt skrętu lewego koła
delta_fr - kąt skrętu prawego koła
delta_sw - kąt skrętu kierownicy
ackermann - "Kąt Ackermanna to geometria związana z układem kierowniczym pojazdu, która określa różnicę w kącie skrętu pomiędzy przednimi kołami w momencie skręcania."
ackermannPercent - ackermann w wartości procentowej

Działanie funkcji

Sprawdzenie kierunku skrętu:

%%Sprawdzenie kierunku zakrętu, gdy R jest dodatnie - skręt w prawo
 if R > 0
        f = -1;
    else
        f = 1;
    end

Obliczanie kątów skrętu, odchylenia, kierownicy i obrotu odchylenia:

delta = wheelbase/1000/R;  
%kąt skrętu (dzielenie przez 1000 w celu konwersji na metry)

beta = f*atan((lr/1000)/sqrt(R^2-(lr/1000)^2)); 
%kąt odchylenia

psi1 = vV/R;
%kąt obrotu odchylenia

delta_sw = delta * 180/pi * 5.093;
%kąt skrętu kierownicy (5.093 to mnożnik zależny od układu kierowniczego)

Obliczanie kątów skrętu dla koła wewnętrznego i zewnętrznego:

if R > 0    %Gdy R jest dodatnie - skręt w prawo, a prawe koło jest wewnętrznym do łuku
    delta_fl = atan((wheelbase/1000)/(R+(track_f/1000/2)));     %kąt skrętu lewego koła
    delta_fr = atan((wheelbase/1000)/(R-(track_f/1000/2)));     %kąt skrętu lewego koła

    ackermann = atan(wheelbase/((wheelbase/tan(delta_fl))-track_f));    %wartość ackermanna
    ackermannPercent = delta_fr/ackermann*100;  %procentowa wartość ackermanna
else
    delta_fl = atan((wheelbase/1000)/(R-(track_f/1000/2))); 
    delta_fr = atan((wheelbase/1000)/(R+(track_f/1000/2)));           

    ackermann = atan(wheelbase/((wheelbase/tan(delta_fr))-track_f));
    ackermannPercent = delta_fl/ackermann*100;                       
end  

4.2.4 - Inicjalizacja powtórki symulacji

Wstęp

Przebieg inicjalizacji powtórki symulacji w pliku initializeSimulationReplay.m

Funkcja initalizeSimulationReplay()

Opisywane niżej linie są wykresami prezentującymi trasę przejechaną przez bolid w trakcie symulacji.
Na początku funkcja ładuje plik z zapisem symulacji przejazdu oraz czyści linie wyświetlane w interfejsie.

Następnie na elemencie app.RunNumberSpinner program próbuje wykonać poniższe operacje (zablokować interakcje z nim oraz ustawić jego wartość na 1). Jeśli wystąpi jakiś błąd i nie będzie się tego dało zrobić to jest włączany oraz jego zakres jest zmieniany na od 1 do ilości przejazdów.

drawPedalPlots() - tworzy elementy obrazujące nacisk pedałów. Deklaracja funkcji na końcu pliku.

Następnie ustawiane są kolory zależne od wybranego motywu.

Funkcja hold() z parametrem ‘on’ sprawia, że kolejne rysowane linie nie wymazują poprzednich. Następnie na GUI są przeprowadzane poniższe operacje:

Do struktory o nazwie saveFileData przypisywane są wszystkie wartości z wybranego wcześniej pliku z zapisem przejazdu (saveFile), żeby później te informacje zostały wpisane do elementów GUI (app.DropDown).

Wykonując poniższe funkcje program kolejno:
-zmienia limity rysowania linii
-rysuje zaznaczone w checkboxach rodzaje linii
-rysuje apexy jeśli odpowiedni checkbox jest zaznaczony

Funkcja drawPedalPlots()

Ustawia właściwości elementów obrazujących nacisk pedałów.

Funkcja recordPedalPlot()

Pobierając plik z telemetrią ustawia wartości elementów obrazujących nacisk pedałów.

4.2.5 - Inicjowanie Opon do symulacji

Wstęp

Plik LoadTIR.m umożliwia załadowanie pliku z danymi opony do symulacji. Wszystkie odniesienia do danej linii kodu odnoszą się do pliku dostępnego w oryginalnym repozytorium, bez żadnych uprzednich modyfikacji kodu.

Wybór pliku

Plik rozpoczyna sie deklaracją funkcji loadTIR z parametrem w postaci lokalizacji pliku zawierającego parametry opony. Parametr ten pojawia się także w plikach Conti_Tire_Plots zarówno dla obliczeń w płaszczyźnie wzdłużnej i poprzecznej, a także w pliku Find_maximum_corner_speed. Celem modyfikacji rodzaju opony konieczne będzie dostosowanie kodu, aby możliwy był wybór większej ilości opon i przeprowadzenia obliczeń na ich parametrach.

Następnie w linii 7 plik jest otwierany w trybie tylko do odczytu i inicjowane są dwie zmienne pełniące funkcję liczników.

Inicjacja parametrów

W pętli działającej do momentu zakończenia pliku zawierającego parametry zczytywane są kolejne parametry. Osobno przetwarzając każdą linijkę pliku. W pierwszej kolejności sprawdzane jest, czy dana linia kodu nie jest komentarzem bądź tytułem. korzystając z ustandaryzowanego sposobu wpisywania parametrów kolejne dane i ich nazwy są zczytywane i zapisywane do pamięci. Po zczytaniu danych plik jest zamykany i niepotrzebne dane są usuwane z pamięci.

Sprawdzenie masy

Ze względu na konflikt nazw zmiennych podmieniana jest nazwa zmiennej opisującej masę na nazwę pomocniczą.

Generowanie opon

Korzystając z pobranych wcześniej danych generowana jest parametryczna struktura opony.

Program przepisuje odczytane wcześniej dane do formatu właściwego, który ułatwia pracę nad danymi. Sprawdzane jest między innymi, czy odczytywana wartość ma format tekstowy czy liczbowy.

Finalnie zapisane dane są opisywane korzystając z nazw zmiennych.

4.2.6 - paramtery układu napędowego

Wstęp

Interfejs i jego oddziaływanie poszczególnych danych. Dany plik zaprojektowany jest w App Designer i jest podzielony na Design View oraz Code View

DrivetrainSetupUIFigure: Objekt reprezentujący figurę w UI PowertrainDataPanel: Panel przedstawiający dane o układzie napędowym UITable: Tablica przedstawiająca tablicę w UI idle_rpm1minEditField: Miejsce do edytowania obrotów na luzie TorquemultiplierEditField: Miejsce do edytowania mnożnika momentu obrotowego n_max1minEditField: Miejsce do edycji maksymalnych obrotów DrivetrainEfficencyEditField: Miejsce do edycji efektywności układu napędowego LayoutDropDown: Rozwijane UI do wyboru układu LayoutDropDownLabel: Etykieta do rozwijanego elemntu UI PowertrainSwitch: Przycisk do wyboru układu napędowego EPowertrainParametersPanel: Panel zawierający parametry elektryczne układu napędowego InverterEfficiencyEditField: Miejsce do edycji efektywności falownika PowerlimitWEditField: Miejsce do edycji limitu mocy w watach DeleteEngineButton: Przycisk, który usuwa parametry silnika EnginePresetDropDown: Rozwijany element UI do wybory presetów silnika Panel_2: Obiekt reprezentujący panel. z_chaindriveEditField: Obiekt NumericEditField reprezentujący pole edycji dla napędu łańcuchowego. z_sprocketEditField: Obiekt NumericEditField reprezentujący pole edycji dla zębatki. ChaindriveSingleGearsetCheckBox: Obiekt CheckBox reprezentujący pole wyboru dla pojedynczego układu napędowego łańcuchowego. loadPanel: Obiekt Panel reprezentujący panel dla obciążenia. TY20BaselineButton: Obiekt Button reprezentujący przycisk dla podstawowej konfiguracji TY20. SaveButton: Obiekt Button reprezentujący przycisk do zapisu. ResetButton: Obiekt Button reprezentujący przycisk do resetowania. ElectricBaselineButton: Obiekt Button reprezentujący przycisk dla podstawowej konfiguracji elektrycznej. TY19BaselineButton: Obiekt Button reprezentujący przycisk dla podstawowej konfiguracji TY19. ChaindrivePanel: Obiekt Panel reprezentujący panel dla napędu łańcuchowego. i_PEditField: Obiekt NumericEditField reprezentujący pole edycji dla i_P. GearboxPanel: Obiekt Panel reprezentujący panel dla skrzyni biegów. n_downshift1minEditField: Obiekt NumericEditField reprezentujący pole edycji dla obrotów przy redukcji biegów. EnableGearboxCheckBox: Obiekt CheckBox reprezentujący pole wyboru dla włączenia skrzyni biegów. PlotGearboxdataButton: Obiekt Button reprezentujący przycisk do generowania wykresu danych skrzyni biegów. GearboxTable: Obiekt Table reprezentujący tabelę dla danych skrzyni biegów. Button_4: Obiekt Button reprezentujący kolejny przycisk. Button_3: Obiekt Button reprezentujący jeszcze jeden przycisk. n_shift1minEditField: Obiekt NumericEditField reprezentujący pole edycji dla obrotów przy zmianie biegów. t_shiftsEditField: Obiekt NumericEditField reprezentujący pole edycji dla czasu zmiany biegów. UIAxes3: Obiekt UIAxes reprezentujący osie do generowania wykresów. UIAxes2: Obiekt UIAxes reprezentujący kolejne osie do generowania wykresów. UIAxes: Obiekt UIAxes reprezentujący jeszcze inne osie do generowania wykresów.

Klasa Drivetrain reprezentuje obiekt odpowiedzialny za aktualizację wykresu dla krzywych momentu i mocy silnika.

• Obiekt głównej aplikacji

CallingApp   

• Metoda updateMotorGraph(app) aktualizuje wykresy dla jednego silnika. Metoda ta pobiera dane z tabeli UITable, oblicza moc i moment dla każdej wartości obrotów, a następnie rysuje wykresy dla momentu i mocy.

• Aktualizuje etykietę przekładni i zwraca wartość przekładni

i_tot = updateGearRatio(app);

• Pobiera wartość mnożnika momentu

torque_multiplier = app.TorquemultiplierEditField.Value;

• Pobiera dane z tabeli UITable

data = app.UITable.Data;

• Separuje dane na dwie 1D tablice, dodając 0 na początku, ponieważ obie osie powinny zaczynać się od zera

x = [1; data(:,1)]; n = RPM
y = [0; data(:,2)] * torque_multiplier; M = Moment

• Oblicza moc silnika dla danej wartości obrotów i momentu

p = zeros(1:size(x,1));
for n = 1 : length(x)
p(n) = (y(n) * x(n)) / 9.5488 / 1000;
end

• Czyści wykres UIAxes, aby można go było ponownie utworzyć

cla(app.UIAxes,'reset');

• Ustawia osie

app.UIAxes.XLabel.String='RPM [1/min]';
yyaxis(app.UIAxes,'left'); 

• Rysuje wykres momentu

plot(app.UIAxes,x,y);

• Zatrzymuje wykres, aby można było narysować nową oś

hold(app.UIAxes);
title(app.UIAxes,"Single Motor");
yyaxis(app.UIAxes,'right');
app.UIAxes.YLabel.String='Moc [kW]';

• Rysuje wykres mocy

plot(app.UIAxes,x,p);

• Wyłącza możliwość przybliżania dla wykresu

disableDefaultInteractivity(app.UIAxes);

• Sprawdza, który układ silnika jest wybrany i dostosowuje liczbę silników

Motorsdropdown = app.LayoutDropDown.Value;
if (Motorsdropdown == "2 Motor RWD")
    numberMotors = 2;
elseif (Motorsdropdown == "1 Motor RWD")
    numberMotors = 1;
elseif (Motorsdropdown == "AWD")
    numberMotors = 4;
end

• Oblicza moment wytworzony przez daną liczbę silników

y_2 = y * numberMotors;
p_2 = zeros(1:length(x));

• Oblicza moc silników dla danej wartości obrotów i momentu

for n = 1 : length(x)
p_2(n) = (y_2(n) * x(n)) / 9.5488 / 1000;
end

• Czyści wykres UIAxes2, aby można go było ponownie utworzyć

cla(app.UIAxes2,'reset');

• Metoda rysująca wykresy dla przekładni wtórnej. x - Tablica wartości osi X. y_2 - Tablica wartości osi Y dla momentu obrotowego. p_2 - Tablica wartości osi Y dla mocy.

• Motorsdropdown - Wybrany rodzaj silnika.

(void)drawPlotsWithX:(NSArray *)x y_2:(NSArray *)y_2 p_2:(NSArray *)p_2 Motorsdropdown:(NSString *)Motorsdropdown {

• Aktualizuje przekładnię wtórną.

return Wartość całkowitego przekładniowego stosunku.
(double)updateGearRatio
return i_tot;

• Zmienia schemat kolorów aplikacji.

(void)changeColorScheme

-Poniżej znajdują się zmienne reprezentujące kolory i style aplikacji. PrimaryColor: Kolor podstawowy aplikacji. OnPrimaryColor: Kolor tekstu na tle PrimaryColor. PrimaryVariantColor: Wariant koloru podstawowego aplikacji. OnPrimaryVariantColor: Kolor tekstu na tle PrimaryVariantColor. SecondaryColor: Kolor drugorzędny aplikacji. OnSecondaryColor: Kolor tekstu na tle SecondaryColor. BackgroundColor: Kolor tła aplikacji. OnBackgroundColor: Kolor tekstu na tle BackgroundColor. SurfaceColor: Kolor powierzchni aplikacji. OnSurfaceColor: Kolor tekstu na tle SurfaceColor. ErrorColor: Kolor błędu aplikacji. OnErrorColor: Kolor tekstu na tle ErrorColor. BorderType: Typ obramowania aplikacji. Host_Logo: Logo hosta aplikacji.

• Ustawia kolor tła dla interfejsu użytkownika DrivetrainSetupUIFigure.

app.DrivetrainSetupUIFigure.Color = BackgroundColor;

• Ustawia kolor czcionki dla etykiety Copyright2021BalticRacingbyEricDorniedenLabel.

app.Copyright2021BalticRacingbyEricDorniedenLabel.FontColor = OnBackgroundColor;

• Ustawia kolor czcionki, tła i typ obramowania dla panelu PowertrainDataPanel.

app.PowertrainDataPanel.ForegroundColor = OnBackgroundColor;
app.PowertrainDataPanel.BackgroundColor = BackgroundColor;
app.PowertrainDataPanel.BorderType = BorderType;

• Ustawia kolor czcionki, tła i typ obramowania dla panelu loadPanel.

app.loadPanel.ForegroundColor = OnSurfaceColor;
app.loadPanel.BackgroundColor = SurfaceColor;
app.loadPanel.BorderType = BorderType;

• Ustawia kolor czcionki, tła i typ obramowania dla panelu Panel.

app.Panel.ForegroundColor = OnSurfaceColor;
app.Panel.BackgroundColor = SurfaceColor;
app.Panel.BorderType = BorderType;

• Ustawia kolor czcionki, tła i typ obramowania dla panelu EPowertrainParametersPanel.

app.EPowertrainParametersPanel.ForegroundColor = OnSurfaceColor;
app.EPowertrainParametersPanel.BackgroundColor = SurfaceColor;
app.EPowertrainParametersPanel.BorderType = BorderType;

• Ustawia kolor czcionki, tła i typ obramowania dla panelu ChaindrivePanel.

app.ChaindrivePanel.ForegroundColor = OnSurfaceColor;
app.ChaindrivePanel.BackgroundColor = SurfaceColor;
app.ChaindrivePanel.BorderType = BorderType;

• Ustawia kolor czcionki, tła i typ obramowania dla panelu GearboxPanel.

app.GearboxPanel.ForegroundColor = OnSurfaceColor;
app.GearboxPanel.BackgroundColor = SurfaceColor;
app.GearboxPanel.BorderType = BorderType;

• Ustawia kolor czcionki dla przycisku PowertrainSwitch.

app.PowertrainSwitch.FontColor = OnSurfaceColor;

• Ustawia kolor czcionki dla etykiety LayoutDropDownLabel oraz kolor tła i czcionki dla rozwijanej listy LayoutDropDown.

app.LayoutDropDownLabel.FontColor = OnSurfaceColor;
app.LayoutDropDown.BackgroundColor = PrimaryColor;
app.LayoutDropDown.FontColor = OnPrimaryColor;

Analogicznie są ustawiane inne kolory.

• Funkcja saveData zapisuje dane z aplikacji do obiektu CallingApp. app - Obiekt aplikacji zawierający dane do zapisania.

function saveData(app)

• Zapisuje dane z rozwijanej listy EnginePresetDropDown do obiektu CallingApp.engineData

app.CallingApp.engineData = app.EnginePresetDropDown.Items;

• Zapisuje wartość z pola PowerlimitWEditField do obiektu CallingApp.p_max

app.CallingApp.p_max = app.PowerlimitWEditField.Value;

• Zapisuje wartość z pola DrivetrainEfficencyEditField do obiektu CallingApp.drivetrain_eff

app.CallingApp.drivetrain_eff = app.DrivetrainEfficencyEditField.Value;

Analogicznie są zapisywane inne wartości.

• Sprawdza, który układ silnika jest wybrany i dostosowuje liczbę silników w obiekcie CallingApp.num_motors

var Motorsdropdown = app.LayoutDropDown.Value;

• Wybiera odpowiednią liczbę silników na podstawie wartości wybranej z rozwijanej listy. Motorsdropdown - wartość wybrana z rozwijanej listy

if (Motorsdropdown == "2 Motor RWD") {
    app.CallingApp.num_motors = 2;
} else if (Motorsdropdown == "1 Motor RWD") {
    app.CallingApp.num_motors = 1;
} else if (Motorsdropdown == "AWD") {
    app.CallingApp.num_motors = 4;
}

• Ustawienie elementów rozwijanej listy EnginePresetDropDown na wartości z app.CallingApp.engineData

app.EnginePresetDropDown.Items = app.CallingApp.engineData;

• Ustawienie wartości pola PowerlimitWEditField na app.CallingApp.p_max

app.PowerlimitWEditField.Value = app.CallingApp.p_max;

• Ustawienie wartości pola DrivetrainEfficencyEditField na app.CallingApp.drivetrain_eff

app.DrivetrainEfficencyEditField.Value = app.CallingApp.drivetrain_eff;

• Ustawienie wartości pola TorquemultiplierEditField na app.CallingApp.trq_multiplier

app.TorquemultiplierEditField.Value = app.CallingApp.trq_multiplier;

• Ustawienie danych tabeli GearboxTable na app.CallingApp.i_param

app.GearboxTable.Data = app.CallingApp.i_param;

• Ustawienie wartości pola InverterEfficiencyEditField na app.CallingApp.invertor_eff

app.InverterEfficiencyEditField.Value = app.CallingApp.invertor_eff;

• Ustawienie wartości pola EnableGearboxCheckBox na app.CallingApp.gearbox

app.EnableGearboxCheckBox.Value = app.CallingApp.gearbox;

Analogicznie są ustawiane inne pola wartości.

• Ustawienie tekstu rozwijanej listy EngineLayoutDropDown w zależności od wartości app.CallingApp.num_motors

if (app.CallingApp.num_motors == 1) {
    app.LayoutDropDown.Value = "1 Motor RWD";
} else if (app.CallingApp.num_motors == 2) {
    app.LayoutDropDown.Value = "2 Motor RWD";
} else if (app.CallingApp.num_motors == 4) {
    app.LayoutDropDown.Value = "AWD";
}

• Aktywacja/dezaktywacja parametrów E/C Panelu w zależności od wartości pola PowertrainSwitch

if (app.PowertrainSwitch.Value == "Electric") {
    app.PowerlimitWEditField.Enable = true;
    app.InverterEfficiencyEditField.Enable = true;
} else {
    app.PowerlimitWEditField.Enable = false;
    app.InverterEfficiencyEditField.Enable = false;
}

• Dla każdego wiersza w tabeli, funkcja wywołuje funkcję updateGearRatio(app) w celu obliczenia całkowitego przełożenia. Następnie funkcja aktualizuje wartości w drugiej i trzeciej kolumnie tabeli na podstawie obliczonych wartości.

for i = 1:size(app.GearboxTable.Data, 1)
    i_tot = updateGearRatio(app);
    
    app.GearboxTable.Data(i,2) = app.GearboxTable.Data(i,1) * i_tot;
    app.GearboxTable.Data(i,3) =  app.n_max1minEditField.Value/(30/pi*app.GearboxTable.Data(i,2)/app.CallingApp.R0)*3.6;

• Włącza możliwość edycji pól związanych z przesunięciami biegów.

app.t_shiftsEditField.Enable

• Włącza lub wyłącza możliwość edycji etykiety pola t_shiftsEditField.

app.t_shiftsEditFieldLabel.Enable

• Włącza lub wyłącza możliwość edycji pola n_shift1minEditField.

app.n_shift1minEditField.Enable

Analogicznie są włączabne możliwości edycji w innych polach.

• Kod wykonywany po utworzeniu komponentu

function startupFcn(app, mainapp)

• Aktualizuje wykres momentu i mocy silnika na podstawie danych z UITable

updateMotorGraph(app);

• Callback edycji komórki: UITable

function UITableCellEdit(app, event)
updateMotorGraph(app);

• Funkcja wywoływana po zmianie wartości: LayoutDropDown

function LayoutDropDownValueChanged(app, event)
updateMotorGraph(app);

• Funkcja wywoływana po zmianie wartości: TorquemultiplierEditField

function TorquemultiplierEditFieldValueChanged(app, event)
updateMotorGraph(app);

Analogicznie są wywoływane inne funckje

• Dodaje wpis do UITable

data = app.UITable.Data;
app.UITable.Data = [data; [0 0]];

• Funkcja wywoływana po naciśnięciu przycisku Button_2. Usuwa ostatni wpis w tabeli UITable.

    data = app.UITable.Data;
    data((length(data)),:) = [];
    app.UITable.Data = data;

• Funkcja wywoływana przy próbie zamknięcia okna DrivetrainSetupUIFigure. Zapisuje dane i wyłącza przycisk Drivetrain Options w głównym oknie aplikacji.

function DrivetrainSetupUIFigureCloseRequest(app, event)
    saveData(app);
    app.CallingApp.DrivetrainButton.Enable = 'on';
    delete(app)

• Funkcja wywoływana po naciśnięciu przycisku SaveButton.

function SaveButtonPushed(app, event)
    saveData(app);

• Funkcja wywoływana po naciśnięciu przycisku ResetButton.

function ResetButtonPushed(app, event)
    loadData(app);

• Funkcja wywoływana po zmianie wartości pola InverterEfficiencyEditField. Aktualizuje wykres silnika.

function InverterEfficiencyEditFieldValueChanged(app, event)
    updateMotorGraph(app);

• Funkcja wywoływana po zmianie wartości przełącznika PowertrainSwitch. Aktualizuje parametry zależne od rodzaju napędu.

function PowertrainSwitchValueChanged(app, event)
    value = app.PowertrainSwitch.Value;
    if value == "Electric"      
        app.PowerlimitWEditField.Enable = true;
        app.InverterEfficiencyEditField.Enable = true;
        app.CallingApp.ptype = 1; 
    else   
        app.PowerlimitWEditField.Enable = false;
        app.InverterEfficiencyEditField.Enable = false;
        app.CallingApp.ptype = 0;      
    end
    updateMotorGraph(app)
    updateGearRatio(app)

• Funkcja wywoływana po naciśnięciu przycisku Button_3. Dodaje nowy wiersz do tabeli GearboxTable.

function Button_3Pushed(app, event)
    data = app.GearboxTable.Data;
    app.GearboxTable.Data = [data; 0,0,0];

• Funkcja wywoływana po naciśnięciu przycisku Button_4. Usuwa ostatni wpis w tabeli GearboxTable.

function Button_4Pushed(app, event)
    Deletes the last entry in the UITable
    data = app.GearboxTable.Data;
    data((size(data,1)),:,:) = [];
    app.GearboxTable.Data = data;

• Funkcja wywoływana po zmianie wartości pola i_PEditField. Aktualizuje wykres silnika.

function i_PEditFieldValueChanged(app, event)
    updateMotorGraph(app);

• Funkcja wywoływana po naciśnięciu przycisku PlotGearboxdataButton. Wyświetla wykres danych z tabeli GearboxTable.

function PlotGearboxdataButtonPushed(app, event)
    plotGearboxData(app.GearboxTable.Data,app.n_shift1minEditField.Value,app.t_shiftsEditField.Value,app.n_max1minEditField.Value);

• Funkcja wywoływana po edycji komórki w tabeli GearboxTable. Aktualizuje przekładnie.

function GearboxTableCellEdit(app, event)
    updateGearRatios(app);      

• Funkcja wywoływana po zmianie wartości pola EnableGearboxCheckBox. Aktualizuje przekładnie.

function EnableGearboxCheckBoxValueChanged(app, event)
    updateGearbox(app);    

• Funkcja wywoływana po naciśnięciu przycisku TY19BaselineButton. Ustawia wartości związane z układem napędowym dla trybu spalinowego, ładuje dane z pliku “Dynojet Momentenverlauf.mat”, ustawia parametry układu napędowego dla symulacji oraz wywołuje funkcję loadData(app) w celu załadowania danych.

function TY19BaselineButtonPushed(app, event)
    app.PowertrainSwitch.Value = "Combustion";
    app.PowerlimitWEditField.Enable = false;
    app.InverterEfficiencyEditField.Enable = false;
    app.EnableGearboxCheckBox.Value = 1;

    triumphEngine = load('Dynojet Momentenverlauf.mat'); 

ptype - Typ napędu. n_max - Maksymalna prędkość obrotowa. i_param - Parametry prądowe. i_P - Wzmocnienie regulatora prądu. z_chaindrive - Liczba zębów w łańcuchu napędowym. z_sprocket - Liczba zębów w zębatce. gearbox - Przełożenie skrzyni biegów. engine_param - Parametry silnika. num_motors - Liczba silników. idleRPM - Prędkość obrotowa na biegu jałowym.

    app.CallingApp.ptype = 0; 
    app.CallingApp.n_max = 11000;
    app.CallingApp.i_param = [1.857; 1.565; 1.35; 1.238; 1.136];
    app.CallingApp.i_P = 1.848;
    app.CallingApp.z_chaindrive = 37;
    app.CallingApp.z_sprocket = 11;  
    app.CallingApp.gearbox = 1;
    app.CallingApp.engine_param = [triumphEngine.n(:) triumphEngine.M(:)];
    app.CallingApp.num_motors = 1;
    app.CallingApp.idleRPM = 2000;
    loadData(app);
end

• Funkcja wywoływana po naciśnięciu przycisku ElectricBaselineButton, ustawia wartości związane z układem napędowym dla trybu elektrycznego, umożliwia edycję pól PowerlimitWEditField i InverterEfficiencyEditField, wyłącza pole EnableGearboxCheckBox, ustawia parametry układu napędowego dla symulacji oraz wywołuje funkcję loadData(app) w celu załadowania danych.

function ElectricBaselineButtonPushed(app, event)
    app.PowertrainSwitch.Value = "Electric";
    app.PowerlimitWEditField.Enable = true;
    app.InverterEfficiencyEditField.Enable = true;
    app.EnableGearboxCheckBox.Value = 0;

    app.CallingApp.ptype = 1; 
    app.CallingApp.n_max = 6000;
    app.CallingApp.i_param = 1;
    app.CallingApp.i_P = 1;
    app.CallingApp.z_chaindrive = 66;
    app.CallingApp.z_sprocket = 17;     
    app.CallingApp.gearbox = 0;
    app.CallingApp.engine_param = [0 140; 1000 140; 2000 138; 3000 136; 4000 135; 5000 127; 6000 115];
    app.CallingApp.num_motors = 2;
    app.CallingApp.idleRPM = 0;

    loadData(app);
end

• Funkcja wywoływana po naciśnięciu przycisku TY20BaselineButton, ustawia wartości związane z układem napędowym dla trybu spalania, ładuje dane z pliku “Dynojet Momentenverlauf.mat”, Ustawia parametry układu napędowego dla symulacji oraz wywołuje funkcję loadData(app) w celu załadowania danych.

function TY20BaselineButtonPushed(app, event)
    app.PowertrainSwitch.Value = "Combustion";
    app.PowerlimitWEditField.Enable = false;
    app.InverterEfficiencyEditField.Enable = false;
    app.EnableGearboxCheckBox.Value = 1;

    triumphEngine = load('Dynojet Momentenverlauf.mat'); 

    app.CallingApp.ptype = 0; 
    app.CallingApp.n_max = 11000;
    app.CallingApp.i_param = [2.579; 1.720; 1.429; 1.238];
    app.CallingApp.i_P = 1.848;
    app.CallingApp.z_chaindrive = 37;
    app.CallingApp.z_sprocket = 11;  
    app.CallingApp.gearbox = 1;
    app.CallingApp.engine_param = [triumphEngine.n(:) triumphEngine.M(:)];
    app.CallingApp.num_motors = 1;
    app.CallingApp.idleRPM = 2000;

    loadData(app);

• Funkcja wywoływana po zmianie wartości pola ChaindriveSingleGearsetCheckBox, ustawia wartość zmiennej i_chain na podstawie wartości pól związanych z przekładnią, jeśli pole ChaindriveSingleGearsetCheckBox jest zaznaczone, włącza pole związane z ilością zębów koła zębatego.

function ChaindriveSingleGearsetCheckBoxValueChanged(app, event)
    value = app.ChaindriveSingleGearsetCheckBox.Value;

    if value
        app.i_chain = app.z_sprocketEditField.Value * app.z_chaindriveEditField.Value;
        app.z_sprocketEditField.Enable =  'true';
    else
        app.i_chain = 1;

• Funkcja wywoływana po zmianie wartości w polu EnginePresetDropDown, aktualizuje parametry silnika na podstawie wybranego silnika oraz Aktualizuje interfejs użytkownika.

function EnginePresetDropDownValueChanged(app, event)
    value = app.EnginePresetDropDown.Value;

• Wczytaj plik .mat dla wybranego silnika

engine = load([value '.mat']); 

• Wczytaj parametry silnika z pliku .mat

app.CallingApp.engine_param = [engine.n(:) engine.M(:)];

• Funkcja wywoływana po naciśnięciu przycisku SaveEngineButton, zapisuje zmienne silnika do pliku .mat oraz dodaje nowy silnik do listy rozwijanej, jeśli nazwa nie jest już częścią listy.

function SaveEngineButtonPushed(app, event)
    data = app.UITable.Data;     
    n = data(:,1);
    M = data(:,2);

• Otwiera okno dialogowe do zapisu pliku

    [filename, pathname] = uiputfile('*.mat','Zapisz zmienne silnika jako','NowySilnik.mat');
    newfilename = fullfile(pathname, filename);

• Zapisuje plik z podanymi parametrami

    save(newfilename, 'n','M');

• Dodaje nowy silnik do listy rozwijanej, jeśli nazwa nie jest już częścią listy.

    if ~strcmp(app.EnginePresetDropDown.Items, filename(1:end-4))
    data = app.EnginePresetDropDown.Items;
    data(end) = [];
    app.EnginePresetDropDown.Items = [data filename(1:end-4) "NowySilnik"];
    app.CallingApp.engineData = app.EnginePresetDropDown.Items;

• Funkcja wywoływana po naciśnięciu przycisku DeleteEngineButton, usuwa wybrany silnik z listy rozwijanej oraz aktualizuje interfejs użytkownika.

function DeleteEngineButtonPushed(app, event)
    selected = app.EnginePresetDropDown.Value;

• Sprawdza, czy użytkownik próbuje usunąć wpis “NowySilnik”

    if selected == "NowySilnik"
    app.CallingApp.engine_param = [0 0; 1000 0; 2000 0; 3000 0; 4000 0; 5000 0; 6000 0];
    return;
end
    data = app.EnginePresetDropDown.Items;

• Znajduje indeks wybranego silnika i usuwa go z listy

    ind = find(strcmp(data,selected));
    data(ind) = [];

• Aktualizuj listę rozwijaną

    app.EnginePresetDropDown.Items = data;
    app.CallingApp.engineData = data;

• Przełącza na pierwszy silnik

    app.EnginePresetDropDown.Value = app.EnginePresetDropDown.Items(1);

• Tworzenie UIFigure i komponentów

function createComponents(app)

• Ustawia widoczność figury na wyłączoną.

app.DrivetrainSetupUIFigure = uifigure('Visible', 'off');

• Ustawia pozycję figury na [100 100 1107 764].

app.DrivetrainSetupUIFigure.Position = [100 100 1107 764];

• Ustawia nazwę figury na ‘Drivetrain Setup’.

app.DrivetrainSetupUIFigure.Name = 'Drivetrain Setup';

• Ustawia ikonę figury na ‘Baltic.png’.

app.DrivetrainSetupUIFigure.Icon = 'Baltic.png';

• Wyłącza możliwość zmiany rozmiaru figury.

app.DrivetrainSetupUIFigure.Resize = 'off';

• Ustawia funkcję wywoływaną przy próbie zamknięcia figury na DrivetrainSetupUIFigureCloseRequest.

app.DrivetrainSetupUIFigure.CloseRequestFcn = createCallbackFcn(app, @DrivetrainSetupUIFigureCloseRequest, true);

• Tworzenie panelu PowertrainDataPanel

app.PowertrainDataPanel = uipanel(app.DrivetrainSetupUIFigure);
app.PowertrainDataPanel.Title = 'Dane napędu';
app.PowertrainDataPanel.Position = [2 1 1107 764];

• Tworzenie UIAxes

app.UIAxes = uiaxes(app.PowertrainDataPanel);
title(app.UIAxes, 'Pojedynczy silnik')
xlabel(app.UIAxes, 'RPM [1/min]')
ylabel(app.UIAxes, 'Moment obrotowy [Nm]')
app.UIAxes.XTickLabelRotation = 0;
app.UIAxes.YTickLabelRotation = 0;
app.UIAxes.ZTickLabelRotation = 0;
app.UIAxes.Position = [552 535 525 185];

• Tworzenie UIAxes2

app.UIAxes2 = uiaxes(app.PowertrainDataPanel);
title(app.UIAxes2, 'Tytuł')
xlabel(app.UIAxes2, 'X')
ylabel(app.UIAxes2, 'Y')
app.UIAxes2.XTickLabelRotation = 0;
app.UIAxes2.YTickLabelRotation = 0;
app.UIAxes2.ZTickLabelRotation = 0;
app.UIAxes2.Position = [552 130 525 185];

• Tworzenie UIAxes3

app.UIAxes3 = uiaxes(app.PowertrainDataPanel);
title(app.UIAxes3, 'Tytuł')
xlabel(app.UIAxes3, 'X')
ylabel(app.UIAxes3, 'Y')
app.UIAxes3.XTickLabelRotation = 0;
app.UIAxes3.YTickLabelRotation = 0;
app.UIAxes3.ZTickLabelRotation = 0;
app.UIAxes3.Position = [552 333 525 185];

• Tworzenie panelu GearboxPanel

app.GearboxPanel = uipanel(app.PowertrainDataPanel);
app.GearboxPanel.TitlePosition = 'centertop';
app.GearboxPanel.Title = 'Skrzynia biegów';
app.GearboxPanel.Position = [263 83 257 480];

• Tworzenie etykiety t_shiftsEditFieldLabel

app.t_shiftsEditFieldLabel = uilabel(app.GearboxPanel);
app.t_shiftsEditFieldLabel.HorizontalAlignment = 'right';
app.t_shiftsEditFieldLabel.Position = [77 398 55 23];
app.t_shiftsEditFieldLabel.Text = 't_shift [s]';

• Tworzenie pola edycyjnego t_shiftsEditField

app.t_shiftsEditField = uieditfield(app.GearboxPanel, 'numeric');
app.t_shiftsEditField.LowerLimitInclusive = 'off';
app.t_shiftsEditField.UpperLimitInclusive = 'off';
app.t_shiftsEditField.Limits = [0 Inf];
app.t_shiftsEditField.Position = [150 399 87 22];
app.t_shiftsEditField.Value = 0.035;

• Tworzenie etykiety n_shift1minEditFieldLabel

app.n_shift1minEditFieldLabel = uilabel(app.GearboxPanel);
app.n_shift1minEditFieldLabel.HorizontalAlignment = 'right';
app.n_shift1minEditFieldLabel.Position = [51 371 80 23];
app.n_shift1minEditFieldLabel.Text = 'n_shift [1/min]';

• Tworzenie pola edycyjnego n_shift1minEditField

app.n_shift1minEditField = uieditfield(app.GearboxPanel, 'numeric');
app.n_shift1minEditField.UpperLimitInclusive = 'off';
app.n_shift1minEditField.Limits = [1 Inf];
app.n_shift1minEditField.ValueDisplayFormat = '%.0f';
app.n_shift1minEditField.Tooltip = {''};
app.n_shift1minEditField.Position = [150 372 87 22];
app.n_shift1minEditField.Value = 10500;

• Tworzenie przycisku Button_3

app.Button_3 = uibutton(app.GearboxPanel, 'push');
app.Button_3.ButtonPushedFcn = createCallbackFcn(app, @Button_3Pushed, true);
app.Button_3.Position = [10 26 37 22];
app.Button_3.Text = '+';

• Tworzenie przycisku Button_4

app.Button_4 = uibutton(app.GearboxPanel, 'push');
app.Button_4.ButtonPushedFcn = createCallbackFcn(app, @Button_4Pushed, true);
app.Button_4.Position = [47 26 37 22];
app.Button_4.Text = '-';

• Tworzenie tabeli GearboxTable

app.GearboxTable = uitable(app.GearboxPanel);
app.GearboxTable.ColumnName = {'Gear Ratio'; 'Final Ratio'; 'Vmax [km/h]'};
app.GearboxTable.RowName = {};
app.GearboxTable.ColumnEditable = [true false false];
app.GearboxTable.CellEditCallback = createCallbackFcn(app, @GearboxTableCellEdit, true);
app.GearboxTable.Position = [7 47 245 282];

• Tworzenie przycisku PlotGearboxdataButton

app.PlotGearboxdataButton = uibutton(app.GearboxPanel, 'push');
app.PlotGearboxdataButton.ButtonPushedFcn = createCallbackFcn(app, @PlotGearboxdataButtonPushed, true);
app.PlotGearboxdataButton.Position = [136 14 112 22];
app.PlotGearboxdataButton.Text = 'Plot Gearbox data';

• Tworzenie pola wyboru EnableGearboxCheckBox

app.EnableGearboxCheckBox = uicheckbox(app.GearboxPanel);
app.EnableGearboxCheckBox.ValueChangedFcn = createCallbackFcn(app, @EnableGearboxCheckBoxValueChanged, true);
app.EnableGearboxCheckBox.Text = 'Enable Gearbox';
app.EnableGearboxCheckBox.Position = [7 435 109 22];

• Tworzenie etykiety n_downshift1minEditFieldLabel

app.n_downshift1minEditFieldLabel = uilabel(app.GearboxPanel);
app.n_downshift1minEditFieldLabel.HorizontalAlignment = 'right';
app.n_downshift1minEditFieldLabel.Position = [15 344 116 23];
app.n_downshift1minEditFieldLabel.Text = 'n_downshift [1/min]';

• Tworzenie pola edycyjnego n_downshift1minEditField

app.n_downshift1minEditField = uieditfield(app.GearboxPanel, 'numeric');
app.n_downshift1minEditField.UpperLimitInclusive = 'off';
app.n_downshift1minEditField.Limits = [1 Inf];
app.n_downshift1minEditField.ValueDisplayFormat = '%.0f';
app.n_downshift1minEditField.Tooltip = {''};
app.n_downshift1minEditField.Position = [150 345 87 22];
app.n_downshift1minEditField.Value = 6000;

• Tworzenie panelu ChaindrivePanel

app.ChaindrivePanel = uipanel(app.PowertrainDataPanel);
app.ChaindrivePanel.Title = 'Chaindrive';
app.ChaindrivePanel.Position = [264 576 256 162];

• Tworzenie etykiety i_PLabel

app.i_PLabel = uilabel(app.ChaindrivePanel);
app.i_PLabel.HorizontalAlignment = 'right';
app.i_PLabel.Position = [136 112 55 23];
app.i_PLabel.Text = 'i_P [-]';

• Tworzenie pola edycyjnego i_PEditField

app.i_PEditField = uieditfield(app.ChaindrivePanel, 'numeric');
app.i_PEditField.LowerLimitInclusive = 'off';
app.i_PEditField.UpperLimitInclusive = 'off';
app.i_PEditField.Limits = [0 Inf];
app.i_PEditField.ValueChangedFcn = createCallbackFcn(app, @i_PEditFieldValueChanged, true);
app.i_PEditField.Position = [200 112 48 22];
app.i_PEditField.Value = 1;

• Tworzenie panelu loadPanel

app.loadPanel = uipanel(app.PowertrainDataPanel);
app.loadPanel.Title = 'load';
app.loadPanel.Position = [566 42 524 56];

• Tworzenie przycisku TY19BaselineButton

app.TY19BaselineButton = uibutton(app.loadPanel, 'push');
app.TY19BaselineButton.ButtonPushedFcn = createCallbackFcn(app, @TY19BaselineButtonPushed, true);
app.TY19BaselineButton.Position = [14 8 100 22];
app.TY19BaselineButton.Text = 'TY-19 Baseline';

• Tworzenie przycisku ElectricBaselineButton

app.ElectricBaselineButton = uibutton(app.loadPanel, 'push');
app.ElectricBaselineButton.ButtonPushedFcn = createCallbackFcn(app, @ElectricBaselineButtonPushed, true);
app.ElectricBaselineButton.Position = [232 8 108 22];
app.ElectricBaselineButton.Text = 'Electric Baseline';

• Tworzenie przycisku ResetButton

app.ResetButton = uibutton(app.loadPanel, 'push');
app.ResetButton.ButtonPushedFcn = createCallbackFcn(app, @ResetButtonPushed, true);
app.ResetButton.FontSize = 14;
app.ResetButton.Position = [352 6 56 26];
app.ResetButton.Text = 'Reset';

• Tworzenie przycisku SaveButton

app.SaveButton = uibutton(app.loadPanel, 'push');
app.SaveButton.ButtonPushedFcn = createCallbackFcn(app, @SaveButtonPushed, true);
app.SaveButton.FontSize = 14;
app.SaveButton.Position = [415 6 99 26];
app.SaveButton.Text = 'Save';

• Tworzenie przycisku TY20BaselineButton

app.TY20BaselineButton = uibutton(app.loadPanel, 'push');
app.TY20BaselineButton.ButtonPushedFcn = createCallbackFcn(app, @TY20BaselineButtonPushed, true);
app.TY20BaselineButton.Position = [123 8 100 22];
app.TY20BaselineButton.Text = 'TY-20 Baseline';

• Tworzenie panelu Panel_2

app.Panel_2 = uipanel(app.PowertrainDataPanel);
app.Panel_2.Position = [264 575 256 107];

• Tworzenie CheckBoxa dla napędu łańcuchowego / pojedynczego układu biegów

app.ChaindriveSingleGearsetCheckBox = uicheckbox(app.Panel_2);
app.ChaindriveSingleGearsetCheckBox.ValueChangedFcn = createCallbackFcn(app, @ChaindriveSingleGearsetCheckBoxValueChanged, true);
app.ChaindriveSingleGearsetCheckBox.Text = {'Napęd łańcuchowy /'; 'Pojedynczy układ biegów'};
app.ChaindriveSingleGearsetCheckBox.Position = [6 74 101 28];

• Tworzenie etykiety dla pola edycji zębów koła zębatego

app.z_sprocketEditFieldLabel = uilabel(app.Panel_2);
app.z_sprocketEditFieldLabel.HorizontalAlignment = 'right';
app.z_sprocketEditFieldLabel.Position = [112 77 78 22];
app.z_sprocketEditFieldLabel.Text = 'z_sprocket [-]';

• Tworzenie pola edycji zębów koła zębatego

app.z_sprocketEditField = uieditfield(app.Panel_2, 'numeric');
app.z_sprocketEditField.UpperLimitInclusive = 'off';
app.z_sprocketEditField.Limits = [1 Inf];
app.z_sprocketEditField.ValueChangedFcn = createCallbackFcn(app, @z_sprocketEditFieldValueChanged, true);
app.z_sprocketEditField.Position = [198 77 49 22];
app.z_sprocketEditField.Value = 17;

• Tworzenie etykiety dla pola edycji zębów napędu łańcuchowego

app.z_chaindriveEditFieldLabel = uilabel(app.Panel_2);
app.z_chaindriveEditFieldLabel.HorizontalAlignment = 'right';
app.z_chaindriveEditFieldLabel.Position = [103 43 87 22];
app.z_chaindriveEditFieldLabel.Text = 'z_chaindrive [-]';

• Tworzenie pola edycji zębów napędu łańcuchowego

app.z_chaindriveEditField = uieditfield(app.Panel_2, 'numeric');
app.z_chaindriveEditField.UpperLimitInclusive = 'off';
app.z_chaindriveEditField.Limits = [1 Inf];
app.z_chaindriveEditField.ValueChangedFcn = createCallbackFcn(app, @z_chaindriveEditFieldValueChanged, true);
app.z_chaindriveEditField.Position = [198 43 49 22];
app.z_chaindriveEditField.Value = 66;

• Tworzenie etykiety dla współczynnika przekładni

app.GearRatioLabel = uilabel(app.Panel_2);
app.GearRatioLabel.Position = [159 8 89 22];
app.GearRatioLabel.Text = 'Gear Ratio';

• Tworzenie etykiety dla rozwijanej listy wyboru silnika

app.EnginePresetDropDownLabel = uilabel(app.PowertrainDataPanel);
app.EnginePresetDropDownLabel.HorizontalAlignment = 'right';
app.EnginePresetDropDownLabel.Position = [21 378 81 22];
app.EnginePresetDropDownLabel.Text = 'Engine Preset';

• Tworzenie rozwijanej listy wyboru silnika

app.EnginePresetDropDown = uidropdown(app.PowertrainDataPanel);
app.EnginePresetDropDown.Items = {'Triumph_D67LD', 'EMRAX_188_TorqueData_Peak', 'EMRAX_208_TorqueData_Peak', 'Emrax 228', 'Emrax 268', 'Emrax 348', 'Rotax_125_Junior_MAX_evo', 'Rotax_125_MAX_DD2_evo', 'Rotax_125_MAX_evo', 'new Engine'};
app.EnginePresetDropDown.ValueChangedFcn = createCallbackFcn(app, @EnginePresetDropDownValueChanged, true);
app.EnginePresetDropDown.Position = [112 378 135 22];
app.EnginePresetDropDown.Value = 'Triumph_D67LD';

• Tworzenie przycisku do usuwania silnika

app.DeleteEngineButton = uibutton(app.PowertrainDataPanel, 'push');
app.DeleteEngineButton.ButtonPushedFcn = createCallbackFcn(app, @DeleteEngineButtonPushed, true);
app.DeleteEngineButton.Tooltip = {'Usuwa aktualnie wybrany silnik, jeśli pozostało więcej niż jeden typ silnika.'};
app.DeleteEngineButton.Position = [155 97 91 22];
app.DeleteEngineButton.Text = 'Delete Engine';

• Tworzenie przycisku do zapisywania silnika

app.SaveEngineButton = uibutton(app.PowertrainDataPanel, 'push');
app.SaveEngineButton.ButtonPushedFcn = createCallbackFcn(app, @SaveEngineButtonPushed, true);
app.SaveEngineButton.Position = [68 97 84 22];
app.SaveEngineButton.Text = 'Save Engine';

• Tworzenie panelu dla parametrów napędu elektrycznego

app.EPowertrainParametersPanel = uipanel(app.PowertrainDataPanel);
app.EPowertrainParametersPanel.TitlePosition = 'centertop';
app.EPowertrainParametersPanel.Title = 'E Powertrain Parameters';
app.EPowertrainParametersPanel.Position = [18 411 230 92];

• Tworzenie etykiety dla pola edycji limitu mocy

app.PowerlimitWEditFieldLabel = uilabel(app.EPowertrainParametersPanel);
app.PowerlimitWEditFieldLabel.HorizontalAlignment = 'right';
app.PowerlimitWEditFieldLabel.Position = [33 43 86 22];
app.PowerlimitWEditFieldLabel.Text = 'Power limit [W]';

• Tworzenie pola edycji limitu mocy

app.PowerlimitWEditField = uieditfield(app.EPowertrainParametersPanel, 'numeric');
app.PowerlimitWEditField.LowerLimitInclusive = 'off';
app.PowerlimitWEditField.UpperLimitInclusive = 'off';
app.PowerlimitWEditField.Limits = [0 Inf];
app.PowerlimitWEditField.ValueDisplayFormat = '%.0f';
app.PowerlimitWEditField.Position = [136 43 87 22];
app.PowerlimitWEditField.Value = 80000;

• Tworzenie etykiety dla pola edycji sprawności falownika

app.InverterEfficiencyEditFieldLabel = uilabel(app.EPowertrainParametersPanel);
app.InverterEfficiencyEditFieldLabel.HorizontalAlignment = 'right';
app.InverterEfficiencyEditFieldLabel.Position = [1 12 116 22];
app.InverterEfficiencyEditFieldLabel.Text = 'Inverter Efficiency [-]';

• Tworzenie pola edycji sprawności falownika

app.InverterEfficiencyEditField = uieditfield(app.EPowertrainParametersPanel, 'numeric');
app.InverterEfficiencyEditField.LowerLimitInclusive = 'off';
app.InverterEfficiencyEditField.UpperLimitInclusive = 'off';
app.InverterEfficiencyEditField.Limits = [0 Inf];
app.InverterEfficiencyEditField.ValueChangedFcn = createCallbackFcn(app, @InverterEfficiencyEditFieldValueChanged, true);
app.InverterEfficiencyEditField.Position = [137 12 86 22];
app.InverterEfficiencyEditField.Value = 0.95;

• Tworzenie panelu

app.Panel = uipanel(app.PowertrainDataPanel);
app.Panel.Title = 'Panel';
app.Panel.Position = [17 517 227 220];

• Tworzenie przełącznika dla wyboru napędu

app.PowertrainSwitch = uiswitch(app.Panel, 'slider');
app.PowertrainSwitch.Items = {'Electric', 'Combustion'};
app.PowertrainSwitch.ValueChangedFcn = createCallbackFcn(app, @PowertrainSwitchValueChanged, true);
app.PowertrainSwitch.Position = [85 170 45 20];
app.PowertrainSwitch.Value = 'Electric';

• Tworzenie etykiety dla rozwijanej listy wyboru układu

app.LayoutDropDownLabel = uilabel(app.Panel);
app.LayoutDropDownLabel.HorizontalAlignment = 'right';
app.LayoutDropDownLabel.Position = [40 132 42 22];
app.LayoutDropDownLabel.Text = 'Layout';

• Tworzenie rozwijanej listy rozmieszczenia napędu.

app.LayoutDropDown = uidropdown(app.Panel);
app.LayoutDropDown.Items = {'2 Motor RWD', '1 Motor RWD', 'AWD'};
app.LayoutDropDown.ValueChangedFcn = createCallbackFcn(app, @LayoutDropDownValueChanged, true);
app.LayoutDropDown.Position = [93 132 107 22];
app.LayoutDropDown.Value = '2 Motor RWD';

• Tworzenie etykiety pola edycji dla sprawności układu napędowego.

app.DrivetrainEfficencyEditFieldLabel = uilabel(app.Panel);
app.DrivetrainEfficencyEditFieldLabel.HorizontalAlignment = 'right';
app.DrivetrainEfficencyEditFieldLabel.Position = [22 98 123 22];
app.DrivetrainEfficencyEditFieldLabel.Text = 'Sprawność układu napędowego [-]';

• Tworzenie pola edycji dla sprawności układu napędowego.

app.DrivetrainEfficencyEditField = uieditfield(app.Panel, 'numeric');
app.DrivetrainEfficencyEditField.LowerLimitInclusive = 'off';
app.DrivetrainEfficencyEditField.Limits = [0 1];
app.DrivetrainEfficencyEditField.ValueChangedFcn = createCallbackFcn(app, @DrivetrainEfficencyEditFieldValueChanged, true);
app.DrivetrainEfficencyEditField.Position = [155 98 52 22];
app.DrivetrainEfficencyEditField.Value = 0.95;

• Tworzenie etykiety pola edycji dla maksymalnej prędkości obrotowej.

app.n_max1minEditFieldLabel = uilabel(app.Panel);
app.n_max1minEditFieldLabel.HorizontalAlignment = 'right';
app.n_max1minEditFieldLabel.Position = [51 68 81 22];
app.n_max1minEditFieldLabel.Text = 'n_max [1/min]';

• Tworzenie pola edycji dla maksymalnej prędkości obrotowej.

app.n_max1minEditField = uieditfield(app.Panel, 'numeric');
app.n_max1minEditField.UpperLimitInclusive = 'off';
app.n_max1minEditField.Limits = [1 Inf];
app.n_max1minEditField.ValueDisplayFormat = '%.0f';
app.n_max1minEditField.Position = [155 68 53 22];
app.n_max1minEditField.Value = 6000;

• Tworzenie etykiety pola edycji dla mnożnika momentu obrotowego.

app.TorquemultiplierEditFieldLabel = uilabel(app.Panel);
app.TorquemultiplierEditFieldLabel.HorizontalAlignment = 'right';
app.TorquemultiplierEditFieldLabel.Position = [20 38 108 22];
app.TorquemultiplierEditFieldLabel.Text = 'Mnożnik momentu obrotowego [-]';

• Tworzenie pola edycji dla mnożnika momentu obrotowego.

app.TorquemultiplierEditField = uieditfield(app.Panel, 'numeric');
app.TorquemultiplierEditField.LowerLimitInclusive = 'off';
app.TorquemultiplierEditField.UpperLimitInclusive = 'off';
app.TorquemultiplierEditField.Limits = [0 Inf];
app.TorquemultiplierEditField.ValueChangedFcn = createCallbackFcn(app, @TorquemultiplierEditFieldValueChanged, true);
app.TorquemultiplierEditField.Position = [155 38 54 22];
app.TorquemultiplierEditField.Value = 1;

• Tworzenie etykiety pola edycji dla prędkości jałowej.

app.idle_rpm1minEditFieldLabel = uilabel(app.Panel);
app.idle_rpm1minEditFieldLabel.HorizontalAlignment = 'right';
app.idle_rpm1minEditFieldLabel.Position = [42 8 91 22];
app.idle_rpm1minEditFieldLabel.Text = 'Prędkość jałowa [1/min]';

• Tworzenie pola edycji dla prędkości jałowej.

app.idle_rpm1minEditField = uieditfield(app.Panel, 'numeric');
app.idle_rpm1minEditField.UpperLimitInclusive = 'off';
app.idle_rpm1minEditField.Limits = [0 Inf];
app.idle_rpm1minEditField.Position = [156 8 53 22];
app.idle_rpm1minEditField.Value = 2000;

• Tworzenie etykiety z informacją o prawach autorskich.

app.Copyright2021BalticRacingbyEricDorniedenLabel = uilabel(app.PowertrainDataPanel);
app.Copyright2021BalticRacingbyEricDorniedenLabel.Position = [834 1 274 22];
app.Copyright2021BalticRacingbyEricDorniedenLabel.Text = 'Copyright © 2021 Baltic Racing by Eric Dornieden';

• Wyświetlanie logo Baltic Racing.

app.Image2 = uiimage(app.PowertrainDataPanel);
app.Image2.Position = [7 6 196 77];
app.Image2.ImageSource = 'balticracing_logo_transparent.png';

• Tworzenie przycisku dodawania.

app.Button = uibutton(app.PowertrainDataPanel, 'push');
app.Button.ButtonPushedFcn = createCallbackFcn(app, @ButtonPushed, true);
app.Button.Position = [25 98 21 21];
app.Button.Text = '+';

• Tworzenie przycisku odejmowania.

app.Button_2 = uibutton(app.PowertrainDataPanel, 'push');
app.Button_2.ButtonPushedFcn = createCallbackFcn(app, @Button_2Pushed, true);
app.Button_2.Position = [45 98 20 21];
app.Button_2.Text = '-';

• Tworzenie tabeli do wyświetlania danych napędu.

app.UITable = uitable(app.PowertrainDataPanel);
app.UITable.ColumnName = {'RPM [1/min]'; 'Moment obrotowy [Nm]'};
app.UITable.RowName = {};
app.UITable.ColumnEditable = true;
app.UITable.CellEditCallback = createCallbackFcn(app, @UITableCellEdit, true);
app.UITable.Position = [24 119 222 258];

• Wyświetlanie okna po utworzeniu wszystkich komponentów.

app.DrivetrainSetupUIFigure.Visible = 'on';

• Konstruktor aplikacji, tworzy obiekt aplikacji Drivetrain, przyjmuje opcjonalne argumenty wejściowe

function app = Drivetrain(varargin)

• Tworzenie UIFigure i komponentów

createComponents(app)

• Rejestrowanie aplikacji w App Designer

registerApp(app, app.DrivetrainSetupUIFigure)

• Wykonanie funkcji startupFcn

runStartupFcn(app, @(app)startupFcn(app, varargin{:}))

• Jeśli nie ma argumentów wyjściowych, usuń obiekt aplikacji

if nargout == 0
    clear app

• Usunięcie UIFigure przy usuwaniu aplikacji

delete(app.DrivetrainSetupUIFigure)

4.2.7 - Linia Krzywa 2D

Zmienne wejściowe:

1. Vertices:

• Macierz M x 2
• Opis: Lista punktów tworzących linię, gdzie każda z M wierszy zawiera współrzędne x i y danego punktu.
• Przykład: Vertices = [x1, y1; x2, y2; ...; xM, yM]

2. Lines (opcjonalnie):

• Macierz N x 2
• Opis: Lista odcinków linii zdefiniowana przez indeksy punktów z Vertices. Każdy wiersz zawiera dwa indeksy, które definiują odcinek linii.
• Przykład: Lines = [index1, index2; index2, index3; ...; indexN-1, indexN]
• Domyślnie: Jeśli Lines nie jest podane, przyjmuje się, że Lines = [1 2; 2 3; ...; M-1 M], co oznacza, że punkty są połączone w kolejności, w jakiej są podane.

Zmienna wyjściowa:

1. k:

• Wektor M x 1
• Opis: Wartości krzywizny dla każdego z M punktów linii. Każdy element wektora k odpowiada krzywiźnie w odpowiednim punkcie Vertices.
• Przykład: k = [k1; k2; ...; kM], gdzie ki to krzywizna w punkcie i.

Przykład użycia:

Jeśli mamy punkty linii:

Vertices = [0, 0; 1, 1; 2, 0; 3, -1]; i chcemy obliczyć krzywiznę, możemy wywołać funkcję: k = LineCurvature2D(Vertices);

Jeśli chcemy określić własne odcinki linii:

Lines = [1, 2; 2, 3; 3, 4];
k = LineCurvature2D(Vertices, Lines);

Przykłady:

Koło

1. Generowanie losowych kątów:

r = sort(rand(15,1)) * 2 * pi;

• Generujemy 15 losowych liczb w zakresie od 0 do 1 (rand(15,1)).
• Sortujemy te liczby rosnąco (sort).
• Przekształcamy je na kąty w zakresie od 0 do 2π poprzez mnożenie przez 2π.

2. Tworzenie punktów okręgu:

Vertices = [sin(r) cos(r)] * 10;

• Używamy funkcji trygonometrycznych sin i cos, aby przekształcić kąty na współrzędne punktów na okręgu.
• Skalujemy współrzędne przez 10, aby uzyskać punkty na okręgu o promieniu 10.
• Vertices to macierz 15x2, gdzie każda para [sin(r_i) cos(r_i)] * 10 reprezentuje współrzędne punktu.

3. Tworzenie linii:

Lines = [(1:size(Vertices,1))' (2:size(Vertices,1)+1']; Lines(end,2) = 1;

• Tworzymy macierz Lines, która definiuje odcinki linii przez indeksy punktów w Vertices.
• Każdy wiersz Lines łączy punkt i z punktem i+1.
• Ostatnia para jest specjalnie ustawiona (Lines(end,2) = 1), aby zamknąć okrąg, łącząc ostatni punkt z pierwszym.

4. Obliczenie krzywizny:

k = LineCurvature2D(Vertices, Lines);

• Wywołujemy funkcję LineCurvature2D z punktami Vertices i liniami Lines, aby obliczyć krzywiznę.
• k to wektor wartości krzywizny dla każdego punktu.

figure, hold on;

• Tworzy nowe okno wykresu.
• Włącza tryb hold on, co pozwala na nałożenie wielu wykresów na jednej figurze bez ich nadpisywania.

5. Obliczenie normalnych do linii:

N = LineNormals2D(Vertices,Lines);

• Wywołuje funkcję LineNormals2D, która oblicza normalne do linii w punktach Vertices na podstawie Lines.
• N to macierz zawierająca wektory normalne dla każdego punktu.

6. Skalowanie wartości krzywizny:

k = k * 100;

• Skaluje wartości krzywizny k przez mnożenie przez 100, aby lepiej widoczne były na wykresie.
• N to macierz zawierająca wektory normalne dla każdego punktu.

7. Wykreślanie normalnych do linii:

plot([Vertices(:,1) Vertices(:,1)+k.*N(:,1)]',[Vertices(:,2) Vertices(:,2)+k.*N(:,2)]','g');

• Wykreśla wektory normalne w każdym punkcie Vertices.
• Vertices(:,1) to współrzędne x punktów początkowych.
• Vertices(:,1) + k.*N(:,1) to współrzędne x końców wektorów normalnych.
• Vertices(:,2) to współrzędne y punktów początkowych.
• Vertices(:,2) + k.*N(:,2) to współrzędne y końców wektorów normalnych.
• Kolor wykresu: zielony ('g').

8. Wykreślanie linii:

plot([Vertices(Lines(:,1),1) Vertices(Lines(:,2),1)]',[Vertices(Lines(:,1),2) Vertices(Lines(:,2),2)]','b');

• Wykreśla linie łączące punkty z Vertices zgodnie z Lines.

• Vertices(Lines(:,1),1) i Vertices(Lines(:,2),1) to współrzędne x punktów początkowych i końcowych odcinków linii.

• Vertices(Lines(:,1),2) i Vertices(Lines(:,2),2) to współrzędne y punktów początkowych i końcowych odcinków linii.

• Kolor wykresu: niebieski ('b').

9. Wykreślanie idealnego okręgu:

plot(sin(0:0.01:2*pi)*10, cos(0:0.01:2*pi)*10, 'r.');

• Wykreśla idealny okrąg o promieniu 10.

• sin(0:0.01:2*pi)*10 i cos(0:0.01:2*pi)*10 to współrzędne x i y punktów na okręgu.

• Kolor wykresu: czerwony ('r').

10. Ustawienie równej skali osi:

axis equal;

• Ustawia równe jednostki na osiach x i y, co sprawia, że okrąg wygląda proporcjonalnie.

Przykład, Ręka:

1. Wczytanie danych z pliku:

load('testdata');

• Wczytuje dane z pliku testdata.mat, które zawierają zmienne Vertices (współrzędne punktów) i Lines (lista odcinków linii).

2. Obliczenie krzywizny linii:

k = LineCurvature2D(Vertices, Lines);

• Wywołuje funkcję LineCurvature2D, która oblicza wartości krzywizny dla punktów zdefiniowanych w Vertices i Lines.
• k to wektor zawierający wartości krzywizny dla każdego punktu.

3. Utworzenie nowej figury i włączenie trybu hold on:

figure, hold on;

• Tworzy nowe okno wykresu.
• Włącza tryb hold on, co pozwala na nałożenie wielu wykresów na jednej figurze bez ich nadpisywania.

4. Obliczenie normalnych do linii:

N = LineNormals2D(Vertices, Lines);

• Wywołuje funkcję LineNormals2D, która oblicza wektory normalne dla punktów z Vertices na podstawie Lines.
• N to macierz zawierająca wektory normalne dla każdego punktu.

5. Skalowanie wartości krzywizny:

k = k * 100;

• Skaluje wartości krzywizny k przez mnożenie przez 100, aby lepiej widoczne były na wykresie.

6. Wykreślanie normalnych do linii:

plot([Vertices(:,1) Vertices(:,1) + k .* N(:,1)]', [Vertices(:,2) Vertices(:,2) + k .* N(:,2)]', 'g');

• Wykreśla wektory normalne w każdym punkcie Vertices.
• Vertices(:,1) to współrzędne x punktów początkowych.
• Vertices(:,1) + k .* N(:,1) to współrzędne x końców wektorów normalnych.
• Vertices(:,2) to współrzędne y punktów początkowych.
• Vertices(:,2) + k .* N(:,2) to współrzędne y końców wektorów normalnych.
• Kolor wykresu: zielony ('g').

7. Wykreślanie linii:

plot([Vertices(Lines(:,1),1) Vertices(Lines(:,2),1)]', [Vertices(Lines(:,1),2) Vertices(Lines(:,2),2)]', 'b'); `

• Wykreśla linie łączące punkty z Vertices zgodnie z Lines.
• Vertices(Lines(:,1),1) i Vertices(Lines(:,2),1) to współrzędne x punktów początkowych i końcowych odcinków linii.
• Vertices(Lines(:,1),2) i Vertices(Lines(:,2),2) to współrzędne y punktów początkowych i końcowych odcinków linii.
• Kolor wykresu: niebieski ('b').

8. Wykreślanie punktów:

plot(Vertices(:,1), Vertices(:,2), 'r.');

• Wykreśla punkty Vertices.
• Kolor wykresu: czerwony ('r').

9. Ustawienie równej skali osi:

axis equal;

• Ustawia równe jednostki na osiach x i y, co zapewnia proporcjonalne wyświetlanie.

10. Lista zmiennych i ich opis:

Vertices:

• Typ: Macierz M x 2
• Opis: Współrzędne punktów (wierzchołków) linii.

Lines:

• Typ: Macierz N x 2
• Opis: Lista odcinków linii, zdefiniowana przez indeksy punktów w Vertices.

k:

• Typ: Wektor M x 1
• Opis: Wartości krzywizny dla punktów Vertices, skalowane przez 100.

N:

• Typ: Macierz M x 2
• Opis: Wektory normalne dla punktów z Vertices, obliczone przez LineNormals2D.

Funkcja

Obliczenie krzywizny linii na podstawie zadanych wierzchołków (Vertices) i odcinków linii (Lines). Obejmuje on kroki takie jak uzupełnianie brakujących sąsiadów, przeliczanie wektorów normalnych oraz obliczanie krzywizny na podstawie dopasowania wielomianu do wierzchołków.

Kod:

% Function is written by D.Kroon University of Twente (August 2011)

% If no line-indices, assume a x(1) connected with x(2), x(3) with x(4) ...
if(nargin<2)
    Lines=[(1:(size(Vertices,1)-1))' (2:size(Vertices,1))'];
end

% Get left and right neighbor of each points
Na=zeros(size(Vertices,1),1); Nb=zeros(size(Vertices,1),1);
Na(Lines(:,1))=Lines(:,2); Nb(Lines(:,2))=Lines(:,1);

% Check for end of line points, without a left or right neighbor
checkNa=Na==0; checkNb=Nb==0;
Naa=Na; Nbb=Nb;
Naa(checkNa)=find(checkNa); Nbb(checkNb)=find(checkNb);

% If no left neighbor use two right neighbors, and the same for right... 
Na(checkNa)=Nbb(Nbb(checkNa)); Nb(checkNb)=Naa(Naa(checkNb));

% Correct for sampeling differences
Ta=-sqrt(sum((Vertices-Vertices(Na,:)).^2,2));
Tb=sqrt(sum((Vertices-Vertices(Nb,:)).^2,2)); 

% If no left neighbor use two right neighbors, and the same for right... 
Ta(checkNa)=-Ta(checkNa); Tb(checkNb)=-Tb(checkNb);

% Fit a polygons to the vertices 
% x=a(3)*t^2 + a(2)*t + a(1) 
% y=b(3)*t^2 + b(2)*t + b(1) 
% we know the x,y of every vertice and set t=0 for the vertices, and
% t=Ta for left vertices, and t=Tb for right vertices,  
x = [Vertices(Na,1) Vertices(:,1) Vertices(Nb,1)];
y = [Vertices(Na,2) Vertices(:,2) Vertices(Nb,2)];
M = [ones(size(Tb)) -Ta Ta.^2 ones(size(Tb)) zeros(size(Tb)) zeros(size(Tb)) ones(size(Tb)) -Tb Tb.^2];
invM=inverse3(M);
a(:,1)=invM(:,1,1).*x(:,1)+invM(:,2,1).*x(:,2)+invM(:,3,1).*x(:,3);
a(:,2)=invM(:,1,2).*x(:,1)+invM(:,2,2).*x(:,2)+invM(:,3,2).*x(:,3);
a(:,3)=invM(:,1,3).*x(:,1)+invM(:,2,3).*x(:,2)+invM(:,3,3).*x(:,3);
b(:,1)=invM(:,1,1).*y(:,1)+invM(:,2,1).*y(:,2)+invM(:,3,1).*y(:,3);
b(:,2)=invM(:,1,2).*y(:,1)+invM(:,2,2).*y(:,2)+invM(:,3,2).*y(:,3);
b(:,3)=invM(:,1,3).*y(:,1)+invM(:,2,3).*y(:,2)+invM(:,3,3).*y(:,3);

% Calculate the curvature from the fitted polygon
k = 2*(a(:,2).*b(:,3)-a(:,3).*b(:,2)) ./ ((a(:,2).^2+b(:,2).^2).^(3/2));

function  Minv  = inverse3(M)
% This function does inv(M) , but then for an array of 3x3 matrices
adjM(:,1,1)=  M(:,5).*M(:,9)-M(:,8).*M(:,6);
adjM(:,1,2)=  -(M(:,4).*M(:,9)-M(:,7).*M(:,6));
adjM(:,1,3)=  M(:,4).*M(:,8)-M(:,7).*M(:,5);
adjM(:,2,1)=  -(M(:,2).*M(:,9)-M(:,8).*M(:,3));
adjM(:,2,2)=  M(:,1).*M(:,9)-M(:,7).*M(:,3);
adjM(:,2,3)=  -(M(:,1).*M(:,8)-M(:,7).*M(:,2));
adjM(:,3,1)=  M(:,2).*M(:,6)-M(:,5).*M(:,3);
adjM(:,3,2)=  -(M(:,1).*M(:,6)-M(:,4).*M(:,3));
adjM(:,3,3)=  M(:,1).*M(:,5)-M(:,4).*M(:,2);
detM=M(:,1).*M(:,5).*M(:,9)-M(:,1).*M(:,8).*M(:,6)-M(:,4).*M(:,2).*M(:,9)+M(:,4).*M(:,8).*M(:,3)+M(:,7).*M(:,2).*M(:,6)-M(:,7).*M(:,5).*M(:,3);
Minv=bsxfun(@rdivide,adjM,detM);

Kroki działania:

1. Sprawdzenie i przypisanie domyślnych indeksów linii:

if(nargin<2) Lines=[(1:(size(Vertices,1)-1))' (2:size(Vertices,1))']; end

• Jeśli nie podano Lines, domyślnie zakłada, że punkty są połączone sekwencyjnie.

2. Znalezienie lewego i prawego sąsiada dla każdego punktu:

Na=zeros(size(Vertices,1),1); Nb=zeros(size(Vertices,1),1); Na(Lines(:,1))=Lines(:,2); Nb(Lines(:,2))=Lines(:,1);

• Na i Nb przechowują indeksy lewych i prawych sąsiadów dla każdego punktu.

3. Sprawdzenie punktów bez sąsiadów i uzupełnienie braków:

checkNa=Na==0; checkNb=Nb==0;
Naa=Na; Nbb=Nb;
Naa(checkNa)=find(checkNa); Nbb(checkNb)=find(checkNb);

Na(checkNa)=Nbb(Nbb(checkNa)); Nb(checkNb)=Naa(Naa(checkNb));

• Jeśli punkt nie ma lewego lub prawego sąsiada, używa dwóch sąsiadów z przeciwnej strony.

4. Korekta różnic próbkowania:

Ta=-sqrt(sum((Vertices-Vertices(Na,:)).^2,2));
Tb=sqrt(sum((Vertices-Vertices(Nb,:)).^2,2)); 

Ta(checkNa)=-Ta(checkNa); Tb(checkNb)=-Tb(checkNb);

• Oblicza odległości do sąsiadów, uwzględniając brakujące wartości.

5. Dopasowanie wielomianu do wierzchołków:

x = [Vertices(Na,1) Vertices(:,1) Vertices(Nb,1)]; y = [Vertices(Na,2) Vertices(:,2) Vertices(Nb,2)]; M = [ones(size(Tb)) -Ta Ta.^2 ones(size(Tb)) zeros(size(Tb)) zeros(size(Tb)) ones(size(Tb)) -Tb Tb.^2]; invM=inverse3(M); a(:,1)=invM(:,1,1).*x(:,1)+invM(:,2,1).*x(:,2)+invM(:,3,1).*x(:,3); a(:,2)=invM(:,1,2).*x(:,1)+invM(:,2,2).*x(:,2)+invM(:,3,2).*x(:,3); a(:,3)=invM(:,1,3).*x(:,1)+invM(:,2,3).*x(:,2)+invM(:,3,3).*x(:,3); b(:,1)=invM(:,1,1).*y(:,1)+invM(:,2,1).*y(:,2)+invM(:,3,1).*y(:,3); b(:,2)=invM(:,1,2).*y(:,1)+invM(:,2,2).*y(:,2)+invM(:,3,2).*y(:,3); b(:,3)=invM(:,1,3).*y(:,1)+invM(:,2,3).*y(:,2)+invM(:,3,3).*y(:,3);

• Dopasowuje wielomiany do współrzędnych punktów, biorąc pod uwagę sąsiadów.

6. Obliczenie krzywizny:

k = 2*(a(:,2).*b(:,3)-a(:,3).*b(:,2)) ./ ((a(:,2).^2+b(:,2).^2).^(3/2));

7. Odwracanie macierzy 3x3:

function  Minv  = inverse3(M)
adjM(:,1,1)=  M(:,5).*M(:,9)-M(:,8).*M(:,6);
adjM(:,1,2)=  -(M(:,4).*M(:,9)-M(:,7).*M(:,6));
adjM(:,1,3)=  M(:,4).*M(:,8)-M(:,7).*M(:,5);
adjM(:,2,1)=  -(M(:,2).*M(:,9)-M(:,8).*M(:,3));
adjM(:,2,2)=  M(:,1).*M(:,9)-M(:,7).*M(:,3);
adjM(:,2,3)=  -(M(:,1).*M(:,8)-M(:,7).*M(:,2));
adjM(:,3,1)=  M(:,2).*M(:,6)-M(:,5).*M(:,3);
adjM(:,3,2)=  -(M(:,1).*M(:,6)-M(:,4).*M(:,3));
adjM(:,3,3)=  M(:,1).*M(:,5)-M(:,4).*M(:,2);
detM=M(:,1).*M(:,5).*M(:,9)-M(:,1).*M(:,8).*M(:,6)-M(:,4).*M(:,2).*M(:,9)+M(:,4).*M(:,8).*M(:,3)+M(:,7).*M(:,2).*M(:,6)-M(:,7).*M(:,5).*M(:,3);
Minv=bsxfun(@rdivide,adjM,detM);

Lista zmiennych i ich opis:

Vertices:

• Typ: Macierz M x 2
• Opis: Współrzędne punktów (wierzchołków) linii.

Lines:

• Typ: Macierz N x 2
• Opis: Lista odcinków linii, zdefiniowana przez indeksy punktów w Vertices.

Na:

• Typ: Wektor M x 1
• Opis: Indeksy lewych sąsiadów dla każdego punktu.

Nb:

• Typ: Wektor M x 1
• Opis: Indeksy prawych sąsiadów dla każdego punktu.

checkNa, checkNb:

• Typ: Wektory logiczne M x 1
• Opis: Wskazuje, które punkty nie mają lewego lub prawego sąsiada.

Naa, Nbb:

• Typ: Wektory M x 1
• Opis: Kopie Na i Nb, używane do uzupełniania braków.

Ta, Tb:

• Typ: Wektory M x 1
• Opis: Odległości do lewych i prawych sąsiadów.

x, y:`

• Typ: Macierze M x 3
• Opis: Współrzędne x i y dla punktów i ich sąsiadów.

M:

• Typ: Macierz M x 9
• Opis: Macierz współczynników dla dopasowania wielomianu.

invM:

• Typ: Macierz M x 3 x 3
• Opis: Odwrotność macierzy M.

a, b:

• Typ: Macierze M x 3
• Opis: Współczynniki wielomianów dopasowanych do współrzędnych x i y.

k:

• Typ: Wektor M x 1
• Opis: Wartości krzywizny dla punktów Vertices.

4.2.8 - Linia Znormalizowana 2D

Wejście i wyjście:

Fragment kodu przyjmuje listę punktów/wierzchołków V o wymiarach 2 x M jako dane wejściowe. Opcjonalnie można podać listę odcinków Lines, która jest listą N x 2 zawierającą indeksy wierzchołków definiujących poszczególne odcinki linii (jeśli nie jest podana, zakłada się, że Lines=[1 2; 2 3 ; ... ; M-1 M]). Jako wynik zwraca normalne do wierzchołków N o wymiarach 2 x M.

• V = Lista punktów/wierzchołków w postaci macierzy 2 x M.
• Lines (opcjonalny) = Lista o wymiarach N x 2 zawierająca odcinki linii, wyrażone przez indeksy wierzchołków (jeśli nie jest podana, zakładamy, że Lines=[1 2; 2 3 ; ... ; M-1 M]).
• N = Normalne do wierzchołków w postaci macierzy 2 x M.

Przykład:

Ten fragment kodu to przykładowe użycie funkcji LineNormals2D w celu obliczenia normalnych do linii na płaszczyźnie 2D. Dane wejściowe są wczytywane z pliku testowego (testdata). Następnie funkcja LineNormals2D jest wywoływana, aby obliczyć normalne do linii na podstawie podanych wierzchołków (Vertices) i odcinków (Lines). Otrzymane normalne są następnie wykorzystywane do wygenerowania wykresu, który przedstawia oryginalne linie oraz normalne do tych linii, przedstawione jako linie przechodzące przez wierzchołki i skierowane w kierunku normalnej zwiększonej dziesięciokrotnie.

• testdata = nazwa pliku testowego.

FUNKCJA:

Funkcja napisana przez D. Kroona z Uniwersytetu w Twente (sierpień 2011)

Początek kodu odpowiada za ustalenie listy odcinków linii w przypadku, gdy nie są podane indeksy linii. Lista zmiennych:

• nargin = Liczba argumentów wejściowych funkcji.
• Lines = Lista odcinków linii, gdzie każdy odcinek jest połączeniem kolejnych punktów. Jeśli nie są podane indeksy linii, ta lista jest automatycznie generowana.

Obliczanie wektorów stycznych do krzywej poprzez różnicę pomiędzy współrzędnymi punktów końcowych i początkowych odcinków linii.

• Lines(:,1) = indeksy początkowych punktów odcinków linii.
• Lines(:,2) = indeksy końcowych punktów odcinków linii.
• Vertices(Lines(:,1),:) = współrzędne początkowych punktów odcinków linii.
• Vertices(Lines(:,2),:) = współrzędne końcowych punktów odcinków linii.

Wpływ wektorów stycznych na odległość dla każdego punktu/wierzchołka krzywej:

• LL: Obliczana jest długość wektorów stycznych DT za pomocą funkcji sqrt(DT(:,1).^2+DT(:,2).^2).

• DT(:,1)=DT(:,1)./max(LL.^2,eps): Normalizowane są współrzędne x wektorów stycznych przez kwadrat długości wektora (LL), z tym że minimalna wartość to eps (najmniejsza wartość reprezentowalna w danej precyzji arytmetyki).

• DT(:,2)=DT(:,2)./max(LL.^2,eps): Normalizowane są współrzędne y wektorów stycznych przez kwadrat długości wektora (LL), z tym że minimalna wartość to eps.

• D1=zeros(size(Vertices)); D1(Lines(:,1),:)=DT;: Tworzona jest macierz zerowa D1 o takim samym rozmiarze jak lista punktów/wierzchołków. Następnie wiersze odpowiadające początkowym punktom odcinków linii otrzymują wartości wektorów stycznych DT.

• D2=zeros(size(Vertices)); D2(Lines(:,2),:)=DT;: Tworzona jest macierz zerowa D2 o takim samym rozmiarze jak lista punktów/wierzchołków. Następnie wiersze odpowiadające końcowym punktom odcinków linii otrzymują wartości wektorów stycznych DT.

• D=D1+D2;: Sumowane są macierze D1 i D2, uzyskując macierz D, która zawiera wpływ wektorów stycznych na odległość dla każdego punktu/wierzchołka krzywej.

Normalizowanie wektorów normalnych:

• LL: Obliczana jest długość wektorów normalnych D za pomocą funkcji sqrt(D(:,1).^2+D(:,2).^2).

• N(:,1)=-D(:,2)./LL: Współrzędna x normalizowanego wektora normalnego jest ujemnym ilorazem współrzędnej y wektora normalnego przez długość LL.

• N(:,2)= D(:,1)./LL: Współrzędna y normalizowanego wektora normalnego jest ilorazem współrzędnej x wektora normalnego przez długość LL.

Ostatecznie macierz N zawiera znormalizowane wektory normalne.

4.2.9 - Maksymalna prędkość na łuku

Opisany plik: Find_maximum_corner_speed.m

• Czyszczenie środowiska

clear all
close all

Te dwie linie służą do czyszczenia środowiska MATLAB. clear all usuwa wszystkie zmienne z przestrzeni roboczej, a close all zamyka wszystkie otwarte okna graficzne.

• Wczytywanie danych

load('Aero Downforce Daten.mat');    % Aero Daten

Ta linia wczytuje dane dotyczące sił aerodynamicznych z pliku .mat.

• Wczytywanie danych opon

FileNameLocation = ('C19_CONTINENTAL_FORMULASTUDENT_205_470_R13_65kPa.tir');
TIRparam = loadTIR(FileNameLocation);

Te dwie linie wczytują dane o oponach z pliku .tir za pomocą funkcji loadTIR.

• Inicjalizacja zmiennych

R = 10;
m = 280;
FZ_stat = 800;
k = 0;

Te linie inicjalizują zmienne używane w późniejszych obliczeniach. R to promień, m to masa, FZ_stat to statyczne obciążenie pionowe, a k to krok iteracji.

• Pętla główna

for i = 1:8
    v1 = 5;
    v2 = 100;
    FZ_stat = 800 + (i-1)*200;
    ...
end

Ta pętla wykonuje obliczenia dla różnych wartości obciążenia pionowego. W każdej iteracji, FZ_stat jest zwiększane o 200 jednostek.

• Obliczenia w pętli

while v1 < v2
    v1 = v1 + k;        
    Faero = interp1(v,FA,v1*3.6,'linear','extrap'); % [N] Abtriebskraft interpoliert        
    FZ(i) = FZ_stat + Faero/2;       
    v2 = sqrt(max(MF52_Fy_cs(0:-0.1:-12,FZ(i),0,0,TIRparam))*R/m);        
    k = k+0.0001;
end

Wewnątrz pętli głównej znajduje się pętla while, która wykonuje obliczenia dla danego obciążenia pionowego, dopóki pewien warunek nie zostanie spełniony. W każdej iteracji, v1 jest zwiększane o k, a k jest zwiększane o 0.0001.

• Interpolacja siły aerodynamicznej

Faero = interp1(v,FA,v1*3.6,'linear','extrap'); % [N] Abtriebskraft interpoliert

Ta linia interpoluje siłę aerodynamiczną (Faero) na podstawie prędkości (v1).

• Obliczanie obciążenia pionowego

FZ(i) = FZ_stat + Faero/2;

Ta linia oblicza obciążenie pionowe (FZ) na podstawie statycznego obciążenia pionowego (FZ_stat) i siły aerodynamicznej (Faero).

• Obliczanie prędkości

v2 = sqrt(max(MF52_Fy_cs(0:-0.1:-12,FZ(i),0,0,TIRparam))*R/m);

Ta linia oblicza prędkość (v2) na podstawie obciążenia pionowego (FZ), promienia (R) i masy (m).

• Obliczanie maksymalnego przyspieszenia bocznego

aQmax(i) = v2^2/R/9.81;

Ta linia oblicza maksymalne przyspieszenie boczne (aQmax) na podstawie prędkości (v2) i promienia (R).

• Wykres wyników

scatter(FZ,aQmax)

Ta linia tworzy wykres punktowy (scatter plot), pokazujący maksymalne przyspieszenie boczne (aQmax) w funkcji obciążenia pionowego (FZ).

4.2.10 - Manadżer symulacji

Wstęp

simulationManager

Co się dzieje w ciele funkcji

1. Na początku podejmowana jest próba przypisania zmiennej sensitivityID2 z klasy startingParameters załadowanej z pliku generateStartingParameters.m do zmiennej lokalnej o tej samej nazwie. Jeśli się nie uda przypisywana jest jej wartość “0”.

   W praktyce try powinien być wykonany, bo z pliku generateStartingParameters.m możemy wywnioskować, że w każdym przypadku będzie ta zmienna przechowywała jakąś wartość.

2. Jeśli ilość kroków symulacji (numSteps) będzie większa od 1 oraz zmienna sensitivityID będzie różna od 0 (w praktyce; jeśli sensitivity analysis będzie wyłączone) to wykonuje się kod przedstawiony wyżej, gdzie funkcja zeros() tworzy tablicę o wymiarach 1 x numSteps wypełnioną zerami.

3. W warunku mamy drugą wartość do śledzenia przy rysowaniu wykresu, czyli jeśli zaznaczony zostanie CheckBox włączający ją to warunek się spełni i wtedy:
   tic - uruchamia stoper
   wykonuje się pętla od 1 do numSteps z pętlą wewnętrzną z tym samym zakresem z przedstawionymi działaniami arytmetycznymi. Rezultatem tej pętli są wypiełnione tablice minValue i minValue2
   

   Ale jeśli warunek się nie spełni, czyli nie włączymy drugiej wartości do śledzenia to:
   tic - uruchamia stoper
   wykonuje się analogiczna pętla ale tylko dla minValue jak przedstawiono poniżej:

   

4. Następnie zmienna steps jest zmniejszana o 1, żeby nie przekroczyć zakresu w następującej pętli równoległej, która do kolejnych komórek w tablicy result przypisuje wartości zwracane przez wywoływaną funkcję Vehiclesim_Endurance_GUI_Version() z parametrami

• startingParameters
• minValue()
• minValue2()
• sensitivityID
• sensitivityID2

Do pliku z logami przez funkcję writeToLogfile zostaje zapisany czas wykonywania wszystkich powyższych operacji od momentu procedury tic do toc (zliczającej upłynięty czas).

Ładowana jest nazwa pliku z setupem.

Rezultaty są zapisywane do pliku .mat, dodając “_result” do nazwy, w tej samej lokalizacji co jest plik z setupem.

Jeśli jednak warunek 2. się nie spełni to wywoływana jest funkcja Vehiclesim_Endurance_GUI_Version(startingParameters).

4.2.11 - Parametry opon, poślizgi i siły

Użyte pliki:

-Tires/C19_CONTINENTAL_FORMULASTUDENT_205_470_R13_65kPa.tir
-MF52_ALPHA_cs.m
-MF52_Fx_cs.m
-MF52_Fx_ps.m
-MF52_Fy_cs.m
-MF52_Fy_ps.m
-calculateLatTireforces.m
-calculateLongiTireForces.m
-calculateWheelloadLongDisp.m
-calculateWheelloadLatDisp.m
-calculateVTireStiff.m

Dokumentacja pliku parametrycznego opisu opony Continental

Plik zawiera parametryczny opis opony Continental, który jest używany do modelowania jej zachowania. Poniżej znajduje się dokumentacja poszczególnych sekcji tego pliku. WstępPlik zawiera informacje o marce opony, modelu, klasie, rozmiarze oraz innych parametrach fizycznych opony. Został wygenerowany przez Wilke Eikermanna i Hannesa Dettmanna z działu badań i rozwoju Continental Reifen Deutschland GmbH. Plik jest własnością Continental AG i jego dystrybucja jest możliwa tylko za wyraźnym zezwoleniem Continental AG lub jej spółek zależnych.

! : FILE_TYPE : TOF                                     
! : FILE_VERSION : 3                                       
! : TIRE_VERSION : MF-Tyre 5.2                             
!
! : COMMENT    : Tire Brand                                 CONTINENTAL                   
! : COMMENT    : Tire Trade                                 FORMULA STUDENT C19              
! : COMMENT    : Tire Class                                 Competition                    
! : COMMENT    : Tire Size                                  205/470 R13                    
! : COMMENT    : Tire Width                            [m]  0.200                         
! : COMMENT    : Tire Unloaded Radius                  [m]  0.235                         
! : COMMENT    : Tire Aspect Ratio                     [-]  0.34                           
! : COMMENT    : Rim Width                            [in]  7                             
! : COMMENT    : Rim Radius                            [m]  0.1651                        
! : COMMENT    : Inflation Pressure                  [kPa]  65                            

USE_MODE w modelu opony

USE_MODE to parametr w modelu opony, który określa, jakie obliczenia są wykonywane. Każda wartość USE_MODE odpowiada innemu zestawowi obliczeń:

• 0: Oblicza tylko Fz (siłę pionową), nie wykonuje ewaluacji Magic Formula.
• 1: Oblicza tylko Fx (siłę podłużną).
• 2: Oblicza tylko Fy, Mx, Mz (siłę boczną, moment względem osi X i moment względem osi Z).
• 3: Oblicza Fx, Fy, Mx, Mz bez kombinacji sił/momenty.
• 4: Oblicza Fx, Fy, Mx, Mz z kombinacją sił/momenty. Dodanie 10 do dowolnej z powyższych wartości uwzględnia efekty relaksacji w obliczeniach. Na przykład, USE_MODE = 12 oznacza, że obliczenia są wykonywane tylko dla Fy, Mx, Mz i uwzględniają efekty relaksacji. Ważne jest, aby zauważyć, że model opony jest ważny tylko dla określonego USE_MODE. Inne tryby mogą nie dostarczyć dokładnych wyników, ponieważ model został skonstruowany do pracy w określonym trybie.

Jednostki

W pliku parametrycznym wszystkie dane podawane są w odniesieniu do jednostek układu SI

[UNITS]
LENGTH                    = 'meter'   
FORCE                     = 'newton'  
ANGLE                     = 'radians'
MASS                      = 'kg'      
TIME                      = 'second'

Model

Sekcja modelu zawiera informacje o typie modelu opony, wersji formatu pliku, stronie opony, trybie użycia i innych parametrach związanych z modelem opony.

[MODEL]
TYRESIDE                  = 'Right'   
PROPERTY_FILE_FORMAT      = 'MF_05'   
TYPE                      = 'TIR'     
FITTYP                    =           5    $typarr(  2)
USE_MODE                  =          14    $typarr(  1)
MFSAFE1                   =         121    $typarr(  3)
MFSAFE2                   =         121    $typarr(  4)
MFSAFE3                   =         242    $typarr(  5)
VXLOW                     = +1.000e+000    $typarr( 29)
LONGVL                    = +1.111e+001    $typarr( 30)

Wymiary

Sekcja wymiarów zawiera informacje o fizycznych wymiarach opony, takich jak promień opony bez obciążenia, szerokość opony, stosunek wysokości do szerokości, promień obręczy i szerokość obręczy.

[DIMENSION]
UNLOADED_RADIUS           = +2.350e-001    $typarr(  7)
WIDTH                     = +2.000e-001    $typarr(  8)
ASPECT_RATIO              = +3.400e-001    $typarr(  6)
RIM_RADIUS                = +1.651e-001    $typarr(  9)
RIM_WIDTH                 = +1.778e-001    $typarr( 10)

Kształt

Ten kod definiuje kształt opony za pomocą profilu bocznego opony wzdłuż jej szerokości. Każda linia reprezentuje punkt na profilu opony, gdzie pierwsza wartość to odległość od środka opony (wzdłuż promienia), a druga wartość to szerokość opony w tym punkcie.

• 1.0 0.0 oznacza, że na początku (w środku opony), szerokość opony wynosi 0.0.
• 1.0 0.4 oznacza, że gdy przechodzimy na zewnątrz opony, szerokość opony zwiększa się do 0.4.
• 1.0 0.9 oznacza, że szerokość opony nadal rośnie, osiągając 0.9.
• 0.9 1.0 oznacza, że na zewnątrz opony, szerokość opony osiąga swoje maksimum (1.0), ale odległość od środka opony nieznacznie się zmniejsza (0.9).

W ten sposób kod definiuje kształt opony jako profil boczny, który jest symetryczny względem osi opony. Wizualizacja tego kształtu przypominałaby krzywą, która jest szeroka na zewnątrz, ale zwęża się do środka opony.

[SHAPE]
{radial width}
 1.0    0.0
 1.0    0.4
 1.0    0.9
 0.9    1.0

Parametry pionowe

• VERTICAL_STIFFNESS = Sztywność pionowa opony.
• VERTICAL_DAMPING = Tłumienie pionowe opony.
• BREFF = Parametr BREFF opony.
• DREFF = Parametr DREFF opony.
• FREFF = Parametr FREFF opony.
• FNOMIN = Nominalna siła F opony.

[VERTICAL]
VERTICAL_STIFFNESS        = +8.600e+004    $typarr( 15)
VERTICAL_DAMPING          = +3.885e+003    $typarr( 16)
BREFF                     = +3.811E+000    $typarr( 11)
DREFF                     = +4.088e-001    $typarr( 12)
FREFF                     = +3.564e-002    $typarr( 13)
FNOMIN                    = +8.000e+002    $typarr( 14)

Zakresy

Sekcja: LONG_SLIP_RANGE

KPUMIN = -0.250e+000    $typarr( 23)
KPUMAX = +0.250e+000    $typarr( 24)

• KPUMIN = Minimalna wartość długotrwałego poślizgu (KPU) dla opony.
• KPUMAX = Maksymalna wartość długotrwałego poślizgu (KPU) dla opony.

Sekcja: SLIP_ANGLE_RANGE

ALPMIN = -2.094e-001    $typarr( 25)
ALPMAX = +2.094e-001    $typarr( 26)

• ALPMIN = Minimalny kąt poślizgu (ALP) dla opony.
• ALPMAX = Maksymalny kąt poślizgu (ALP) dla opony.

Sekcja: INCLINATION_ANGLE_RANGE

CAMMIN = -1.047e-001    $typarr( 27)
CAMMAX = +1.047e-001    $typarr( 28)

• CAMMIN = Minimalny kąt nachylenia (CAM) dla opony.
• CAMMAX = Maksymalny kąt nachylenia (CAM) dla opony.

Sekcja: VERTICAL_FORCE_RANGE

FZMIN = +2.286e+002    $typarr( 21)
FZMAX = +1.600e+003    $typarr( 22)

• FZMIN = Minimalna siła pionowa (FZ) dla opony.
• FZMAX = Maksymalna siła pionowa (FZ) dla opony.

Współczynniki

Współczynniki skalujące

LFZO  = 1  # Współczynnik skalowania nominalnego (ocenianego) obciążenia
LCX   = 1  # Współczynnik skalowania kształtu Fx
LMUX  = 1  # Współczynnik skalowania szczytowego współczynnika tarcia Fx
LEX   = 1  # Współczynnik skalowania czynnika krzywizny Fx
LKX   = 1  # Współczynnik skalowania sztywności poślizgu Fx
LHX   = 0  # Współczynnik skalowania przesunięcia poziomego Fx
LVX   = 0  # Współczynnik skalowania przesunięcia pionowego Fx
LGAX  = 1  # Współczynnik skalowania skrętu dla Fx
LCY   = 1  # Współczynnik skalowania kształtu Fy
LMUY  = 1  # Współczynnik skalowania szczytowego współczynnika tarcia Fy
LEY   = 1  # Współczynnik skalowania czynnika krzywizny Fy
LKY   = 1  # Współczynnik skalowania sztywności skrętnej Fy
LHY   = 0  # Współczynnik skalowania przesunięcia poziomego Fy
LVY   = 0  # Współczynnik skalowania przesunięcia pionowego Fy
LGAY  = 1  # Współczynnik skalowania skrętu dla Fy
LTR   = 1  # Współczynnik skalowania szczytu śladu pneumatycznego
LRES  = 0  # Współczynnik skalowania przesunięcia momentu resztkowego
LGAZ  = 1  # Współczynnik skalowania skrętu dla Mz
LXAL  = 1  # Współczynnik skalowania wpływu alfa na Fx
LYKA  = 1  # Współczynnik skalowania wpływu alfa na Fy
LVYKA = 1  # Współczynnik skalowania Fy indukowanego przez kappę
LS    = 1  # Współczynnik skalowania ramienia momentu Fx
LSGKP = 1  # Nie zdefiniowano
LSGAL = 1  # Nie zdefiniowano
LGYR  = 1  # Nie zdefiniowano
LMX   = 1  # Współczynnik skalowania momentu wywracającego
LVMX  = 0  # Współczynnik skalowania przesunięcia pionowego Mx
LMY   = 1  # Współczynnik skalowania momentu oporu toczenia  

Współczynniki w płaszczyźnie wzdłużnej i poprzecznej

Współczynniki w płaszczyźnie wzdłużnej opisują zachowanie opony podczas poślizgu podłużnego, zarówno w stanie czystego poślizgu, jak i poślizgu łączonego.

[LONGITUDINAL_COEFFICIENTS]
% Współczynniki - poślizg podłużny (poślizg czysty)
PCX1 = +1.786E+000 $typarr(61) % Współczynnik kształtu Cfx dla siły podłużnej
PDX1 = +2.933E+000 $typarr(62) % Tarcie podłużne Mux przy Fznom
PDX2 = -4.400E-001 $typarr(63) % Zmienność tarcia Mux z obciążeniem
PDX3 = +2.080E+001 $typarr(60) % Zmienność tarcia Mux z pochyleniem
PEX1 = +8.710E-001 $typarr(64) % Krzywizna podłużna Efx przy Fznom
PEX2 = -3.800E-002 $typarr(65) % Zmienność krzywizny Efx z obciążeniem
PEX3 = +0.000E+000 $typarr(66) % Zmienność krzywizny Efx z kwadratem obciążenia
PEX4 = +7.100E-002 $typarr(67) % Czynnik w krzywiznie Efx podczas jazdy
PKX1 = +8.531E+001 $typarr(68) % Sztywność poślizgu podłużnego Kfx/Fz przy Fznom
PKX2 = -2.025E+001 $typarr(69) % Zmienność sztywności poślizgu Kfx/Fz z obciążeniem
PKX3 = +5.000E-001 $typarr(70) % Wykładnik w sztywności poślizgu Kfx/Fz z obciążeniem
PHX1 = +0.000E+000 $typarr(71) % Przesunięcie poziome Shx przy Fznom
PHX2 = +0.000E+000 $typarr(72) % Zmienność przesunięcia Shx z obciążeniem
PVX1 = +0.000E+000 $typarr(73) % Przesunięcie pionowe Svx/Fz przy Fznom
PVX2 = +0.000E+000 $typarr(74) % Zmienność przesunięcia Svx/Fz z obciążeniem

% Współczynniki - poślizg podłużny (poślizg łączony)
RBX1 = +2.372E+001 $typarr(75) % Czynnik nachylenia dla redukcji Fx poślizgu łączonego
RBX2 = +2.597E+001 $typarr(76) % Zmienność nachylenia redukcji Fx z kappa
RCX1 = +7.495E-001 $typarr(77) % Czynnik kształtu dla redukcji Fx poślizgu łączonego
REX1 = -4.759E-001 $typarr(82) % Czynnik krzywizny łączonego Fx
REX2 = +8.109E-001 $typarr(83) % Czynnik krzywizny łączonego Fx z obciążeniem
RHX1 = +0.000E+000 $typarr(78) % Czynnik przesunięcia dla redukcji Fx poślizgu łączonego

Współczynniki w płaszczyźnie poprzecznej opisują zachowanie opony podczas poślizgu poprzecznego, zarówno w stanie czystego poślizgu, jak i poślizgu łączonego.

[LATERAL_COEFFICIENTS]
% Współczynniki - poślizg poprzeczny (poślizg czysty)
PCY1 = +1.725E+000 $typarr(91) % Współczynnik kształtu Cfx dla siły podłużnej
PDY1 = +2.733E+000 $typarr(92) % Tarcie podłużne Mux przy Fznom
PDY2 = -6.022E-001 $typarr(93) % Zmienność tarcia Mux z obciążeniem
PDY3 = +4.007E+000 $typarr(94) % Zmienność tarcia Mux z pochyleniem
PEY1 = -5.000E-001 $typarr(95) % Krzywizna podłużna Efx przy Fznom
PEY2 = -2.000E+000 $typarr(96) % Zmienność krzywizny Efx z obciążeniem
PEY3 = +2.260E-001 $typarr(97) % Zmienność krzywizny Efx z kwadratem obciążenia
PEY4 = -3.367E-002 $typarr(98) % Czynnik w krzywiznie Efx podczas jazdy
PKY1 = -5.047E+001 $typarr(99) % Sztywność poślizgu podłużnego Kfx/Fz przy Fznom
PKY2 = +1.923E+000 $typarr(100) % Zmienność sztywności poślizgu Kfx/Fz z obciążeniem
PKY3 = +2.877E-001 $typarr(101) % Wykładnik w sztywności poślizgu Kfx/Fz z obciążeniem
PHY1 = +0.000E+000 $typarr(102) % Przesunięcie poziome Shx przy Fznom
PHY2 = +0.000E+000 $typarr(103) % Zmienność przesunięcia Shx z obciążeniem
PHY3 = -1.810E-002 $typarr(104) % Zmienność przesunięcia Shx z obciążeniem
PVY1 = +0.000E+000 $typarr(105) % Przesunięcie pionowe Svx/Fz przy Fznom
PVY2 = +0.000E+000 $typarr(106) % Zmienność przesunięcia Svx/Fz z obciążeniem
PVY3 = -2.649E+000 $typarr(107) % Przesunięcie pionowe Svx/Fz przy Fznom
PVY4 = -1.058E+000 $typarr(108) % Zmienność przesunięcia Svx/Fz z obciążeniem

% Współczynniki - poślizg poprzeczny (poślizg łączony)
RBY1 = +2.033E+001 $typarr(109) % Czynnik nachylenia dla redukcji Fx poślizgu łączonego
RBY2 = +8.152E+000 $typarr(110) % Zmienność nachylenia redukcji Fx z kappa
RBY3 = -1.243E-002 $typarr(111) % Zmienność nachylenia redukcji Fx z kappa
RCY1 = +9.317E-001 $typarr(112) % Czynnik kształtu dla redukcji Fx poślizgu łączonego
REY1 = -3.982E-004 $typarr(113) % Czynnik krzywizny łączonego Fx
REY2 = +3.077E-001 $typarr(114) % Czynnik krzywizny łączonego Fx z obciążeniem
RHY1 = +0.000E+000 $typarr(115) % Czynnik przesunięcia dla redukcji Fx poślizgu łączonego
RHY2 = +0.000E+000 $typarr(116) % Czynnik przesunięcia dla redukcji Fx poślizgu łączonego
RVY1 = +0.000E+000 $typarr(117) % Czynnik przesunięcia dla redukcji Fx poślizgu łączonego
RVY2 = +0.000E+000 $typarr(118) % Czynnik przesunięcia dla redukcji Fx poślizgu łączonego
RVY3 = +0.000E+000 $typarr(119) % Czynnik przesunięcia dla redukcji Fx poślizgu łączonego
RVY4 = +0.000E+000 $typarr(120) % Czynnik przesunięcia dla redukcji Fx poślizgu łączonego
RVY5 = +0.000E+000 $typarr(121) % Czynnik przesunięcia dla redukcji Fx poślizgu łączonego
RVY6 = +0.000E+000 $typarr(122) % Czynnik przesunięcia dla redukcji Fx poślizgu łączonego
PTY1 = +3.260e+000 $typarr(123) % Czynnik przesunięcia dla redukcji Fx poślizgu łączonego
PTY2 = +2.250e+000 $typarr(124) % Czynnik przesunięcia dla redukcji Fx poślizgu łączonego

Współczynniki toczenia

QSY1 				= -3.090E-002			$typarr(126)
QSY2 				= -9.210E-002			$typarr(127)
QSY3 				= +0.000e+000			$typarr(128)
QSY4 				= +0.000e+000			$typarr(129)

Współczynniki nadsterowności (overturning)

QSX1 				= +0.000E+000			$typarr( 86)
QSX2 				= +1.269E+000			$typarr( 87)
QSX3 				= -2.807E-003			$typarr( 88)

Współczynniki korygujące (aligning)

QBZ1				= +6.895E+000			$typarr(131)
QBZ2				= +2.394E+000			$typarr(132)
QBZ3				= -3.945E+000			$typarr(133)
QBZ4				= +0.000E+000			$typarr(134)
QBZ5				= -1.369E-003			$typarr(135)
QBZ9				= +2.684E-007			$typarr(136)
QBZ10				= +1.994E+000			$typarr(130)
QCZ1				= +1.139E+000			$typarr(137)
QDZ1				= +1.396E-001			$typarr(138)
QDZ2				= -1.797E-002			$typarr(139)
QDZ3				= +0.000E+000			$typarr(140)
QDZ4				= -9.072E+000			$typarr(141)
QDZ6				= -2.000E-001			$typarr(142)
QDZ7				= +5.000E-001			$typarr(143)
QDZ8				= -1.406E+000			$typarr(144)
QDZ9				= +4.252E-001			$typarr(145)
QEZ1				= -9.783E+000			$typarr(146)
QEZ2				= +8.208E+000			$typarr(147)
QEZ3				= -2.000E+001			$typarr(148)
QEZ4				= -1.832E-001			$typarr(149)
QEZ5				= -6.352E+000			$typarr(150)
QHZ1				= +0.000E+000			$typarr(151)
QHZ2				= +0.000E+000			$typarr(152)
QHZ3				= +1.186E-001			$typarr(153)
QHZ4				= -5.376E-002			$typarr(154)
SSZ1				= +0.000E+000			$typarr(155)
SSZ2				= +4.650E-003			$typarr(156)
SSZ3				= -1.530E+000			$typarr(157)
SSZ4				= +0.000E+000			$typarr(158)
QTZ1				= +1.000E+000			$typarr(159)
MBELT				= +2.700E+000			$typarr(160)

Niestety nie znaleziono objaśnień dla współczynników toczenia, nadsterowności i korygujących.

Obliczenia poślizgów

Poślizg łączony w kierunku wzdłużnym

SHXA = RHX1;        
ALPHAS = ALPHA + SHXA;  
BXA = (RBX1 + RBX3 .* GAMMA^2) .* cos(atan(RBX2 .* KAPPA)) .* LXAL;
CXA = RCX1;
EXA = REX1 + REX2 * DFZ;
GXA0 = cos(CXA .* atan(BXA .* ALPHAS - EXA .* (BXA .* ALPHAS - atan(BXA .* ALPHAS))));
GXA = GXA0 ./ cos(CXA .*atan(BXA .* SHXA - EXA .* (BXA .* SHXA - atan(BXA .* SHXA))));

FX = FX0 .* GXA;    

SHXA = RHX1;
Ustawienie przesunięcia poziomego SHXA na wartość współczynnika RHX1, który opisuje przesunięcie poziome dla redukcji siły Fx przy poślizgu łączonym.

ALPHAS = ALPHA + SHXA;
Korekta kąta poślizgu (ALPHA) o przesunięcie poziome (SHXA), dając skorygowany kąt poślizgu ALPHAS.

BXA = (RBX1 + RBX3 .* GAMMA^2) .* cos(atan(RBX2 .* KAPPA)) .* LXAL;
Obliczenie BXA, czynnika nachylenia dla redukcji siły Fx przy poślizgu łączonym, z uwzględnieniem kąta nachylenia GAMMA, poślizgu KAPPA oraz współczynnika skalowania LXAL, wpływającego na Fx zależnie od kąta alfa.

CXA = RCX1;
Ustawienie CXA na wartość współczynnika RCX1, który określa kształt funkcji redukcji siły Fx przy poślizgu łączonym.

EXA = REX1 + REX2 * DFZ;
Obliczenie EXA, czynnika krzywizny łączonego Fx, z uwzględnieniem zmiany obciążenia pionowego opony DFZ.

GXA0 = cos(CXA .* atan(BXA .* ALPHAS - EXA .* (BXA .* ALPHAS - atan(BXA .* ALPHAS))));
Obliczenie GXA0, pierwotnej wartości funkcji kształtu siły Fx, na podstawie skorygowanego kąta poślizgu ALPHAS, czynnika nachylenia BXA, kształtu funkcji CXA i czynnika krzywizny EXA.

GXA = GXA0 ./ cos(CXA .*atan(BXA .* SHXA - EXA .* (BXA .* SHXA - atan(BXA .* SHXA))));
Normalizacja GXA0 poprzez podzielenie przez wartość korygującą, aby uwzględnić przesunięcie poziome SHXA w obliczeniach, dając końcową wartość funkcji kształtu siły Fx GXA.

FX = FX0 .* GXA;
Obliczenie końcowej siły poślizgu podłużnego FX, mnożąc pierwotną siłę podłużną FX0 przez funkcję kształtu GXA.

Czysty poślizg w kierunku wzdłużnym

GAMMAX = GAMMA .* LGAX;
SHX = (PHX1 + PHX2 .* DFZ) .* LHX;
KAPPAX = KAPPA + SHX;
CX = PCX1 .* LCX;
MUX = (PDX1 + PDX2 .* DFZ) .* (1 - PDX3 .* GAMMAX.^2) .* LMUX;
DX = MUX .* Fz;
EX = (PEX1 + PEX2 .* DFZ + PEX3 .* DFZ.^2) .* (1 - PEX4 .* sign(KAPPAX)) .* LEX;
KX = Fz .* (PKX1 + PKX2 .* DFZ) .* exp(PKX3 .* DFZ) .* LKX;
BX = KX ./ (CX .* DX);
SVX = Fz .* (PVX1 + PVX2 .* DFZ) .* LVX .* LMUX;

FX0 = DX .* sin(CX .* atan(BX .* KAPPAX - EX .* (BX .* KAPPAX - atan(BX .* KAPPA)))) + SVX;

FX = FX0;

GAMMAX = GAMMA .* LGAX;
Korekta kąta nachylenia GAMMA przez współczynnik skalowania LGAX, dając skorygowany kąt nachylenia GAMMAX.

SHX = (PHX1 + PHX2 .* DFZ) .* LHX;
Obliczenie przesunięcia poziomego SHX w oparciu o zmianę obciążenia pionowego DFZ i współczynnik skalowania LHX, uwzględniając podstawowe przesunięcie PHX1 i jego zmienność z DFZ (PHX2).

KAPPAX = KAPPA + SHX;
Korekta poślizgu KAPPA o przesunięcie poziome SHX, dając skorygowany poślizg KAPPAX.

CX = PCX1 .* LCX;
Ustawienie sztywności kształtu CX na podstawie podstawowego współczynnika PCX1 i współczynnika skalowania LCX.

MUX = (PDX1 + PDX2 .* DFZ) .* (1 - PDX3 .* GAMMAX.^2) .* LMUX;
Obliczenie szczytowego współczynnika tarcia MUX z uwzględnieniem zmiany obciążenia pionowego DFZ, skorygowanego kąta nachylenia GAMMAX, oraz współczynnika skalowania LMUX.

DX = MUX .* Fz;
Obliczenie siły podstawowej DX jako produkt szczytowego współczynnika tarcia MUX i obciążenia pionowego Fz.

EX = (PEX1 + PEX2 .* DFZ + PEX3 .* DFZ.^2) .* (1 - PEX4 .* sign(KAPPAX)) .* LEX;
Obliczenie czynnika krzywizny EX, uwzględniając zmianę obciążenia pionowego DFZ, znak skorygowanego poślizgu KAPPAX i współczynnik skalowania LEX.

KX = Fz .* (PKX1 + PKX2 .* DFZ) .* exp(PKX3 .* DFZ) .* LKX;
Obliczenie sztywności poślizgu KX jako funkcji obciążenia pionowego Fz, zmiany obciążenia DFZ i współczynnika skalowania LKX.

BX = KX ./ (CX .* DX);
Obliczenie sztywności kształtu BX jako stosunek sztywności poślizgu KX do iloczynu sztywności kształtu CX i siły podstawowej DX.

SVX = Fz .* (PVX1 + PVX2 .* DFZ) .* LVX .* LMUX;
Obliczenie przesunięcia pionowego SVX jako funkcji obciążenia pionowego Fz, zmiany obciążenia DFZ, współczynnika skalowania LVX oraz wpływu szczytowego współczynnika tarcia LMUX.

FX0 = DX .* sin(CX .* atan(BX .* KAPPAX - EX .* (BX .* KAPPAX - atan(BX .* KAPPA)))) + SVX;
Obliczenie siły poślizgu podłużnego FX0 z uwzględnieniem podstawowej siły DX, czynnika kształtu CX, sztywności kształtu BX, skorygowanego poślizgu KAPPAX, czynnika krzywizny EX oraz przesunięcia pionowego SVX.

FX = FX0;
Przypisanie ostatecznej wartości siły poślizgu podłużnego FX na podstawie obliczonej wartości FX0.

Poślizg łączony w kierunku poprzecznym

SHYK = RHY1 + RHY2 .* DFZ;       
KAPPAS = KAPPA + SHYK;
BYK = RBY1 .* cos(atan(RBY2 .* (ALPHA - RBY3))) .* LYKA;
CYK = RCY1;
EYK = REY1 + REY2 * DFZ;
DYK = FY0 ./ (cos(CYK .* atan(BYK .* SHYK - EYK .* (BYK .* SHYK - atan(BYK .* SHYK)))));
DVYK = MUY .* Fz .* (RVY1 + RVY2 .* DFZ + RVY3 .* GAMMA) .* cos(atan(RVY4 .* ALPHA));
SVYK = DVYK .* sin(RVY5 .* atan(RVY6 .* KAPPA)) .* LVYKA;
GYK0 = cos(CYK .* atan(BYK .* KAPPAS - EYK .* (BYK .* KAPPAS - atan(BYK .* KAPPAS))));
GYK = GYK0 ./ (cos(CYK .* atan(BYK .* SHYK - EYK .* (BYK .* SHYK - atan(BYK .* SHYK)))));

FY = FY0 .* GYK + SVYK;

SHYK = RHY1 + RHY2 .* DFZ;
Obliczenie przesunięcia poziomego SHYK na podstawie zmiany obciążenia pionowego DFZ i stałych RHY1 oraz RHY2.

KAPPAS = KAPPA + SHYK;
Korekta poślizgu KAPPA o przesunięcie poziome SHYK, dając skorygowany poślizg KAPPAS.

BYK = RBY1 .* cos(atan(RBY2 .* (ALPHA - RBY3))) .* LYKA;
Obliczenie współczynnika kształtu BYK dla bocznej siły poślizgu, uwzględniając kąt poślizgu ALPHA i współczynnik skalowania LYKA, który wpływa na relację między kątem poślizgu a siłą boczną.

CYK = RCY1;
Ustawienie wartości sztywności kształtu CYK na stałą RCY1.

EYK = REY1 + REY2 * DFZ;
Obliczenie czynnika krzywizny EYK w oparciu o zmianę obciążenia pionowego DFZ i stałe REY1 oraz REY2.

DYK = FY0 ./ (cos(CYK .* atan(BYK .* SHYK - EYK .* (BYK .* SHYK - atan(BYK .* SHYK)))));
Obliczenie siły podstawowej DYK dla bocznej siły poślizgu, korzystając z podstawowej wartości siły bocznej FY0 i korygując ją o czynniki kształtu BYK, sztywności CYK oraz krzywizny EYK.

DVYK = MUY .* Fz .* (RVY1 + RVY2 .* DFZ + RVY3 .* GAMMA) .* cos(atan(RVY4 .* ALPHA));
Obliczenie wartości pionowego przesunięcia DVYK na podstawie szczytowego współczynnika tarcia MUY, obciążenia pionowego Fz, zmiany obciążenia DFZ, kąta nachylenia GAMMA i kąta poślizgu ALPHA.

SVYK = DVYK .* sin(RVY5 .* atan(RVY6 .* KAPPA)) .* LVYKA;
Obliczenie dodatkowego składnika siły bocznej SVYK, który jest funkcją przesunięcia pionowego DVYK, poślizgu KAPPA oraz współczynnika skalowania LVYKA, wpływającego na siłę boczną indukowaną przez poślizg.

GYK0 = cos(CYK .* atan(BYK .* KAPPAS - EYK .* (BYK .* KAPPAS - atan(BYK .* KAPPAS))));
Obliczenie pierwotnej wartości funkcji kształtu siły bocznej GYK0, na podstawie korygowanego poślizgu KAPPAS, czynnika kształtu BYK, sztywności CYK oraz krzywizny EYK.

GYK = GYK0 ./ (cos(CYK .* atan(BYK .* SHYK - EYK .* (BYK .* SHYK - atan(BYK .* SHYK)))));
Normalizacja GYK0 przez podzielenie przez korektę, aby uwzględnić przesunięcie poziome SHYK w obliczeniach, dając końcową wartość funkcji kształtu siły bocznej GYK.

FY = FY0 .* GYK + SVYK;
Obliczenie końcowej bocznej siły poślizgu FY, mnożąc podstawową siłę boczną FY0 przez funkcję kształtu GYK i dodając składnik przesunięcia pionowego SVYK.

Czysty poślizg w kierunku poprzecznym

GAMMAY = GAMMA .* LGAY;
SHY = (PHY1 + PHY2 .* DFZ) .* LHY + PHY3 .* GAMMAY;
ALPHAY = ALPHA + SHY;
CY = PCY1 .* LCY;
MUY = (PDY1 + PDY2 .* DFZ) .* (1 - PDY3 .* GAMMAY.^2) .* LMUY;
DY = MUY .* Fz;
EY = (PEY1 + PEY2 .* DFZ) .* (1 - (PEY3 + PEY4 .* GAMMAY) .* sign(ALPHAY)) .* LEY;
KY = PKY1 .* FZ0 .* sin(2 * atan(Fz ./ (PKY2 .* FZ0 .* LFZO))) .* (1 - PKY3 .* abs(GAMMAY)) .* LFZO .* LKY;
BY = KY ./ (CY .* DY);
SVY = Fz .* ((PVY1 + PVY2 .* DFZ) .* LVY + (PVY3 + PVY4 .* DFZ) .* GAMMAY) .* LMUY;

FY0 = DY .* sin(CY .* atan(BY .* ALPHAY - EY .* (BY .* ALPHAY - atan(BY .* ALPHAY)))) + SVY;

FY = FY0;

GAMMAY = GAMMA .* LGAY;
Skorygowany kąt nachylenia GAMMAY, który uwzględnia współczynnik skalowania LGAY.

SHY = (PHY1 + PHY2 .* DFZ) .* LHY + PHY3 .* GAMMAY;
Przesunięcie poziome SHY, które uwzględnia zmianę obciążenia pionowego (DFZ), skorygowany kąt nachylenia (GAMMAY), oraz współczynniki skalowania LHY i PHY3.

ALPHAY = ALPHA + SHY;
Skorygowany kąt poślizgu ALPHAY, który uwzględnia przesunięcie poziome SHY.

CY = PCY1 .* LCY;
Sztywność kształtu CY, obliczona na podstawie współczynnika PCY1 i współczynnika skalowania LCY.

MUY = (PDY1 + PDY2 .* DFZ) .* (1 - PDY3 .* GAMMAY.^2) .* LMUY;
Szczytowy współczynnik tarcia MUY, który uwzględnia zmianę obciążenia pionowego (DFZ), skorygowany kąt nachylenia (GAMMAY), oraz współczynnik skalowania LMUY.

DY = MUY .* Fz;
Podstawowa siła DY, obliczona jako produkt szczytowego współczynnika tarcia MUY i obciążenia pionowego Fz.

EY = (PEY1 + PEY2 .* DFZ) .* (1 - (PEY3 + PEY4 .* GAMMAY) .* sign(ALPHAY)) .* LEY;
Czynnik krzywizny EY, który uwzględnia zmianę obciążenia pionowego (DFZ), skorygowany kąt nachylenia (GAMMAY), znak skorygowanego kąta poślizgu (ALPHAY), oraz współczynnik skalowania LEY.

KY = PKY1 .* FZ0 .* sin(2 * atan(Fz ./ (PKY2 .* FZ0 .* LFZO))) .* (1 - PKY3 .* abs(GAMMAY)) .* LFZO .* LKY;
Sztywność KY, obliczona na podstawie nominalnego obciążenia pionowego FZ0, obciążenia pionowego Fz, skorygowanego kąta nachylenia (GAMMAY), oraz współczynników skalowania LFZO i LKY.

BY = KY ./ (CY .* DY);
Stosunek sztywności BY, obliczony jako stosunek sztywności KY do iloczynu sztywności kształtu CY i podstawowej siły DY.

SVY = Fz .* ((PVY1 + PVY2 .* DFZ) .* LVY + (PVY3 + PVY4 .* DFZ) .* GAMMAY) .* LMUY;
Przesunięcie pionowe SVY, które uwzględnia obciążenie pionowe Fz, zmianę obciążenia pionowego (DFZ), skorygowany kąt nachylenia (GAMMAY), oraz współczynniki skalowania LVY i LMUY.

FY0 = DY .* sin(CY .* atan(BY .* ALPHAY - EY .* (BY .* ALPHAY - atan(BY .* ALPHAY)))) + SVY;
Podstawowa siła boczna FY0, obliczona jako suma siły DY pomnożonej przez funkcję trygonometryczną, która uwzględnia sztywność kształtu CY, stosunek sztywności BY, skorygowany kąt poślizgu ALPHAY, czynnik krzywizny EY, oraz przesunięcie pionowe SVY.

FY = FY0;
Przypisanie ostatecznej wartości siły bocznej FY na podstawie obliczonej wartości FY0.

Poślizg Alfa w kierunku poprzecznym (czysty)

GAMMAY = GAMMA .* LGAY;
SHY = (PHY1 + PHY2 .* DFZ) .* LHY + PHY3 .* GAMMAY;
ALPHAY = ALPHA + SHY;
CY = PCY1 .* LCY;
MUY = (PDY1 + PDY2 .* DFZ) .* (1 - PDY3 .* GAMMAY.^2) .* LMUY;
DY = MUY .* Fz;
EY = (PEY1 + PEY2 .* DFZ) .* (1 - (PEY3 + PEY4 .* GAMMAY) .* sign(ALPHAY)) .* LEY;
KY = PKY1 .* FZ0 .* sin(2 * atan(Fz ./ (PKY2 .* FZ0 .* LFZO))) .* (1 - PKY3 .* abs(GAMMAY)) .* LFZO .* LKY;
BY = KY ./ (CY .* DY);
SVY = Fz .* ((PVY1 + PVY2 .* DFZ) .* LVY + (PVY3 + PVY4 .* DFZ) .* GAMMAY) .* LMUY;

FY0 = DY .* sin(CY .* atan(BY .* ALPHAY - EY .* (BY .* ALPHAY - atan(BY .* ALPHAY)))) + SVY;

FY = FY0;

GAMMAY = GAMMA .* LGAY;
Dostosowuje kąt nachylenia (GAMMA) przez współczynnik skalowania (LGAY), aby uwzględnić wpływ nachylenia na generowanie siły bocznej.

SHY = (PHY1 + PHY2 .* DFZ) .* LHY + PHY3 .* GAMMAY;
Oblicza poziome przesunięcie (SHY) krzywej siły bocznej spowodowane zmianą obciążenia pionowego (DFZ) i kątem nachylenia (GAMMAY), wykorzystując współczynniki skalowania LHY i PHY3.

ALPHAY = ALPHA + SHY;
Dostosowuje kąt poślizgu (ALPHA) o obliczone poziome przesunięcie (SHY), uwzględniając zmieniony efektywny kąt poślizgu ze względu na zmiany obciążenia i nachylenia.

CY = PCY1 .* LCY;
Określa współczynnik kształtu (CY) dla siły bocznej, uwzględniając podstawową wartość (PCY1) i współczynnik skalowania (LCY).

MUY = (PDY1 + PDY2 .* DFZ) .* (1 - PDY3 .* GAMMAY.^2) .* LMUY;
Oblicza szczytowy współczynnik tarcia (MUY) dla siły bocznej, uwzględniając zmianę obciążenia pionowego (DFZ), kwadrat kąta nachylenia (GAMMAY^2) i współczynnik skalowania LMUY.

DY = MUY .* Fz;
Oblicza podstawową siłę boczną (DY) poprzez pomnożenie szczytowego współczynnika tarcia (MUY) przez obciążenie pionowe (Fz).

EY = (PEY1 + PEY2 .* DFZ) .* (1 - (PEY3 + PEY4 .* GAMMAY) .* sign(ALPHAY)) .* LEY;
Określa czynnik krzywizny (EY) dla krzywej siły bocznej, biorąc pod uwagę zmianę obciążenia pionowego (DFZ), kąt nachylenia (GAMMAY), znak dostosowanego kąta poślizgu (ALPHAY) oraz współczynnik skalowania LEY.

KY = PKY1 .* FZ0 .* sin(2 * atan(Fz ./ (PKY2 .* FZ0 .* LFZO))) .* (1 - PKY3 .* abs(GAMMAY)) .* LFZO .* LKY;
Oblicza sztywność przy skręcaniu (KY), uwzględniając nominalne obciążenie pionowe (FZ0), rzeczywiste obciążenie pionowe (Fz), kąt nachylenia (GAMMAY) oraz współczynniki skalowania LFZO i LKY.

BY = KY ./ (CY .* DY);
Określa współczynnik sztywności (BY) dla krzywej siły bocznej na podstawie sztywności przy skręcaniu (KY), współczynnika kształtu (CY) i podstawowej siły bocznej (DY).

SVY = Fz .* ((PVY1 + PVY2 .* DFZ) .* LVY + (PVY3 + PVY4 .* DFZ) .* GAMMAY) .* LMUY;
Oblicza pionowe przesunięcie (SVY) krzywej siły bocznej ze względu na zmianę obciążenia pionowego (DFZ), kąt nachylenia (GAMMAY) i współczynniki skalowania LVY i LMUY.

FY0 = DY .* sin(CY .* atan(BY .* ALPHAY - EY .* (BY .* ALPHAY - atan(BY .* ALPHAY)))) + SVY;
Oblicza początkową siłę boczną (FY0) jako sumę siły (DY) pomnożonej przez funkcję trygonometryczną, uwzględniającą współczynnik kształtu (CY), współczynnik sztywności (BY), dostosowany kąt poślizgu (ALPHAY), czynnik krzywizny (EY) oraz pionowe przesunięcie (SVY).

FY = FY0;
Przypisuje końcową wartość siły bocznej (FY) na podstawie obliczonej wartości początkowej (FY0).

Obliczanie sił poprzecznych

Plik calculateLatTireforces.m zawiera funkcję służącą do obliczania maksymalnych sił bocznych (poprzecznych), które mogą być przenoszone przez opony pojazdu. Stworzona przez Erica Dorniedena z zespołu Baltic Racing, funkcja ta jest chroniona prawami autorskimi tej organizacji z roku 2021.

Obliczanie sił

Funkcja calculateLatTireforces przyjmuje jako argumenty siły pionowe działające na poszczególne koła pojazdu (FWZ_vl, FWZ_vr, FWZ_hl, FWZ_hr), kąt nachylenia opony względem podłoża (GAMMA), parametry opony (TIRparam), a także początkowe kąty poślizgu dla opon przednich (alpha_f) i tylnych (alpha_r). Zwraca maksymalne siły boczne dla każdego koła (FWYmax_fl, FWYmax_fr, FWYmax_rl, FWYmax_rr), całkowite siły boczne dla osi przedniej i tylnej (FWYmax_f, FWYmax_r), oraz obliczone kąty poślizgu dla opon przednich i tylnych (alpha_f, alpha_r).

Główna funkcja

W zależności od liczby argumentów, funkcja używa dwóch różnych metod obliczania sił bocznych:

1. Dla ośmiu argumentów, obliczenia są bezpośrednie, wykorzystując funkcję MF52_Fy_cs do określenia maksymalnej siły bocznej dla każdej opony:

   FWYmax_fl = max(abs(MF52_Fy_cs(alpha_f,FWZ_vl,GAMMA,0,TIRparam)));
   

2. Gdy liczba argumentów jest mniejsza niż osiem, funkcja przeprowadza iteracyjne obliczenia dla zakresu kątów poślizgu od 0 do 12 stopni (co 0,025 stopnia), wybierając wartość maksymalną i odpowiadający jej kąt poślizgu dla każdej opony:

   x = 0:0.025:12; % Zakres kątów poślizgu [deg]
   [FWYmax_fl, index] = max(abs(MF52_Fy_cs(x,FWZ_vl,GAMMA,0,TIRparam)));
   alpha_fl = x(index);
   

Wynikowe Siły Osi

Na koniec, funkcja sumuje siły boczne dla opon położonych po tej samej stronie osi, aby uzyskać całkowitą siłę boczną, jaką może przenieść oś przednia i tylna:

FWYmax_f = FWYmax_fl + FWYmax_fr; % [N] Maksymalna siła boczna osi przedniej

Obliczanie sił wzdłużnych

Plik calculateLongiTireforces.m zawiera funkcję do obliczania maksymalnych sił podłużnych, które mogą być przenoszone przez opony pojazdu. Autorem kodu jest Eric Dornieden z zespołu Baltic Racing, a prawa autorskie należą do Baltic Racing z 2021 roku.

Główna Funkcja

Funkcja calculateLongiTireforces akceptuje jako argumenty wejściowe siły pionowe działające na każde koło pojazdu (FWZ_vl, FWZ_vr, FWZ_hl, FWZ_hr), kąt nachylenia opony (GAMMA), parametry opon (TIRparam) oraz kąty poślizgu dla opon przednich (alpha_f) i tylnych (alpha_r). Funkcja zwraca maksymalne siły podłużne dla każdej z opon (FWXmax_fl, FWXmax_fr, FWXmax_rl, FWXmax_rr) oraz sumaryczne maksymalne siły podłużne dla osi przedniej i tylnej (FWXmax_f, FWXmax_r).

Obliczanie Sił

Funkcja wykorzystuje różne metody obliczania maksymalnych sił podłużnych w zależności od liczby przekazanych argumentów:

1. Dla ośmiu argumentów funkcja bezpośrednio oblicza maksymalną siłę podłużną dla każdej opony, używając funkcji MF52_Fx_cs, która prawdopodobnie modeluje siły opon na podstawie danych takich jak kąt poślizgu, obciążenie pionowe, kąt przechylenia i parametry opony:

   FWXmax_fl = max(abs(MF52_Fx_cs(alpha_f,FWZ_vl,GAMMA,0:0.01:0.2,TIRparam)));
   

2. Gdy liczba argumentów jest inna, funkcja zakłada kąt poślizgu równy zero i oblicza maksymalne siły podłużne dla każdej opony w oparciu o ten założony kąt poślizgu:

   FWXmax_fl = max(abs(MF52_Fx_cs(0,FWZ_vl,GAMMA,0:0.01:0.2,TIRparam)));
   

Wynikowe Siły Osi

Po obliczeniu maksymalnych sił podłużnych dla każdej opony, funkcja sumuje siły dla opon umieszczonych po tej samej stronie osi, aby określić całkowitą maksymalną siłę podłużną, którą może przenieść oś przednia i tylna:

FWXmax_f = FWXmax_fl + FWXmax_fr; % [N] Maksymalna siła podłużna osi przedniej  

Obciążenie dynamiczne w kierunku poprzecznym

Funkcja calculateWheelloadLatDisp oblicza przemieszczenie obciążenia koła w kierunku poprzecznym. Jest to kluczowy element w obliczaniu przeniesienia obciążenia koła.

Sygnatura funkcji

function [dFWZfl_y, dFWZfr_y, dFWZrl_y, dFWZrr_y, dFWZfl_geometric, dFWZfr_geometric, dFWZrl_geometric, dFWZrr_geometric, dFWZfl_elastic, dFWZfr_elastic, dFWZrl_elastic, dFWZrr_elastic] = calculateWheelloadLatDisp(h_COG, track_f, track_r, lr, lf, wheelbase, FVY, h_rc_f, h_rc_r)

Opis parametrów

• h_COG: Wysokość środka ciężkości pojazdu.
• track_f, track_r: Szerokość toru przedniego i tylnego koła.
• lr, lf: Odległość od tylnego i przedniego końca pojazdu do środka ciężkości.
• wheelbase: Rozstaw osi pojazdu.
• FVY: Siła boczna działająca na pojazd.
• h_rc_f, h_rc_r: Wysokość środka ciężkości przedniego i tylnego zawieszenia.

Opis działania

Funkcja oblicza przeniesienie obciążenia koła w kierunku poprzecznym na podstawie różnych parametrów pojazdu i sił działających na pojazd. Obliczenia są wykonywane dla każdego koła pojazdu.

1. Przeniesienie obciążenia geometryczne:

   dFWZfl_geometric = -lr/wheelbase*FVY*h_rc_f/track_f;        % [N] Geometryczne przeniesienie obciążenia dla koła przedniego lewego
   dFWZfr_geometric = lr/wheelbase*FVY*h_rc_f/track_f;         % [N] Geometryczne przeniesienie obciążenia dla koła przedniego prawego
   dFWZrl_geometric = -lf/wheelbase*FVY*h_rc_r/track_r;        % [N] Geometryczne przeniesienie obciążenia dla koła tylnego lewego
   dFWZrr_geometric = lf/wheelbase*FVY*h_rc_r/track_r;         % [N] Geometryczne przeniesienie obciążenia dla koła tylnego prawego
   

2. Przeniesienie obciążenia sprężyste:

   dFWZfl_elastic = -lr/wheelbase*FVY*(h_COG-h_rc_f)/track_f;  % [N] Elastyczne przeniesienie obciążenia dla koła przedniego lewego
   dFWZfr_elastic = lr/wheelbase*FVY*(h_COG-h_rc_f)/track_f;   % [N] Elastyczne przeniesienie obciążenia dla koła przedniego prawego
   dFWZrl_elastic = -lf/wheelbase*FVY*(h_COG-h_rc_r)/track_r;  % [N] Elastyczne przeniesienie obciążenia dla koła tylnego lewego
   dFWZrr_elastic = lf/wheelbase*FVY*(h_COG-h_rc_r)/track_r;   % [N] Elastyczne przeniesienie obciążenia dla koła tylnego prawego
   

3. Dynamiczne przeniesienie obciążenia:

   dFWZfl_y = dFWZfl_geometric + dFWZfl_elastic;               % [N] Przeciążenie dynamiczne koła przedniego lewego
   dFWZfr_y = dFWZfr_geometric + dFWZfr_elastic;               % [N] Przeciążenie dynamiczne koła przedniego prawego
   dFWZrl_y = dFWZrl_geometric + dFWZrl_elastic;               % [N] Przeciążenie dynamiczne koła tylnego lewego
   dFWZrr_y = dFWZrr_geometric + dFWZrr_elastic;               % [N] Przeciążenie dynamiczne koła tylnego prawego
   

Obciążenie dynamiczne w kierunku wzdłużnym

Funkcja calculateWheelloadLongDisp oblicza dynamiczne przemieszczenie obciążenia koła w kierunku podłużnym. Jest to kluczowy element w obliczaniu przeniesienia obciążenia koła.

Sygnatura funkcji

function [dFWZfl_x, dFWZfr_x, dFWZrl_x, dFWZrr_x] = calculateWheelloadLongDisp(h_COG, m_ges, aVX, wheelbase)

Opis parametrów

• h_COG: Wysokość środka ciężkości pojazdu.
• m_ges: Masa całkowita pojazdu.
• aVX: Przyspieszenie pojazdu w kierunku podłużnym.
• wheelbase: Rozstaw osi pojazdu.

Opis działania

Funkcja oblicza dynamiczne przeniesienie obciążenia koła w kierunku podłużnym na podstawie różnych parametrów pojazdu i sił działających na pojazd. Obliczenia są wykonywane dla każdego koła pojazdu.

dFWZfl_x = -m_ges*aVX*h_COG/wheelbase