Praca Inżynierska z Automatyki i Robotyki
Regulatory PID, roboty mobilne, manipulatory, systemy wizyjne – od modelu przez symulację po prototyp
Spis treści
Praca inżynierska z automatyki i robotyki – kompletny przewodnik
Kliknij w dowolną sekcję, aby przejść bezpośrednio do niej
Specyfika pracy inżynierskiej z automatyki i robotyki
Praca inżynierska z automatyki i robotyki to projekt praktyczny, który musi zawierać model matematyczny systemu, symulacje, projekt układu sterowania. W przeciwieństwie do prac czysto teoretycznych, tutaj liczy się przede wszystkim weryfikacja eksperymentalna i działanie w czasie rzeczywistym.
Co musi zawierać praca z automatyki i robotyki:
- Model matematyczny – Opis dynamiki systemu (równania różniczkowe, transmitancje, przestrzeń stanów)
- Projekt regulatora – PID, LQR, MPC lub inny algorytm sterowania
- Symulacje – MATLAB/Simulink, Python, Gazebo – weryfikacja przed budową
- Działający prototyp – Fizyczny robot, stanowisko, lub symulacja
- Pomiary i testy – Odpowiedzi skokowe, stabilność, dokładność, czas ustalania
- Kod sterownika – Firmware mikrokontrolera (C/C++) lub skrypt Python
Rodzaje projektów z automatyki i robotyki
Regulatory i układy sterowania
Regulatory PID, kaskadowe, rozmyte, MPC. Stabilizacja, śledzenie trajektorii, kompensacja zakłóceń.
Przykład: Regulator PID temperatury pieca z auto-tuningiem i kompensacją zakłóceń
Roboty mobilne
Roboty kołowe, śledzące linie, autonomiczne. Nawigacja, mapowanie, unikanie przeszkód, SLAM.
Przykład: Robot mobilny z nawigacją autonomiczną wykorzystujący kamerę
Manipulatory i ramiona robotyczne
Kinematyka prosta/odwrotna, planowanie ruchu, sterowanie pozycyjne, chwytaki.
Przykład: Ramię robotyczne 6-DOF z sterowaniem w przestrzeni zadaniowej
Systemy wizyjne
Detekcja obiektów, śledzenie, rozpoznawanie wzorców, sterowanie na podstawie obrazu.
Przykład: System sortowania obiektów na podstawie koloru i kształtu z OpenCV
Drony i UAV
Quadcopter, sterowanie lotem, stabilizacja, wykorzystanie GPS.
Przykład: Quadcopter z autonomiczną nawigacją GPS i unikaniem przeszkód
Automatyka przemysłowa
PLC, SCADA, HMI, Industry 4.0, systemy monitoringu i sterowania procesami.
Przykład: System sterowania linią produkcyjną z HMI i zbieraniem danych OEE
Narzędzia i oprogramowanie w automatyce
Modelowanie i symulacja
| Oprogramowanie | Kiedy wybrać | Trudność |
|---|---|---|
| MATLAB/Simulink | Standard w automatyce, regulatory, analiza stabilności | Średnia |
| Python | Open-source, regulatory podstawowe, integracja z ROS | Łatwa |
| LabVIEW | Akwizycja danych, DAQ, National Instruments hardware | Średnia |
| Scilab/Xcos | Darmowa alternatywa dla MATLAB, podstawowe regulatory | Łatwa |
Robotyka i symulatory
| Narzędzie | Zastosowanie | Trudność |
|---|---|---|
| ROS/ROS2 | Framework robotyczny, sensory, aktuatory | Wysoka |
| Gazebo | Symulator robotów, fizyka, sensory (LIDAR, kamery) | Średnia |
| V-REP (CoppeliaSim) | Symulator robotów, łatwy w użyciu, wiele przykładów | Łatwa |
| Webots | Symulator open-source, roboty mobilne, manipulatory | Średnia |
Hardware i platformy
- Arduino – Szybkie prototypy, proste regulatory, sensory podstawowe
- Raspberry Pi – Linux, ROS, OpenCV
- STM32 – Real-time control, PWM, enkodery, regulatory profesjonalne
- Jetson Nano – AI/ML, YOLO, detekcja obiektów
- PLC (Siemens/Allen-Bradley) – Automatyka przemysłowa, ladder
Computer Vision i AI
- OpenCV – Przetwarzanie obrazu, detekcja, śledzenie obiektów
- YOLO/Darknet – Detekcja obiektów w czasie rzeczywistym, sieć neuronowa
- TensorFlow/PyTorch – Deep learning, klasyfikacja, segmentacja
Nasze rekomendacje:
Regulator PID: MATLAB/Simulink (projekt) + STM32 (implementacja) + oscyloskop
Robot mobilny: ROS2 + Gazebo (symulacja) + Raspberry Pi + Arduino (hardware)
Manipulator: Python + ROS + MoveIt + Gazebo + serwomotory
System wizyjny: Raspberry Pi 4 + OpenCV + Python + kamera USB
Etapy realizacji projektu dla pracy dyplomowej z automatyki
MIESIĄC 1: Modelowanie i projekt
• Tydzień 1-2: Przegląd literatury, specyfikacja wymagań
• Tydzień 3-4: Model matematyczny, identyfikacja parametrów
MIESIĄC 2: Projekt regulatora i symulacje
• Tydzień 5-6: Synteza regulatora (PID tuning, LQR)
• Tydzień 7-8: Symulacje MATLAB/Simulink, weryfikacja stabilności
MIESIĄC 3: Implementacja i hardware
• Tydzień 9-10: Budowa stanowiska, montaż sensorów/aktuatorów
• Tydzień 11-12: Implementacja firmware
MIESIĄC 4: Testy i dokumentacja
• Tydzień 13-14: Pomiary, charakterystyki, optymalizacja
• Tydzień 15-16: Dokumentacja, prezentacja, przygotowanie do obrony
Faza 1: Modelowanie systemu (Miesiąc 1)
- Specyfikacja wymagań
- Parametry wyjściowe (czas ustalania, przeregulowanie, dokładność)
- Ograniczenia (zakres sygnału sterującego, częstotliwość próbkowania)
- Warunki pracy (zakłócenia, szumy pomiarowe)
- Modelowanie matematyczne
- Równania różniczkowe opisujące dynamikę
- Transmitancja operatorowa G(s)
- Reprezentacja w przestrzeni stanów (A, B, C, D)
- Identyfikacja parametrów
- Pomiary odpowiedzi skokowej
- Metoda Zieglera-Nicholsa
- System Identification Toolbox (MATLAB)
- Analiza właściwości
- Stabilność (lokalizacja biegunów)
- Sterowalność i obserwowalność
- Analiza częstotliwościowa (Bode, Nyquist)
Faza 2: Projekt regulatora (Miesiąc 2)
Co powinieneś mieć gotowe po tym etapie:
- ✅ Transmitancja regulatora R(s) lub algorytm dyskretny
- ✅ Nastawy parametrów (Kp, Ki, Kd dla PID)
- ✅ Symulacje układu zamkniętego w Simulink
- ✅ Weryfikacja stabilności
- ✅ Analiza odporności na zakłócenia
- ✅ Testy dla różnych wartości zadanych
% Projekt regulatora PID
% Parametry z odpowiedzi skokowej
K = 10; % Wzmocnienie statyczne
T = 2.5; % Stała czasowa [s]
L = 0.5; % Opóźnienie transportowe [s]
% Wzory Zieglera-Nicholsa (metoda Cohena-Coona)
Kp = (1.35/K) * (T/L);
Ti = 2.5 * L;
Td = 0.37 * L;
% Parametry regulatora PID
Ki = Kp / Ti;
Kd = Kp * Td;
fprintf('Nastawy regulatora PID:\n');
fprintf('Kp = %.3f\n', Kp);
fprintf('Ki = %.3f\n', Ki);
fprintf('Kd = %.3f\n', Kd);
% Transmitancja regulatora
s = tf('s');
R = Kp + Ki/s + Kd*s;
% Układ zamknięty
G = K / (T*s + 1) * exp(-L*s); % Obiekt z opóźnieniem
T_closed = feedback(R*G, 1);
% Symulacja
figure;
step(T_closed);
title('Odpowiedź układu zamkniętego z PID');
grid on;
% Analiza jakości
info = stepinfo(T_closed);
fprintf('Czas ustalania: %.2f s\n', info.SettlingTime);
fprintf('Przeregulowanie: %.1f %%\n', info.Overshoot);
Faza 3: Implementacja (Miesiąc 3)
Hardware setup:
- Mikrokontroler – STM32, Arduino, Raspberry Pi
- Sensory – Enkodery, czujniki położenia, kamery
- Aktuatory – Silniki DC/BLDC, serwa, przekaźniki
- Sterowniki mocy – H-bridge, ESC, sterownik silnika
- Zasilanie – Stabilizowane 5V/12V
- Komunikacja – UART, I2C, SPI
Implementacja firmware:
- Algorytm PID dyskretny
- Częstotliwość próbkowania
- Filtracja sygnałów
- Saturacja sygnału
- Watchdog
// Implementacja regulatora PID w C (STM32/Arduino)
typedef struct {
float Kp, Ki, Kd;
float integral;
float prev_error;
float dt;
float output_min, output_max;
} PID_Controller;
void PID_Init(PID_Controller *pid, float Kp, float Ki, float Kd,
float dt, float out_min, float out_max) {
pid->Kp = Kp;
pid->Ki = Ki;
pid->Kd = Kd;
pid->dt = dt;
pid->integral = 0;
pid->prev_error = 0;
pid->output_min = out_min;
pid->output_max = out_max;
}
float PID_Compute(PID_Controller *pid, float setpoint, float measurement) {
// Obliczenie uchybu
float error = setpoint - measurement;
// Człon proporcjonalny
float P = pid->Kp * error;
// Człon całkujący z anti-windup
pid->integral += error * pid->dt;
float I = pid->Ki * pid->integral;
// Człon różniczkujący
float derivative = (error - pid->prev_error) / pid->dt;
float D = pid->Kd * derivative;
// Sygnał sterujący
float output = P + I + D;
// Saturacja
if (output > pid->output_max) {
output = pid->output_max;
// Anti-windup: cofnij całkowanie
pid->integral -= error * pid->dt;
} else if (output < pid->output_min) {
output = pid->output_min;
pid->integral -= error * pid->dt;
}
pid->prev_error = error;
return output;
}
// Użycie w main loop (np. 100Hz)
void loop() {
float setpoint = 1000.0; // Zadana prędkość [RPM]
float rpm = readEncoder(); // Pomiar z enkodera
float control_signal = PID_Compute(&pid, setpoint, rpm);
setPWM(control_signal); // Sterowanie silnikiem
delay(10); // 100Hz control loop
}
Faza 4: Testy i walidacja (Miesiąc 4)
Scenariusze testowe:
- Odpowiedź skokowa – Czas ustalania, przeregulowanie, uchyb ustalony
- Śledzenie trajektorii – Sinus, rampa, trajektoria złożona
- Odporność na zakłócenia – Skokowa zmiana obciążenia
- Odporność – Zmiana parametrów obiektu (±20%)
- Testy graniczne – Maksymalna prędkość, przyspieszenie
- Testy bezpieczeństwa – Reakcja na utratę sensora, sygnału
Metryki jakości sterowania:
| Parametr | Wymagane | Uzyskane | Status |
|---|---|---|---|
| Czas ustalania ts | < 2.0 s | 1.8 s | ✓ OK |
| Przeregulowanie Mp | < 10% | 7.5% | ✓ OK |
| Uchyb ustalony ess | < 2% | 0.5% | ✓ OK |
| Zapas fazy PM | > 45° | 52° | ✓ OK |
Dokumentacja techniczna – co musi być
1. Model matematyczny
Pełny opis matematyczny systemu z wyprowadzeniem równań.
Co powinna zawierać sekcja modelowania:
- Schemat blokowy systemu
- Równania różniczkowe (ciągłe lub dyskretne)
- Transmitancja operatorowa G(s) lub G(z)
- Reprezentacja w przestrzeni stanów
- Identyfikacja parametrów (jeśli z pomiarów)
- Weryfikacja modelu (porównanie symulacja vs. rzeczywistość)
2. Analiza częstotliwościowa
Charakterystyki Bode, Nyquist, zapasy stabilności.
% Analiza częstotliwościowa układu zamkniętego
% Wykres Bode
figure;
bode(T_closed);
grid on;
title('Charakterystyka Bode układu zamkniętego');
% Zapasy stabilności
[Gm, Pm, Wcg, Wcp] = margin(G*R);
fprintf('Zapas wzmocnienia: %.2f dB\n', 20*log10(Gm));
fprintf('Zapas fazy: %.2f deg\n', Pm);
fprintf('Częstotliwość przecięcia wzmocnienia: %.2f rad/s\n', Wcg);
fprintf('Częstotliwość przecięcia fazy: %.2f rad/s\n', Wcp);
% Wykres Nyquist
figure;
nyquist(G*R);
title('Wykres Nyquista');
grid on;
3. Diagramy i schematy
Dokumentacja wizualna systemu sterowania.
Wymagane diagramy:
- Diagram blokowy – Połączenia między blokami (obiekt, regulator, sensory)
- Schemat Simulink – Screenshot z opisami bloków
- Schemat hardware – Połączenia elektroniczne (mikrokontroler, sensory, aktuatory)
- Flowchart – Algorytm głównej pętli sterowania
4. Wyniki testów i pomiarów
Dokumentacja eksperymentalna z wykresami i analizą.
| Test | Wynik symulacji | Wynik eksperyment | Błąd [%] |
|---|---|---|---|
| Czas ustalania [s] | 1.6 | 1.8 | 12.5% |
| Przeregulowanie [%] | 6.2 | 7.5 | 21.0% |
| Uchyb ustalony [%] | 0.3 | 0.5 | 66.7% |
Analiza rozbieżności:
Różnice między symulacją a eksperymentem wynikają z: (1) nieuwzględnionego tarcia w łożyskach, (2) opóźnień czasowych w pętli pomiarowej, (3) nieliniowości przekładni. Model można ulepszyć poprzez dodanie tłumienia nieliniowego i martwej strefy w sterowaniu.
Przykładowe projekty pracy inżynierskiej z automatyki o robotyki
Prace inżynierskie z automatyki i robotyki, które możesz zrealizować również i ty
System wizyjny sortowania obiektów
Ocena: 4.5
OpenCV + Python, detekcja koloru HSV, klasyfikacja kształtu (contour analysis), ramię 2-DOF, servo MG996R, Raspberry Pi 4.
Autonomiczny line-following robot z PID
Ocena: 4.5
Czujniki IR 8-kanałowe, regulator PID prędkości różnicowej, Arduino Mega, silniki 12V z enkoderami, auto-tuning online.
System sterowania linią produkcyjną (PLC)
Ocena: 5.0
Siemens S7-1200, TIA Portal v17, Ladder Logic + SCL, HMI KTP700, integracja z czujnikami indukcyjnymi/pojemnościowymi, zbieranie danych OEE.
4 najczęstsze błędy (i jak ich uniknąć)
❌ Błąd #1: "Model matematyczny zrobię na końcu"
Dlaczego to nie działa: Model jest fundamentem. Bez niego nie zaprojektujesz regulatora, nie zweryfikujesz stabilności.
✅ Rozwiązanie: Model NAJPIERW. Identyfikuj parametry z pomiarów, weryfikuj odpowiedź skokową przed projektem regulatora.
❌ Błąd #2: "Symulacja działa, to wystarczy"
Dlaczego to problem: Symulacja nie uwzględnia rzeczywistego tarcia, opóźnień, szumów. Hardware ZAWSZE zachowuje się inaczej.
✅ Rozwiązanie: Zbuduj prototyp (choćby prosty). Porównaj wyniki symulacja vs. rzeczywistość. Wyjaśnij rozbieżności.
❌ Błąd #3: Ignorowanie szumów pomiarowych
Co się dzieje: Człon różniczkujący PID amplifikuje szum → oscylacje, niestabilność.
✅ Rozwiązanie: Filtr dolnoprzepustowy na pomiarze.
// Prosty filtr dolnoprzepustowy (EMA - Exponential Moving Average)
float alpha = 0.1; // Im mniejsze, tym mocniejsze filtrowanie
float filtered_value = 0;
float read_sensor_filtered() {
float raw = analogRead(SENSOR_PIN);
filtered_value = alpha * raw + (1 - alpha) * filtered_value;
return filtered_value;
}
❌ Błąd #4: Brak testów granicznych i safety
Problem: Prototyp działa w warunkach nominalnych, ale crashuje przy ekstremach lub awariach.
✅ Rozwiązanie: Testy: maksymalne obciążenie, utrata sensora, nagłe zakłócenie.
FAQ – Pytania o prace z automatyki
Zależy od uczelni i promotora, ale w 80% przypadków potrzebny jest prototyp.
Kiedy wystarczy symulacja:
- Układy niebezpieczne (wysokie napięcia, duże moce)
- Systemy bardzo drogie (manipulatory przemysłowe >50k PLN)
- Promotor wyraźnie zgodził się na samą symulację
W pozostałych przypadkach: Komisja chce zobaczyć działający system. Prototyp = wyższa ocena.
Pro tip: Możesz zrobić uproszczony prototyp (np. robot 2-DOF zamiast 6-DOF) i pokazać resztę w symulacji.
Typowe koszty (2025):
| Typ projektu | Koszt |
|---|---|
| Regulator PID (stanowisko) | 300-800 PLN |
| Mikrokontroler + sensory + aktuatory | 150-400 PLN |
| Konstrukcja mechaniczna | 100-300 PLN |
| Zasilanie, kable, montaż | 50-100 PLN |
| Typ projektu | Koszt |
|---|---|
| Robot mobilny | 800-2000 PLN |
| Podwozie + silniki + sterowniki | 400-800 PLN |
| LIDAR (RPLidar A1) | 250-400 PLN |
| Raspberry Pi 4 + akcesoria | 300-500 PLN |
| Baterie, ładowarka | 150-300 PLN |
Sposoby na obniżenie kosztów:
- Użyj Arduino/ESP32 zamiast STM32 (łatwiejszy, tańszy)
- Gotowe podwozie robota (200-400 PLN) zamiast budowa od zera
- Pożycz oscyloskop/zasilacz z laboratorium uczelni
- Używane części z AliExpress/marketplace (oszczędność 30-50%)
Zależy od zastosowania i dostępności licencji.
MATLAB/Simulink - kiedy wybrać:
- ✅ Uczelnia ma licencję (większość politechnik ma)
- ✅ Regulatory klasyczne (PID, LQR, MPC)
- ✅ Analiza częstotliwościowa (Bode, Nyquist)
- ✅ Simulink dla modelowania graficznego
- ✅ Control System Toolbox, Robotics Toolbox
- ✅ Promotor wymaga MATLAB
Python - kiedy wybrać:
- ✅ Brak licencji MATLAB (Python darmowy)
- ✅ Integracja z ROS (Robot Operating System)
- ✅ Computer vision (OpenCV, bardzo łatwe w Python)
- ✅ Machine learning (TensorFlow, PyTorch)
- ✅ Szybkie prototypy, skrypty automatyzujące
Najlepsze podejście: MATLAB do projektu regulatora i symulacji, Python/C++ do implementacji na hardware.
Istnieje kilka metod, od najprostszych do zaawansowanych:
Metoda 1: Ziegler-Nichols (klasyka)
- Zmierz odpowiedź skokową obiektu
- Wyznacz parametry: K (wzmocnienie), T (stała czasowa), L (opóźnienie)
- Użyj wzorów Zieglera-Nicholsa: Kp = 1.2T/(KL), Ti = 2L, Td = 0.5L
- Prosta, ale często daje duże przeregulowanie (~30%)
Metoda 2: Trial and error (praktyczna)
- Zacznij od Kp, ustaw Ki=0, Kd=0
- Zwiększaj Kp aż pojawią się oscylacje
- Zmniejsz Kp o 30-50%
- Dodaj Ki aby wyeliminować uchyb ustalony (zaczynaj od małych wartości)
- Dodaj Kd aby zmniejszyć przeregulowanie (opcjonalne)
Metoda 3: MATLAB auto-tuning (najlepsza)
- Użyj `pidtune()` w MATLAB – automatyczny dobór
- PID Tuner App w Simulink – interaktywny tuning
- Daje optymalne nastawy minimalizujące IAE/ISE
Niestabilność to najczęstszy problem. Oto checklista debugowania:
Krok 1: Weryfikuj parametry regulatora
- Zmniejsz Kp o 50% → jeśli oscylacje znikną, to zbyt duże wzmocnienie
- Ustaw Ki=0, Kd=0 → testuj samego P
- Sprawdź znak sprzężenia: czy + zamiast - (bardzo częsty błąd!)
Krok 2: Sprawdź częstotliwość próbkowania
- Zbyt wolna pętla → zwiększ częstotliwość do min. 10× pasmo układu
- Zbyt szybka + szumy → dodaj filtry
Krok 3: Mechanika i sprzęt
- Sprawdź luz w przekładniach
- Sprawdź tarcie w łożyskach
- Szumy w pomiarze → dodaj kondensatory filtrujące
- Martwa strefa w sterownikach mocy
Pro tip: Zacznij od BARDZO MAŁYCH nastaw (Kp=0.1) i stopniowo zwiększaj. Lepiej powolna zbieżność niż niestabilność.
TAK! Arduino jest w 100% OK dla większości projektów inżynierskich.
Arduino wystarczy dla:
- ✅ Regulatory PID do ~100Hz (większość aplikacji)
- ✅ Roboty mobilne (prędkość, nie czas krytyczny)
- ✅ Prototypy i proof-of-concept
- ✅ Układy z ≤10 sensorami/aktuatorami
STM32 potrzebny dla:
- ❗ Pętle >500Hz (szybkie serwo, balanser)
- ❗ Real-time OS (FreeRTOS)
- ❗ Zaawansowane protokoły (CAN, EtherCAT)
- ❗ Precyzyjne PWM (16-bit)
Najważniejsze: Uzasadnij wybór w pracy. "Wybrałem Arduino bo wystarczająca wydajność dla pętli 100Hz i łatwiejsza praca programistyczna" → OK!
Realistyczny harmonogram (4 miesiące):
- Miesiąc 1: 1-2 godziny dziennie (literatura, model, symulacje)
- Miesiąc 2: 2-3 godziny dziennie (projekt regulatora, testy symulacyjne)
- Miesiąc 3: 3-4 godziny dziennie (budowa hardware, debugging, testy)
- Miesiąc 4: 2-3 godziny dziennie (pomiary, dokumentacja, prezentacja)
- Ostatnie 2 tygodnie: 1 godzina dziennie (finalne poprawki)
ŁĄCZNIE: ~250-300 godzin pracy (60-75 godzin/miesiąc)
⚠️ Uwaga na "martwy czas: oczekiwanie na komponenty (7-14 dni), zabawa z niedziałającym sprzętem. Zacznij WCZEŚNIE!
Potrzebujesz pomocy z napisaniem pracy do projektu?
Nie musisz przechodzić przez to sam. Nasz zespół ekspertów z pomoże Ci na każdym etapie.
Skontaktuj się z nami
Odpowiemy najszybciej jak to możliwe i dopytamy o szczegóły
Wolisz napisać bezpośrednio?
Email: iza@dyplombezstresu.pl