O co chodzi w skrócie
Wykorzystujemy silnik skryptów Pythona w CODESYS oraz lokalnego agenta AI (np. Klein z podpiętym modelem Claude / GPT / DeepSeek), aby zautomatyzować nudne czynności: tworzenie bloków funkcyjnych, list zmiennych globalnych (GVL), zmiennych trwałych (PERSISTENT), struktur danych, programu głównego i konfiguracji zadań.
Efekt: szybciej stawiasz szablon projektu, a swój czas poświęcasz na logikę procesu i testy.
Jak to jest generowane – logika działania (bez technikaliów)
- Kontekst i materiały wejściowe
– Masz lokalny folder z przykładowymi skryptami i „stubami” API CODESYS Script Engine.
– Agent AI dostaje opis celu (co chcesz zbudować) oraz dostęp do tych plików, żeby zrozumieć, jak nazywają się metody i obiekty w ekosystemie CODESYS. - Analiza i plan
– Agent czyta Twoje pliki i „stuby” API (lokalnie), rozumie dostępne operacje (np. tworzenie POU, GVL, struktur).
– Układa plan działań: co utworzyć, w jakiej kolejności, jak nazwać elementy (zgodnie z Twoją konwencją). - Generacja artefaktów projektu
– Na podstawie planu agent generuje plik(i) automatyzujące czynności: założenie urządzenia, dodanie aplikacji, konfigurację zadań, utworzenie bloków, list zmiennych, struktur, itp.
– Rezultatem są gotowe elementy w projekcie CODESYS: struktura folderów, POU (FB/PRG), GVL, PERSISTENT, TYPE, podstawowe komentarze i nazwy. - Uruchomienie i weryfikacja
– Ty uruchamiasz tę automatyzację z poziomu CODESYS (menu narzędzi), a potem oglądasz efekty w drzewie projektu.
– Ustawiasz tryb symulacji (jeśli potrzebny), porządkujesz nazewnictwo, uzupełniasz opisy, a przede wszystkim planujesz testy.
Co konkretnie potrafi dla Ciebie zrobić agent (przykłady artefaktów)
- Struktura projektu: tworzy podstawy aplikacji, zadania cykliczne, wiąże program główny do zadań.
- Bloki funkcyjne: generuje FB według Twojej specyfikacji (wejścia/wyjścia, proste metody, komentarze).
- Dane wspólne: zakłada GVL (zmienne globalne), PERSISTENT (ustawienia zapamiętywane), TYPE/STRUCT (porządek w danych procesowych).
- Naming i komentarze: stosuje uzgodnioną konwencję (np. notacja węgierska) i język komentarzy (np. EN dla zespołów międzynarodowych).
- Szkielety logiki: przygotowuje układ kroków/sekwencji (np. pod PackML), do których potem łatwo dopinasz właściwą logikę procesu.
Klucz: agent nie „magicznie programuje” za Ciebie całej maszyny, ale buduje 80% rusztowania, które sam ręcznie kończysz i testujesz.
Jak tym pracować – proces krok po kroku (bez zaglądania do kodu)
- Porządek w materiałach: przygotuj folder z przykładowymi automatyzacjami i stubami API – agent ma z czego się uczyć.
- Opis celu (prompt): precyzyjnie opisz, co ma powstać (jakie bloki, jakie zmienne, jaki naming, które elementy mają być trwałe, jakie struktury danych).
- Analiza przez agenta: daj narzędziu dostęp tylko do potrzebnych plików. Agent sam wskaże, z jakich „stubs” korzysta i jakie operacje są dostępne.
- Generacja: agent wygeneruje pliki/konfiguracje tworzące elementy projektu.
- Uruchomienie w CODESYS: odpalasz generowanie z menu narzędzi.
- Przegląd i higiena: sprawdzasz nazwy, opisy, komentarze; porządkujesz strukturę projektu.
- Testy i dopracowanie: dopiero teraz podłączasz logikę procesu, komunikację, bezpieczeństwo – i zaczynasz testy (symulator, FAT/SAT).
Zasady bezpieczeństwa i jakości (BHP/QA)
- AI ≠ autoryzacja: traktuj wynik jako propozycję. Każdy fragment zweryfikuj (przegląd, symulacja, testy).
- Konwencja nazewnictwa: spójne prefiksy (di/do/ai/ao, fb/prg/gvl), jednolity styl – ułatwia debug i code-review.
- Rozdział odpowiedzialności: inny plik/obszar na generację artefaktów, inny na logikę procesu – łatwiej aktualizować/porównywać.
- Wersjonowanie: repozytorium Git (commit „po generacji”, tagi). Zawsze wiesz, co i kiedy zostało utworzone.
- Dane wrażliwe: nie podawaj agentowi rzeczy, których nie może widzieć (API-keys, dokumenty klienta, IP).
- Koszty i limity: monitoruj zużycie tokenów. Generuj porcjami, recyklinguj „prompty”.
- Traceability: zapisuj, z których plików API agent skorzystał – potem wiesz, gdzie szukać definicji.
Kiedy AI najbardziej pomaga
- Start nowego projektu (szkielet: POU, GVL, TYPE, zadania).
- Migracja stylu (np. ujednolicenie nazewnictwa i komentarzy w wielu projektach).
- Edukacja zespołu (przykładowe bloki z opisami „jak to ma wyglądać u nas”).
- Prototypowanie (szybkie szkielety sekwencji, które potem ręcznie uszczelniasz).
A kiedy nie
- Gdy wymagana jest diagnostyka bezpieczeństwa i walidacja, której nie przeskoczysz „generatorem”.
- Gdy masz niestandardowe biblioteki i brak jasnej dokumentacji – agent nie „odgadnie” semantyki bez materiałów.
- Gdy pracujesz na poufnych danych klienta – ogranicz lub maskuj kontekst, albo używaj w pełni lokalnych modeli.
Minimalna checklist’a wdrożenia
- Ustal naming i konwencje (prefiksy, język komentarzy).
- Zbierz pliki referencyjne: przykłady i stubs API.
- Napisz jasny opis celu (co ma powstać, w jakiej kolejności).
- Daj agentowi tylko niezbędny dostęp.
- Wygeneruj artefakty i obejrzyj strukturę projektu.
- Zrób code-review i symulację.
- Dodaj testy awaryjne (timeouty, interlocki, E-STOPy).
- Zacommituj i opisz zmiany.
Dlaczego AI + Python w CODESYS?
Zacznijmy uczciwie: AI nie zastępuje automatyka. Może wygenerować szkice kodu, ale każdy fragment musi być przetestowany (FAT/SAT, testy jednostkowe, symulator). Celem jest przyspieszenie pracy: automatyczne tworzenie POU, GVL, struktur, szablonów FB i programu głównego — a my skupiamy się na logice procesu i bezpieczeństwie.
Wymagania
- CODESYS 3.5 z włączonym Script Engine (IronPython)
- VS Code (opcjonalnie, dla wygody edycji skryptów)
- Lokalny agent AI Klein (lub inny runner), podłączony do modelu Claude 3.7 Sonnet (możesz użyć też ChatGPT/DeepSeek — zasada ta sama)
- Klucz API do wybranego modelu (koszt wg użycia — płacisz za tokeny/operacje)
ℹ️ W moim case zużycie wyniosło ok. $16 na eksplorację API i generację kodów. Traktuj to jako inwestycję R&D, nie warunek konieczny do nauki.
Krok 1 — gdzie jest Script Engine i jak go uruchomić?
- W CODESYS: Tools → Scripting → Execute Script File…
Zobaczysz okno z ikoną Python — to IronPython wbudowany w CODESYS.
Pliki „stubów” API znajdziesz domyślnie tu:
C:\Program Files\CODESYS 3.5.xx.xx\CODESYS\ScriptLib\Stubs\scriptengine
Pro tip (VS Code): skopiuj cały folder scriptengine do katalogu z Twoimi skryptami:
my-codesys-scripts/
├── scriptengine/
└── my_script.py
- Dzięki temu VS Code podpowiada typy, nazwy metod i modułów.
Krok 2 — mój porządek w repo: „Codesys Python”
Tworzę własny folder z użytkowymi skryptami (np. codesys_python/) i tam trzymam gotowce:
- create_device.py – dodanie urządzenia + Task Configuration,
- create_fb.py – utworzenie FUNCTION_BLOCK + metoda,
- create_gvl.py – Global Variable List (GVL),
- create_persistent.py – PERSISTENT VARS,
- create_datatypes.py – STRUKTURY.
Dzięki temu agent AI ma z czego się uczyć: przegląda moje pliki, rozumie nazwy funkcji (np. create_pou, create_gvl, create_persistentvars) i buduje na tym nową automatyzację.
Krok 3 — podłączenie lokalnego agenta AI (Klein + Claude Sonnet)
W dolnym pasku agenta wybieram model Claude 3.7 Sonnet. Agent:
- czyta wskazane lokalne pliki (np. create_fb.py, create_gvl.py),
- uczy się API Script Engine (bez przeszukiwania internetu),
- proponuje gotowe skrypty dopasowane do mojego repo i naming-convention.
Przykład: agent sam odnalazł w stubach metodę create_persistentvars() i parametry gvlsettings — szukał tego w pliku script language object container. To skraca godziny grzebania po API.
Krok 4 — szybkie skrypty, które realnie przyspieszają pracę
4.1. Dodaj urządzenie + Task
# device_repository, projects pochodzą z scriptengine.*
devId = None
for dev in device_repository.get_all_devices("CODESYS Control Win V3"):
devId = dev.device_id
proj = projects.primary
existing = proj.find('testdev')
if existing:
existing[0].remove()
proj.add('testdev', devId)
app = proj.find('Application', True)[0]
tc = app.create_task_configuration()
task = tc.create_task('Task')
task.pous.add('PLC_PRG')4.2. Utwórz FB + metodę
proj = projects.primary
app = proj.find("Application", True)[0]
fb = app.create_pou("FB_TemperatureCtrl") # FUNCTION_BLOCK
fb.textual_declaration.replace("""FUNCTION_BLOCK FB_TemperatureCtrl
VAR_INPUT
rPV : REAL;
rSP : REAL;
END_VAR
VAR_OUTPUT
rOUT : REAL;
END_VAR
VAR
rErr : REAL;
END_VAR""")
fb.textual_implementation.replace("""rErr := rSP - rPV;
rOUT := rErr * 0.5; // prosta regulacja P
""")
m = fb.create_method("DoStep", "VOID")
m.textual_declaration.replace("""METHOD DoStep : VOID
VAR_INPUT
dt : TIME;
END_VAR""")
m.textual_implementation.replace("""// tutaj np. aktualizacja licznika czasu""")4.3. Utwórz GVL + PERSISTENT
app = projects.primary.find("Application", True)[0]
gvl = app.create_gvl("GVL_Process")
gvl.textual_declaration.replace("""VAR_GLOBAL
g_xSystemOn : BOOL := FALSE;
g_rLevel : REAL;
END_VAR""")
pgvl = app.create_persistentvars("GVL_Settings")
pgvl.textual_declaration.replace("""VAR_GLOBAL PERSISTENT
p_xAutoStart : BOOL := TRUE;
p_tDelay : TIME := T#5S;
END_VAR""")4.4. Struktury danych
dt = app.create_datatype("ST_Pump")
dt.textual_declaration.replace("""TYPE ST_Pump :
STRUCT
xCmdStart : BOOL;
xCmdStop : BOOL;
tRunTime : TIME;
uiStarts : UINT;
END_STRUCT
END_TYPE""")Te fragmenty to szablony startowe — agent AI może je rozszerzyć o Twoje wymagania (naming wg notacji węgierskiej, komentarze EN, itp.).
Krok 5 — jak pracuję z agentem (prompt → analiza → działanie)
- Proszę agenta: „Stwórz FB/struktury/GVL wg…”.
- Agent czyta moje lokalne skrypty i stuby API.
- Agent wyciąga właściwe metody (create_pou, create_method, create_gvl, create_persistentvars, create_task_configuration).
- Agent generuje plik: np. pump_station_generator.py, z pełnym szkieletem projektu.
- Ja wklejam i odpalam skrypt w CODESYS: Tools → Scripting → Execute Script File.
- Testy robię w następnej lekcji (świadomie — tu skupiamy się na konfiguracji i generacji).
💸 Każde „czytanie pliku” i „plan/act” u agenta to koszt (u mnie ~0,02$ za małe operacje, więcej za dłuższe generacje). Warto pilnować limitów.
Krok 6 — przykładowe prompty, które działają
Prompt 1 — utwórz FB z metodą i komentarzami:
Przeanalizuj lokalne pliki create_fb.py oraz stuby scriptengine.
Utwórz skrypt Python dla CODESYS Script Engine, który:
1) tworzy FUNCTION_BLOCK „FB_TemperatureCtrl” z wejściami rPV, rSP i wyjściem rOUT,
2) dodaje metodę DoStep(dt: TIME),
3) wstawia komentarze w języku angielskim,
4) zachowuje naming wg konwencji z repo (notacja węgierska tam, gdzie to sensowne).
Na końcu wyjaśnij, w którym pliku stub znajduje się definicja funkcji create_pou/create_method.
Prompt 2 — wygeneruj GVL + PERSISTENT + TYPE:
Utwórz skrypt Python do CODESYS Script Engine, który:
– tworzy GVL „GVL_Process” (g_xSystemOn, g_rLevel),
– tworzy PERSISTENT VARS „GVL_Settings” (p_xAutoStart, p_tDelay),
– dodaje TYPE „ST_Pump” (xCmdStart, xCmdStop, tRunTime, uiStarts).
Pokaż użyte metody API i wskaż, z którego pliku stub pochodzą.
Prompt 3 — generator projektu (z mojego case o przepompowni):
Masz opis projektu w tekście poniżej. Napisz skrypt Python, który:
– tworzy TYPE’y i struktury danych,
– generuje GVL, PERSISTENT GVL, GVL_Constants,
– tworzy FB sterujący jedną pompą (auto/manual, ack, liczniki),
– generuje program główny i dodaje go do Task Configuration,
– komentarze po angielsku, nazewnictwo wg notacji węgierskiej.
Zastosuj API z CODESYS Script Engine. Wymień pliki stub, z których korzystasz.
Krok 7 — tryb symulacji (przydatne makro)
proj = projects.primary
dev = proj.find('testdev')[0]
if not dev.get_simulation_mode():
dev.set_simulation_mode(True)Najważniejsze wnioski
- AI realnie skraca czas przygotowania projektu — szczególnie przy tworzeniu szablonów (POU, GVL, TYPE).
- Moc lokalnego agenta to kontekst Twojego repo — czyta pliki i uczy się Twojej konwencji.
- CODESYS Script Engine daje pełną automatyzację: od dodania urządzeń i zadań po generację kompletnej struktury projektu.
- Koszt API istnieje — ale jest uzasadniony, gdy oszczędza godziny rozgryzania API i szukania funkcji.
- Bezpieczeństwo i testy są po Twojej stronie. AI to turbo-notatnik i generator, nie „operator maszyny”.
Zadanie dla Ciebie
- Skopiuj folder scriptengine do swojego projektu z Pythonem i skonfiguruj VS Code.
- Uruchom w CODESYS: Tools → Scripting → Execute Script File i przetestuj skrypt „dodaj urządzenie + Task”.
- Użyj Prompt 1 (albo własnego) u agenta AI — wygeneruj skrypt tworzący FB + metodę.
- Dodaj GVL i PERSISTENT (Prompt 2).
- Uruchom skrypty i sprawdź, czy obiekty pojawiły się poprawnie w projekcie.
- Napisz krótkie sprawozdanie: co zadziałało, co poprawiłeś ręcznie, gdzie agent pomógł najbardziej.
Chcesz wiedzieć więcej odnośnie agentów AI do programowania PLC?
Sprawdź nasz Kurs Automatyki i Programowania PLC ze Sztuczną Inteligencją AI.
O autorze
