Structured Text Tutorial to Expand Your PLC Programming Skills
Do you also struggle reading your own and others huge ladder diagrams? The truth is, that even though ladder diagram (LD) is an easy programming language for beginners, it can be very hard to read and understand. That’s why Structured Structu red Text Text is a better L! programming language, and you can learn it in this tutorial. "t can be almost impossible to find head and tail in a larger L! program written in ladder logic. #o, what might seem easy to learn (especially for technicians and electricians) is not always the best thing to program in. $our ladder diagram will be hard to understand for others than yourself. %ow can " be sure about that? Try it yourself. Ta&e a loo& at one of these ladder logic e'amples, e'amples , and see how long it ta&es to understand it. #ee my point? Luc&ily for us there’s a better L! programming language available. "t’s called Structured Te Text xt.
$ou can also download the whole tutorial as a D file Structured Te Text xt Tutorial [PDF]
Content of Structured Text Tutorial •
Wat is Structured Text Programming!
•
Te flo" of Structured Text
•
S#ntax o
!omments
•
Statements
•
$aria%les $a ria%les and Ta Tags gs o
Data Types
•
Expressions
•
&perators o
*rithmetic +perators
o
elational +perators
o
Logical +perators
o
-itwise +perators
•
Statements and &perators
•
Conditional Statements
•
o
" #tatements
o
!*# #tatements
'epeating Loops o
+ Loops
$ou can also download the whole tutorial as a D file Structured Te Text xt Tutorial [PDF]
Content of Structured Text Tutorial •
Wat is Structured Text Programming!
•
Te flo" of Structured Text
•
S#ntax o
!omments
•
Statements
•
$aria%les $a ria%les and Ta Tags gs o
Data Types
•
Expressions
•
&perators o
*rithmetic +perators
o
elational +perators
o
Logical +perators
o
-itwise +perators
•
Statements and &perators
•
Conditional Statements
•
o
" #tatements
o
!*# #tatements
'epeating Loops o
+ Loops
•
•
o
/%"L Loops
o
*T Loops
Structured Text Programming Soft"are o
-ec&hoff Twin!at 0
o
!odesys
Conclusion
Wat is Structured Text Programming! #tructured Te't is L! programming language defined by PL PLC& C&pe pen n in (EC )**+*,+. The programming language is te't1based, compared to the graphics1based ladder diagram. *t first, it may seem better to use a graphical programming language for L! programming. programming. -ut in in my opinion, opinion, that that is only true for smaller smaller L! programs. programs. -y using a te't1based L! programming language, your program will ta&e up much smaller space, and the flow2logic will be easier to read and understand. *nother advantage is that you can combine the different programming languages. $ou can even have function bloc&s containing functions written in #tructured Te't. The fact that this is a standardi3ed programming language also gives us the option to program different L! brands with #tructured Te't. robably the most common L! (in urope at least) is the #iemens #4 L!’s. They can be programmed with #tructured Te't and you can start already now with the #iemens #415677 #tarter 8it,, which is also a great &it to get you introduced to the #iemens L! 8it environment.
-ig,le.el Programming Languages
"f you are already familiar with high1level programming languages li&e %, ython and !, #tructured Te't will seem familiar to you. The synta' of #tructured Te't is developed to loo& li&e the synta' of a high1level programming language with loops, variables, conditions and operators. -ut on the other hand, if you have never seen a high1level programming language, #tructured Te't can be a great introduction to those languages and the synta' used.
-efore you read this tutorial " recommend that you ta&e a brief loo& at this L! program written in #tructured Te't. Try to see if you can understand the function of this program. Does #tructured Te't loo& familiar to you? PROGRAM stexample VAR x : BOOL; END_VAR x := TRUE; REPEAT x := FALSE; UNTIL x := FALSE; END_REPEAT; END_PROGRAM;
Te Flo" of Structured Text The first thing you should learn is the structure or the synta' of #tructured Te't. /hen you understand the structure, you will understand how the flow of your program wor&s. #tarting with the e'ample above, you can see that the whole program begins with P'&/'01 and ends with E2D3P'&/'01. verything in between is your L! program. These two words are the delimiting &eywords for program declarations. 9ore on &eywords later. Don’t be confused about the :D;+<*9, because your program won’t end completely here. /hen the L! reaches the :D;+<*9 the L! scan cycle will start over again, and your program will repeat itself.
#tructured Te't rogram low.
This is =ust li&e ladder logic or any other L! programming language > it will run over and over again. *nd if you are used to programming microcontrollers, the +<*92:D;+<*9 will be similar to the infinite loop in !. 2&TE4 +ne thing to add here is that, when you are programming in #tructured Te't, you will often not use the +<*92:D;+<*9 construct. "t will already be done by the L! programming software, and the code you have to write, is what you want inside that construct.
The flow control of L! programs written in #tructured Te't is the same as in ladder logic execute one line at a time .
Starting "it te S#ntax of Structured Text The synta' of a programming language is the definition of how it is written. To be more precise, what symbols is used to give the language its form and meaning. *s you can see in the e'ample, #tructured Te't is full of colons, semicolons and other symbols. *ll these symbols has a meaning and is used to represent something. #ome of them are operators, some are functions, statements or variables. *ll the details of the synta' will be e'plained as you move through this tutorial. -ut there are some general rules for the synta' of #tructured Te't you should &now about. $ou don’t have to memori3e all the synta' rules for now, as you will when you get your hands into the programming •
0ll statements are di.ided %# semicolons #tructured Te't consists of statements and semicolons to separate them.
•
Te language is not case,sensiti.e ven though it is good practice to use upper1 and lowercase for readability, it’s not necessary.
•
Spaces a.e no function -ut they should be used for readability.
/hat’s really important to understand here is that, when you write a L! program in #tructured Te't, your computer will translate that to a language the L! can understand. /hen you upload the #tructured Te't L! program to your L!, the programming software you use will compile your program. This means that it will translate the code to a sort of macine code which can be e'ecuted by the L!. The compiler uses the synta' of the programming language to understand your program. or e'ample ach time the compiler sees a semicolon, it will &now that the end of te current statement is reached. The compiler will read everything until it reaches a semicolon, and then e'ecute that statement.
Comment S#ntax
"n te'tual programming languages you have the ability to write te't that doesn’t get e'ecuted. This feature is used to ma&e comments in your code. !omments are good, and as a beginner you should always comment your code. "t ma&es it easier to understand your code later. "n #tructured Te't you can ma&e either one line comments or multiple line comments. Single line comment4 // !mme"t
Comment after end of ST line4 #exp$ess%!"&; /' !mme"t '/
or #stateme"t&; (' !mme"t ')
1ultiple line comment4 /' sta$t !mme"t *** e"+ !mme"t '/
or
(' sta$t !mme"t *** e"+ !mme"t ')
Sould You Comment E.er# Detail!
*s you gradually get better and better, you should ma&e fewer and fewer comments about the functionality. The reason for this is The Tao of rogramming, which is a boo& about programming inspired by the old !hinese Tao Te !hing. +r actually the principle behind the boo& is the reason. Ta&e this little story in chapter 6. A novice asked the Master: “Here is a programmer that never designs, documents or tests his programs. Yet all who know him consider him one of the best programmers in the world. h! is this"# $he Master replied: “$hat programmer has mastered the $ao. He has gone be!ond the need for design% he does not become angr! when the s!stem crashes, but accepts the universe without concern. He has gone be!ond the need for documentation% he no longer cares if an!one else sees his code. He has gone be!ond the need for testing% each of his programs are perfect within themselves, serene and elegant, their purpose self&evident. $rul!, he has entered the m!ster! of $ao.#
*lthough this might be put on the edge, you should always write your code so it is as easy as possible to understand. ven without comments. $ou start doing this by simply ma&ing the code easy to read with spaces. -ut for now, you should not worry about comments. 9a&e as many as you want while you are still a beginner.
1aking Statements "it Structured Text #o, #tructured Te't consists of statements. -ut what is statements? $ou probably &now statements as something coming from humans. $ou can ma&e a statement, a president or even a company can ma&e a statement. *nd in L! programming, statements are almost the same.
* statement is you telling the L! what to do.
Let’s ta&e the first statement as an e'ample , : BOOL;
The compiler will read this as one statement, because when it reaches the semicolon, it &nows that this is the end of that statement. emember, statements are separated by semicolons. That’s the main synta' rule of this language. "n this statement you are telling the L! to create a .aria%le called 5 and that variable should be a 6&&L type.
7sing $aria%les in Structured Text -efore we dig deeper into the statement, let me get bac& to the &eywords i mentioned before. *s you can see, the variable @ is defined in between two other &eywords > $0' and E2D3$0' . -oth the +<*92:D;+<*9 and A*2:D;A* are constructs, meaning that they delimit a certain area in your program for something specific. The +<*9 construct is where all your L! program is, and the A* construct is where you define variables. *ll the four are called &eywords, because they are reserved words. $ou can’t use those words for anything else when you are programming in #tructured Te't. The name of your program cannot be +<*9 or even program (#TL is not case sensitive), because that word can only be used to ma&e a construct to delimit your L! program. -ac& to .aria%lesB "f you &now other programming languages, chances are that you &now about variables already. -ut if you don’t, here’s an introduction to variables you probably will li&e
A variable is a place where !ou can store data.
Depending on what type of data you want to store, there are several data t#pes available. The different &inds of data are called data types. or e'ample, if you have a variable where you want to store either T'7E or F0LSE, you can declare it as a 6&&L type. The -++L type is a %oolean data t#pe which means that it can contain a %oolean .alue (TC or *L#). :ow, that was two thing about variables. They have a certain data type, and they contain a value of that data type. -ut there’s one more thing you can control in your variables. The name of the variable. To ma&e it easy for you to use your variables throughout your L! program, they all have names. /hen you define a variable in the A* construct, you start by giving the varible its name , : BOOL;
This statement will create a variable called @, with a -++L data type. -e aware, that when you are programming with some L! software li&e #iemens #T 4 or oc&well you won’t use the A*2:D;A* til declare variables. "nstead variables are often called tags or symbols, and even though you are programming in #tructured Te't, you declare them visually (li&e in the image below) or in a function bloc&.
$aria%les8 Tags or S#m%ols!
+ne last thing to add here is that variables are often called tags in L! programming. "n the L! programming software #tudio 777 Logi' Designer for *llen -radley L!’s, variables are called tags. -ut if you are programming in older versions of #"9*T"! #T 4 rogramming #oftware for #iemens L!’s, variables are called symbols. "n the newer versions of #T 4 (from T"* ortal version 55) variables are called tags.
#"9*T"! #T 4 T"* ortal Aariables called L! tags.
-ut no matter what variables are called, they always have the same function. *nd with "! E550510 rogramming software li&e #T 4, !odesys or #tudio 777, the standard data types will always be available.
Data T#pes in Structured Text
Depending on what L! brand you are using, you will have some different data types available. "n a #iemens L! you have data types in #T 4 available that are similar to the standard ones in "! E550510. -ut you will also have other data types only used in #"9:# L!’s li&e the #T"9. *ll the standard data types are defined by the L!+pen +rgani3ation and they are part of the L! programming languages. very L! programming software with #tructured Te't has these data types included. "n the "! standard the data types are divided into two categories Elementar# data t#pes and deri.ed data t#pes. Elementar# data t#pes •
"ntegers
•
loating points
•
Time
•
#trings
•
-it strings
Cnder each elementary data types there are several (EC data t#pes available. These are the data types defined in (EC )**+*,+ (ntegers4 (EC Data T#pe #":T ":T D":T L":T C#":T C":T LD":T CL":T
Format #hort "nteger "nteger Double "nteger Long "nteger Cnsigned #hort "nteger Cnsigned "nteger Long Double "nteger Cnsigned Long "nteger
'ange 156F ' 564 1064EF ' 064E4 16G05 ' 6G0515 16GE0 ' 6GE015 7 ' 6 7 ' 6G5E15 7 ' 6G0615 7 ' 6GE15
Floating points4 (EC Data T#pe *L L*L
Format eal :umbers Long eal :umbers
'ange H57GH0F H57GH07F
Time4 (EC Data T#pe
T"9
Format Duration of time after an event
D*T
!alendar date
T"9;+;D*$
Time of day
D*T;*:D;T"9 Date and time of day
7se TI57dh0Fm4s56ms T"9I57dh0Fm DI5JFJ17166 D*TI5JFJ17166 T+DI50674 T"9;+;D*$I50674.44 DTI5JFJ17E15150E5.44 D*T;*:D;T"9I5JFJ17E151
50E5.44
Strings4 (EC Data T#pe #T":<
Format !haracter #tring
'ange K9y string’
6it strings4 (EC Data T#pe -++L -$T /+D D/+D L/+D
Format -oolean -yte /ord Double /ord Long /ord
'ange 5 bit F bits 5E bits 06 bits E bits
Deri.ed data t#pes •
#tructured data types
•
numerated data types
•
#ub1ranges data types
•
*rray data types
The derived data types are your own custom data t#pes. *ll the derived data types are built by ma&ing a construction of the &eywords TYPE and E2D3TYPE. "n between the &eywords is the &ind of derived data type you want to declare. *ll these different data types might seem a little overwhelming for now. specially if you haven’t used a te'tual programming language before. -ut there’s no need to worry. or now, you only have to remember a few of them to get started programming with #tructured Te't. *s you get better and your programs more complicated, you will gradually learn about more data types as you use them. /hat’s important here is that you don’t move ahead too fast . $ou want to get the basics right.
*s you can see the different data types can hold different data formats and thereby different values. -ut how do you put the values in the variables? *nd how do you use the variables? /ith statements and operators.
&perators and Expressions in STL The ne't thing you should &now about is operators. +perators are used to manipulate data and is a part of almost any programming language. This leads us to the second thing you should &now about > expressions. ust li&e operators, e'pressions are a crucial part of programming languages. An expression is a construct that, when evaluated, yields a value. This means that when the compiler compiles an e'pression, it will evaluate the e'pression and replace the statement with the result. Ta&e this e'ample with the two variables 0 and 6. 0 contains the value *9 and 6 contains :. A-B
The result of this e'pression is *:. #o instead of *M-, the compiler will put in the value 5F. An expression are composed of operators and operands. #o what are operators and operands? #ince, you =ust saw an e'ample of an e'pression, you =ust saw both an operator and two operands. * and - are both operands and the M is an operator.
rogramming language e'pressions with operands and operators.
emember that operators are used to manipulate data. That is e'actly what the M is doing. "t is ta&ing the value of the variable * and adding it to the value in -. The M is also called the addition operator because the operation is addition.
&perators There are several operators available in #tructured Te't. *gain, "! E550510 describes all the standard operators in the #tructured Te't language &peration
S#m%ol
Precedenc e
arenthesi3atio (e'pression %ighest n ) unction 9*@(*,-) valuation :egation > !omplement :+T 'ponentiation NN
9ultiply Divide 9odulo *dd #ubtract
N 2 9+D M > O, P, OQ, !omparison PQ Ruality Q "neRuality OP -oolean *:D S -oolean *:D *:D -oolean @+ 'clusive + -oolean + +
Lowest
*ll the operators in the table above are sorted after precedence . This is also called order of operations, and you may &now about if from mathematics. The order of operations is the order in which the operations are e'ecuted or calculated. ust ta&e a loo& at this e'pression A - B ' MA,(. D)
%ow will this e'pression be evaluated by the compiler? *s you can see in the table of operators the operator with the highest precedence is parenthesis. This means that the first thing, that will be evaluated, is everything in parenthesi3es > in this e'ample (!, D). -ut since 9*@(!, D) is actually a function, we can =ump one row down in the table to function evaluation. #o, in the above e'pression, the first thing that will be evaluated is the function 9*@(!, D). The function will yield (replace the function) with the answer. /hich in this case is the highest of the two variables ! and D. Let’s image ! is the result. The e'pression will now loo& li&e this A - B ' .
:ow, you can go down through the table, until you reach a row with the ne't operator used in this e'pression. There are two operations left multiply and addition. -ut since multiply has a higher precedence, that will be the first to be evaluated.
- N ! comes first and then the result is added to *. very time an e'pression is evaluated, the evaluation follows the order of precedence as in the table above.
; T#pes of &perators8 ; T#pes of Expressions
The operators used for e'pressions in #tructured Te't can be divided into four groups. ach group of operators will have its specific function and will yield a specific data type. 5. 0ritmetic &perators 6. 'elational &perators 0. Logical &perators . 6it"ise &perators
0ritmetic &perators
*ll the aritmetic operators are often =ust called mathematical operators because they represent math. The result will always be the mathematical result of the e'pression. •
•
< (add) = (subtract2negate)
•
> (multiply)
•
>> (e'ponent)
•
? (divide)
•
1&D (modulo divide)
Example4 01 MOD 2
'esult4
(
'elational &perators
To compare or find a relation between two values you can use one of the relational operators. They are used for comparison and the result will be a boolean value (-++L type), either TC or *L#. •
@ (eRual)
•
A (less than)
•
A@ (less than or eRual)
•
B (greater than)
•
B@ (greater than or eRual)
•
AB (not eRual)
Example4 TEMPERATURE := 34*3; TEMPERATURE &= 055*5
'esult4
)A*+
Logical &perators
"f you want to compare boolean values (-++L) and ma&e some logic out of it, you have to use logical operators. These operators also yields a boolean value of TC or *L# as a result of the e'pression. •
or 02D
•
&'
•
5&'
•
2&T
Example4 LIMIT_S6IT.70 := TRUE; LIMIT_S6IT.78 := FALSE; LIMIT_S6IT.70 OR LIMIT_S6IT.78
'esult4
$-
6it"ise &perators
The last group of operators are called %it"ise operators because the operations are performed bitwise. "t simply means that a logic operation is performed for each bit of two numbers. The result is a new number > the total result of the bitwise operations. •
or 02D
•
&'
•
5&'
•
2&T
Example4 01 AND 9
'esult4
/0 #ince this operation is bitwise the calculation will be per bit. #o to understand what’s going on here, you have to convert the numbers to binary values
5 Q 5555 F Q 5777 :ow each bit in the number 5555 (5) can be used in a logical operation with the other number 5777 (F) 0000 AND 0555
6it num%er 7 5 6 0
**** * 5 5 5 5
*999 : 'esult 5 * 7 9 7 9 7 9
&perators and Statements #o, in the previous section you learned that expressions e.aluate. 9eaning that all e'pressions will yield the result and the compiler will replace the e'pression with the result. -ut what if you want the L! (compiler) not to evaluate something, but to D& something? Statements are the answer.
*s " mentioned previously in this article, statements are you telling the L! what to do. "t’s the instruction you give the L! to ta&e action. "f you ma&e an e'pression that yields a result, that won’t do much. 'pressions are all the calculations and if you don’t use the results of those e'pressions in some actions (statements), it will be li&e buying groceries but not coo&ing. Let’s ta&e a loo& at the actions or statements that you can ma&e in #tructured Te't.
0ssignment Statement and &perator
There are several statements available in #tructured Te't. *ll of them represent an action or a condition. -eginning with actions, the most fundamental statement in #tructured Te't is the assignment statement. #tatements are also described in the "! standard developed by L!+pen, and the first one they list is the assignment statement.
%ere’s how an assignment statement loo&s li&e A := B;
/hat does this statement tell the compiler to do? To ta&e the .alue of the variable 6 and put it in the variable 0. The L! is assigning a value to a variable. %ere’s an even simpler e'ample A := 05;
This statement will ta&e the value 57 and put it into the variable *. +r said in another way > the variable * will be assigned the value 57. #ince the value of * is now 57, we can ma&e another statement, but this time with an e'pression B := A - 8;
/hen this line of code is compiled, the e'pression * M 6 will be evaluated to 56. The compiler will replace the e'pression with the result 56. The statement will now loo& li&e this to the compiler B := 08;
/hat will happen now, is that the compiler will assign the value 56 to the variable -.
%ow an assignment statement with an e'pression will be evaluated by the compiler.
The last thing is that the Q symbol is called the assignment operator. $es, it is an operator =ust li&e the operators used in e'pressions. +ften those two types of operators are mista&en for each other and used wrong. * common mista&e is to use the eRuality operator (Q) instead of the assignment operator (Q). -ut even though they loo& li&e each other there’s a huge difference. Ta&e these two e'amples A = B A := B;
The first line is an e'pression. #ince this is an e'pression, the operator will be used to evaluate the line. The eRuality operator evaluates in the following way "f the right side and the left side is eRual it evaluates to TC or 5. "f not, it will evaluate to *L# or 7. /ith some other operators, the eRuality operator is a relational operator. *ll the relational operators will evaluate to either TC or *L#. +n the second line you’ll see a statement. This time the operator will be used for an action instead of an evaluation. *ssignment is the action, and here the value of * will be given the value of -. *t last, you can always identify a statement by the semicolon. +nce again, the semicolon is how the compiler &nows when the end of a statement is reached. $ou can have all sorts of e'pressions in your assignment statements, from simple values li&e numbers to variables and functions. -ecause all e'pressions will be evaluated first, and then, the result of that evaluation will be used in the assignment statement.
Conditional Statements /ell, the assignment statement was pretty simple Ta&e the value of the right side and store it in what’s on the left side. -ut let’s 3oom out a bit and thin& about L! programs. * L! program is a piece of logic (" call it L! logic) and therefore has to ma&e some decisions. That’s why we use a L! or any other controller. To decide and act on the current state.
#implified The L! will loo& at the states of all the inputs and use your L! program to decide what outputs to set. #o in your L! program you need a way to ma&e decisions. This brings us to conditional statements. !onditional statements are used for e'actly that To make decisions. There are two ways of doing conditional statements in #tructured Te't (F statements and C0SE statements.
(F Statements
" thin& -ill
" statements are decisions with conditions. -ut even though "1statements are Ruite simple to understand, you still have to &now how to give the L! the conditional statements. This brings us bac& to the synta'. There’s a special synta' for " statements. This means, that you have to write it in a certain way for the compiler to understand it. -ecause =ust li&e semicolons are used to end statements, there are special &eywords to ma&e an " statement. %ere’s how the synta' for " statements loo&s li&e in #TL IF !!lea" exp$ess%!"< T7EN #stateme"t&; ELSIF !!lea" exp$ess%!"< T7EN #stateme"t&; ELSE #stateme"t&; END_IF ;
:otice that the synta' for " statements loo&s very similar to plain nglish. The first line contains two &eywords " and T%:. -etween those two &eywords are the condition, which is an e'pression. -ut not =ust any e'pression. * boolean e'pression.
6oolean and 2umeric Expressions
$ou can divide e'pressions into two groups depending on what they yield. -oolean e'pressions evaluates to a -++L type value, TC or *L#. %ere’s an e'ample of a boolean e'pression 0 = 0
This e'pression will evaluate to or yield TC. * boolean e'pression could also loo& li&e this 0 & 8
-ut this time the boolean e'pression will evaluate to *L#, since 5 is not larger than 6. :umeric e'pressions evaluates to an integer or a floating point number. * numeric e'pression could loo& as simple as this one 04*8 - 03*9
This e'pression will evaluate to the floating point number 00.7, and therefore is a numeric e'pression.
-oolean e'pressions are used in " statements as conditions. IF the boolean expression evaluates to $-, THEN the following statements will be executed.
The L! will only e'ecute the statements after the &eyword T%:, if the e'pression evaluates to TC. This is illustrated by the following e'ample A := 5; IF A = 5 T7EN B := 5; END_IF ;
Line number 0 will only be e'ecuted if * is eRual to 7. "n this case it will. * 7 is assigned to the variable * in a statement right before the " statement. #ee what " =ust did here?
"n the e'ample above a decision was made depending on the value of a variable. :ow, even though this was a fairly simple decision, we can already translate that into real L! programming. Let’s say you want to ma&e a program that sets a L! output depending on the state of an input. /ith a simple " statement you can do that in #tructured Te't IF INPUT0=TRUE T7EN OUTPUT0 := TRUE; END_IF;
*lthough this e'ample is =ust a piece of a bigger program (the variable ":CT5 represents an input and +CTCT5 an output) it illustrates how the decision for a L! output can be made. The +CTCT5 variable will only be set to TC " the ":CT5 variable is TC. #ince, both the ":CT5 and +CTCT5 variables are of the type -++L, the first line in the statement could also loo& li&e this IF INPUT0 T7EN
ust writing the e'pression as ":CT5U will still evaluate as TC, when the variable is TC.
Wat ELSE (F not!
or now, you’ve seen a simple " statement, where statements are only e'ecuted if an e'pression is TC. "f that e'pression evaluates to *L# the statements will simply not be e'ecuted. -ut what if your L! program reRuires multiple conditions? +f course you could write this as multiple individual " statements. -ut #tructured Te't has more options to the " statements. ust li&e most other programming languages you can use the ELS(F and ELSE &eywords for multiple conditions in the same " statement. -oth L#" and L# are optional in " statements, but this is how the synta' loo&s li&e IF !!lea" exp$ess%!"< T7EN #stateme"t&; ELSIF !!lea" exp$ess%!"< T7EN #stateme"t&; ELSE #stateme"t&;
END_IF ;
"f the boolean e'pression on line 5 is *L#, the statements below will simply not be e'ecuted. "nstead the compiler will chec& the boolean e'pression after the L#" &eyword. %ere it wor&s =ust li&e with the " &eyword "f the boolean e'pression after the &eyword is true, the following statements will be e'ecuted. *t last is the ELSE &eyword. "t wor&s as a default option for your " statement. "f all the " and L#" boolean e'pressions are evaluated to *L#, the statements after the L# &eyword will be e'ecuted.
%ow the L! will e'ecute " statements in #tructured Te't.
Com%ining &perators for 0d.anced Conditions
-eside ma&ing multiple conditions you can also e'pand your conditions to include multiple variables. $ou can combine multiple e'pressions, typically done with a logical operator, to get a larger e'pression. /hat if you want not =ust 5 but 6 inputs to be TC before an output is set. The e'pression would loo& li&e this IF (INPUT0) AND (INPUT8) T7EN OUTPUT0 := TRUE; END_IF;
:ow the e'pression will evaluate to TC, only if ":CT5 and ":CT6 is TC.
C0SE Statements
The second way of ma&ing decisions in #tructured Te't is with !*# statements. ssentially, !*# statements and " statements are the same. -ut !*# statements use numeric expressions instead of boolean e'pressions. !*# statements also have a slightly different synta', that ma&es it more suitable for certain purposes. This is how the synta' for !*# statements loo&s li&e in #tructured Te't .ASE "me$% exp$ess%!"< OF $eslt0: #stateme"t&; $esltN: #statemte"t&; ELSE #stateme"t&; END_.ASE;
"n !*# statements there are only 5 e'pression. The result of that e'pression is then used to decide which statements that are e'ecuted. *s a default option, !*# statements also have an L# &eyword. The statements after that &eyword are e'ecuted only if none of the results (or cases) matches the result of the numeric e'pression. %ere’s a very simple e'ample PROGRAM_STEP := 4; .ASE PROGRAM_STEP OF 0: PROGRAM_STEP := PROGRAM_STEP-0; 8: PROGRAM_STEP := PROGRAM_STEP-8; 4: PROGRAM_STEP := PROGRAM_STEP-4; ELSE PROGRAM_STEP := PROGRAM_STEP-05; END_.ASE;
*lthough this is a very simple e'ample (the variable has a fi'ed value) the e'ample shows you how to ma&e a decision depending on the result of a numeric e'pression. "n this e'ample the numeric e'pression is simply =ust the value of the variable, 0. "f could be any e'pression that evaluates to an integer or a floating point value.
(teration "it 'epeating Loops robably one of the most powerful features in #tructured Te't is the ability to ma&e loops that repeat lines of code. +nce again, !ode.org has made one of the best introductions to repeating loops. This time, aceboo& founder, 9ar& Vuc&erberg uses a little more than a minute to e'plain repeating loops.
"n relation to L! programming loops can be used for many different purposes. $ou might have a function or a set of statements that you want to e'ecute a certain amount of times or until something stops the loop. "n #tructured Te't you will find 0 different types of repeating loops 5. F&' 6. W-(LE 0. 'EPE0T
!ommon for all the types of loops is that they have a condition for either repeating or stopping the loop. The condition in F&' and W-(LE loops decides whether the loop should repeat or not. -ut for the 'EPE0T loop the condition is an 72T(L condition, and it will decide whether the loop should stop or not.
F&' Loops
The first loop is the + loop and is used to repeat a specific number of times. + loops has some other &eywords. T+, -$, D+ and :D;+. This is the synta' of + loops in #tructured Te't
FOR !"t := %"%t%al_>ale TO ?%"al_>ale B@ %"$eme"t DO #stateme"t&; END_FOR;
*t first sight the first line loo&s a bit complicated, but it isn’t if you divide it in chun&s )18eyword that starts the + loop statement. count :2 initial3value This assignment operation is where you set the initial value you want to count from. !ount is the variable name and initial;value is the value you want to start counting from. $1 8eyword before the value to count up to. final3value This is the value you want to count to. lace 577 here and your loop will count up to 577. 4Y 8eyword to use custom incremental value. increment The value of which you want to increase the count for every time the loop runs. "f you set the increment to 57 and the count to 577, the loop will run 57 times. 51 6statement7% 853)1-% This last part between the &eyword D+ and :D;+ is the statements you want to e'ecute each time your loop runs. These statements will be e'ecuted as many times as the loops repeats. #ince + loops can only have a preset amount of time they will repeat, that is what they are used for. "n L! programming this could be something as simple as an item that has to be painted2dried four times. * + loop that counts to four will wor& =ust fine here. *t last you can use an " statement with the &eyword E5(T to stop the loop before the count. $ou can add a boolean condition that if TC stops the loop. IF !!lea" exp$ess%!"< T7EN E,IT; END_IF;
W-(LE Loops
The while loop is a little different from the + loop, because it is used to repeat the loop as long as some conditions are TC. * /%"L loop will repeat as long as a boolean e'pression evaluates to TC. %ere’s the synta' of /%"L loops 67ILE !!lea" exp$ess%!"< DO #stateme"t&; END_67ILE;
-etween the /%"L and D+ &eywords are the boolean e'pression. "f that boolean e'pression evaluates to TC, all the statements until the :D;/%"L &eyword will be e'ecuted. /hen :D;/%"L is reached, the boolean e'pression will be evaluated again. This will happen over and over again until the e'pression doesn’t evaluate to TC. -ut to ma&e the loop stop at one point, you have to change a value in the boolean e'pression. +nly in that way can the boolean e'pression go from TC to *L#. %ere’s an e'ample of a /%"L loop in #tructured Te't !"te$ := 5; 67ILE !"te$ # 05 DO counter := counter + 1;
ma%"e_stats := !"te$ ' 05; END_67ILE;
"f you loo& at the third line you will see how the loop will eventually stop repeating. The boolean e'pression uses the counter variable and chec&s if its value is less than or eRual to 57. -ut since the value of counter is set to 7 right before the /%"L loop, the boolean e'pression will be TC unless counter is changed. That is what’s happening in line 0. This is the first statement in the /%"L loop, and with the other statements, are e'ecuted each time the loop repeats. "n the third line the value of the counter variable is increased by 5. $ou can say that the incremental value is 5. "n the e'ample above, the loop will repeat 57 times. /hen the value of count reaches 57, the boolean e'pression will be evaluated to *L# (because 57 is not less than 57) and the loop will stop.
$ou can also use the @"T &eyword in the /%"L loop to stop repeating the loop before the boolean e'pression is *L#. The synta' is an " statement with the @"T &eyword in. lace it anywhere between D+ and :D;/%"L &eywords. IF !!lea" exp$ess%!"< T7EN E,IT; END_IF;
'EPE0T Loops
The last type of repeating loop in #tructured Te't is the *T loop. "t wor&s the opposite way of the /%"L loop. This loop will stop repeating when a boolean e'pression is TC. "n #T, the synta' for *T loops loo&s li&e this REPEAT #stateme"t&; UNTIL !!lea" exp$ess%!"< END_REPEAT;
:otice here that since the boolean e'pression in this type of loop is after the statements, the statements will always be e'ecuted at least one time. This is useful if you want an action to happen one time and then, with a condition, decide if that action should happen again. ust as with the /%"L loops you have to change a value in the boolean e'pression along the way, to ma&e the loop stop repeating. This can be done be incrementing the value of a variable (to count), or it can be done with a conditional statement li&e an " statement inside the loop.
Structured Text Programming Soft"are :ow, even if you have read this article in detail, you’ve only started learning #tructured Te't. /hat you should do now is get your hands in the dirt and start using #tructured Te't. $ou should write some L! programs. -ecause that is the way to really learn #tructured Te't and master the programming language.
6eckoff T"inCat +
+ne of the best pieces of L! programming software when you want to learn #tructured Te't is -ec&hoff Twin!at 0. The programming software from -ec&hoff is fully compatible with all the "! E550510 L! programming languages including Ladder Diagram (LD) and #tructured Te't (#T). or learners, the biggest advantage of Twin!at 0 is that it has a simulator included. $ou don’t need to buy a L!, you =ust use the soft PLC. +n $ouTube there is a free series of videos from #Ruishy-rained. $ou should follow himW %e even made a video series about his D"$ 0D rinter . "t’s a great video tutorial to get you started with #tructured Te't L! programming in Twin!at 0.
Codes#s
$ou may have heard of !odesys before. "t is an open source software environment for "! E550510 L! programming. +pen source =ust means that it is free for download, which ma&es it perfect for students. *lthough there are not many great resources on how to use !odesys for beginners, -rian %obby has made some ama3ing tutorial videos. The first video shows you how to create a new pro=ect in !odesys. * little Ladder Logic is also included in the video.
The second video helps you program in #tructured Te't with !odesys.
Conclusion Learning a new programming language can be Ruite a challenge. -ut for beginners there are some very basic things you should always &eep in mind •
Learning takes time $ou =ust started out.
