**Robot** — cz. „robota" = ciężka praca; termin ukuty przez Karla Čapka (R.U.R., 1920). W przemyśle: programowalna maszyna wykonująca zadania (spawanie, paletyzacja, montaż). W kontekście pytania: głównie roboty przemysłowe (manipulatory) — ramiona z 4–7 osiami obrotu, sterowane komputerowo.
**Język programowania robotów** — język do definiowania zachowania robota: ruchy, logika, I/O. Może być specjalizowany (dedykowany producenta) lub ogólny (C++, Python z bibliotekami). Klasyfikacja wg poziomu abstrakcji — od zadań po sygnały silników.
**Robot przemysłowy (industrial robot)** — manipulator: ramię mechaniczne z 4–7 osiami obrotu (degrees of freedom), zamocowane na stałe, sterowane komputerowo. Typowe zastosowania: spawanie, malowanie, paletyzacja, montaż. Standard ISO 8373: „automatycznie sterowany, reprogramowalny, wielozadaniowy manipulator". Przykłady: ABB IRB 6700 (spawanie karoserii), KUKA KR 210 (paletyzacja), FANUC M-20iA (montaż elektroniki). W odróżnieniu od cobotów (collaborative robots), roboty przemysłowe pracują w klatkach bezpieczeństwa — nie wolno wchodzić w ich zasięg podczas pracy.
**Język ogólnego przeznaczenia (general-purpose language)** — język programowania zaprojektowany do rozwiązywania DOWOLNYCH problemów: aplikacje webowe, bazy danych, gry, systemy operacyjne, AI. Przykłady: C++, Python, Java, C#, Rust. Nie ma wbudowanych komend ruchu robota — trzeba pisać biblioteki lub sterowniki od zera. W kontekście robotyki: C++ i Python używane z frameworkami (ROS, MoveIt), ale NIE są to języki specjalizowane.
// C++ (ogólny) — żeby ruszyć robotem, musisz:
robot.setJointAngle(0, 45.0); // sam zarządzasz komunikacją
robot.setJointAngle(1, 30.0); // sam pilnujesz kinematyki
robot.sendCommand(); // sam wysyłasz pakiety
// RAPID (specjalizowany) — komenda ruchu to prymityw języka:
MoveL pTarget, v500, fine, tool1; // gotowe, 1 linia
**Składnia (syntax)** — reguły, JAK pisać poprawne polecenia w danym języku. Składnia określa: jakie słowa kluczowe istnieją, jak je łączyć, jak kończyć instrukcje, jak grupować bloki kodu. Analogia: składnia to gramatyka języka naturalnego — „Ala ma kota" jest poprawne, „kota Ala ma" jest zrozumiałe, ale „ma Ala kota" w programowaniu dałoby błąd.
Różne składnie — ta sama instrukcja „jeśli x > 5, zrób coś":
C-like: if (x > 5) { doSomething(); }
Pascal-like: IF x > 5 THEN doSomething; ENDIF
Python-like: if x > 5:\n do_something()
**Typy danych (data types)** — kategorie wartości, jakie język rozpoznaje. Typ mówi kompilatorowi/interpreterowi ile pamięci zająć i jakie operacje są dozwolone. Języki robotów mają UNIKALNE typy, których nie znajdziesz w C++ czy Pythonie.
Typy ogólne (istnieją w każdym języku):
INT / num → liczba całkowita: 42, -7, 0
REAL / float → liczba zmiennoprzecinkowa: 3.14, -0.001
BOOL → prawda/fałsz: TRUE, FALSE
STRING → tekst: "Hello"
Typy SPECYFICZNE dla robotyki (nie istnieją w C++/Python):
robtarget → pozycja + orientacja + konfiguracja ramienia (RAPID)
tooldata → definicja narzędzia (TCP + masa + środek ciężkości)
speeddata → prędkość TCP + prędkość obrotowa
zonedata → strefa zbliżenia (jak blisko celu jechać)
**Instrukcja (instruction/statement)** — pojedyncze polecenie w programie. Komputer/robot wykonuje instrukcje po kolei (sekwencyjnie). W językach robotów instrukcje dzielą się na:
1. Ruchu: MoveL pTarget, v500, fine, tool1;
2. I/O: SetDO doGripper, 1;
3. Czekania: WaitTime 0.5;
4. Kontroli: IF sensor = TRUE THEN ...
5. Przypisania: nCycles := nCycles + 1;
6. Wywołania: PickPart; (wywołanie procedury)
---
**Zadanie robotyczne (robotic task)** — czynność, którą robot ma wykonać w ramach procesu produkcyjnego. Składa się z sekwencji ruchów, operacji I/O i logiki. Przykłady:
- Pick & place: podnieś obiekt z punktu A, przenieś do punktu B
- Spawanie: jedź po ścieżce spoiny z włączonym łukiem
- Paletyzacja: układaj pudła na palecie w warstwy 4×3
- Montaż: włóż kołek w otwór z kontrolą siły
**Ruch robota (robot motion)** — zmiana pozycji ramienia robota w czasie. Każdy ruch jest zdefiniowany przez cztery elementy: CEL (dokąd), TYP (jak — liniowo, stawowo, po łuku), PRĘDKOŚĆ (jak szybko), PRECYZJA (strefa zbliżenia). W językach robotów ruch to PRYMITYW — jedno polecenie, nie pętla obliczeń.
Trzy typy ruchu — jak robot jedzie z A do B:
PTP / MoveJ (joint):
A ●─ ─ ─ ── ● B ← ścieżka TCP nieprzewidywalna (krzywa)
Ale najszybszy! Interpolacja w przestrzeni stawów.
LIN / MoveL (linear):
A ●──────────● B ← TCP jedzie po prostej linii
Wolniejszy, ale precyzyjna ścieżka. Wymaga ciągłego IK.
CIRC / MoveC (circular):
A ●╲ ╱● B ← TCP jedzie po łuku kołowym
╲ ● H ╱ H = punkt pomocniczy (definiuje łuk)
╲─────╱
**Definiowanie ruchów** — w językach specjalizowanych ruch definiujesz JEDNĄ instrukcją z parametrami. Nie musisz pisać pętli sterowania silnikami — język ukrywa kinematykę odwrotną, planowanie trajektorii i sterowanie serwomechanizmami.
MoveL pTarget, v500, z10, tGripper;
│ │ │ │ └── narzędzie (jaki TCP)
│ │ │ └── precyzja (strefa zbliżenia)
│ │ └── prędkość (500 mm/s)
│ └── cel (pozycja docelowa)
└── typ ruchu (liniowy)
---
**I/O cyfrowe i analogowe (digital/analog I/O)** — interfejsy wejścia/wyjścia robota do komunikacji z urządzeniami zewnętrznymi (chwytaki, czujniki, przenośniki, lampy sygnalizacyjne).
- **I/O cyfrowe (digital)** — sygnał ma dwa stany: 0 (OFF) lub 1 (ON). Jak wyłącznik światła. Użycie: włącz/wyłącz chwytak, sprawdź czy czujnik wykrył obiekt, sygnalizuj gotowość do PLC.
- **I/O analogowe (analog)** — sygnał ciągły w zakresie, np. 0–10V lub 4–20mA. Jak regulator głośności. Użycie: ustaw siłę chwytaka proporcjonalnie (nie tylko ON/OFF), odczytaj temperaturę z termopary, ustaw prędkość przenośnika.
I/O analogowe — jak potencjometr (wartość ciągła):
SetAO aoForce, 5.7; // RAPID: ustaw wyjście analogowe na 5.7V
// np. siła chwytaka proporcjonalna do napięcia:
// 0V = brak siły, 10V = maksymalna siła
---
**Pozycja (position)** — punkt w przestrzeni, do którego robot ma dojechać. Opisywana trzema współrzędnymi: x, y, z (odległości w milimetrach od początku układu współrzędnych). Sama pozycja to za mało — robot musi też wiedzieć, JAK narzędzie ma być obrócone w tym punkcie (orientacja).
Pozycja: (x=400, y=200, z=100)
Znaczenie: 400mm do przodu, 200mm w prawo, 100mm w górę
od początku układu współrzędnych robota (podstawa)
**Układ kartezjański (Cartesian coordinate system)** — układ współrzędnych xyz, w którym każdy punkt w przestrzeni jest opisany trzema prostopadłymi odległościami od początku. Nazwa od René Descartesa (Kartezjusz). W robotyce: pozycja TCP wyrażona w mm: x=400, y=200, z=100. Alternatywa: przestrzeń stawowa (kąty: q₁=30°, q₂=45°, q₃=-10°…), która opisuje tę samą pozycję z perspektywy silników.
Układ kartezjański:
Z ↑
│ ● TCP (400, 200, 100)
│ ╱
│ ╱
│ ╱
├──────→ Y
╱
╱
X
Przestrzeń stawowa (ta sama pozycja, ale w kątach):
**Orientacja (orientation)** — kierunek, w jakim narzędzie (TCP) jest skierowane w danym punkcie. Pozycja mówi GDZIE jest, orientacja mówi JAK jest obrócone. Wyrażana jako kwaternion (q1,q2,q3,q4) w RAPID lub kąty Eulera (A,B,C) w KRL.
Ta sama pozycja, różne orientacje:
Orientacja 1: chwytak skierowany w dół ↓ (spawanie poziomej płyty)
Orientacja 2: chwytak skierowany w bok → (wkładanie elementu w otwór)
Orientacja 3: chwytak skierowany w górę ↑ (podpieranie od spodu)
W RAPID (kwaternion): [1, 0, 0, 0] = narzędzie pionowo w dół
W KRL (kąty Eulera): A=0, B=0, C=180 = obrót 180° wokół Z
**Konfiguracja ramienia (robot configuration)** — dla jednej pozycji + orientacji robot 6-osiowy może mieć do 8 różnych ustawień stawów (jak zgięcie łokcia do góry lub do dołu). Konfiguracja to dodatkowy parametr, który mówi robotowi KTÓRE rozwiązanie kinematyki odwrotnej wybrać.
Ta sama pozycja, dwie konfiguracje:
Konfiguracja 1 ("łokieć do góry"): Konfiguracja 2 ("łokieć na dół"):
╱──╲ ╲──╱
╱ ╲ ╲ ╲
───╱ ● TCP ───╱ ● TCP
W RAPID: robtarget = [[x,y,z], [orientacja], [konfiguracja], [osie_zewn]]
Konfiguracja = [cf1, cf4, cf6, cfx] — opisuje kwadranty stawów
---
**Język strukturalny (structured language)** — język z jasno zdefiniowanymi blokami kodu: procedury (PROC/ENDPROC), pętle (WHILE/ENDWHILE, FOR/ENDFOR), warunki (IF/ELSE/ENDIF). Przeciwieństwo: kod spaghetti z GOTO i nienazwanymi skokami. RAPID jest strukturalny — program składa się z modułów (MODULE/ENDMODULE) zawierających procedury. Łatwy do czytania i utrzymania.
Strukturalność RAPID:
MODULE MainModule ← moduł (pojemnik)
PROC PickPart() ← procedura (nazwany blok)
IF ready THEN ← warunek
MoveL ...;
ENDIF
ENDPROC ← wyraźny koniec bloku
ENDMODULE
**Język wielozadaniowy (multitasking language)** — język umożliwiający uruchamianie wielu programów (tasków) jednocześnie na jednym kontrolerze. W RAPID: jeden task steruje ruchem ramienia, drugi monitoruje czujniki bezpieczeństwa, trzeci komunikuje się z PLC. Każdy task działa „równolegle" (w rzeczywistości: szybkie przełączanie kontekstu).
Task 2 (SAFETY): WHILE TRUE DO (ciągły monitoring)
IF DI(emergency) THEN Stop;
ENDWHILE
Task 3 (COMM): czytaj/wysyłaj dane do PLC (komunikacja)
← kontroler przełącza się między taskami co ~4ms
---
**Język Pascal-like** — język, którego składnia przypomina język Pascal (Niklaus Wirth, 1970). Cechy: bloki zaczynają się słowem kluczowym i kończą `END` (nie nawiasami `{}`), zmienne deklarowane na początku bloku (`VAR`/`DECL`), średniki jako separatory, brak rozróżniania wielkości liter (case-insensitive). KRL i Karel mają składnię Pascal-like.
Pascal: KRL (KUKA):
PROGRAM example; DEF PickAndPlace()
VAR x: INTEGER; DECL INT x
BEGIN ; (brak BEGIN/END w KRL,
x := 10; ; ale DEF/END pełni tę rolę)
IF x > 5 THEN IF x > 5 THEN
WriteLn('tak'); ; zrób coś
END; ENDIF
END. END
**Approximacja (approximation)** — termin KUKA odpowiadający „strefie zbliżenia" w RAPID. Parametr `$APO.CDIS = 10` oznacza: robot zaczyna skręcać w stronę następnego celu, gdy jest 10mm od bieżącego. Efekt identyczny jak `z10` w RAPID — płynniejszy ruch, szybszy cykl, ale TCP nie dochodzi dokładnie do zaprogramowanego punktu.
LIN XTarget C_DIS // C_DIS = zastosuj approximację
---
**Język Python-like** — składnia inspirowana Pythonem: brak nawiasów klamrowych `{}`, proste wywołania funkcji, brak deklaracji typów, czytelny kod przypominający pseudokod. URScript jest Python-like — ale UWAGA: wcięcia w URScript NIE definiują bloków (w odróżnieniu od Pythona). Bloki kończą się słowem `end`.
**Język skryptowy (scripting language)** — język interpretowany (nie kompilowany): program czytany i wykonywany linia po linii w trakcie działania, bez osobnego kroku kompilacji. Zalety: szybkie testowanie (zmień kod → uruchom od razu), brak czekania na kompilację. Wady: wolniejszy od skompilowanego kodu (ale dla robota to nie problem — wąskim gardłem jest fizyczny ruch, nie szybkość interpretera). URScript jest skryptowy.
**Typowanie dynamiczne (dynamic typing)** — zmiennej NIE deklarujesz typu — język sam go rozpoznaje w momencie przypisania. Zmienna może zmieniać typ w trakcie programu. Przeciwieństwo: typowanie statyczne (C++, KRL) — typ deklarujesz z góry i nie może się zmienić.
Dynamiczne (URScript/Python): Statyczne (KRL):
x = 42 ← x jest liczbą DECL INT x ← x musi być INT
x = "hello" ← teraz x tekst x = 42 ← OK
← BRAK błędu x = "hello" ← BŁĄD kompilacji!
**Niski próg wejścia (low barrier to entry)** — URScript jest łatwy do nauki, bo łączy cechy ułatwiające start:
1. Brak deklaracji typów — nie musisz znać `INT`, `REAL`, `E6POS`
2. Składnia Python-like — jeśli znasz Pythona, czytasz URScript od razu
4. Coboty adresowane do małych firm bez zespołu programistów
5. Darmowy symulator URSim — uczysz się bez kupowania robota
6. Polyscope (GUI) — operator może programować drag & drop
Krzywa uczenia się (orientacyjnie):
URScript: dni (Python-like, prosty)
RAPID: tygodnie (strukturalny, wiele typów danych)
KRL: tygodnie (Pascal-like, dwa pliki)
Karel/TP: dni (TP) / tygodnie (Karel pełny)
ROS+C++: miesiące (framework + język ogólny + Linux)
---
**Język proceduralny (procedural language)** — paradygmat programowania, w którym program to sekwencja PROCEDUR (funkcji) wywoływanych po kolei. Każda procedura wykonuje konkretne zadanie. Brak obiektów i klas (to byłby język obiektowy). Wszystkie języki robotów są proceduralne — program to lista kroków: jedź tu, zamknij chwytak, jedź tam, otwórz chwytak.
Proceduralny = lista kroków: Obiektowy = obiekty i metody:
PickPart(); robot.pick(objectA);
MoveTo(placePos); objectA.moveTo(placePos);
OpenGripper(); gripper.open();
**Język C-like** — składnia inspirowana językiem C: nawiasy klamrowe `{}` lub `:=` do przypisań, średniki na końcu instrukcji, zmienne ze znakiem `$` dla zmiennych systemowych. PDL2 (Comau) jest C-like: `$DOUT[1] := TRUE` przypomina składnię C z operatorem przypisania.
**Task-level (poziom zadania)** — najwyższy: opisujesz CO robot ma zrobić, nie JAK. „Podnieś A, połóż na B." Robot sam planuje ruchy. Przykłady: PDDL, Behavior Trees.
**Robot-level (poziom robota)** — komendy ruchu w przestrzeni kartezjańskiej lub konfiguracyjnej: move_to(x,y,z), grasp(). Programista mówi GDZIE jechać, robot oblicza JAK (kinematyka odwrotna). Tu działają języki producentów: RAPID (ABB), KRL (KUKA), Karel (FANUC), PDL2 (Comau), URScript (Universal Robots).
**Motion-level (poziom ruchu)** — planowanie trajektorii: generowanie ciągu punktów od startu do celu z unikaniem kolizji. Kinematyka odwrotna, interpolacja. Przykłady: MoveIt (ROS), OMPL.
**Kinematyka odwrotna (inverse kinematics, IK)** — obliczenie kątów w stawach robota, aby efektor (np. chwytak) znalazł się w zadanej pozycji. Problem odwrotny: znasz cel (x,y,z + orientacja), szukasz konfiguracji (kąty q₁…qₙ). Może mieć 0, 1 lub wiele rozwiązań. Robot 6-osiowy: zazwyczaj do 8 rozwiązań dla jednej pozycji.
**Vendor lock-in** — każdy producent ma WŁASNY język. Program napisany w RAPID nie działa na robocie KUKA. To motywacja dla ROS i standardów. Porównanie języków:
**TCP (Tool Center Point)** — punkt centralny narzędzia zamontowanego na końcu ramienia (np. czubek spawarki, środek chwytaka). Wszystkie komendy ruchu LIN i CIRC odnoszą się do TCP — robot steruje tak, żeby ten punkt poruszał się po żądanej ścieżce.
**Strefa zbliżenia (zone)** — parametr określający, jak blisko celu robot musi dojechać zanim zacznie ruch do kolejnego punktu. `fine` = dojazd dokładnie do punktu (zatrzymanie), `z10` = robot zaczyna skręcać w stronę następnego punktu gdy jest 10mm od celu (ruch „na okrągło", płynniejszy i szybszy).
Specjalizowane języki programowania robotów to języki stworzone wyłącznie do sterowania robotami przemysłowymi. Nie są językami ogólnego przeznaczenia (jak C++ czy Python) — ich składnia, typy danych i instrukcje są zaprojektowane wokół zadań robotycznych: definiowania ruchów, obsługi I/O cyfrowych i analogowych, zarządzania narzędziami (TCP) i reagowania na błędy w czasie rzeczywistym.
2.**KRL — KUKA Robot Language** — Pascal-like (`DEF/END`, `DECL`). Program = dwa pliki: `.src` (kod) + `.dat` (pozycje). Komendy ruchu: `PTP`, `LIN`, `CIRC`. Prędkość ustawiana zmienną systemową `$VEL.CP`. Approximacja (`C_DIS`) zamiast stref. Symulator: KUKA.Sim Pro.
3.**Karel (FANUC)** — Pascal-like (`PROGRAM/BEGIN/END`). Dwa tryby: Karel (pełny tekstowy) i TP (Teach Pendant — uproszczony, listowy, numerowane linie). W praktyce fabrycznej dominuje TP — operatorzy bez wykształcenia programistycznego uczą się numerowanych linii `L P[2] 500mm/sec FINE`. Symulator: ROBOGUIDE.
5.**PDL2 (Comau)** — proceduralny, C-like. `MOVE LINEAR TO`, `$DOUT[1] := TRUE`. Stosowany głównie w automotive (Fiat/Stellantis). Symulator: RoboSim.
**Języki task-level (planowanie):**
6.**PDDL (Planning Domain Definition Language)** — deklaratywny język opisu problemów planowania. Definiujesz stany, akcje (warunki + efekty) i cel — planner automatycznie znajduje sekwencję akcji. Nie steruje robotem bezpośrednio, lecz generuje plan, który robot-level realizuje.
7.**Behavior Trees** — struktury drzew zachowań (Sequence, Selector, Action, Condition). Stosowane w robotyce i grach. Alternatywa dla maszyn stanów — łatwiejsze w rozbudowie i debugowaniu.
**Middleware i frameworki (uniwersalne, nie jednego producenta):**
8.**ROS / ROS 2** — middleware publish/subscribe, programowanie w Python/C++. NIE jest językiem specjalizowanym per se, ale jest de facto standardem łączącym roboty wielu producentów. Biblioteka **MoveIt** (motion planning) przełamuje vendor lock-in.
9.**Orocos** — framework C++ do hard real-time sterowania (<1ms).WypełnialukęROSwpętlachregulacjiwymagającychgwarancjiczasowych.
**Wspólne cechy języków specjalizowanych:**
- Wbudowane typy pozycji (kartezjańska, stawowa) — nie istnieją w C++ czy Pythonie
- Komendy ruchu jako prymitywy języka (`MoveL`, `LIN`, `movel`) — nie wywołania bibliotek
- Obsługa I/O cyfrowego/analogowego jako element składni
- Parametry ruchu (prędkość, strefa zbliżenia, narzędzie) jako argumenty instrukcji
- Brak wskaźników, zarządzania pamięcią, struktur danych ogólnego przeznaczenia — język zoptymalizowany pod jedno zastosowanie
- TP program jest częściej używany w praktyce (prostszy, operatorzy go rozumieją)
**Przykład Karel:**
PROGRAM pick_place
VAR
home_pos : POSITION
pick_pos : POSITION
place_pos : POSITION
cycle_count : INTEGER
BEGIN
cycle_count = 0
-- Jedź do domu
MOVE TO home_pos
WHILE cycle_count <100DO
-- Podnoszenie
MOVE TO pick_pos
DOUT[1] = ON -- zamknij chwytak
DELAY 300 -- czekaj 300ms
-- Odkładanie
MOVE TO place_pos
DOUT[1] = OFF -- otwórz chwytak
DELAY 300
cycle_count = cycle_count + 1
ENDWHILE
END pick_place
**Przykład TP (Teach Pendant) — to widzi operator:**
1: J P[1] 100% FINE ; joint move do Home, 100% speed
2: L P[2] 500mm/sec FINE ; linear do Pick
3: DO[1]=ON ; chwytak zamknij
4: WAIT 0.30(sec)
5: L P[3] 500mm/sec FINE ; linear do Place
6: DO[1]=OFF ; chwytak otwórz
7: WAIT 0.30(sec)
8: JMP LBL[1] ; skocz do linii 1
**Uwaga:** W praktyce fabrycznej TP jest dominujący — operatorzy uczą się numerowanych linii, nie pełnego Karela.
---
#### URScript (Universal Robots)
**Producent:** Universal Robots (coboty — collaborative robots). **Składnia:** Python-like (brak nawiasów klamrowych, wcięcia nie mają znaczenia, ale styl jest skryptowy). **Symulator:** URSim (darmowy, oparty na VM).
**Kluczowe cechy:**
- Skryptowy i prosty — niski próg wejścia (coboty = roboty współpracujące z ludźmi)
- Wbudowane funkcje force control (sterowanie siłą) — unikalne dla cobotów
- Typy: brak deklaracji typów (dynamiczne), `pose` = [x,y,z,rx,ry,rz]
- Polyscope — graficzny interfejs do programowania (drag & drop + URScript)
**Przykład URScript:**
def pick_and_place():
# Pozycje jako pose: [x, y, z, rx, ry, rz] w metrach i radianach
### Porównanie składni — ten sam ruch w 5 językach
Zadanie: ruch liniowy do punktu pPick z prędkością ~500mm/s
RAPID (ABB): MoveL pPick, v500, fine, tGripper;
KRL (KUKA): LIN XPick
Karel (FANUC): MOVE TO pick_pos ; z opcją LINEAR
TP (FANUC): L P[2] 500mm/sec FINE
URScript (UR): movel(pick, a=0.5, v=0.5)
PDL2 (Comau): MOVE LINEAR TO pick_pos
### Języki uniwersalne i middleware
#### ROS / ROS 2 (Robot Operating System)
**ROS** to middleware (NIE system operacyjny!) — warstwa komunikacji między modułami (węzłami). Programuje się w Python lub C++. Architektura publish/subscribe: węzły publikują wiadomości na tematy (topics), inne węzły subskrybują.
timer = node.create_timer(0.1, lambda: pub.publish(msg)) # co 100ms
rclpy.spin(node)
**MoveIt** — biblioteka ROS do planowania ruchu manipulatorów. Obejmuje: IK, collision avoidance, trajectory planning. Wspiera roboty wielu producentów — klucz do przełamania vendor lock-in.
# MoveIt — planowanie ruchu w Pythonie:
move_group = MoveGroupCommander("arm")
move_group.set_pose_target(target_pose) # cel w kartezjańskiej
plan = move_group.plan() # automatyczny plan trajektorii
move_group.execute(plan) # wykonaj
#### Orocos (Open Robot Control Software)
Framework C++ do **hard real-time** sterowania robotów. Tam gdzie ROS nie wystarczy (pętle regulacji <1ms),Orocoswypełnialukę.CzęstołączonyzROS:ROSdokomunikacji+Orocosdosterowania.
---
### Task-level: PDDL i Behavior Trees
#### PDDL (Planning Domain Definition Language)
Język opisu problemów planowania. Definiujesz: stany, akcje z warunkami i efektami, cel. Planner (np. Fast Downward) automatycznie znajduje sekwencję akcji.
