This is an expansion to discussion we have already had on selection of a proper programming language for an specific application.

Normally, programs based on graphical representation of logics is ideal for people who are familiar with logical gates (FBD) and others who know relay-contactor control circuits(LAD).These are options that are available for almost all popular PLCs from different manufacturers based on what forced by international standards.

All other graphical languages can be converted to equivalent STL codes, a language close to machine level, but generally all STL codes can not be converted to graphical equivalent.The most important advantage of using STL compare to its graphical counterparts would be ease and speed of development and development of a complex logic in one network(there is aslo a line number limitation for that).When you want to run a timer in STL,you skip all unnecessary parts and just ,concisely, write the important sections.There are also some limitations with graphical languages like indirect addressing and cumbesome implementation of complex logics in LAD(FBD).

Finally, SCL is the high level programming langauge.It is like PASCAL and ,ideally speaking, can help us to implement any possible complex loop,data management and computational algorithms.Despite the fact that SCL is not efficient with conversion instructions but overally, it offers flexible options for experienced programmers(or even starters).

1- Graphical languages are efficient with binary logics.Check the attachment as inspired from Hans Berger to show complexity of STL compared to the LAD/FBD. In practice, for complex binary codes that are viewed in STL,the first choice we try to monitor codes in LAD/FBD by stroking (CTRL+1/CTRL+3).Check the STL and SCL equivalent in the following:

It can be easily checked that testing and monitoring (even understanding) of binary functions are convenient in LAD/FBD.

2-Calculations in loop on arrays show the dominance of SCL over STL due to simplicity.This example is an easy implementation of filling a 10*10 array of INT and form a multiplicaion table,Read more here from a previous discussion in the Forum:

The first sample codes, illustrate a solution in SCL. A simple and easy array multiplication and filling the table in a target DB(No thing more):

While same solution in STL requires an extensive programming labour to calculate the physical addresses and much primitive (machine level) instructions.Two loops with internal and external counters and calculating the target cell by using counters and physical structure of DB to form pointer. It is obvious that the 2nd solution is not as easy (neat) as the solution in SCL.

As the feedback of the "TIP" , I will ask to split the new discussion.New discussions will be added when I pass fatigue after a long flight !

3-SCL is efficient with structural programming as a higher programming language.Structural programming is helpful to implement complex algorithms for regulation ,tuning and even same for developing firmware of small controllers with similar programming packages. Simply , you can implement any possible and complex flowchart with it while you are bounded with controller(resources) itself!

SCL is widely used in PCS 7 to create blocks, determine their dynamic behavior and their properties in CFC editor.In the following manual find some revealed , basic blocks utilized in PCS 7 libraries and similar structure can be observed.Similar extensive logic can not easily be developed by STL/LAD and even it is really difficult to trace the errors in run-time.


In the following, you will find a simple SCL codes borrowed from a very old post in the forum.You can check the structure used to develpe the codes (simple and understandable). In the attachment also find the converted STL version of same algorithm and , for sure you will find it difficult to understand!
[code]
FUNCTION_BLOCK FB67

TITLE ='rate limiter'
AUTHOR :HDH
VERSION : '1.0'



// Block Parameters
VAR_INPUT
// Input Parameters
input:REAL;
rst:BOOL:=false;
step:REAL:=0.1; //100ms call
factor:REAL:=1.0;
high:REAL:=100;
low:REAL:=0;
END_VAR

VAR_IN_OUT
// I/O Parameters
first:BOOL:=true;
END_VAR

VAR_OUTPUT
// Output Parameters
out:REAL;
END_VAR

VAR_TEMP
// Temporary Variables

END_VAR
VAR
// Static Variables
buffer:REAL:=0;
in:REAL;
END_VAR

// Statement Section

IF rst=true THEN
buffer:=0;
//first:=true;
out:=0;
in:=0;
;
ELSE
IF first= true THEN

buffer:=in;
first:=false;
END_IF;
IF input >= high THEN
in:=high;
END_IF;
IF input <= low THEN
in:=low;
END_IF;

IF (input > low) AND (input<high) THEN
in:=input;
END_IF;

IF in > (buffer+step) THEN
buffer:= (buffer+(step* factor));
END_IF;

IF in < (buffer-step) THEN
buffer:= (buffer-(step*factor));
END_IF;

IF in = buffer THEN
buffer:=in;


END_IF;
;
out:= buffer;
END_IF;

;
END_FUNCTION_BLOCK[/code]