Sterowanie falownikiem Sinamics V20 w Codesys na Finder OPTA

Sterownik Finder OPTA Codesys to programowalny przekaźnik logiczny, wyposażony w 8 wejść analogowo-cyfrowych i 4 wyjścia przekaźnikowe na pokładzie. Czytaj więcej o Finder OPTA. W tym artykule pokażemy, jak skonfigurować Finder OPTA z modułami EMR/SSR w środowisku CODESYS oraz jak napisać program do sterowania silnikiem przez falownik za pomocą cyfrowych sygnałów sterujących. Omówimy krok po kroku konfigurację sprzętu i oprogramowania, przedstawimy kod sterujący (zarówno w języku drabinkowym LD, jak i tekstowym ST) oraz zaprezentujemy prostą wizualizację do testowania działania programu.

Sterownik Finder OPTA (wersja Codesys Advance) wraz z modułami rozszerzeń EMR i SSR. Moduły te dodają odpowiednio 16 dodatkowych wejść i 8 wyjść przekaźnikowych 6 A (EMR) lub 8 wyjść półprzewodnikowych 3 A (SSR)

Podłączenie Finder OPTA i falownika Sinamics V20

Moduły EMR/SSR dołączamy do sterownika Finder OPTA poprzez boczny port AUX. Należy zdjąć plastikową zaślepkę z boku sterownika i wpiąć moduł na szynę DIN obok urządzenia – można łańcuchowo podłączyć maksymalnie 5 modułów rozszerzeń. Po fizycznym dołączeniu modułów i ich zasileniu, można przystąpić do konfiguracji w środowisku Codesys.

Połączenie falownika: W naszym przykładzie wykorzystujemy trzy cyfrowe wejścia falownika do podstawowego sterowania silnikiem:

• RUN (On/Off) – uruchomienie/stop silnika (bieg ciągły),
• DIR (Reverse) – zmiana kierunku obrotów (praca w kierunku przeciwnym po załączeniu),
• JOG – praca chwilowa (jog) z zadanym parametrem falownika, np. wolnym biegiem do testów.

Te wejścia falownika podłączamy do wyjść cyfrowych sterownika (konkretnie do wyjść modułów rozszerzeń). W naszym układzie sygnał RUN i JOG sterowane są z modułu SSR (szybkie wyjścia tranzystorowe), natomiast sygnał DIR z modułu SSR lub EMR – w implementacji użyjemy SSR, choć równie dobrze mógłby to być przekaźnik EMR.

Dodatkowo do sterownika podłączone są przyciski sterujące: Start, Stop (grzybek NC) i Reset – jako wejścia cyfrowe modułu EMR, oraz przełącznik dwupozycyjny Lewo/Prawo (do wyboru kierunku) podłączony do dwóch wejść cyfrowych modułu SSR. Falownik można również rozbudować o sygnały zwrotne – np. wyjście Running (sygnalizacja pracy) czy Fault (awaria) podłączone do wejść sterownika – ale w tym projekcie skupimy się na sterowaniu podstawowym. Warto wspomnieć, że bardziej zaawansowane sterowanie falownikiem (np. zadawanie prędkości) mogłoby odbywać się przez komunikację Modbus RTU (zaciski P+ i N- falownika do portu RS485 sterownika A/B) lub sygnał analogowy (wymaga modułu analogowego OPTA) – jednak tutaj wykorzystujemy najprostsze sterowanie cyfrowe.

Konfiguracja projektu Codesys (Finder OPTA)

Przed przystąpieniem do programowania należy zainstalować odpowiednią wersję CODESYS oraz wtyczkę Finder OPTA Configurator (dostępną na stronie Findera) – umożliwia ona dodanie sterownika Finder OPTA do listy urządzeń w Codesys. Zakładamy, że środowisko jest już gotowe. Możemy teraz utworzyć nowy projekt i skonfigurować sprzęt:

Kroki konfiguracji projektu:

1. Utworzenie projektu oraz połączenie ze sterownikiem pokazaliśmy w naszym ostatnim artykule: Pierwsze uruchomienie i konfiguracja sterownika Finder OPTA Codesys
2. W drzewie projektu rozwiń I/O Expansions. Kliknij prawym na I/O Expansions i wybierz Plug Device… . Z listy dostępnych urządzeń wybierz moduł EMR Expansion i dodaj go. Następnie ponownie Plug Device… i dodaj moduł SSR Expansion. Po dodaniu powinny pojawić się węzły odpowiadające modułom EMR i SSR.
3. Domyślnie każde z 16 wejść modułów może działać jako analogowe (0–10 V) lub cyfrowe. W naszym projekcie wszystkie wykorzystane wejścia będą traktowane jako cyfrowe (0/1). Należy więc zaznaczyć w drzewie dodany moduł EMR, przejść do zakładki Parameters i dla używanych kanałów wejściowych ustawić tryb Digital (cyfrowy) zamiast domyślnego analogowego. Podobnie dla modułu SSR – przełączyć odpowiednie wejścia na cyfrowe. Następnie możemy sprawdzić zakładkę I/O Mapping lub Mapping modułów, gdzie widać przydzielone adresy wejść/wyjść. Zwróć uwagę, że każde wejście zajmuje 16-bitowy adres (Word) – np. wejścia modułu SSR mogą być zmapowane od %IW25 wzwyż (kolejno %IW25, %IW26, itd.)

Program sterujący w języku Ladder

Po konfiguracji sprzętowej przyszedł czas na napisanie programu sterującego pracą falownika. Zrealizujemy klasyczny układ sterowania silnikiem elektrycznym z wykorzystaniem języka drabinkowego (Ladder Diagram), uwzględniając funkcje start/stop, kierunek biegu oraz tryb chwilowego ruchu (jog). Program będzie korzystał z sygnałów wejściowych z przycisków i przełącznika oraz wysteruje odpowiednie wyjścia do falownika i lampki sygnalizacyjne.

Założenia logiki sterowania: Przed załączeniem napędu wymagane będzie odblokowanie układu (Reset). Naciśnięcie Start uruchomi silnik w wybranym kierunku (o ile układ jest odblokowany i wybrano kierunek), przycisk Stop zatrzyma pracę silnika w każdym momencie. Dodatkowo, jeśli przełącznik kierunku jest w pozycji neutralnej (żaden kierunek nie wybrany), silnik nie może pracować ciągle – zamiast tego dostępny jest tryb JOG (ruch chwilowy przy wciśnięciu odpowiedniego przycisku). Stan pracy silnika oraz gotowości układu będą sygnalizowane lampkami (zielona Start – silnik pracuje, czerwona Stop – silnik zatrzymany, żółta Reset – konieczne odblokowanie/reset). Poniżej omówiono kolejne elementy logiki drabinkowej.

PROGRAM LAD_PRG
VAR
   // SSR Outputs
   Relay1_SSR AT %QX2.0 : BOOL;
   Relay2_SSR AT %QX2.1 : BOOL;
   xStopLight_SSR AT %QX2.2 : BOOL;
   xOnOff_VFD_SSR AT %QX2.3 : BOOL;
   xReverse_SSR AT %QX2.4 : BOOL;
   Relay6_SSR AT %QX2.5 : BOOL;
   Relay7_SSR AT %QX2.6 : BOOL;
   xJog_SSR AT %QX2.7 : BOOL;
   
   // EMR Outputs
   xResetLight_SSR AT %QX1.6 : BOOL;
   xStartLight_SSR AT %QX1.7 : BOOL;
   
   // EMMR Inputs
   xStartBtn_EMR AT %IW9 : BOOL;
   xStopBtn_EMR AT %IW10 : BOOL;
   xResetBtn_EMR AT %IW11 : BOOL;
   
   // Inputs SSR
   xFwd_LeftSwitch_SSR AT %IW25 : BOOL;
   xRev_RightSwitch_SSR AT %IW26 : BOOL;
   
     // Zmienne pomocnicze
    xMotorRunning       : BOOL;     // Status pracy silnika
    xMotorEnabled       : BOOL;     // Silnik odblokowany
    xDirectionSet       : BOOL;     // Kierunek ustawiony
    xStartTrig          : R_TRIG;   // Detekcja zbocza przycisku START
    xStopTrig           : R_TRIG;   // Detekcja zbocza przycisku STOP
    xResetTrig          : R_TRIG;   // Detekcja zbocza przycisku RESET
	  xStartEdge          : BOOL;   // Detekcja zbocza przycisku START
    xStopEdge           : BOOL;   // Detekcja zbocza przycisku STOP
    xResetEdge          : BOOL;   // Detekcja zbocza przycisku RESET
	  xStartCondition: BOOL;
    
    // Timery
    tStartDelay         : tp;      // Opóźnienie startu (bezpieczeństwo)
    tStopDelay          : tp;      // Opóźnienie zatrzymania

END_VAR

Wykrywanie zboczy sygnałów
Do obsługi przycisków monostabilnych (Start, Reset, Stop) wykorzystujemy bloki R_TRIG, które wykrywają zbocza narastające. Wyjścia tych bloków (np. xStartEdge, xStopEdge, xResetEdge) przyjmują wartość TRUE jedynie w momencie wciśnięcia odpowiedniego przycisku.

Obsługa przycisku Stop
Przycisk Stop jest podłączony jako NC (Stop_BTN), tak aby w stanie spoczynku dawał sygnał logiczny 1. Wciśnięcie (przerwanie) powoduje przejście do stanu 0, co w logice skutkuje zatrzymaniem silnika i zablokowaniem układu. Detekcja zbocza Stop realizowana jest przez blok R_TRIG, a sygnał zatrzymania ustawia xMotorRunning := FALSE oraz xMotorEnabled := FALSE.

Wybór kierunku (lewo/prawo)
Przełącznik kierunku ma dwa wejścia: Left_SW i Right_SW. Przy pomocy bramki XOR ustawiamy xDirectionSet na TRUE tylko wtedy, gdy aktywny jest dokładnie jeden kierunek (czyli nie występuje pozycja neutralna ani obie jednocześnie). Gdy oba wejścia są nieaktywne (pozycja neutralna), aktywowany jest tryb Jog.

Start/Stop z podtrzymaniem
Reset odblokowuje układ (xMotorEnabled := TRUE). Po wykryciu zbocza StartEdge — przy poprawnie ustawionym kierunku i nieaktywnym silniku — inicjowany jest start przez uruchomienie timera opóźniającego. Po upływie skonfigurowanego czasu opóźnienia (np. 500 ms) ustawiane jest xMotorRunning := TRUE. Podtrzymanie stanu pracy silnika realizowane jest przez odpowiednie zatrzaskiwanie w logice (set/reset).

Opóźnienie rozruchu
Blok TP (czasowy impuls) stosowany jest do bezpiecznego opóźnienia faktycznego załączenia silnika — przykładowo o 500 ms. Po upływie tego czasu krótki impuls ustawia xMotorRunning, co z kolei uruchamia falownik.

Zatrzymanie silnika
Naciśnięcie Stop lub ustawienie przełącznika kierunku w pozycję neutralną powoduje zatrzymanie silnika: xMotorRunning := FALSE i zablokowanie układu (xMotorEnabled := FALSE). Aby ponownie uruchomić system, wymagany jest Reset.

Sterowanie falownikiem

• xMotorRunning aktywuje wyjście OnOff_VFD (RUN).
• Right_SW steruje kierunkiem przez wyjście Reverse_VFD (REV).
• Tryb Jog jest dostępny po przytrzymaniu przycisku Jog_Button, ale tylko jeśli Jog_Enabled = TRUE (czyli przełącznik kierunku znajduje się w pozycji neutralnej).

Sygnalizacja stanu

• Zielona lampka (Start_Light) świeci, gdy xMotorRunning = TRUE (silnik pracuje).
• Czerwona lampka (Stop_Light) świeci, gdy xMotorRunning = FALSE (silnik zatrzymany).
• Żółta lampka (Reset_Light) świeci, gdy xMotorEnabled = FALSE (układ zablokowany i wymaga resetu).

Lampki jednoznacznie sygnalizują gotowość, stan pracy oraz konieczność resetu.

Powyższe elementy tworzą kompletny program drabinkowy. Ze względu na ograniczoną formę tekstową trudno przedstawić pełny listing Ladder bez grafiki, ale wszystkie założenia wdrożymy poniżej w kodzie Structured Text (ST), który jest równoważny funkcjonalnie z naszym ladderem. Dla zainteresowanych – pełny projekt Ladder możesz pobrać na końcu tego artykułu. Poniżej przedstawiamy szczegółowo kod w ST, opatrzony komentarzami.

Program sterujący w języku strukturalnym (ST)

Poniżej znajduje się implementacja opisanej wyżej logiki w języku tekstowym strukturalnym ST. Program jest nieco bardziej rozbudowany – dodano w nim obsługę trybu JOG z poziomu wizualizacji Codesys. Zmienne wejściowe/wyjściowe odpowiadają fizycznym sygnałom (przyciski, przełącznik oraz wyjścia falownika i lampki), zaś zmienne wewnętrzne realizują logikę sterowania. Kod został podzielony na sekcje odpowiadające funkcjonalnościom omówionym wcześniej:

PROGRAM PLC_PRG
VAR
   // SSR Outputs
   Relay1_SSR AT %QX2.0 : BOOL;
   Relay2_SSR AT %QX2.1 : BOOL;
   xStopLight_SSR AT %QX2.2 : BOOL;
   xOnOff_VFD_SSR AT %QX2.3 : BOOL;
   xReverse_SSR AT %QX2.4 : BOOL;
   Relay6_SSR AT %QX2.5 : BOOL;
   Relay7_SSR AT %QX2.6 : BOOL;
   xJog_SSR AT %QX2.7 : BOOL;
   
   // EMR Outputs
   xResetLight_SSR AT %QX1.6 : BOOL;
   xStartLight_SSR AT %QX1.7 : BOOL;
   
   // Inputs
   xStartBtn_EMR AT %IW9 : BOOL;
   xStopBtn_EMR AT %IW10 : BOOL;
   xResetBtn_EMR AT %IW11 : BOOL;
   
   // Inputs SSR
   xFwd_LeftSwitch_SSR AT %IW25 : BOOL;
   xRev_RightSwitch_SSR AT %IW26 : BOOL;
   
      // Zmienne pomocnicze
    xMotorRunning       : BOOL;     // Status pracy silnika
    xMotorEnabled       : BOOL;     // Silnik odblokowany
    xDirectionSet       : BOOL;     // Kierunek ustawiony
    xStartEdge          : R_TRIG;   // Detekcja zbocza przycisku START
    xStopEdge           : R_TRIG;   // Detekcja zbocza przycisku STOP
    xResetEdge          : R_TRIG;   // Detekcja zbocza przycisku RESET
	  xStartBtn_visu: BOOL;
	  xStopBtn_visu: BOOL;
	  xResetBtn_visu: BOOL;
	  xJogEnabled: BOOL;

    
    // Timery
    tStartDelay         : tp;      // Opóźnienie startu (bezpieczeństwo)
    tStopDelay          : tp;      // Opóźnienie zatrzymania
    xJogBtn_visu: BOOL;
	
	xRelay0 AT %QX1.0:BOOL;
	xRelay1 AT %QX1.1:BOOL;
	xRelay2 AT %QX1.2:BOOL;
	xRelay3 AT %QX1.3:BOOL;
	xRelay4 AT %QX1.4:BOOL;
	xRelay5 AT %QX1.5:BOOL;

END_VAR

// =============================================================================
// GŁÓWNA LOGIKA STEROWANIA FALOWNIKIEM
// =============================================================================

// Detekcja zboczy przycisków (logika OR: fizyczne LUB wizualizacyjne)
xStartEdge(CLK := xStartBtn_EMR OR xStartBtn_visu);
xStopEdge(CLK := NOT xStopBtn_EMR OR xStopBtn_visu);     // STOP NC - detekcja zwolnienia przycisku
xResetEdge(CLK := xResetBtn_EMR OR xResetBtn_visu);

// =============================================================================
// 1. OKREŚLENIE KIERUNKU OBROTÓW I TRYBU JOG
// =============================================================================
// Sprawdzenie czy jeden z przełączników kierunku jest aktywny
xDirectionSet := xFwd_LeftSwitch_SSR XOR xRev_RightSwitch_SSR;

// Sprawdzenie czy oba przełączniki kierunku są wyłączone (stan neutralny dla JOG)
xJogEnabled := NOT xFwd_LeftSwitch_SSR AND NOT xRev_RightSwitch_SSR;

// Ustawienie sygnału kierunku dla falownika:
// FALSE = jazda do przodu (gdy xFwd_LeftSwitch_SSR = TRUE)
// TRUE = jazda do tyłu (gdy xRev_RightSwitch_SSR = TRUE)
xReverse_SSR := xRev_RightSwitch_SSR AND xDirectionSet;

// =============================================================================
// 2. LOGIKA WŁĄCZANIA/WYŁĄCZANIA SILNIKA
// =============================================================================

// RESET - odblokowanie systemu
IF xResetEdge.Q THEN
    xMotorEnabled := TRUE;
    xMotorRunning := FALSE;
END_IF

// START - uruchomienie silnika (tylko gdy spełnione warunki)
IF xStartEdge.Q AND xMotorEnabled AND (xDirectionSet OR xJogEnabled) AND NOT xMotorRunning THEN
    tStartDelay(IN := TRUE, PT := T#500MS);  // Impuls 500ms dla bezpieczeństwa
    IF tStartDelay.Q THEN
        xMotorRunning := TRUE;
    END_IF
ELSE
    tStartDelay(IN := FALSE);
END_IF

// STOP - zatrzymanie silnika (przycisk NC)
IF xStopEdge.Q THEN    // Gdy przycisk STOP zostanie wciśnięty (NC otwiera się)
    xMotorRunning := FALSE;
    xMotorEnabled := FALSE;  // Zablokowanie do następnego RESET
END_IF

// Awaryjne zatrzymanie - gdy przełączniki kierunku w złej pozycji
IF NOT xDirectionSet AND NOT xJogEnabled AND xMotorRunning THEN
    xMotorRunning := FALSE;
    xMotorEnabled := FALSE;
END_IF

// Automatyczne zatrzymanie przy przejściu do trybu JOG
IF xJogEnabled AND xMotorRunning THEN
    xMotorRunning := FALSE;
    // xMotorEnabled pozostaje TRUE - nie blokujemy systemu, tylko zatrzymujemy silnik
END_IF

// =============================================================================
// 3. WYJŚCIA STERUJĄCE FALOWNIKIEM
// =============================================================================

// GŁÓWNE ZEZWOLENIE na jazdę falownika - tylko w trybie normalnym z ustawionym kierunkiem
// W trybie JOG ta zmienna musi być FALSE
xOnOff_VFD_SSR := xMotorRunning AND xDirectionSet;

// KIERUNEK OBROTÓW dla falownika:
// xReverse_SSR = FALSE -> jazda PRZÓD (gdy xFwd_LeftSwitch_SSR = TRUE)
// xReverse_SSR = TRUE -> jazda TYŁ (gdy xRev_RightSwitch_SSR = TRUE)
// (xReverse_SSR jest już ustawione w sekcji 1)

// Tryb JOG (impulsowy) - aktywny tylko gdy oba przełączniki kierunku wyłączone i silnik pracuje
xJog_SSR := xMotorEnabled AND xJogEnabled AND xJogBtn_visu;

// =============================================================================
// 4. SYGNALIZACJA ŚWIETLNA
// =============================================================================

// Lampka START - świeci gdy silnik pracuje
xStartLight_SSR := xMotorRunning;

// Lampka STOP - świeci gdy silnik zatrzymany lub system zablokowany
xStopLight_SSR := NOT xMotorRunning OR NOT xMotorEnabled;

// Lampka RESET - miga gdy system wymaga resetu, świeci stale gdy odblokowany
IF NOT xMotorEnabled THEN
    xResetLight_SSR := TRUE;  // Można dodać miganie przez timer
ELSE
    xResetLight_SSR := FALSE;
END_IF

// =============================================================================
// KOMENTARZE EDUKACYJNE:
// =============================================================================
/*
ZASADY DZIAŁANIA PROGRAMU:

1. PRZYCISKI STERUJĄCE:
   - Każdy przycisk (START/STOP/RESET) ma dwa źródła sygnału:
     * Fizyczny przycisk (xStartBtn_EMR, xStopBtn_EMR, xResetBtn_EMR)
     * Przycisk wizualizacyjny (xStartBtn_visu, xStopBtn_visu, xResetBtn_visu)
   - Oba sygnały są połączone logika OR - działanie któregokolwiek uruchamia funkcję

2. TRYBY PRACY:
   - TRYB NORMALNY: jeden przełącznik kierunku aktywny (przód LUB tył)
   - TRYB JOG: oba przełączniki kierunku wyłączone (stan neutralny)
   - JOG umożliwia impulsowe sterowanie silnikiem bez ustalonego kierunku

3. BEZPIECZEŃSTWO:
   - Silnik można uruchomić tylko po RESET
   - Musi być ustawiony kierunek (normalny) LUB włączony tryb JOG
   - Opóźnienia przy starcie i stopie zapobiegają przypadkowym włączeniom
   - Przejście do trybu JOG automatycznie zatrzymuje silnik (bez blokady systemu)

3. SEKWENCJA URUCHOMIENIA:
   TRYB NORMALNY:
   - Ustaw kierunek (przełącznik przód lub tył)
   - Wciśnij RESET (odblokowanie systemu)
   - Wciśnij START (uruchomienie silnika)
   
   TRYB JOG:
   - Ustaw oba przełączniki kierunku w pozycji OFF (stan neutralny)
   - Wciśnij RESET (odblokowanie systemu)
   - Wciśnij START (uruchomienie w trybie JOG)

4. ZATRZYMANIE:
   - Wciśnij STOP (przycisk NC - natychmiastowe zatrzymanie) - fizycznie lub w wizualizacji
   - System zostanie zablokowany do następnego RESET

5. SYGNALIZACJA:
   - Zielona (START): silnik pracuje
   - Czerwona (STOP): silnik zatrzymany
   - Żółta (RESET): system wymaga odblokowania

6. STEROWANIE FALOWNIKIEM:
   TRYB NORMALNY:
   - xOnOff_VFD_SSR = TRUE -> zezwolenie na jazdę (tylko gdy ustawiony kierunek)
   - xReverse_SSR = FALSE -> jazda PRZÓD 
   - xReverse_SSR = TRUE -> jazda TYŁ
   
   TRYB JOG:
   - xOnOff_VFD_SSR = FALSE -> brak głównego zezwolenia
   - xJog_SSR = TRUE -> sterowanie impulsowe JOG (niezależne od xOnOff_VFD_SSR)

7. WIZUALIZACJA:
   - Zmienne xStartBtn_visu, xStopBtn_visu, xResetBtn_visu można podłączyć 
     do przycisków w systemie HMI/SCADA
   - xJogBtn_visu - przycisk JOG w wizualizacji (impulsowy)
   - Działają równolegle z przyciskami fizycznymi

8. ROZDZIELENIE TRYBÓW PRACY:
   - TRYB NORMALNY: xOnOff_VFD_SSR steruje falownikiem, xJog_SSR = FALSE
   - TRYB JOG: xJog_SSR steruje falownikiem, xOnOff_VFD_SSR = FALSE
   - Oba tryby wykluczają się wzajemnie
   - Przejście z trybu normalnego do JOG automatycznie zatrzymuje silnik

9. AUTOMATYCZNE ZATRZYMANIA:
   - Przejście do trybu JOG (oba przełączniki OFF) → STOP (bez blokady)
   - Błędna pozycja przełączników (oba ON) → STOP + BLOKADA systemu
   - Wciśnięcie przycisku STOP → STOP + BLOKADA systemu
*/



// Wyłączanie relay
xRelay0 := FALSE;
xRelay1 := FALSE;
xRelay2 := FALSE;
xRelay3 := FALSE;
xRelay4 := FALSE;
xRelay5 := FALSE;

Cały program napisaliśmy przy pomocy sztucznej inteligencji, sprawdź jak możesz nauczyć się programować PLC ze sztuczną inteligencją tutaj -> Wykorzystanie Sztucznej Inteligencji AI do programowania sterowników PLC

Program realizuje kompletną logikę sterowania falownikiem w dwóch trybach pracy: normalnym (jazda przód/tył) oraz impulsowym JOG. Obsługuje zarówno fizyczne przyciski (START, STOP, RESET), jak i ich odpowiedniki z wizualizacji (np. HMI), łącząc je logicznie.

Po RESET system zostaje odblokowany i gotowy do pracy. Uruchomienie silnika (START) jest możliwe tylko wtedy, gdy:

• ustawiono kierunek jazdy (przód lub tył) lub
• aktywny jest tryb JOG (brak kierunku),
• system nie jest zablokowany i silnik nie pracuje.

Dla bezpieczeństwa zastosowano opóźnienie startu 500 ms. Wciśnięcie STOP zatrzymuje silnik i blokuje system do ponownego RESET. Dodatkowo, system sam wykrywa błędne pozycje przełączników lub zmianę trybu i odpowiednio reaguje – zatrzymując silnik.

Na końcu programu ustawiane są sygnały wyjściowe do falownika (ON/OFF, kierunek, JOG), a także stany lampek sygnalizacyjnych (START, STOP, RESET). Całość zapewnia bezpieczne i przejrzyste sterowanie napędem.

Pobierz gotowy projekt w Codesys 3.5 SP21:

Podsumowanie

W artykule pokazaliśmy krok po kroku, jak przygotować środowisko Codesys i sterownik Finder OPTA do współpracy z modułami rozszerzeń EMR/SSR, a następnie jak zaprogramować sterowanie falownikiem (napędem silnikowym) za pomocą wyjść cyfrowych PLC. Przedstawiona aplikacja obejmuje podstawowe funkcje: start/stop, zmiana kierunku oraz tryb JOG, realizowane w oparciu o logikę drabinkową i wewnętrzne sygnały podtrzymania. Dzięki dodatkowemu wykorzystaniu wizualizacji Codesys mogliśmy łatwo przetestować działanie programu. Zaimplementowane rozwiązanie jest na tyle uniwersalne, że można je rozbudować o kolejne elementy (np. dodatkowe zabezpieczenia, sygnalizację stanów falownika takich jak osiągnięcie prędkości, usterka, itp., a także sterowanie prędkością przez wyjście analogowe lub Modbus). Mamy nadzieję, że ten przykład posłuży jako przydatny szablon przy realizacji własnych projektów z wykorzystaniem sterownika Finder OPTA i falowników. Zachęcamy do eksperymentowania i modyfikowania kodu pod konkretne zastosowania. Powodzenia w automatyzacji!

O autorze

Szymon Adamek

Automatyk, Manager ds. klienta w ControlByte

Zobacz posty autora