SCL-keel - Tööstuslikud infovõrgud ja IT turvalisus

Kursuse eesmärk

Õppijad omandavad praktilised teadmised ja oskused SCL-keeles programmeerimiseks Siemens TIA Portali keskkonnas. Kursus keskendub SCL-i põhistruktuuri, lihtloogika ja keerukamate lahenduste loomisele.

Kursuse struktuur ja õppetunnid

I. Sissejuhatus SCL-i (Structured Control Language)

Õppetunni eesmärk:

Anda ülevaade, mis on SCL, milleks seda kasutatakse ja kuidas see erineb teistest PLC programmeerimiskeeltest.
Luua põhiarusaam, kuidas SCL-i kasutada Siemens TIA Portali keskkonnas.

1. Mis on SCL?

Structured Control Language (SCL) on Siemens TIA Portali keskkonnas kasutatav kõrgetasemeline programmeerimiskeel, mis järgib IEC 61131-3 standardit. SCL sarnaneb selliste keeltekonventsioonidega nagu Pascal või C ja sobib keerukate matemaatiliste operatsioonide ja tingimusloogika teostamiseks.

1.1 SCL-i peamised omadused:

Lugemise lihtsus: Kõrgem tase kui Ladder Diagram ja Function Block Diagram, sobib hästi keerukate ülesannete lahendamiseks.
Muutuja-põhine programmeerimine: Kasutab deklareeritud muutujaid (nt Input1, Counter).
Paindlikkus: Sobib hästi matemaatiliste arvutuste, loogiliste tingimuste ja korduste jaoks.

1.2 Kuidas SCL erineb teistest keeldest?

Keel	Kasutamine	Eelis
Ladder Diagram (LD)	Graafiline loogika	Lihtne arusaadavus ja kasutus masinaoperaatoritele
Function Block Diagram (FBD)	Blokipõhine funktsioonide juhtimine	Visuaalne ja struktureeritud lähenemine
Structured Control Language (SCL)	Tekstipõhine loogika ja matemaatika	Lihtne keerukate algoritmide jaoks

2. Kus kasutatakse SCL-i?

Tootmisliinide automatiseerimine: Komplekssed loogikad ja juhtimisprotsessid.
Keerukad arvutused: Protsesside optimeerimiseks ja andmeanalüüsiks.
Tootmise jälgimine ja vigade käsitlemine.

3. Kuidas SCL töötab?

Programm on jagatud muutujate deklaratsiooni ja tegevuste loogika vahel:
Muutujad kirjeldavad, mida programm kasutab (nt sisendid, väljundid, loendurid).
Loogika kirjeldab, mida programm nende muutujatega teeb.

4. Praktiline tutvustus: TIA Portal ja SCL-programmi struktuur

4.1. Projekt TIA Portalis

Ava TIA Portal ja loo uus projekt.
Lisa Programmimoodul ja vali keelena SCL.
Uuri SCL-programmi põhistruktuuri:

Muutujate deklaratsioon:
scl VAR Input1 : BOOL; // Sisendsignaal Output1 : BOOL; // Väljundsignaal Counter : INT := 0; // Loendur (algväärtus 0) END_VAR
Programmi keha:
scl BEGIN IF Input1 THEN Counter := Counter + 1; // Suurenda loendurit END_IF; Output1 := (Counter > 10); // Lülita väljund sisse, kui loendur ületab 10 END;

4.2. Esimene harjutus: Muutujate deklareerimine

Loo muutujad:

Input1 (BOOL) – Sisend, mis esindab lülitit.
Output1 (BOOL) – Väljund, mis esindab LED-i.
Counter (INT) – Loendur, mis suurendab iga kord, kui lüliti on sisse lülitatud.

Lisa lihtne loogika, mis suurendab loendurit ja lülitab LED-i sisse.

5. Praktiline harjutus: Esimene programm

Eesmärk: Loo programm, mis jälgib lüliti olekut ja loendab, mitu korda see on sisse lülitatud. Kui loendur ületab 10, lülita LED sisse.

Näidisprogramm:

VAR
    Input1 : BOOL;       // Lüliti
    Output1 : BOOL;      // LED
    Counter : INT := 0;  // Loendur
END_VAR

BEGIN
    IF Input1 THEN
        Counter := Counter + 1;      // Loenduri suurendamine
    END_IF;
    Output1 := (Counter > 10);       // Lülita LED sisse, kui Counter > 10
END;

6. Kordamine ja küsimused

Mis on SCL-i eelised teiste programmeerimiskeelte ees?
Milliseid andmetüüpe saab SCL-is kasutada?
Mida teeb deklaratsioon VAR?

7. Hindamine

Küsimused:

Millist andmetüüpi kasutatakse LED-i esindamiseks?
Kuidas suurendada muutujat Counter ühe võrra?

Praktiline test:
Muuda programmi nii, et LED lülitub sisse ainult siis, kui Counter jõuab 15-ni.

8. Järgmine tund: Loogika ja tingimused

SCL-i tingimusloogika (IF-THEN-ELSE).
Loogiliste operaatorite kasutamine.

See kava annab tugeva aluse, kuidas SCL-i õppimist alustada. Kui oled valmis, liigume järgmise tunni juurde! 😊

II. Lihtloogika ja tingimused SCL-is

Õppetunni eesmärk:

Õppida kasutama tingimusloogikat SCL-is.
Mõista, kuidas kasutada IF-THEN-ELSE konstruktsioone ja loogilisi operaatoreid (AND, OR, NOT).
Luua praktilisi tingimusloogika näiteid ja rakendada neid reaalses stsenaariumis.

1. Tingimusloogika põhimõtted

Tingimusloogika võimaldab programmil teha otsuseid, lähtudes sisenditest ja muutuja olekust. Peamine struktuur selleks on IF-THEN-ELSE, mida kasutatakse loogiliste otsuste langetamiseks.

2. SCL-i tingimusloogika struktuur

2.1 IF-THEN-ELSE

Süntaks:

  IF (tingimus) THEN
      // Kui tingimus on TRUE, täidetakse see blokk
  ELSE
      // Kui tingimus on FALSE, täidetakse see blokk
  END_IF;

Näide:

  IF Input1 THEN
      Output1 := TRUE;  // Lülitab LED-i sisse
  ELSE
      Output1 := FALSE; // Lülitab LED-i välja
  END_IF;

2.2 Sisemised IF-avaldised (nested IF)

Süntaks:

  IF (tingimus1) THEN
      // Tegevus 1
  ELSIF (tingimus2) THEN
      // Tegevus 2
  ELSE
      // Tegevus 3
  END_IF;

Näide:

  IF Temperature > 50 THEN
      Alarm := TRUE;  // Häire, kui temperatuur on liiga kõrge
  ELSIF Temperature < 10 THEN
      Alarm := TRUE;  // Häire, kui temperatuur on liiga madal
  ELSE
      Alarm := FALSE; // Kõik on korras
  END_IF;

3. Loogilised operaatorid SCL-is

3.1 AND (ja)

Mõlemad tingimused peavad olema TRUE, et tulemuseks oleks TRUE.
Näide:

  IF (Input1 AND Input2) THEN
      Motor := TRUE; // Käivitab mootori ainult siis, kui mõlemad sisendid on aktiivsed
  END_IF;

3.2 OR (või)

Vähemalt üks tingimus peab olema TRUE, et tulemuseks oleks TRUE.
Näide:

  IF (Input1 OR Input2) THEN
      Light := TRUE; // Lülitab valguse sisse, kui vähemalt üks nupp on vajutatud
  END_IF;

3.3 NOT (eitus)

Keerab tingimuse loogilise väärtuse vastupidiseks (TRUE → FALSE ja vastupidi).
Näide:

  IF (NOT Input1) THEN
      Alarm := TRUE; // Käivitab häire, kui Input1 on passiivne
  END_IF;

4. Praktilised ülesanded

4.1 Ülesanne: Mootori käivitamine

Eesmärk: Kirjuta programm, mis käivitab mootori, kui mõlemad nupud on vajutatud.
Kood:

  IF (StartButton AND SafetySwitch) THEN
      Motor := TRUE;  // Mootor käivitub
  ELSE
      Motor := FALSE; // Mootor seisab
  END_IF;

4.2 Ülesanne: Mitme tingimuse kontrollimine

Eesmärk: Loo programm, mis lülitab erineva valguse sisse, sõltuvalt töörežiimist.
Kood:

  IF Mode = 1 THEN
      Light1 := TRUE;  // Režiim 1
  ELSIF Mode = 2 THEN
      Light2 := TRUE;  // Režiim 2
  ELSE
      Light1 := FALSE;
      Light2 := FALSE;
  END_IF;

4.3 Ülesanne: Alarmisüsteem

Eesmärk: Häire käivitamine, kui temperatuur ületab 70 kraadi või langeb alla 10 kraadi.
Kood:

  IF (Temperature > 70 OR Temperature < 10) THEN
      Alarm := TRUE;
  ELSE
      Alarm := FALSE;
  END_IF;

SCL keeles saab RS (Reset-Set) ja SR (Set-Reset) trigerite loogika implementeerida tingimuslausete abil. Siin on näited, kuidas seda saab teha:

1. RS Triger (Reset prioriteediga)

RS trigeri loogika tähendab, et Reset (R) omab prioriteeti, st kui nii Set (S) kui ka Reset on aktiivsed, siis loogikaväljund (Q) läheb alati madalaks.

Kood RS Trigeri jaoks:

VAR
    S : BOOL;  // Set sisend
    R : BOOL;  // Reset sisend
    Q : BOOL;  // Väljund
END_VAR

BEGIN
    IF R THEN
        Q := FALSE;  // Reset prioriteediga
    ELSIF S THEN
        Q := TRUE;   // Set, kui Reset pole aktiivne
    END_IF;
END;

Loogika selgitus:

Kui R on TRUE, siis Q saab väärtuse FALSE (Reset toimub).
Kui R on FALSE ja S on TRUE, siis Q saab väärtuse TRUE (Set toimub).
Kui mõlemad on FALSE, siis Q säilitab oma varasema oleku.

2. SR Triger (Set prioriteediga)

SR trigeri loogika tähendab, et Set (S) omab prioriteeti, st kui nii Set kui ka Reset on aktiivsed, siis loogikaväljund (Q) läheb alati kõrgeks.

Kood SR Trigeri jaoks:

VAR
    S : BOOL;  // Set sisend
    R : BOOL;  // Reset sisend
    Q : BOOL;  // Väljund
END_VAR

BEGIN
    IF S THEN
        Q := TRUE;   // Set prioriteediga
    ELSIF R THEN
        Q := FALSE;  // Reset, kui Set pole aktiivne
    END_IF;
END;

Loogika selgitus:

Kui S on TRUE, siis Q saab väärtuse TRUE (Set toimub).
Kui S on FALSE ja R on TRUE, siis Q saab väärtuse FALSE (Reset toimub).
Kui mõlemad on FALSE, siis Q säilitab oma varasema oleku.

Kasutus kontekstis

Trigerite loogikat kasutatakse laialdaselt järgmistes olukordades:

Masina juhtimine: RS triger võib hoida masina olekut näiteks hädaolukorra seiskamise jaoks.
Seadme oleku hoidmine: SR trigerit saab kasutada, et juhtida seadme olekut, mis säilitab oma oleku seni, kuni vastavad tingimused muutuvad.

Täiendav näide koos ajutise Reset-tingimusega

Kui trigeri väljundit peaks automaatselt lähtestama teatud aja möödudes, saab lisada ajarelee loogika:

VAR
    S : BOOL;      // Set sisend
    R : BOOL;      // Reset sisend
    Q : BOOL;      // Väljund
    Timer : TIME;  // Ajarelee
    TimeElapsed : BOOL; // Märge, kas aeg on läbi
END_VAR

BEGIN
    IF S THEN
        Q := TRUE;          // Set
        Timer := T#5s;      // Määra taimer 5 sekundiks
    ELSIF R OR TimeElapsed THEN
        Q := FALSE;         // Reset või aeg on möödas
    END_IF;

    // Kontrolli, kas aeg on möödas
    IF Timer > T#0s THEN
        Timer := Timer - T#10ms;  // Vähenda taimerit
    ELSE
        TimeElapsed := TRUE;      // Märgi, et aeg on läbi
    END_IF;
END;

SCL keeles trigerite kirjutamine nõuab loogilist ülesehitust, kuid võimaldab neid hõlpsasti integreerida keerukatesse juhtimisrakendustesse.

Jah, SCL-i RS ja SR trigerite loogikat saab hõlpsasti siduda tagide tabeliga, mis teeb loogika paremini hallatavaks ja võimaldab sujuvamat integreerimist PLC projektides. Tagide tabel võimaldab määrata muutujate nimed ja aadressid eraldi, lihtsustades koodi lugemist ja muutmist.

1. RS Triger koos tagide tabeliga

Tagide tabel (näide):

Nimi	Tüüp	Kirjeldus	Aadress
S_Input	BOOL	Set sisend	I0.0
R_Input	BOOL	Reset sisend	I0.1
Q_Output	BOOL	Trigeri väljund	Q0.0

SCL-kood:

VAR
    S_Input : BOOL;   // Set sisend (aadress: I0.0)
    R_Input : BOOL;   // Reset sisend (aadress: I0.1)
    Q_Output : BOOL;  // Trigeri väljund (aadress: Q0.0)
END_VAR

BEGIN
    IF R_Input THEN
        Q_Output := FALSE;  // Reset prioriteet
    ELSIF S_Input THEN
        Q_Output := TRUE;   // Set
    END_IF;
END;

2. SR Triger koos tagide tabeliga

Tagide tabel (näide):

Nimi	Tüüp	Kirjeldus	Aadress
S_Start	BOOL	Set sisend	I0.2
R_Stop	BOOL	Reset sisend	I0.3
Machine_State	BOOL	Masina oleku väljund	Q0.1

SCL-kood:

VAR
    S_Start : BOOL;         // Set sisend (aadress: I0.2)
    R_Stop : BOOL;          // Reset sisend (aadress: I0.3)
    Machine_State : BOOL;   // Masina olek (aadress: Q0.1)
END_VAR

BEGIN
    IF S_Start THEN
        Machine_State := TRUE;   // Set prioriteet
    ELSIF R_Stop THEN
        Machine_State := FALSE;  // Reset
    END_IF;
END;

3. Laiendatud näide koos ajutise Reset-tingimusega ja tagide tabeliga

Tagide tabel (näide):

Nimi	Tüüp	Kirjeldus	Aadress
S_Set	BOOL	Set sisend	I0.4
R_Reset	BOOL	Reset sisend	I0.5
Output_Q	BOOL	Väljund	Q0.2
Timer_Value	TIME	Taimeri algväärtus	–
Timer_Elapsed	BOOL	Märge, kas aeg on möödas	M0.0

SCL-kood:

VAR
    S_Set : BOOL;             // Set sisend (aadress: I0.4)
    R_Reset : BOOL;           // Reset sisend (aadress: I0.5)
    Output_Q : BOOL;          // Väljund (aadress: Q0.2)
    Timer_Value : TIME := T#5s;  // Taimeri algväärtus
    Timer_Elapsed : BOOL;     // Märge, kas aeg on möödas
END_VAR

BEGIN
    // Set ja Reset loogika
    IF S_Set THEN
        Output_Q := TRUE;         // Set triger
        Timer_Value := T#5s;      // Taimer algab uuesti
    ELSIF R_Reset OR Timer_Elapsed THEN
        Output_Q := FALSE;        // Reset triger
    END_IF;

    // Taimeri loogika
    IF Timer_Value > T#0ms THEN
        Timer_Value := Timer_Value - T#10ms;  // Vähenda taimerit
        Timer_Elapsed := FALSE;              // Taimer pole läbi
    ELSE
        Timer_Elapsed := TRUE;               // Taimeri aeg on möödas
    END_IF;
END;

Eelised tagide tabeli kasutamisel:

Loetavus:

Muutujate nimed kirjeldavad täpselt nende otstarvet, mistõttu on koodi lihtsam mõista.

Hallatavus:

Kui aadresse tuleb muuta, saab seda teha tagide tabelis, ilma et kogu koodi peaks uuesti kirjutama.

Standardiseerimine:

Suuremates projektides on tagide tabelist abi, et säilitada järjepidevust ja vältida aadresside konflikte.

Tagide tabel muudab SCL-i kirjutamise ja integreerimise tööstuslike süsteemidega sujuvamaks ja tõhusamaks. Kui soovite lisada täiendavaid funktsioone või integreerida koodi keerukamate süsteemidega, andke teada! 😊

5. Täpsemad stsenaariumid

5.1 Tingimuslik väljundi lülitamine

Eesmärk: Lülita valgustid sisse ja välja sõltuvalt mitmest tingimusest.
Kood:

  IF (TimeOfDay = "Night" AND MotionDetected) THEN
      Light := TRUE;  // Lülita valgus sisse öösel ja kui liikumine tuvastatakse
  ELSE
      Light := FALSE;
  END_IF;

5.2 Loogilise tõrke avastamine

Eesmärk: Kui mõlemad ohutusnupud on vajutatud, peaks häire käivituma.
Kood:

  IF (SafetyButton1 AND SafetyButton2) THEN
      Alarm := TRUE;  // Ohutusprobleem
  ELSE
      Alarm := FALSE;
  END_IF;

6. Simulatsioon TIA Portalis

6.1 Simulatsioonikeskkonna seadistamine

Avage oma loodud SCL programm.
Kasutage PLCSIM Advanced või TIA Portali simulatsiooni tööriistu.
Testige programmi järgmiste stsenaariumidega:

Lülitage tingimused (nt sisendid Input1, Input2) ja jälgige väljundeid.
Kontrollige, kas mootor ja valgus lülituvad õigesti vastavalt loogikale.

7. Hindamine

7.1 Küsimused ja ülesanded

Selgitage, kuidas IF-THEN-ELSE töötab.
Mis juhtub, kui lisada loogiline operaator OR järgmisele koodile?

   IF Input1 THEN
       Output1 := TRUE;
   END_IF;

7.2 Praktiline test

Kirjuta programm, mis lülitab mootori sisse, kui temperatuur on vahemikus 20–30 kraadi ja ohutusnupp on aktiivne.

Näidis vastus:

IF (Temperature >= 20 AND Temperature <= 30 AND SafetySwitch) THEN
    Motor := TRUE;
ELSE
    Motor := FALSE;
END_IF;

8. Kokkuvõte ja järgmine tund

Kokkuvõte: Tingimusloogika ja loogiliste operaatorite kasutamine on SCL-i aluseks. Omandatud oskused loovad tugeva aluse keerukamate stsenaariumide lahendamiseks.
Järgmine tund: Matemaatilised operatsioonid ja tsüklid SCL-is.

See põhjalik tund aitab õppijatel SCL-i tingimusloogikat ja lihtloogika ülesandeid edukalt omandada. Kui vajad täiendavaid ülesandeid või näiteid, anna teada! 😊

III. Matemaatilised operatsioonid ja tsüklid SCL-is

Õppetunni eesmärk:

Õppida kasutama matemaatilisi operatsioone ja sisseehitatud funktsioone.
Mõista kordusstruktuuride (FOR, WHILE) toimimist ja rakendamist.
Luua praktilisi programme, mis kasutavad matemaatikat ja tsükleid reaalsetes ülesannetes.

1. Matemaatilised operatsioonid SCL-is

1.1 Põhioperatsioonid

Liitmine (+): Kasutatakse kahe väärtuse liitmiseks.
Lahutamine (-): Lahutab ühe väärtuse teisest.
Korrutamine (*): Korrutab kaks väärtust.
Jagamine (/): Jagab ühe väärtuse teisega.
Näide:

  Result := Value1 + Value2;  // Summa
  Difference := Value1 - Value2;  // Vahe
  Product := Value1 * Value2;  // Korrutis
  Quotient := Value1 / Value2;  // Jagatis

1.2 Sisseehitatud funktsioonid

Trigonomeetria: SIN, COS, TAN.
Ruutjuur: SQRT.
Absoluutväärtus: ABS.
Näide:

  Angle := SIN(30);         // Sine 30 kraadi
  Hypotenuse := SQRT(9);    // Ruutjuur 9-st
  Positive := ABS(-10);     // Absoluutväärtus -10

1.3 Prioriteedid matemaatikas

Matemaatilistes avaldistes järgitakse prioriteete:

Sulud.
Korrutamine (*) ja jagamine (/).
Liitmine (+) ja lahutamine (-).

Näide:

  Result := (Value1 + Value2) * Value3; // Sulud teostatakse esimesena

2. Tsüklid SCL-is

2.1 FOR-tsükkel

Kasutus: Korratakse kindel arv kordi.
Süntaks:

  FOR i := 1 TO 10 DO
      Sum := Sum + i;  // Lisab kõik numbrid vahemikus 1–10
  END_FOR;

Näide:

  FOR i := 1 TO 5 DO
      Result := Result * i;  // Korrutis 1 kuni 5
  END_FOR;

2.2 WHILE-tsükkel

Kasutus: Korratakse seni, kuni tingimus on täidetud.
Süntaks:

  WHILE (Counter < 10) DO
      Counter := Counter + 1;  // Loendab kuni 10
  END_WHILE;

Näide:

  WHILE (Temperature < 100) DO
      Heater := TRUE;  // Lülitab kütte sisse, kuni temperatuur jõuab 100 kraadini
  END_WHILE;

2.3 BREAK ja CONTINUE

BREAK: Lõpetab tsükli enneaegselt.
CONTINUE: Hüppab järgmisele tsükli iteratsioonile.
Näide:

  FOR i := 1 TO 10 DO
      IF i = 5 THEN
          BREAK;  // Lõpeta tsükkel, kui i = 5
      END_IF;
  END_FOR;

3. Praktilised ülesanded

3.1 Ülesanne: Keskmise väärtuse arvutamine

Eesmärk: Arvutage keskmine väärtus viiest sisendist.
Kood:

  VAR
      Values : ARRAY[1..5] OF REAL;
      Sum : REAL := 0.0;
      Average : REAL;
  END_VAR

  FOR i := 1 TO 5 DO
      Sum := Sum + Values[i];  // Liida kõik väärtused
  END_FOR;

  Average := Sum / 5;  // Arvuta keskmine

3.2 Ülesanne: Maksimaalse väärtuse leidmine

Eesmärk: Leia maksimaalne väärtus kümnest mõõtmistulemuse sisendist.
Kood:

  VAR
      Values : ARRAY[1..10] OF REAL;
      MaxValue : REAL := 0.0;
  END_VAR

  FOR i := 1 TO 10 DO
      IF Values[i] > MaxValue THEN
          MaxValue := Values[i];  // Uuenda, kui leitakse suurem väärtus
      END_IF;
  END_FOR;

3.3 Ülesanne: Temperatuuri stabiliseerimine

Eesmärk: Hoia temperatuuri vahemikus 20–25 kraadi.
Kood:

  WHILE (Temperature < 20 OR Temperature > 25) DO
      IF Temperature < 20 THEN
          Heater := TRUE;  // Lülita küte sisse
      ELSE
          Cooler := TRUE;  // Lülita jahutus sisse
      END_IF;
  END_WHILE;

4. Täpsemad ülesanded

4.1 Fibonacci arvude genereerimine

Eesmärk: Genereeri Fibonacci jada esimesed 10 numbrit.
Kood:

  VAR
      Fib : ARRAY[1..10] OF INT;
      i : INT;
  END_VAR

  Fib[1] := 0;
  Fib[2] := 1;

  FOR i := 3 TO 10 DO
      Fib[i] := Fib[i-1] + Fib[i-2];
  END_FOR;

4.2 Realiseerimistsükli katkestus

Eesmärk: Peata tsükkel, kui temperatuur ületab 100 kraadi.
Kood:

  FOR i := 1 TO 100 DO
      IF Temperature > 100 THEN
          BREAK;  // Peata tsükkel
      END_IF;
  END_FOR;

5. Simulatsioon ja testimine

5.1 Testimine TIA Portalis

Loo uus SCL-moodul ja lisa praktilise ülesande kood.
Kasuta PLCSIM Advanced, et simuleerida sisendeid ja vaadata väljundeid.
Analüüsi tsükli ja arvutuste tulemusi logiandmete abil.

6. Hindamine

6.1 Küsimused ja ülesanded

Selgita, kuidas FOR-tsükkel töötab.
Mis on SQRT funktsiooni eesmärk?
Kirjuta kood, mis korrutab kõik väärtused vahemikus 1–5.

6.2 Praktiline test

Kirjuta programm, mis jälgib rõhku ja arvutab keskmise rõhu viie viimase mõõtmise põhjal.

7. Kokkuvõte ja järgmine tund

Kokkuvõte: Matemaatilised operatsioonid ja tsüklid on vajalikud keerukate loogikate ja andmeanalüüsi jaoks. Omandatud oskused on rakendatavad reaalsetes juhtimissüsteemides.
Järgmine tund: Funktsioonid ja funktsiooniblokid SCL-is.

See tund aitab õppijatel tugevdada arusaama matemaatilistest operatsioonidest ja tsüklitest SCL-is, pakkudes nii teooriat kui ka praktilisi ülesandeid. Kui soovid lisamaterjale, anna teada!

IV. Funktsioonid ja funktsiooniblokid SCL-is

Õppetunni eesmärk:

Õppida looma ja kasutama funktsioone (FC) ja funktsiooniblokke (FB) SCL-is.
Mõista nende erinevusi ja rakendusi automaatikas.
Luua praktilisi ülesandeid, mis kasutavad funktsioone ja funktsiooniblokke korduvate ülesannete lihtsustamiseks.

1. Mis on funktsioonid ja funktsiooniblokid?

1.1 Funktsioonid (Functions – FC)

Definitsioon: Funktsioon on korduvkasutatav koodilõik, mis võtab sisendid, töötleb need ja tagastab ühe tulemuse.
Omadused:
Ei oma püsivat mälu (ei mäleta varasemaid väärtusi).
Sobib hästi arvutuste ja lihtsate operatsioonide jaoks.
Näide:

  FUNCTION FC_Addition : REAL
  VAR_INPUT
      A : REAL;
      B : REAL;
  END_VAR
  FC_Addition := A + B; // Tagastab liidetud väärtuse

1.2 Funktsiooniblokid (Function Blocks – FB)

Definitsioon: Funktsiooniblokk on keerukamate loogikate ja protsesside jaoks mõeldud koodilõik, mis kasutab püsivat mälu (säilitab olekut).
Omadused:
Säilitab oma sisemiste muutujate väärtused iga tsükli järel.
Sobib olukordadesse, kus on vaja jälgida protsessi olekut või ajalist järjestust.
Näide:

  FUNCTION_BLOCK FB_Counter
  VAR
      Counter : INT := 0;
  END_VAR
  Counter := Counter + 1; // Loendab kutsumiskordi

2. Funktsioonide loomine ja kasutamine

2.1 Funktsiooni loomine

Funktsioonid vajavad sisendparameetreid ja tagastavad ühe tulemuse.
Näide: Lihtne funktsioon kahekordse väärtuse arvutamiseks.

  FUNCTION FC_Double : REAL
  VAR_INPUT
      Value : REAL;
  END_VAR
  FC_Double := Value * 2;  // Tagastab kahekordse väärtuse

2.2 Funktsiooni kasutamine

Funktsioone kutsutakse programmiblokist, edastades neile vajalikud sisendid.
Näide:

  Result := FC_Double(InputValue);  // Kutsub funktsiooni ja salvestab tulemuse

3. Funktsiooniblokkide loomine ja kasutamine

3.1 Funktsioonibloki loomine

Funktsiooniblokk kasutab sisendeid, väljundeid ja püsivaid muutujaid protsesside juhtimiseks.
Näide: Lihtne loendur:

  FUNCTION_BLOCK FB_Counter
  VAR_INPUT
      Reset : BOOL;
  END_VAR
  VAR_OUTPUT
      Count : INT;
  END_VAR
  VAR
      InternalCount : INT := 0;
  END_VAR

  IF Reset THEN
      InternalCount := 0;
  ELSE
      InternalCount := InternalCount + 1;
  END_IF;

  Count := InternalCount;

3.2 Funktsioonibloki kasutamine

Funktsiooniblokki kutsutakse instantsi kaudu, et püsivad väärtused säiliksid.
Näide:

  FB_Counter_Instance : FB_Counter;  // Instantsi loomine
  FB_Counter_Instance(Reset := FALSE);  // Kutsumine

4. Praktilised ülesanded

4.1 Ülesanne: Summa arvutamine funktsiooniga

Eesmärk: Loo funktsioon, mis liidab kaks arvu ja tagastab summa.
Kood:

  FUNCTION FC_Sum : REAL
  VAR_INPUT
      A : REAL;
      B : REAL;
  END_VAR
  FC_Sum := A + B;

4.2 Ülesanne: Loendur funktsiooniblokiga

Eesmärk: Loo funktsiooniblokk, mis loendab sisendi signaali aktiivsuse kordi.
Kood:

  FUNCTION_BLOCK FB_SignalCounter
  VAR_INPUT
      Signal : BOOL;
  END_VAR
  VAR_OUTPUT
      Count : INT;
  END_VAR

  IF Signal THEN
      Count := Count + 1;
  END_IF;

4.3 Ülesanne: Temperatuuri piiramine funktsiooniga

Eesmärk: Loo funktsioon, mis piirab temperatuuri kindlasse vahemikku (nt 20–30 kraadi).
Kood:

  FUNCTION FC_Clamp : REAL
  VAR_INPUT
      Value : REAL;
      Min : REAL;
      Max : REAL;
  END_VAR

  IF Value < Min THEN
      FC_Clamp := Min;
  ELSIF Value > Max THEN
      FC_Clamp := Max;
  ELSE
      FC_Clamp := Value;
  END_IF;

4.4 Ülesanne: Mootori käivitus funktsiooniblokiga

Eesmärk: Loo funktsiooniblokk, mis lülitab mootori sisse, kui ohutusnupp on vajutatud ja temperatuur on alla 50 kraadi.
Kood:

  FUNCTION_BLOCK FB_MotorControl
  VAR_INPUT
      SafetySwitch : BOOL;
      Temperature : REAL;
  END_VAR
  VAR_OUTPUT
      Motor : BOOL;
  END_VAR

  IF SafetySwitch AND (Temperature < 50) THEN
      Motor := TRUE;
  ELSE
      Motor := FALSE;
  END_IF;

5. Simulatsioon TIA Portalis

Loo SCL-programmi uus funktsioon või funktsiooniblokk.
Kutsu loodud funktsioon või funktsiooniblokk instantsist.
Testi funktsiooni sisenditega ja jälgi väljundeid simulatsioonis.

6. Hindamine

6.1 Küsimused

Millal kasutada funktsiooni ja millal funktsiooniblokki?
Mis vahe on VAR_INPUT ja VAR_OUTPUT vahel?
Kirjuta näide funktsioonist, mis arvutab ruudu.

6.2 Praktiline test

Kirjuta funktsioon, mis arvutab anduri mõõdetud väärtuse keskmise.
Loo funktsiooniblokk, mis jälgib mootori käivitusi ja loendab need.

7. Kokkuvõte ja järgmine tund

Kokkuvõte: Funktsioonid ja funktsiooniblokid aitavad luua korduvkasutatavaid ja struktureeritud programme.
Järgmine tund: Vigade käsitlemine ja tõrkeotsing SCL-is.

See tund annab selge ülevaate funktsioonide ja funktsiooniblokkide loomisest ning nende praktilisest kasutamisest. Kui vajad täiendavaid näiteid või ülesandeid, anna teada! 😊

V. Vigade käsitlemine ja tõrkeotsing SCL-is

Õppetunni eesmärk:

Õppida tuvastama ja parandama vigu SCL-programmides.
Mõista vigade käsitlemise mehhanisme ja tõhusate koodipraktikate tähtsust.
Rakendada vigade logimist ja tõrkeotsingut simulatsioonikeskkonnas.

1. Mis on vead SCL-is ja miks need tekivad?

1.1 Veatüübid

Süntaksivead:

Esinevad, kui kood ei vasta SCL-i keeles reeglitele.
Näited:
- Puuduvad semikoolonid (;).
- Valesti määratud muutujad.
Näide:
scl IF (Input1 THEN // Süntaksiviga: sulg puudu Output1 := TRUE; END_IF;

Loogikavead:

Kood käivitub edukalt, kuid käitub valesti, kuna loogika ei ole korrektne.
Näide:
scl IF Temperature > 100 THEN Alarm := FALSE; // Vale loogika, peaks olema TRUE END_IF;

Käitusvead (Runtime Errors):

Tekivad programmi käivitamisel, näiteks andmetüübi konfliktid või väärtuste ületamine.
Näide:
- Jagamine nulliga.
- Arv ületab lubatud suuruse.

2. Vigade käsitlemise meetodid

2.1 IF-THEN kontroll

Kasutage tingimusavaldusi, et vältida potentsiaalseid vigu.
Näide:

  IF Divider <> 0 THEN
      Result := Numerator / Divider;  // Jagamine toimub ainult, kui jagaja ei ole 0
  ELSE
      Result := 0;  // Vea vältimine
  END_IF;

2.2 Piirangute kontroll (Clamping)

Kehtestage väärtustele piirangud enne nende kasutamist.
Näide:

  IF Temperature > 100 THEN
      Temperature := 100;  // Piira maksimaalse väärtuseni
  END_IF;

2.3 Logi ja jälgi vigade tekkimise allikat

Lisage koodi vigu jälgivad muutujad või logisõnumid.
Näide:

  IF ErrorCondition THEN
      ErrorLog := ErrorLog + 1;  // Loenda vigu
  END_IF;

3. Vigade käsitlemine TRY-CATCH mehhanismiga

TRY-CATCH võimaldab käsitleda käitusvigu ja vältida programmi seiskumist. Kuigi see pole alati kõikides SCL versioonides saadaval, saab seda rakendada teatud süsteemides.
Näide:

  TRY
      Result := Value1 / Value2;  // Võimalik jagamine nulliga
  CATCH
      Result := 0;  // Vea korral tagasta ohutu väärtus
  END_TRY;

4. Vigade logimine

4.1 Vigade jälgimine

Kasutage süsteemipõhiseid loogikamuutujaid ja salvestage vigade olek.
Näide:

  IF Error THEN
      ErrorLog := ErrorLog + 1;  // Lisa viga logisse
  END_IF;

4.2 Vigade kuvamine kasutajaliidesel (HMI)

Integreerige veasõnumid HMI-ga, et operaatorid saaksid vigu reaalajas jälgida.
Näide:

  IF MotorOverload THEN
      ErrorMessage := 'Mootori ülekoormus';
  END_IF;

5. Praktilised ülesanded

5.1 Ülesanne: Jagamise vea vältimine

Eesmärk: Kirjuta programm, mis kontrollib jagajat enne arvutuse tegemist.
Kood:

  IF Divider <> 0 THEN
      Result := Numerator / Divider;
  ELSE
      Result := 0;  // Vältida jagamise viga
  END_IF;

5.2 Ülesanne: Temperatuuri ohutu vahemik

Eesmärk: Kontrolli, kas temperatuur jääb kindlasse vahemikku.
Kood:

  IF (Temperature < 20 OR Temperature > 80) THEN
      Alarm := TRUE;  // Käivita alarm
  ELSE
      Alarm := FALSE;
  END_IF;

5.3 Ülesanne: Loogilise vea parandus

Eesmärk: Paranda programm, kus alarmi loogika on valesti määratud.
Vale kood:

  IF Temperature > 100 THEN
      Alarm := FALSE;  // Vale loogika
  END_IF;

Parandus:

  IF Temperature > 100 THEN
      Alarm := TRUE;  // Õige loogika
  END_IF;

6. Tõrkeotsing TIA Portalis

6.1 Simulatsioon

Ava TIA Portal ja käivita loodud programm simulatsioonirežiimis.
Jälgi sisendite ja väljundite olekut simulatsioonitööriistade abil.
Vaata logisid ja leia vead.

6.2 Silur (Debugger)

Kasuta TIA Portali silumisvahendit, et jälgida programmi täitmist reaalajas.
Kontrolli muutujate väärtusi ja jälgi, kus viga esineb.

6.3 Diagnostikablokid

Lisa diagnostikablokid, et jälgida süsteemi tööd ja vigu.
Näiteks jälgi mootori käivitustsüklite arvu.

7. Hindamine

7.1 Küsimused

Kuidas käsitleda jagamise viga, kui jagaja väärtus on 0?
Mida tähendab “loogikaviga” ja kuidas seda parandada?
Millal tuleks kasutada TRY-CATCH mehhanismi?

7.2 Praktiline test

Kirjuta programm, mis jälgib mootori temperatuuri ja lülitab mootori välja, kui temperatuur ületab ohutu piiri.

Näidis vastus:

IF MotorTemperature > 100 THEN
    Motor := FALSE;  // Lülita mootor välja
    Alarm := TRUE;   // Käivita häire
END_IF;

8. Kokkuvõte ja järgmine tund

Kokkuvõte: Vigade käsitlemine ja tõrkeotsing on kriitiline oskus, mis tagab süsteemi töökindluse ja ohutuse.
Järgmine tund: Integreerimine ja simulatsioon SCL-is.

See tund annab õppijatele praktilised tööriistad ja oskused, et tuvastada ja lahendada vigu SCL-programmides. Kui vajad täiendavaid näiteid või ülesandeid, anna teada! 😊

VI. Integreerimine ja simulatsioon SCL-is

Õppetunni eesmärk:

Õppida SCL-koodide integreerimist reaalsete või simuleeritud PLC-süsteemidega TIA Portalis.
Rakendada simulatsioonikeskkonda koodi testimiseks ja valideerimiseks.
Kontrollida ja optimeerida süsteemi tööd simulatsioonivahendite abil.

1. SCL-koodide integreerimine PLC-süsteemidega

1.1 Integreerimise põhimõtted

Reaalsed PLC-seadmed: SCL-kood töötab reaalsetel Siemens PLC-del nagu S7-1200 või S7-1500.
Simuleeritud PLC: Kasutatakse TIA Portali simulatsiooni tööriista (PLCSIM Advanced), et testida programmi enne reaalses seadmes käivitamist.

1.2 Integreerimise sammud TIA Portalis

Uue projekti loomine:

Ava TIA Portal ja loo uus projekt.
Lisa PLC-seade (nt S7-1200 või S7-1500).

Programmi lisamine:

Loo uus SCL-programmimoodul.
Lisa oma SCL-kood programmi.

Muutujate kaardistamine:

Määra sisendite ja väljundite aadressid PLC seadme tegelike I/O terminalidega.
Näide: VAR_INPUT StartButton : BOOL; // Mapped to I0.0 StopButton : BOOL; // Mapped to I0.1 END_VAR VAR_OUTPUT Motor : BOOL; // Mapped to Q0.0 END_VAR

Kompileerimine ja laadimine:

Kompileeri programm, et veenduda, et see on vigadeta.
Lae programm simuleeritud PLC-sse või reaalsesse seadmesse.

2. Simulatsiooni seadistamine

2.1 PLCSIM Advanced

Mis on PLCSIM Advanced?
Siemens TIA Portali sisseehitatud tööriist PLC-programmide simulatsiooniks.
Võimaldab testida koodi ilma reaalse PLC-ta.
Simulatsiooni eelised:
Vähendab riistvara vajadust.
Kiirendab koodi testimist ja vigade avastamist.

2.2 Simulatsiooni käivitamine

Simulatsioonirežiimi aktiveerimine:

Ava PLCSIM Advanced ja valmista ette simuleeritud PLC.
Määra samad sisendite ja väljundite aadressid nagu koodis.

Koodi testimine:

Käivita simulatsioon ja jälgi sisendite/väljundite olekut.
Muuda sisendite väärtusi simulatsioonivahendi kaudu (nt vajuta nuppe või lülita signaale).

Diagnostika kasutamine:

Kasuta TIA Portali diagnostikavahendeid, et jälgida muutujate väärtusi ja programmi voogu.

3. Praktilised ülesanded

3.1 Ülesanne: Lihtne mootori juhtimine simulatsioonis

Eesmärk: Juhtida mootorit Start ja Stop nuppude abil.
Kood:

  VAR_INPUT
      StartButton : BOOL;
      StopButton : BOOL;
  END_VAR
  VAR_OUTPUT
      Motor : BOOL;
  END_VAR

  BEGIN
      IF StartButton THEN
          Motor := TRUE;
      ELSIF StopButton THEN
          Motor := FALSE;
      END_IF;
  END;

Testimine:
Käivita simulatsioon ja jälgi, kuidas mootori olek muutub Start ja Stop nuppude aktiveerimisel.

3.2 Ülesanne: Valgusfoori simulatsioon

Eesmärk: Simuleeri valgusfoori loogikat.
Kood:

  VAR
      Timer : INT := 0;
      LightRed : BOOL;
      LightGreen : BOOL;
  END_VAR

  BEGIN
      Timer := Timer + 1;
      IF Timer <= 50 THEN
          LightRed := TRUE;
          LightGreen := FALSE;
      ELSE
          LightRed := FALSE;
          LightGreen := TRUE;
          IF Timer > 100 THEN
              Timer := 0;  // Taaskäivita tsükkel
          END_IF;
      END_IF;
  END;

Testimine:
Jälgi, kuidas valgusfoori loogika töötab, kui taimer loeb tsükleid.

3.3 Ülesanne: Temperatuuri kontroll

Eesmärk: Loo simulatsioon, mis lülitab jahutuse sisse, kui temperatuur ületab 50 kraadi.
Kood:

  VAR_INPUT
      Temperature : REAL;
  END_VAR
  VAR_OUTPUT
      Cooler : BOOL;
  END_VAR

  BEGIN
      IF Temperature > 50 THEN
          Cooler := TRUE;
      ELSE
          Cooler := FALSE;
      END_IF;
  END;

Testimine:
Simuleeri temperatuuri väärtusi ja jälgi, kuidas jahutuse olek muutub.

4. Diagnostika ja optimeerimine

4.1 Diagnostikavahendid

Live Watch Table: Jälgi muutujate reaalajas väärtusi TIA Portalis.
Logi andmete salvestamine: Salvesta sisendite ja väljundite muutused analüüsimiseks.
Stsenaariumide testimine: Kasuta simulatsioonis erinevaid sisendeid ja kontrolli, kas kood käitub ootuspäraselt.

4.2 Optimeerimine

Koodi lihtsustamine: Vähenda tarbetut koodi ja optimeeri loogikat.
Ressursside kasutamine: Kontrolli, et kood ei koorma PLC mälu ega protsessorit.

5. Hindamine

5.1 Küsimused

Miks on simulatsioon kasulik enne programmi reaalset kasutamist?
Mis on PLCSIM Advanced tööriista eelised võrreldes reaalse PLC-ga testimisega?

5.2 Praktiline test

Simuleeri programmi, mis arvutab mootori töökordade arvu ja kuvab selle diagnostikatabelis.

6. Kokkuvõte ja järgmine tund

Kokkuvõte: Integreerimine ja simulatsioon on kriitilised sammud, mis tagavad koodi töökindluse enne reaalsesse süsteemi rakendamist.
Järgmine tund: Lõppprojekt – terviklik lahendus SCL-is.

See tund võimaldab õppijatel omandada praktilised oskused koodi integreerimiseks ja simuleerimiseks, kindlustades süsteemi töökindluse.

VII. Lõppprojekt – Terviklik lahendus SCL-is

Õppetunni eesmärk:

Kombineerida kogu kursusel õpitu ühte terviklikku projekti.
Lahendada reaalne automaatikaprobleem, kasutades funktsioone, funktsiooniblokke, tingimusloogikat, tsükleid ja simulatsiooni.
Õppida looma struktureeritud, korduvkasutatavat ja optimeeritud koodi.

1. Projekti kirjeldus

1.1 Projekti eesmärk

Luua tootmisliini juhtimisprogramm, mis simuleerib järgmisi funktsioone:

Konveieri mootor käivitub ja peatub Start ja Stop nuppude abil.
Konveieril asuvate detailide loendamine.
Häire käivitamine, kui temperatuuri- või kiirusnäitajad ületavad ohutu piiri.
Tööaja ja töötsüklite jälgimine diagnostika eesmärgil.

2. Projekti etapid

2.1 Etapp 1: Muutujate deklareerimine

Sisendid:
StartButton (BOOL) – Start-nupp.
StopButton (BOOL) – Stop-nupp.
TemperatureSensor (REAL) – Temperatuuriandur.
ItemSensor (BOOL) – Detailide loendur.
Väljundid:
ConveyorMotor (BOOL) – Konveieri mootori juhtimine.
Alarm (BOOL) – Häire aktiveerimine.
Sisemised muutujad:
ItemCount (INT) – Loendatud detailide arv.
OperatingTime (REAL) – Tööaeg minutites.
OverheatCount (INT) – Kordade arv, mil temperatuur ületab ohutu piiri.
Näide muutujate deklaratsioonist:

  VAR_INPUT
      StartButton : BOOL;
      StopButton : BOOL;
      TemperatureSensor : REAL;
      ItemSensor : BOOL;
  END_VAR

  VAR_OUTPUT
      ConveyorMotor : BOOL;
      Alarm : BOOL;
  END_VAR

  VAR
      ItemCount : INT := 0;
      OperatingTime : REAL := 0.0;
      OverheatCount : INT := 0;
  END_VAR

2.2 Etapp 2: Konveieri mootori juhtimine

Loogika: Mootor käivitub Start-nupust ja peatub Stop-nupust.
Kood:

  IF StartButton THEN
      ConveyorMotor := TRUE;
  ELSIF StopButton THEN
      ConveyorMotor := FALSE;
  END_IF;

2.3 Etapp 3: Detailide loendamine

Loogika: Loendatakse iga detail, mis liigub konveieri anduri alt läbi.
Kood:

  IF ItemSensor THEN
      ItemCount := ItemCount + 1;
  END_IF;

2.4 Etapp 4: Temperatuuri jälgimine ja häire käivitamine

Loogika: Kui temperatuur ületab 70 °C, käivitatakse häire ja loendatakse ülekuumenemised.
Kood:

  IF TemperatureSensor > 70.0 THEN
      Alarm := TRUE;
      OverheatCount := OverheatCount + 1;
  ELSE
      Alarm := FALSE;
  END_IF;

2.5 Etapp 5: Tööaja jälgimine

Loogika: Jälgitakse konveieri mootori tööaega minutites.
Kood:

  IF ConveyorMotor THEN
      OperatingTime := OperatingTime + 0.1;  // Iga tsükkel lisab 0.1 minutit (simulatsiooni kiirusel)
  END_IF;

2.6 Etapp 6: Funktsiooni ja funktsioonibloki kasutamine

Funktsioon: Temperatuuri piiramine

Eesmärk: Tagada, et temperatuur jääb 0–100 °C vahemikku.
Kood:

  FUNCTION FC_LimitTemperature : REAL
  VAR_INPUT
      Temp : REAL;
  END_VAR

  IF Temp < 0 THEN
      FC_LimitTemperature := 0;
  ELSIF Temp > 100 THEN
      FC_LimitTemperature := 100;
  ELSE
      FC_LimitTemperature := Temp;
  END_IF;

Funktsiooniblokk: Loendur

Eesmärk: Üldotstarbeline loendur anduri signaalide loendamiseks.
Kood:

  FUNCTION_BLOCK FB_Counter
  VAR_INPUT
      Signal : BOOL;
      Reset : BOOL;
  END_VAR
  VAR_OUTPUT
      Count : INT;
  END_VAR

  IF Reset THEN
      Count := 0;
  ELSIF Signal THEN
      Count := Count + 1;
  END_IF;

3. Simulatsioon TIA Portalis

3.1 Simulatsioonikeskkonna seadistamine

Käivita TIA Portal ja loo uus projekt.
Lisa PLC-seade ja PLCSIM Advanced.
Lisa sisendid ja väljundid simulatsioonikeskkonda:

StartButton ja StopButton – Nuppude simuleerimine.
TemperatureSensor – Temperatuuri väärtuse seadistamine.
ItemSensor – Detailide liikumise simuleerimine.

3.2 Testimine

Käivita simulatsioon ja testige järgmisi stsenaariume:

Vajutage Start-nuppu ja kontrollige, kas mootor käivitub.
Simuleerige temperatuur üle 70 °C ja jälgige, kas häire käivitub.
Looge tsüklisignaale ItemSensori jaoks ja jälgige, kas detailide loendur töötab.

3.3 Diagnostika

Kasutage Watch Table tööriista, et jälgida muutujate väärtusi reaalajas.
Salvestage logid, et analüüsida tööaja ja temperatuuri andmeid.

4. Projekti laiendamise ideed

4.1 Automaatne mootori peatus

Peatage mootor automaatselt, kui temperatuur ületab 80 °C.

4.2 Andmete logimine

Lisage funktsioon, mis salvestab detailide arvu ja tööaja eraldi logifaili.

4.3 Mitme konveieri juhtimine

Laiendage projekti, et juhtida kaht konveierit sõltuvalt nende töökoormusest ja temperatuurist.

5. Hindamine

5.1 Küsimused

Miks on oluline piirata temperatuur väärtuste vahemikku?
Kuidas saab funktsiooniblokki (FB) kasutada korduvkasutatava loogika jaoks?

5.2 Praktiline ülesanne

Lisage projektile funktsioon, mis kuvab ülekuumenemiste koguarvu ja tööaja HMI-s.

6. Kokkuvõte

Projekti eesmärk saavutatud: Õppijad integreerisid kursuse teemad terviklikuks lahenduseks.
Edasised sammud: Rakendada õpitud oskusi reaalseadmetes ja arendada keerukamaid lahendusi.

See lõppprojekt ühendab kõik kursuse teemad praktiliseks ja terviklikuks rakenduseks.

Kursuse lõpetamine ja kokkuvõte

Kursuse eesmärgid ja saavutused

Kursus „SCL programmeerimise põhialused“ oli üles ehitatud selleks, et õppijad:

Mõistaksid SCL-i kui tekstitasemel PLC-programmeerimiskeelt.
Õpiksid praktilisi oskusi, nagu tingimusloogika, tsüklite, funktsioonide ja funktsiooniblokkide loomine.
Rakendaksid õpitut terviklikus lahenduses, kasutades TIA Portali ja simulatsioonivahendeid.

Kursuse peamised teemad ja tulemused

Sissejuhatus SCL-i:

Õppijad mõistsid, mis on SCL, kuidas see toimib ja kus seda kasutatakse.

Lihtloogika ja tingimused:

Kasutati IF-THEN-ELSE struktuure ja loogilisi operaatoreid reaalsete stsenaariumide lahendamiseks.

Matemaatilised operatsioonid ja tsüklid:

Loendati, arvutati ja viidi läbi korduvaid operatsioone FOR- ja WHILE-tsüklitega.

Funktsioonid ja funktsiooniblokid:

Loome korduvkasutatavaid komponente ja struktureeritud lahendusi.

Vigade käsitlemine ja tõrkeotsing:

Õpiti tuvastama ja parandama vigu ning optimeerima koodi.

Integreerimine ja simulatsioon:

SCL-programmide testimine simuleeritud PLC-s ja reaalseadmetega.

Õppijate saavutused ja hindamiskriteeriumid

Õpiväljundid:

Õppija oskab kirjutada SCL-koodi, mis sisaldab tingimusloogikat, tsükleid ja matemaatilisi operatsioone.
Õppija oskab kasutada funktsioone ja funktsiooniblokke korduvkasutatava loogika loomiseks.
Õppija suudab testida ja valideerida oma koodi simulatsioonikeskkonnas.
Õppija mõistab, kuidas käsitleda vigu ja optimeerida programmi.

Hindamiskriteeriumid:

Praktiline test: Õppija kirjutab töötava koodi, mis lahendab reaalse automaatikaprobleemi.
Simulatsioon ja integratsioon: Õppija tõendab koodi funktsionaalsust simulatsioonikeskkonnas.
Lõppprojekt: Õppija loob ja esitleb tervikliku lahenduse, mis integreerib kõik kursusel õpitu.

Edasised sammud

Edasised õppimise ja praktika võimalused:

Keerukamad rakendused:

Tööstuslike võrguühenduste (nt Profinet, Modbus) integreerimine.
Andmete logimine ja analüüs.

Erinevad programmeerimiskeeled:

Ladder Diagram (LD), Function Block Diagram (FBD) ja Structured Text (ST) kasutamine koos SCL-iga.

Reaalseadmete kasutamine:

Õppida kasutama SCL-i reaalsete Siemens PLC-dega tootmisprotsesside juhtimisel.

Edasised sertifikaadid ja kvalifikatsioonid:

Siemens SIMATIC TIA Portal sertifikaadid, mis tõendavad oskusi professionaalsel tasemel.
Süsteemihalduse ja -integratsiooni kursused.

Ülesanded

Siin on 20 erinevat ülesannet SCL-keele praktiseerimiseks. Need katavad laia valikut teemasid, alates lihtsast loogikast kuni keerukamate funktsioonide ja simulatsioonideni.

Lihtloogika ja tingimused

Lüliti ja valguse juhtimine:

Loo programm, mis lülitab valguse sisse, kui nupp on vajutatud, ja välja, kui nupp vabastatakse.

Turvaline mootori käivitus:

Mootor võib käivituda ainult siis, kui kaks ohutusnuppu on korraga vajutatud.

Häiresignaali juhtimine:

Käivita häire, kui temperatuur ületab 70 °C ja rõhk ületab 5 bar.

Kiiruse reguleerimine:

Loo kood, mis reguleerib mootori kiirust sõltuvalt temperatuurist: madalam temperatuur → suurem kiirus.

Automaatne valgustus:

Valgus lülitub sisse, kui liikumisandur tuvastab liikumise, ja välja pärast 30-sekundilist vahet.

Matemaatilised operatsioonid

Keskmise väärtuse arvutamine:

Loo programm, mis arvutab kolme sisendi keskmise.

Temperatuuri konverteerimine:

Arvuta temperatuur Celsiuse kraadidest Fahrenheiti kraadideks.

Energiatarbimise arvutamine:

Arvuta, kui palju energiat (kWh) on süsteem tarbinud kindla aja jooksul, lähtudes võimsusest.

Geomeetrilised arvutused:

Loo kood, mis arvutab ruudu ümbermõõdu ja pindala, võttes sisendiks külje pikkuse.

Kütusekulu arvutamine:
- Loo funktsioon, mis arvutab sõiduki kütusekulu, lähtudes läbitud vahemaast ja tarbitud kütusest.

Tsüklid ja kordused

Fibonacci jada:
- Genereeri Fibonacci jada esimesed 10 numbrit.
Loendur:
- Loo loendur, mis loendab iga kord, kui signaal on aktiivne.
Massiivi väärtuste summa:
- Arvuta massiivis olevate numbrite summa.
Kontrollväärtuste otsing:
- Leia massiivist suurim ja väikseim väärtus.
Massiivi väärtuste filtreerimine:
- Arvuta, mitu väärtust massiivis on suuremad kui 50.

Funktsioonid ja funktsiooniblokid

Ruutjuure arvutamine:
- Loo funktsioon, mis arvutab sisestatud arvu ruutjuure.
Loendusfunktsioon:
- Loo funktsiooniblokk, mis loendab sisendi signaali aktiveerimise kordi ja võimaldab loenduri nullida.
Ohutuskontroller:
- Loo funktsiooniblokk, mis jälgib mitme turvalüliti olekut ja lülitab süsteemi välja, kui mõni lüliti on passiivne.
Valgustuse mustri loomine:
- Loo funktsioon, mis lülitab erinevaid valgusgruppe sisse ja välja kindla mustri alusel.
Temperatuuri piirik:
- Loo funktsioon, mis hoiab temperatuuri kindlas vahemikus (nt 20–80 °C), tagastades lubatud vahemikku jääva väärtuse.

Integreeritud ja keerukamad ülesanded

Automaatne tootmisliin:
- Loo programm, mis juhib konveieril töötavat liini, lülitades erinevaid mootoreid sisse ja välja sõltuvalt detailide olemasolust ja liikumisest.
Pakendamisloogika:
- Juhi pakendamasinat, mis loendab iga 10. detaili ja lülitab seejärel pakendaja mootori sisse.
Ventilatsioonisüsteem:
- Loo kood, mis juhib ventilatsiooni sõltuvalt temperatuurist ja niiskusest.
Kütusejaama häiresüsteem:
- Arenda programm, mis tuvastab leke või ülerõhu ja lülitab süsteemi automaatselt välja.
Veetaseme juhtimine:
- Jälgi veepaagi taset ja lülita pump sisse/välja sõltuvalt tasemeanduri näidust.

Simulatsioon ja diagnostika

Simuleeritud temperatuurisüsteem:
- Simuleeri süsteemi, kus temperatuur suureneb ja väheneb tsükliliselt, ning jälgi jahutuse ja kütte olekut.
Mootori diagnostika:
- Jälgi mootori töötsükleid ja lülita mootor välja pärast 100 käivitus-tsüklit.
Vigade logimine:
- Loo programm, mis tuvastab erinevaid vigu (nt kõrge temperatuur, madal rõhk) ja logib need süsteemi.
Automaatne süsteemi lähtestamine:
- Loo funktsioon, mis automaatselt lähtestab loendureid ja parameetreid pärast töötsükli lõppu.
Reaalajas tööaja jälgimine:
- Jälgi konveieri tööaega ja kuva see diagnostikatabelis reaalajas.

Need ülesanded katavad erinevaid SCL-i kasutusvaldkondi ja aitavad õppijatel süvendada teadmisi programmeerimisest, loogikast ja simulatsioonidest. Kui vajad mõne ülesande kohta põhjalikumat seletust või valmis koodi, anna teada! 😊

Siin on ülesannete lahendused, mis on mõeldud õpetajatele õpilaste juhendamiseks ja kontrollimiseks. Iga lahendus sisaldab kommentaare, mis selgitavad, kuidas kood töötab.

Lihtloogika ja tingimused

Lüliti ja valguse juhtimine:

   VAR
       Button : BOOL;
       Light : BOOL;
   END_VAR

   IF Button THEN
       Light := TRUE;  // Lülita valgus sisse, kui nupp on vajutatud
   ELSE
       Light := FALSE; // Lülita valgus välja, kui nupp vabastatakse
   END_IF;

Turvaline mootori käivitus:

   VAR
       SafetyButton1 : BOOL;
       SafetyButton2 : BOOL;
       Motor : BOOL;
   END_VAR

   IF (SafetyButton1 AND SafetyButton2) THEN
       Motor := TRUE;  // Mootor käivitub ainult siis, kui mõlemad nupud on vajutatud
   ELSE
       Motor := FALSE;
   END_IF;

Häiresignaali juhtimine:

   VAR
       Temperature : REAL;
       Pressure : REAL;
       Alarm : BOOL;
   END_VAR

   IF (Temperature > 70.0 AND Pressure > 5.0) THEN
       Alarm := TRUE;  // Käivita häire, kui temperatuur ja rõhk on liiga kõrged
   ELSE
       Alarm := FALSE;
   END_IF;

Kiiruse reguleerimine:

   VAR
       Temperature : REAL;
       Speed : REAL;
   END_VAR

   IF Temperature < 50 THEN
       Speed := 100.0;  // Madala temperatuuriga suurem kiirus
   ELSE
       Speed := 50.0;   // Kõrgemal temperatuuril madalam kiirus
   END_IF;

Automaatne valgustus:

   VAR
       MotionDetected : BOOL;
       Timer : INT;
       Light : BOOL;
   END_VAR

   IF MotionDetected THEN
       Light := TRUE;   // Lülita valgus sisse, kui liikumine tuvastatakse
       Timer := 30;     // Taimer 30 sekundiks
   ELSE
       IF Timer > 0 THEN
           Timer := Timer - 1;  // Vähenda taimerit
       ELSE
           Light := FALSE;  // Lülita valgus välja, kui taimer jõuab 0-ni
       END_IF;
   END_IF;

Matemaatilised operatsioonid

Keskmise väärtuse arvutamine:

   VAR
       Value1, Value2, Value3 : REAL;
       Average : REAL;
   END_VAR

   Average := (Value1 + Value2 + Value3) / 3.0;

Temperatuuri konverteerimine:

   VAR
       Celsius : REAL;
       Fahrenheit : REAL;
   END_VAR

   Fahrenheit := (Celsius * 9.0 / 5.0) + 32.0;

Energiatarbimise arvutamine:

   VAR
       Power : REAL;  // Võimsus kW
       Time : REAL;   // Aeg tundides
       Energy : REAL; // Energia kWh
   END_VAR

   Energy := Power * Time;

Geomeetrilised arvutused:

   VAR
       Side : REAL;
       Perimeter : REAL;
       Area : REAL;
   END_VAR

   Perimeter := 4 * Side;      // Ruudu ümbermõõt
   Area := Side * Side;        // Ruudu pindala

Kütusekulu arvutamine: VAR Distance : REAL; // Läbitud vahemaa FuelUsed : REAL; // Tarbitud kütus FuelConsumption : REAL; // Kütusekulu END_VAR FuelConsumption := FuelUsed / Distance;

Tsüklid ja kordused

Fibonacci jada: VAR Fib : ARRAY[1..10] OF INT; i : INT; END_VAR Fib[1] := 0; Fib[2] := 1; FOR i := 3 TO 10 DO Fib[i] := Fib[i-1] + Fib[i-2]; // Genereeri jada END_FOR;
Loendur: VAR Signal : BOOL; Counter : INT := 0; END_VAR IF Signal THEN Counter := Counter + 1; // Suurenda loendurit iga signaaliga END_IF;
Massiivi väärtuste summa: VAR Values : ARRAY[1..5] OF REAL; Sum : REAL := 0.0; i : INT; END_VAR FOR i := 1 TO 5 DO Sum := Sum + Values[i]; // Liida massiivi väärtused END_FOR;
Kontrollväärtuste otsing: VAR Values : ARRAY[1..10] OF REAL; MaxValue, MinValue : REAL; i : INT; END_VAR MaxValue := Values[1]; MinValue := Values[1]; FOR i := 2 TO 10 DO IF Values[i] > MaxValue THEN MaxValue := Values[i]; END_IF; IF Values[i] < MinValue THEN MinValue := Values[i]; END_IF; END_FOR;
Massiivi väärtuste filtreerimine: VAR Values : ARRAY[1..10] OF REAL; Count : INT := 0; i : INT; END_VAR FOR i := 1 TO 10 DO IF Values[i] > 50 THEN Count := Count + 1; // Loenda väärtused üle 50 END_IF; END_FOR;

Funktsioonid ja funktsiooniblokid

Ruutjuure arvutamine: FUNCTION FC_SquareRoot : REAL VAR_INPUT Value : REAL; END_VAR FC_SquareRoot := SQRT(Value); // Tagasta ruutjuur
Loendusfunktsioon: FUNCTION_BLOCK FB_Counter VAR_INPUT Signal : BOOL; Reset : BOOL; END_VAR VAR_OUTPUT Count : INT; END_VAR IF Reset THEN Count := 0; ELSIF Signal THEN Count := Count + 1; END_IF;
Ohutuskontroller: FUNCTION_BLOCK FB_SafetyControl VAR_INPUT Safety1, Safety2 : BOOL; END_VAR VAR_OUTPUT SystemOn : BOOL; END_VAR IF (Safety1 AND Safety2) THEN SystemOn := TRUE; ELSE SystemOn := FALSE; END_IF;
Valgustuse mustri loomine: FUNCTION_BLOCK FB_LightPattern VAR_INPUT Step : INT; END_VAR VAR_OUTPUT Light1, Light2 : BOOL; END_VAR CASE Step OF 1: Light1 := TRUE; Light2 := FALSE; 2: Light1 := FALSE; Light2 := TRUE; ELSE Light1 := FALSE; Light2 := FALSE; END_CASE;
Temperatuuri piirik: FUNCTION FC_TemperatureClamp : REAL VAR_INPUT Temp : REAL; Min, Max : REAL; END_VAR IF Temp < Min THEN FC_TemperatureClamp := Min; ELSIF Temp > Max THEN FC_TemperatureClamp := Max; ELSE FC_TemperatureClamp := Temp; END_IF;

Need lahendused aitavad õpetajal kontrollida ja juhendada õppijaid, pakkudes näiteid nii algtasemel kui ka keerukamate ülesannete jaoks.

Toetavad materjalid

Siemensi SCL dokumentatsioon: Saadaval TIA Portali abimenüüs.
Näidiskood ja projektid: Loo lihtsad näited ja salvesta need üliõpilastele kättesaadavaks.
Veebikursused: Näiteks YouTube’i või Udemy õpetused.

See kursuse kava pakub tasakaalu teooria ja praktilise õppe vahel, andes üliõpilastele tugeva aluse SCL-keele omandamiseks ja reaalses elus kasutamiseks.

Ülesanne: Automaatne töö

Ülesande püstitus

Väljalükkav moodul sooritab nii üksikut kui ka automaatset töötsüklit. Üksiku tsükli start toimub nuppu S1 vajutamisel (silinder lükkab ühe tooriku välja ja siseneb automaatselt).
Automaatse tsükli start toimub nupu S2 vajutamisel ning peatamine nupu S1 vajutamisel. Pärast peatamissignaali peab seade viimase tsükli lõpuni tegema. Automaatse režiimi ajal põleb indikatsioonilamp H1. Mooduli start on mõlema režiimi korral võimalik vaid algpositsioonist.

Joonis

Pneumoskeem

Joonis

Elektriskeem

Programm

Sümbolite nimekiri

Nimi	Andmetüüp	Aadress	Kommentaar
S1	BOOL	%I0.0	Üksiku tsükli start / Automaattsükli stopp
S2	BOOL	%I0.1	Automaattsükli startnupp
S3	BOOL	%I0.2	Tooriku tuvastamise lõpulüliti
B1	BOOL	%I0.3	Herkonandur (Silinder sisenenud asendis)
Y1	BOOL	%Q0.0	Silindri pneumojaoti juhtsolenoid
H1	BOOL	%Q0.1	Automaatse töö indikatsioonilamp
Mälubitt0	BOOL	%M0.0	Positiivse frondi tuvastamiseks vajalik mälubitt

Programm: Main [OB1]

Väljalükkava mooduli ülesande lahendamine koos tagide tabeliga TIA Portalis

Kui kasutame tagide tabelit TIA Portalis, saame muuta muutujate haldamise ja koodi loetavuse palju lihtsamaks. Järgnevalt on toodud täielik lahendus ülesandele, kasutades tagide tabelit.

1. Tagide tabeli loomine TIA Portalis

Muutujate määratlemine tagide tabelis

Avage TIA Portal projektis “PLC Tags” ja lisage järgmised muutujad tagide tabelisse.

Nimi	Tüüp	Aadress	Kirjeldus
`S1`	BOOL	%I0.0	Nupp üksiku tsükli ja peatamise jaoks
`S2`	BOOL	%I0.1	Nupp automaatse tsükli alustamiseks
`Cylinder_Pos`	BOOL	%I0.2	Silindri asendi andur (TRUE – väljas)
`Cylinder_Out`	BOOL	%Q0.0	Silindri väljaliikumise käsk
`Cylinder_In`	BOOL	%Q0.1	Silindri sissetõmbamise käsk
`H1`	BOOL	%Q0.2	Automaatrežiimi indikatsioonilamp
`Auto_Mode`	BOOL	M0.0	Automaatrežiimi staatus
`Stop_Command`	BOOL	M0.1	Peatamiskäsk automaatrežiimi jaoks
`Single_Cycle`	BOOL	M0.2	Üksiku tsükli aktiivsuse staatus

2. SCL-kood OB1-s

OB1 on tsükliline organisatsiooniplokk, kus toimub põhiloogika. Siin on SCL-kood, mis kasutab tagide tabelis määratud muutujaid.

BEGIN
    // Kontroll algpositsioonist
    IF NOT Cylinder_Pos THEN
        // Üksiku tsükli käivitamine nupuga S1
        IF S1 AND NOT Auto_Mode THEN
            Single_Cycle := TRUE;     // Lülita sisse üksik tsükkel
        END_IF;

        // Automaatse tsükli käivitamine nupuga S2
        IF S2 AND NOT Auto_Mode THEN
            Auto_Mode := TRUE;        // Lülita sisse automaatne režiim
            H1 := TRUE;               // Lülita indikatsioonilamp sisse
        END_IF;
    END_IF;

    // Üksiku tsükli loogika
    IF Single_Cycle THEN
        IF NOT Cylinder_Pos THEN
            Cylinder_Out := TRUE;     // Lükka silinder välja
        ELSIF Cylinder_Pos THEN
            Cylinder_Out := FALSE;    // Peata väljaliikumine
            Cylinder_In := TRUE;      // Tõmba silinder tagasi
        END_IF;

        // Tsükli lõpp
        IF NOT Cylinder_Pos AND Cylinder_In THEN
            Cylinder_In := FALSE;     // Peata sissetõmbamine
            Single_Cycle := FALSE;    // Lõpeta üksik tsükkel
        END_IF;
    END_IF;

    // Automaatrežiimi loogika
    IF Auto_Mode THEN
        IF NOT Cylinder_Pos THEN
            Cylinder_Out := TRUE;     // Lükka silinder välja
        ELSIF Cylinder_Pos THEN
            Cylinder_Out := FALSE;    // Peata väljaliikumine
            Cylinder_In := TRUE;      // Tõmba silinder tagasi
        END_IF;

        // Peatamiskäsk S1 vajutamisel
        IF S1 THEN
            Stop_Command := TRUE;     // Märgi peatamiskäsk
        END_IF;

        // Peata tsükkel, kui silinder naaseb algpositsiooni
        IF Stop_Command AND NOT Cylinder_Pos THEN
            Auto_Mode := FALSE;       // Lõpeta automaatrežiim
            Stop_Command := FALSE;    // Lähtesta peatamiskäsk
            H1 := FALSE;              // Lülita lamp välja
        END_IF;
    END_IF;
END;

3. Koodi selgitus TIA Portalis

a. Globaalsete muutujate kasutamine

Kõik muutujad on määratletud tagide tabelis ja kasutatud otse koodis nende nimedega.
Aadressid, nagu %I0.0 ja %Q0.0, on seotud füüsiliste sisendite ja väljunditega.

b. Automaatrežiimi ja üksiku tsükli haldus

Üksik tsükkel: Kasutab muutujat Single_Cycle ühe tsükli oleku jälgimiseks.
Automaatrežiim: Kasutab muutujat Auto_Mode korduvate tsüklite haldamiseks.

c. Loogika selgus

Tagide tabelis määratud nimed (nt S1, H1, Cylinder_Out) muudavad koodi lihtsamini loetavaks ja hallatavaks.

4. Testimise protseduur

a. Üksiku tsükli testimine

Vajutage S1, kui silinder on algpositsioonis.
Kontrollige, kas silinder liigub välja ja naaseb automaatselt algpositsiooni.
Veenduge, et silinder jääb algpositsioonile tsükli lõpus.

b. Automaatrežiimi testimine

Vajutage S2, kui silinder on algpositsioonis.
Kontrollige silindri korduvat liikumist (välja ja tagasi).
Vajutage S1, kui silinder on liikumises. Kontrollige, et tsükkel lõpetatakse ja režiim peatub pärast praeguse tsükli lõppu.

c. Algpositsiooni kontroll

Proovige käivitada tsükkel, kui silinder ei ole algpositsioonis (Cylinder_Pos = TRUE). Veenduge, et tsükkel ei alga.

5. Tagide tabeli eelised TIA Portalis

Selgus ja loetavus:

Globaalsed nimed nagu S1 ja Cylinder_Out muudavad koodi hõlpsasti mõistetavaks.

Tsentraliseeritud haldus:

Kõik muutujad on hallatavad ühes kohas (tagide tabelis). Aadresside või kirjelduste muutmisel ei ole vaja koodi muuta.

Integreerimine füüsiliste sisenditega:

Sisend- ja väljundmuutujad on otse seotud riistvaraga, mis vähendab vigu.

6. Täiendused

Ajastus: Lisage ajarelee, et reguleerida silindri liikumise kiirust.
Rikke tuvastamine: Lisage loogika, mis tuvastab võimalikke tõrkeid (nt silinder ei liigu ettenähtud aja jooksul).
Häireindikaator: Lisage eraldi indikaator (nt lamp), mis aktiveerub vigase oleku korral.

Rakenduse paigutus

Ülesanne: NING ja VÕI loogika kasutamine 2

Ülesande püstitus

Silinder 1.0 transporteerib tooriku pressi alla pärast startnuppu S1 vajutamist.
Seejuures start võib toimuda ainult algpositsioonist (silinder 1.0 on sisenenud ning seetõttu on andur B1 aktiivne).
Silinder hakkab sisenema väljunud positsioonist (lõppu jõudmisel) automaatselt või avariinuppu S2 vajutamisel.

Pneumoskeem

Joonis Elektriskeem

Programm

Sümbolite nimekiri

Nimi	Andmetüüp	Aadress	Kommentaar
S1	BOOL	%I0.0	Startnupp
S2	BOOL	%I0.1	Avariinupp
B1	BOOL	%I0.2	Herkonandur (Silinder sisenenud asendis)
B2	BOOL	%I0.3	Herkonandur (Silinder väljunud asendis)
Y1.1	BOOL	%Q0.0	Bistabiilse pneumojaoti 1. juhtsolenoid
Y1.2	BOOL	%Q0.1	Bistabiilse pneumojaoti 2. juhtsolenoid

Programm: Main [OB1]

Ülesanne: Silinder 1.0 juhtimine SCL-is

Ülesande eesmärk:

Programmeerida loogika, mis juhib silinder 1.0 käitumist vastavalt järgmistele nõuetele:

Start (S1): Silinder transpordib tooriku pärast startnupu vajutamist, kuid ainult siis, kui silinder on algpositsioonis (andur B1 on aktiivne).
Automaatne sisenemine: Kui silinder jõuab väljas asendisse, alustab see automaatselt tagasiliikumist.
Avariistop (S2): Silinder naaseb algpositsiooni (siseneb), kui avariinupp S2 vajutatakse.

Muutujate tabel

Nimi	Tüüp	Aadress	Kirjeldus
`S1`	BOOL	%I0.0	Startnupp, silindri väljaliikumise käivitamine
`S2`	BOOL	%I0.1	Avariinupp, silindri sissetõmbamise käivitamine
`B1`	BOOL	%I0.2	Algpositsiooni andur (TRUE – algpositsioonis)
`B2`	BOOL	%I0.3	Lõppasendi andur (TRUE – väljas)
`Cylinder_Out`	BOOL	%Q0.0	Silindri väljaliikumise käsk
`Cylinder_In`	BOOL	%Q0.1	Silindri sissetõmbamise käsk

SCL-kood

VAR
    S1 : BOOL;              // Startnupp
    S2 : BOOL;              // Avariinupp
    B1 : BOOL;              // Algpositsiooni andur
    B2 : BOOL;              // Lõppasendi andur
    Cylinder_Out : BOOL;    // Silindri väljaliikumise käsk
    Cylinder_In : BOOL;     // Silindri sissetõmbamise käsk
END_VAR

BEGIN
    // Algpositsiooni kontroll (B1 aktiivne)
    IF B1 THEN
        // Startnupu vajutamine (S1)
        IF S1 THEN
            Cylinder_Out := TRUE;    // Silinder liigub välja
            Cylinder_In := FALSE;    // Peata sissetõmbamine
        END_IF;
    END_IF;

    // Automaatne tagasiliikumine
    IF B2 THEN
        Cylinder_Out := FALSE;       // Peata väljaliikumine
        Cylinder_In := TRUE;         // Tõmba silinder tagasi
    END_IF;

    // Avariistop (S2 vajutamisel)
    IF S2 THEN
        Cylinder_Out := FALSE;       // Peata väljaliikumine
        Cylinder_In := TRUE;         // Tõmba silinder tagasi
    END_IF;
END;

Koodi selgitus

1. Algpositsiooni kontroll:

Loogika algab ainult siis, kui silinder on algpositsioonis (B1 = TRUE).

2. Startnupu funktsioon:

Kui S1 vajutatakse ja silinder on algpositsioonis, liigub silinder välja (Cylinder_Out := TRUE).

3. Automaatne tagasiliikumine:

Kui silinder jõuab lõppasendisse (B2 = TRUE), peatatakse väljaliikumine ja algab sissetõmbamine (Cylinder_In := TRUE).

4. Avariistop:

Kui avariinupp S2 vajutatakse, naaseb silinder algpositsiooni, olenemata asendist.

Teststsenaariumid

1. Startimine algpositsioonist:

Kui andur B1 = TRUE, vajutage S1.
Kontrollige, et silinder liigub välja.

2. Automaatne tagasiliikumine:

Kui silinder jõuab lõppasendisse (B2 = TRUE), alustab see automaatselt tagasiliikumist.

3. Avariistop:

Vajutage S2, kui silinder on liikumises (välja või sisse).
Kontrollige, et silinder naaseb algpositsiooni.

Täiendused ja optimeerimine

Ajastus:

Lisage viivitus, et sissetõmbamine algaks pärast määratud aega.

Vigade tuvastamine:

Lisage kontroll loogika jaoks, mis tuvastab võimalikke rikkeid (nt silinder ei jõua asendisse määratud aja jooksul).

Indikatsioonid:

Lisage lampide loogika (nt roheline lamp algpositsioonil, punane lamp avariiolukorras).

Kui vajate täiendavat juhendamist või täiendusi konkreetse koodi osa kohta, olen valmis aitama! 😊

LAD	FBD
Network 1: Silindri väljumine / üksik start

Network 2: Automaatne start

Network 3: Automaattsükli peatamine

Network 4: Silindri tagastumine

LAD	FBD
Network 1: Silindri väljumine

Network 2: Silindri tagastumine