Manual PROSYD 1131 V21
Manual PROSYD 1131 V21
PLC Programming
with
PROSYD 1131
Copyright 1994, 1997, 1999 by Inter Control Hermann Köhler GmbH & CO.
KG
All rights reserved.
Publisher:
Inter Control
Hermann Köhler GmbH & Co. KG
Schafhofstraße 30
D-90411 Nürnberg
Tel. +49/ 911/ 9522 - 5
Fax. +49/ 911/ 9522 - 857
Internet: http://www.intercontrol.de
Contents
1 A Brief Introduction to PROSYD 1131 ________________________________________________ 1-1
10 Appendix 10-1
Constants 10-69
Variables 10-71
Addresses 10-72
Functions 10-73
11 Index 11-1
How is a project
structured?
A project is put into a file named after the project. The first POU (Program
Organization Unit) created in a new project will automatically be named
PLC_PRG. The process begins here (in compliance with the main function
in a C program), and other POUs can be accessed from the same point
(programs, function blocks and functions).
Once you have defined a Task Configuration, it is no longer necessary to
create a program named PLC_PRG. You will find more about this in the
Task Configuration chapter.
There are different kinds of objects in a project: POUs, data types, display
elements (visualizations) and resources.
The Object Organizer contains a list of all the objects in your project.
How do I set up my
project?
First you should configure your PLC in order to check the accuracy of the
addresses used in the project.
Then you can create the POUs needed to solve your problem.
Now you can program the POUs you need in the desired languages.
Once the programming is complete, you can compile the project and remove
errors should there be any.
Debugging
In case of a programming error you can set breakpoints. If the process stops
at such a breakpoint, you can examine the values of all project variables at
this point in time. By working through sequentially (single step) you can
check the logical correctness of your program.
Additional Online
Functions
An additional debugging function: You can set program variables and inputs
and outputs at certain values. You can use the flow control to check which
program lines have been run. The Sampling Trace allows you to trace and
display the actual course of variables over an extended period of time.
Once the project has been set up and tested, the hardware can be loaded in
the hardware and tested as well. The same online functions you used with
the simulation are available.
Additional PROSYD
1131 Features
The entire project can be documented or exported to a text file at any time.
Summary
PROSYD 1131 is a complete development tool used to program your PLC
which will save you a measurable amount of time setting up your
applications.
Project
A project contains all of the objects in a PLC program. A project is saved in
a file named after the project. The following objects are included in a
project:
POUs (Program Organization Units), data types, visualizations, resources,
and libraries.
POU (Program
Organization Unit)
Functions, function blocks, and programs are POUs.
Each POU consists of a declaration part and a body. The body is written in
one of the IEC programming languages which include IL, ST, SFC, FBD
and LD.
PROSYD 1131 supports all IEC standard POUs. If you want to use these
POUs in your project, you must include the library standard.lib in your
project.
POUs can call up other POUs. However, recursions are not allowed.
Function
A function is a POU, which yields exactly one data element (which can
consist of several elements, such as fields or structures) when it is
processed, and whose call in textual languages can occur as an operator in
expressions.
When declaring a function do not forget that the function must receive a
type. This means, after the function name, you must enter a colon followed
by a type.
A correct function declaration can look like this example:
FUNCTION Fct: INT
In addition, a result must be assigned to the function. That means that
function name is used as an output variable.
A function declaration begins with the keyword FUNCTION and ends with
END_FUNCTION.
Example in IL of a function that takes three input variables and returns the
product of the first two divided by the third:
In SFC a function call can only take place within a step or a transition.
The following typical program for testing the CheckBounds function goes
beyond the boundaries of a defined array. The CheckBounds functions
makes sure that the value TRUE is not assigned to the position A[10], but
rather to the upper area boundary A[7] which is still valid. Therefore, the
CheckBounds function can be used to correct extensions beyond array
boundaries.
Functionblock
A function block is a POU which provides one or more values during the
procedure. As opposed to a function, a function block provides no return
value.
A function block declaration begins with the keyword FUNCTION_BLOCK
and ends with END_FUNCTION_BLOCK.
Example in IL of a function block with two input variables and two output
variables. One output is the product of the two inputs, the other a
comparison for equality:
Function Block
Instances
Reproductions or instances (copies) of a function block can be created.
Each instance possesses its own identifier (the Instance name), and a data
structure which contains its inputs, outputs, and internal variables. Instances
are declared locally or globally as variables, whereas the name of the
function block is indicated as the type of an identifier.
Example of an instance with the name INSTANCE of the FUB function
block:
INSTANCE: FUB;
Function blocks are always called through the instances described above.
Only the input and output parameters can be accessed from outside of an
function block instance. This means the internal variables of the function
blocks remain invisible to the user of the function block.
Example for accessing an input variable:
The function block FB has an input variable in1 of the type INT.
PROGRAM prog
VAR
inst1:fb;
END_VAR
LD 17
ST inst1.in1
CAL inst1
END_PROGRAM
The declaration parts of function blocks and programs can contain instance
declarations. Instance declarations are not permitted in functions.
Access to a function block instance is limited to the POU in which it was
declared unless it was declared globally.
The instance name of a function block instance can be used as the input for a
function or a function block.
Note: All values are retained after processing a function block until the
next it is processed. Therefore, function block calls with the same arguments
do not always return the same output values!
Calling a function
block
You can use the variables of the function block by entering the instance
name, a point, and then the variable name.
If you would like to set the input parameters when you open the function
block, you can do this in the text languages IL and ST by assigning values to
the parameters after the instance name of the function block in parentheses
(this assignment takes place using ":=" just as with the initialization of
variables at the declaration position).
Examples for calling function block FUB described above: The
multiplication result is saved in the variable ERG, and the result of the
comparison is saved in QUAD. An instance of FUB with the name
INSTANCE is declared.
In IL the function block is called as shown in the following image:
In the example below the call is shown in ST. The declaration part is the
same as with IL:
Program
A program is a POU which returns several values during operation.
Programs are recognized globally throughout the project. All values are
retained from the last time the program was run until the next.
A program declaration begins with the keyword PROGRAM and ends with
END_PROGRAM.
PLC_PRG
The PLC_PRG is a special predefined POU. Each project must contain this
special program. This POU is called exactly once per control cycle.
The first time the "Project" "Object Add" command is used after a new
project has been created, the default entry in the POU dialog box will be a
POU named PLC_PRG of the program type. You should not change this
default setting!
If tasks have been defined, then the project may not contain any PLC_PRG,
since in this case the procedure sequence depends upon the task assignment.
Action
Actions can be defined to function blocks and programmes. The action
represents a further implementation which can be entirely created in another
language as the ”normal” implementation. Each action is given a name.
An action works with the data from the function block or programme which
it belongs to. The action uses the same input/output variables and local
variables as the ”normal” implementation uses.
Resources
You need the resources for configuring and organizing your project and for
tracing variable values:
• Global Variables which can be used throughout the project
• PLC Configuration for configuring your hardware
• Task Configuration for guiding your program through tasks
• Sampling Trace for graphic display of variable values
• Watch and Receipt Manager for displaying variable values and setting
default variable values
See the chapter called "The Resources".
Libraries
You can include in your project a series of libraries whose POUs, data types,
and global variables you can use just like user-defined variables. The library
"standard.lib" is a standard part of the program and is always at your
disposal.
See the chapter called "Library Manager".
Data types
Along with the standard data types the user can define his own data types.
Structures, enumeration types and references can be created.
See "Standard" and "Defined data types" in the appendix.
Visualization
PROSYD 1131 provides visualizations so that you can display your project
variables. You can plot geometric elements off-line with the help of the
visualization. They can then change their form online, depending upon
certain variable values.
See the chapter called "Visualization".
2.2 Languages
Modifiers and
operators in IL
In the IL language the following operators and modifiers can be used.
Modifiers:
• C with JMP, CAL, RET: The instruction is only then executed if the
result of the preceding expression is TRUE.
• N with JMPC, CALC, RETC: The instruction is only then executed if
the result of the preceding expression is FALSE.
• N otherwise: Negation of the operand (not of the accumulator)
Below you find a table of all operators in IL with their possible modifiers
and the relevant meaning:
LD 2
MUL 2
ADD 3
ST ERG
LD 2
MUL 2
(
ADD 3
)
ST ERG
Here the resulting value for Erg is 10, the operation MUL is only then
evaluated if you come to ")"; as operand for MUL 5 is then calculated.
Expressions
An expression is a construction which returns a value after its evaluation.
Expressions are composed of operators and operands. An operand can be a
constant, a variable, a function call, or another expression.
Valuation of
expressions
The evaluation of an expression takes place by means of processing the
operators according to certain binding rules. The operator with the strongest
binding is processed first, then the operator with the next strongest binding,
etc., until all operators have been processed.
Operators with equal binding strength are processed from left to right.
Below you find a table of the ST operators in the order of their binding
strength:
Operation Symbol Binding
strength
Put in parentheses (expression) Strongest binding
Function call Function name
(parameter list)
Exponentiation EXPT
Negate -
Building of NOT
complements
Multiply *
Divide /
Modulo MOD
Add +
Subtract -
Compare <,>,<=,>=
Equal to =
Not equal to <>
Boolean AND AND
Boolean XOR XOR
Boolean OR OR Weakest binding
There are the following instructions in ST, arranged in a table together with
example:
IF D:=B*B;
IF D<0.0 THEN
C:=A;
ELSIF D=0.0 THEN
C:=B;
ELSE
C:=D;
END_IF;
CASE CASE INT1 OF
1: BOOL1 := TRUE;
2: BOOL2 := TRUE;
ELSE
BOOL1 := FALSE;
BOOL2 := FALSE;
END_CASE;
FOR J:=101;
FOR I:=1 TO 100 BY 2 DO
IF ARR[I] = 70 THEN
J:=I;
EXIT;
END_IF;
END_FOR;
WHILE J:=1;
WHILE J<= 100 AND ARR[J] <> 70
DO
J:=J+2;
END_WHILE;
REPEAT J:=-1;
REPEAT
J:=J+2;
UNTIL J= 101 OR ARR[J] = 70
END_REPEAT;
EXIT EXIT;
Empty instruction ;
The name already indicates, the Structured Text is designed for structure
programming, i.e. ST offers predetermined structures for certain often used
constructs such as loops for programming.
This offers the advantages of low error probability and increased clarity of
the program.
Loop:
LD Counter
JMPC end
LD Var1
MUL 2
ST Var1
LD Counter
SUB 1
ST Counter
JMP Loop
End:
LD Var1
ST ERG
Erg:=Var1;
You can see, the loop in ST is not only faster to program, but is also
significantly easier to read, especially in view of the convoluted loops in
larger constructs.
The different structures in ST have the following significance:
Assignment operator
On the left side of an assignment there is an operand (variable, address) to
which is assigned the value of the expression on the right side with the
assignment operator :=
Example:
Var1 := Var2 * 10;
After completion of this line Var1 has the tenfold value of Var2.
RETURN instruction
The RETURN instruction can be used to leave a POU, for example
depending on a condition.
IF instruction
With the IF instruction you can check a condition and, depending upon this
condition, execute instructions.
Syntax:
IF <Boolean_expression1> THEN
<IF_instructions>
{ELSIF <Boolean_expression2> THEN
<ELSIF_instructions1>
.
.
ELSIF <Boolean_expression n> THEN
<ELSIF_instructions n-1>
ELSE
<ELSE_instructions>}
END_IF;
The part in braces {} is optional.
If the <Boolean_expression1> returns TRUE, then only the
<IF_Instructions> are executed and none of the other instructions.
Otherwise the Boolean expressions, beginning with
<Boolean_expression2>, are evaluated one after the other until one of the
expressions returns TRUE. Then only those instructions after this Boolean
expression and before the next ELSE or ELSIF are evaluated.
If none of the Boolean expressions produce TRUE, then only the
<ELSE_instructions> are evaluated.
Example:
IF temp<17
THEN heating_on := TRUE;
ELSE heating_on := FALSE;
END_IF;
Here the heating is turned on when the temperature sinks below 17 degrees.
Otherwise it remains off.
CASE instruction
With the CASE instructions one can combine several conditioned
instructions with the same condition variable in one construct.
Syntax:
CASE <Var1> OF
<Value1>: <Instruction 1>
<Value2>: <Instruction 2>
<Value3, Value4, Value5>: <Instruction 3>
<Value6 .. Value10>: <Instruction 4>
...
<Value n>: <Instruction n>
ELSE <ELSE instruction>
END_CASE;
A CASE instruction is processed according to the following model:
• If the variable in <Var1> has the value <Value i>, then the instruction
<Instruction i> is executed.
• If <Var 1> has none of the indicated values, then the <ELSE
Instruction> is executed.
• If the same instruction is to be executed for several values of the
variables, then one can write these values one after the other separated
by commas, and thus condition the common execution.
• If the same instruction is to be executed for a value range of a variable,
one can write the initial value and the end value separated by two dots
one after the other. So you can condition the common condition.
Example:
CASE INT1 OF
1, 5: BOOL1 := TRUE;
BOOL3 := FALSE;
2: BOOL2 := FALSE;
BOOL3 := TRUE;
10..20: BOOL1 := TRUE;
BOOL3:= TRUE;
ELSE
BOOL1 := NOT BOOL1;
FOR loop
With the FOR loop one can program repeated processes.
Syntax:
INT_Var :INT;
WHILE loop
The WHILE loop can be used like the FOR loop with the difference that the
break-off condition can be any Boolean expression. This means you indicate
a condition which, when it is fulfilled, the loop will be executed.
Syntax:
WHILE <Boolean expression>
<Instructions>
END_WHILE;
The <Instructions> are repeatedly executed as long as the
<Boolean_expression> returns TRUE. If the <Boolean_expression> is
already FALSE at the first evaluation, then the <Instructions> are never
executed. If <Boolean_expression> never assumes the value FALSE, then
the <Instructions> are repeated endlessly which causes a relative time delay.
Note: The programmer must make sure that no endless loop is caused.
He does this by changing the condition in the instruction part of the loop, for
example, by counting up or down one counter.
Example:
WHILE counter<>0 DO
Var1 := Var1*2;
Counter := Counter-1;
END_WHILE
The WHILE and REPEAT loops are, in a certain sense, more powerful than
the FOR loop since one doesn't need to know the number of cycles before
executing the loop. In some cases one will, therefore, only be able to work
with these two loop types. If, however, the number of the loop cycles is
clear, then a FOR loop is preferable since it allows no endless loops.
REPEAT loop
The REPEAT loop is different from the WHILE loop because the break-off
condition is checked only after the loop has been executed. This means that
the loop will run through at least once, regardless of the wording of the
break-off condition.
Syntax:
REPEAT
<Instructions>
UNTIL <Boolean expression>
END_REPEAT;
The <Instructions> are carried out until the <Boolean expression> returns
TRUE.
If <Boolean expression> is produced already at the first TRUE evaluation,
then <Instructions> are executed only once. If <Boolean_expression> never
assumes the value TRUE, then the <Instructions> are repeated endlessly
which causes a relative time delay.
Note: The programmer must make sure that no endless loop is caused.
He does this by changing the condition in the instruction part of the loop, for
example by counting up or down one counter.
Example:
REPEAT
Var1 := Var1*2;
Counter := Counter-1;
UNTIL
Counter=0
END_REPEAT;
EXIT instruction
If the EXIT instruction appears in a FOR, WHILE, or REPEAT loop, then
the innermost loop is ended, regardless of the break-off condition.
Step
A POU written in a Sequential Function Chart consists of a series of steps
which are connected with each other through directed connections
(transitions).
There are two types of steps.
• The simplified type consists of an action and a flag which shows if the
step is active. If the action of a step is implemented, then a small
triangle appears in upper right corner of the step.
• An IEC step consists of a flag and one or more assigned actions or
boolean variables. The associated actions appear to the right of the
step. More on this later.
Action
An action can contain a series of instructions in IL or in ST, a lot of
networks in FBD or in LD, or again in Sequential Function Chart (SFC).
With the simplified steps an action is always connected to a step. In order to
edit an action, click twice with the mouse on the step to which the action
belongs. Or select the step and select the menu command "Extras" "Zoom
Action/Transition".
Actions of IEC steps hang in the Object Organizer directly under their SFC-
POU and are loaded with a doubleclick or by pressing <Enter> in their
editor. New actions can be created with "Project" "Add Action".
Transition / Transition
condition
Between the steps there are so-called transitions.
A transition condition can be a Boolean variable, a boolean address, a
boolean constant, or a series of instructions with a Boolean result in ST
syntax (i.e. (i <= 100) AND b) or fully programmed in any language.
Active step
After calling the SFC POU, the action (surrounded by a double border)
belonging to the initial step is executed first. A step, whose action is being
executed, is called active. If the step is active, then the appropriate action is
executed once per cycle. In Online mode active steps are shown in blue.
In a control cycle all actions are executed which belong to active steps.
Thereafter the respective following steps of the active steps become active if
the transition conditions of the following steps are TRUE. The currently
active steps will be executed in the next cycle.
IEC step
Along with the simplified steps the standard IEC steps in SFC are available.
Any number of actions can be assigned to an IEC step. The actions of IEC
steps lie separated from the steps and can be used repeatedly within their
POU. For this they must be associated to the single steps with the command
"Extras" "Associate action".
Along with actions, Boolean variables can be assigned to steps. Through the
so-called qualifiers the actions and Boolean variables are activated and
deactivated, partially with time delays. Since an action can still be active,
even if the next step has been processed, for example through the qualifier S
(Set), one can achieve concurrent processes.
An associated boolean variable is set or reset with each call of the AS. That
means, that with each call it gets the value TRUE or FALSE.
The actions associated with an IEC step are shown at the right of the step in
a two-part box. The left field contains the qualifier, possibly with time
constant, and the right field contains the action name respectively boolean
variable name.
In order to make it easier to follow the processes, all active actions in online
mode are shown in blue like the active steps. After each cycle a check is
made to see which actions are active.
Whether a newly inserted step is an IEC step depends upon whether the
menu command "Extras" "Use IEC-Steps" has been chosen.
In the Object Organizer the actions hang directly underneath their respective
SFC POUs. New actions can be created with "Project" "Add Action".
In order to use IEC steps you must include in your project the special SFC
library Iecsfc.lib .
Qualifier
In order to associate the actions with IEC steps the following qualifiers are
available:
The qualifiers L, D, SD, DS and SL need a time value in the TIME constant
format.
Implicit variables in
SFC
There are implicitly declared variables in the SFC which can be used.
A flag belongs to each step which stores the state of the step. The step flag
(active or inactive state of the step) is called <StepName>.x for IEC steps or
just <StepName> for the simplified steps. This Boolean variable has the
value TRUE when the associated step is active and FALSE when it is
inactive. It can be used in every action and transition of the SFC block.
One can make an enquiry with the variable <ActionName>.x. as to whether
an IEC action is active or not.
Note: During the deactivation of the IEC action the variable already has
the value FALSE.
For IEC steps the implicit variables <StepName>.t can be used to enquire
about the active time of the steps.
SFC Flags
If a step is active in SFC for longer than its attributes state, some special
flags are set. There are also variables which can be set in order to control the
program flow in the sequential function chart. To use the flags it is
necessary, somewhere, globally or locally, to declare them as output or input
variables.
SFCEnableLimit: This variable is of the type BOOL. When it has the value
TRUE, the timeouts of the steps will be registered in SFCError. Other
timeouts will be ignored.
SFCInit: This variable is also of the type BOOL. When the variable has the
value TRUE the sequential function chart is set back to the Init step and the
other SFC flags are reset. The Init step remains active, but is not executed,
for as long as the variable has the value TRUE. It is only when SFCInit is
again set to FALSE that the block can be processed normally again.
SFCQuitError: A variable of the type BOOL. Execution of the SFC
diagram is stopped for as long as the variable has the value TRUE whereby
a possible timeout in the variable SFCError is reset. All previous times in
the active steps are reset when the variable again assumes the value FALSE.
SFCPause: A variable of the type BOOL. Execution of the SFC diagram is
stopped for as long as the variable has the value TRUE.
SFCError: This Boolean variable is set when a timeout has occurred in a
SFC diagram.
SFCTrans: This variable is of the type BOOL. The variable takes on the
value TRUE when a transition is actuated.
SFCErrorStep: This variable is of the type STRING. In this variable the
name of the step is stored which has caused a timeout to occur.
SFCErrorPOU: This variable of the type STRING contains the name of the
block in which a timeout has occurred.
SFCCurrentStep: This variable is of the type STRING. The name of the
step is stored in this variable which is active, independently of the time
monitoring. In the case of simultaneous sequences the step is stored in the
branch on the outer right.
Alternative branch
Two or more branches in SFC can be defined as alternative branches. Each
alternative branch must begin and end with a transition. Alternative
branches can contain parallel branches and other alternative branches. An
alternative branch begins at a horizontal line (alternative beginning) and
ends at a horizontal line (alternative end) or with a jump.
If the step which precedes the alternative beginning line is active, then the
first transition of each alternative branch is evaluated from left to right. The
first transition from the left whose transition condition has the value TRUE
is opened and the following steps are activated (see active step).
Parallel branch
Two or more branches in SFC can be defined as parallel branches. Each
parallel branch must begin and end with a step. Parallel branches can
contain alternative branches or other parallel branches. A parallel branch
begins with a double line (parallel beginning) and ends with a double line
(parallel end) or with a jump.
If the parallel beginning line of the previous step is active and the transition
condition after this step has the value TRUE, then the first steps of all
parallel branches become active (see active step). These branches are now
processed parallel to one another. The step after the parallel end line
becomes active when all previous steps are active and the transition
condition before this step produces the value TRUE.
Jump
A jump is a connection to the step whose name is indicated under the jump
symbol. Jumps are required because it is not allowed to create connections
which lead upward or cross each other.
See also chapter 'The Continuous Function Chart Editor' at 'The Editors in
PROSYD 1131'.
Contact
Each network in LD consists on the left side of a network of contacts
(contacts are represented by two parallel lines: | |) which from left to right
show the condition "On" or "Off".
These conditions correspond to the Boolean values TRUE and FALSE. A
Boolean variable belongs to each contact. If this variable is TRUE, then the
condition is passed on by the connecting line from left to right, otherwise the
right connection receives the value "Out".
Contacts can be connected in parallel, then one of the parallel branches must
transmit the value "On" so that the parallel branch transmits the value "On";
or the contacts are connected in series, then contacts must transmit the
condition "On" so that the last contact transmits the "On" condition. This
therefore corresponds to an electric parallel or series circuit.
A contact can also be negated, recognizable by the slash in the contact
symbol: |/|. Then the value of the line is transmitted if the variable is
FALSE.
Coil
On the right side of a network in LD there can be any number of so-called
coils which are represented by parentheses:( ). They can only be in parallel.
A coil transmits the value of the connections from left to right and copies it
in an appropriate Boolean variable. At the entry line the value ON
(corresponds to the Boolean variable TRUE) or the value OFF
(corresponding to FALSE) can be present.
Contacts and coils can also be negated (in the example the contact
SWITCH1 and the coil %QX3.0 is negated). If a coil is negated
(recognizable by the slash in the coil symbol: (/)), then it copies the negated
value in the appropriate Boolean variable. If a contact is negated, then it
connects through only if the appropriate Boolean value is FALSE.
Set/Reset coils
Coils can also be defined as set or reset coils. One can recognize a set coil
by the "S" in the coil symbol: (S)) It never writes over the value TRUE in
the appropriate Boolean variable. That is, if the variable was once set at
TRUE, then it remains so.
One can recognize a reset coil by the "R" in the coil symbol: (R)) It never
writes over the value FALSE in the appropriate Boolean variable: If the
variable has been once set on FALSE, then it remains so.
LD as FBD
When working with LD it is very possible that you will want to use the
result of the contact switch for controlling other POUs. On the one hand you
can use the coils to put the result in a global variable which can then be used
in another place. You can, however, also insert the possible call directly into
your LD network. For this you introduce a POU with EN input.
Such POUs are completely normal operands, functions, programs, or
function blocks which have an additional input which is labeled with EN.
The EN input is always of the BOOL type and its meaning is: The POU with
EN input is evaluated when EN has the value TRUE.
An EN POU is wired parallel to the coils, whereby the EN input is
connected to the connecting line between the contacts and the coils. If the
ON information is transmitted through this line, this POU will be evaluated
completely normally.
Starting from such an EN POU, you can create networks similar to FBD.
Sampling Trace
The Sampling Trace allows you to trace the value sequence of variables,
depending upon the so-called trigger event. This is the rising edge or falling
Debugging
The debugging functions of PROSYD 1131 make it easier for you to find
errors.
In order to debug, run the command "Project" "Options" and in the dialog
box that pops up under Build options select the item Debugging.
Breakpoint
A breakpoint is a place in the program at which the processing is stopped.
Thus it is possible to look at the values of variables at specific places within
the program.
Breakpoints can be set in all editors. In the text editors breakpoints are set at
line numbers, in FBD and LD at network numbers, and in SFC at steps.
Single step
Single step means:
• In IL: Execute the program until the next CAL, LD or JMP command.
• In ST: Execute the next instruction.
• In FBD, LD: Execute the next network.
• In SFC: Continue the action until the next step.
By proceeding step by step you can check the logical correctness of your
program.
Single Cycle
If Single cycle has been chosen, then the execution is stopped after each
cycle.
Monitoring
In addition to the variable declarations visible on the screen, the current
values from the PLC are continuously read and displayed.
In Online mode PROSYD 1131 monitors all variables visible on the screen.
At the same time variables can be put together in the Watch and Receipt
Manager whose data you would like to see all in one place.
Simulation
During the simulation the created PLC program is not processed in the PLC,
but rather in the calculator on which PROSYD 1131 is running. All online
functions are available. That allows you to test the logical correctness of
your program without PLC hardware.
Let us now start to write a small example program. It is for a simple traffic
signal unit which is supposed to control two traffic signals at an intersection.
The red/green phases of both traffic signals alternate and, in order to avoid
accidents, we will insert yellow or yellow/red transitional phases. The latter
will be longer than the former. We further imagine the use of a CAN bus
system and will do the corresponding configuration.
In this example you will see how time dependent programs can be shown
with the language resources of the IEC1131-3 standard, how one can edit the
different languages of the standard with the help of PROSYD 1131, and
how one can easily connect them while becoming familiar with the
simulation of PROSYD 1131.
Create POU
The beginning is always easy: Start PROSYD 1131 and choose "File"
"New".
In the dialog box which appears, the first POU has already been given the
default name PLC_PRG. Keep this name, and the type of POU should
definitely be a program. Each project needs a program with this name. In
this case we choose as the language of this POU the Continuous Function
Chart Editor (CFC).
Now create three more objects with the command "Project" "Object Add"
with the menu bar or with the context menu (press right mouse button in the
Object Organizer): a program in the language Sequential Function Chart
(SFC) named SEQUENCE, a function block in the language Function Block
Diagram (FBD) named TRAFFICSIGNAL, along with a POU WAIT, also
of the type function block, which we want to program as an Instruction List
(IL).
What does
TRAFFICSIGNAL do?
In the POU TRAFFICSIGNAL we will assign the individual trafficsignal
phases to the lights, i.e. we will make sure that the red light is lit red in the
red phase and in the yellow/red phase, the yellow light in the yellow and
yellow/red phases, etc.
What does
SEQUENCE do?
In SEQUENCE all is combined so that the right light lights up at the right
time for the desired time period.
"TRAFFICSIGNAL"
declaration
Let us now turn to the POU TRAFFICSIGNAL. In the declaration editor
you declare as input variable (between the keywords VAR_INPUT and
END_VAR) a variable named STATUS of the type INT. STATUS will have
four possible conditions, that is one for the TRAFFICSIGNAL phases green,
yellow, yellow/red andred.
Therefore our TRAFFICSIGNAL has three outputs, that is RED, YELLOW
and GREEN. You should declare these three variables. Then the declaration
part of our function block TRAFFICSIGNAL will look like this:
"TRAFFICSIGNAL"
body
Now it is time to determine from the input STATUS of the POU the values
of the output variables. For this go into the body of the POU. Click on the
field to the left beside the first network (the gray field with the number 1).
You have now selected the first network. Now choose the menu item
"Insert" "Operator".
In the first network a box is inserted with the operator AND and two inputs:
Click on the text AND with the mouse pointer and change the text into EQ.
Select the three question marks from the upper of the two inputs and enter
the variable STATUS. Then select the lower of the three question marks and
put a 1 underneath it. You get the following network:
Click now on a place behind the EQ Box. Now the output of the EQ
operation is selected. Choose "Insert" "Assignment". Change the three
question marks ??? to GREEN. You now have created a network with the
following structure:
In order to insert an operator in front of another operator, you must select the
place where the input to which you want to attach the operator feeds into the
box.
Then use the command "Insert" "Operator". Otherwise you can setup
these networks in the same way as the first network.
Now our first POU has been finished. TRAFFICSIGNAL, according to the
input of the value STATUS, controls whichever light color we wish.
Connecting the
standard.lib
For the timer in the POU WAIT we need a POU from the standard library.
Therefore, open the library manager with "Window" "Library Manager".
Choose "Insert" "Additional library". The dialog box appears for
opening files. From the list of the libraries choose standard.lib.
"WAIT" declaration
Now let us turn to the POU WAIT. This POU is supposed to become a timer
with which we can determine the length of the time period of each
TRAFFICSIGNAL phase. Our POU receives as input variable a variable
TIME of the type TIME, and as output it produces a Boolean value which
we want to call OK and which should be TRUE when the desired time
period is finished. We set this value with FALSE by inserting at the end of
the declaration (before the semicolon, however) " := FALSE ".
For our purposes we need the POU TP, a clock generator. This has two
inputs (IN, PT) and two outputs (Q, ET). TP does the following:
As long as IN is FALSE, ET is 0 and Q is FALSE. As soon as IN provides
the value TRUE, the time is calculated at the output ET in milliseconds.
When ET reaches the value PT, then ET is no longer counted. Meanwhile Q
produces TRUE as long as ET is smaller than PT. As soon as the value PT
has been reached, then Q produces FALSE again. In addition you will find a
short description of all POUs from the standard library in the appendix.
In order to use the POU TP in the POU WAIT we must create a local
instance from TP. For this we declare a local variable ZAB (for elapsed
time) of the type TP (between the keywords VAR, END_VAR).
The declaration part of WAIT thus looks like this:
"WAIT" body
In order to create the desired timer, the body of the POU must be
programmed as follows:
At first it is checked whether Q has already been set at TRUE (as though the
counting had already been executed), in this case we change nothing with
the occupation of ZAB, but rather we call the function block ZAB without
input (in order to check whether the time period is already over).
Otherwise we set the variable IN in ZAB at FALSE, and therefore at the
same time ET at 0 and Q at FALSE. In this way all variables are set at the
desired initial condition. Now we assign the necessary time from the
variable TIME into the variable PT, and call ZAB with IN:=TRUE. In the
function block ZAB the variable ET is now calculated until it reaches the
value TIME, then Q is set at FALSE.
The negated value of Q is saved in OK after each execution of WAIT. As
soon as Q is FALSE, then OK produces TRUE.
The timer is finished at this point. Now it is time to combine our two
function blocks WAIT and TRAFFICSIGNAL in the main program
PLC_PRG.
"SEQUENCE" first
expansion level
First we declare the variables we need. They are: an input variable START
of the type BOOL, two output variables TRAFFICSIGNAL1 and
TRAFFICSIGNAL2 of the type INT and one of the type WAIT (DELAY as
delay). The program SEQUENCE now looks like shown here:
If you click directly on the name of a transition or a step, then this is marked
and you can change it. Name the first transition after Init "START", and all
other transitions "DELAY.OK".
The first transition switches through, if START is TRUE and all others
switch through when DELAY in OK produces TRUE, i.e. when the set time
period is finished.
The steps (from top to bottom) receive the names Switch1, Green2, Switch2,
Green1, whereby Init of course keeps its Name. "Switch" should include a
yellow phase, at Green1 TRAFFICSIGNAL1 will be green, at Green2
TRAFFICSIGNAL2 will be green. Finally change the return address of Init
after Switch1. If you have done everything right, then the diagram should be
as follows:
The first expansion phase of our program is completed. Now you can
compile it and also test the simulation.
"SEQUENCE" second
expansion level
In order to ensure that our diagram has at least one alternative branch, and so
that we can turn off our traffic light unit at night, we now include in our
program a counter which, after a certain number of TRAFFICSIGNAL
cycles, turns the unit off.
At first we need a new variable COUNTER of the type INT. Declare this as
usual in the declaration part of PLC_PRG, and initialize it in Init with 0.
Now select the transition after Switch1 and insert a step and then a
transition. Select the resulting transition and insert an alternative branch to
its left. After the left transition insert a step and a transition. After the
resulting new transition insert a jump after Switch1.
Name the new parts as follows: the upper of the two new steps should be
called "Count" and the lower "Off". The transitions are called (from top to
bottom and from left to right) EXIT, TRUE and DELAY.OK. The new part
should therefore look like the part with the black border:
Now two new actions and a new transition condition are to be implemented.
At the step Count, the only thing that happens is that COUNTER is
increased by one:
The EXIT transition checks whether the counter is greater than a certain
number, for example 7:
At Off the state of both lights is set at 5(OFF), (or each other number not
equal 1,2,3 or 4) the COUNTER is reset to 0, and a time delay of 10 seconds
is set:
The result
In our hypothetical situation, night falls after seven TRAFFICSIGNAL
cycles, for ten seconds the TRAFFICSIGNAL turns itself off, then we have
daylight again, the traffic light unit turns itself on again, and the whole
process starts again from the beginning.
PLC_PRG
We have defined and correlated the time sequencing of the phases for both
sets of traffic lights in the block SEQUENCE. Since, however, we see the
traffic lights system as a CAN-module and wish to create the controller
configuration over a CAN-bus, it is necessary for us to make input and
output variables available in the block PLC_PRG. We want to start-up the
traffic lights system over an ON switch and we want to send each of the six
lamps (each traffic light red, green, yellow) the corresponding ”signal
command” for each step of the SEQUENCE. We are now declaring
appropriate Boolean variables for these six outputs and one input, before we
create the programme in the editor, and are allocating them, at the same
time, to the corresponding IEC addresses.
The next step is to declare the variables LIGHT1 and LIGHT2 of the type
TRAFFICSIGNAL in the declaration editor.
These deliver the Boolean value of each of the six lights to the above
mentioned six outputs for each step of the block SEQUENCE. We are not,
however, declaring the output variables which are foreseen within the
PLC_PRG block but under Resources for Global Variables instead. The
Boolean input variable IN, which is used to set the variable START in the
block SEQUENCE to TRUE, can be set in the same way. ON is also
allocated to an IEC address.
Select the tab Resources and open the list Global Variables.
Make the declaration as follows:
The name of the variable (e.g. IN) is followed, after AT, by a percent sign
which begins the IEC address. I stands for input, Q for output, B (used in
this example) stands for byte and the individual bits of the module are
addressed using 0.0 (0.1, 0.2, etc.). We will be handling the controller
configuration afterwards but we want, first of all, to finish off the block
PLC_PRG.
For this we go into the editor window. We have selected the Continuous
Function Chart editor and we consequently obtain, under the menu bar, a
CFC symbol bar with all of the available elements (see Chapter The
Continuous Function Chart Editor).
Click on the right mouse key in the editor window and select the element
Box. Click on the text AND and write ”SEQUENCE” instead. This brings
up the block SEQUENCE with all of the already defined input and output
variables. Insert two further block elements which you name PHASES.
Phases is a function block and this causes you to obtain three red question
marks over the block which you replace with the already locally declared
variables LIGHT1 and LIGHT2. Now set an element of the type Input,
which award the title ON and six elements of the type Output which you
award variable names to, as described, namely L1_green, L1_yellow,
L1_red, L2_green, L2_yellow, L2_red.
All of the elements of the programme are now in place and you can connect
the inputs and outputs, by clicking on the short line at the input/output of an
element and dragging this with a constantly depressed mouse key to the
input/output of the desired element.
Your program should finally look like the example shown here.
Figure 3.19: PLC_PRG, Declaration and presentation with the continuous function chart editor
CAN controller
configuration
Before we actually test the program, to see whether and how it runs, and
finally, as our climax, produce a small visualization we first of all want to
connect the traffic lights system over the CAN bus to the I/O level. To
achieve this go to the tab Resources and select ”Controller configuration”.
The hardware must be described here which the opened project is being
created for. Click with the mouse on the line ”Hardware configuration”. A
dotted box appears within which you can insert a Sub-element CAN using
the right mouse key. A dialog opens up in which global CAN properties
can be entered. It is sufficient for our example to confirm the pre-set
configuration with OK. An element CAN [0] appears in the configuration
window. Extend the contents of the dotted box by inserting a sub-element
using the right mousekey. You will receive a list of the pre-set configuration
possibilities. The contents of this selection list depends on the EDS files
(Electronic Data Sheet) which are located in the sub-directory PLCCONF
belonging to the library directory. For our example select one CAN element
with eight digital inputs (...8DI...) and one with eight digital outputs
(...8DO...). You are presented, in each case, with a dialog for setting the
basic parameters of the CAN module. Take note, for our example, that we
just need to enter a Node ID (the input must fit to the setting of the
associated module) and confirm this with OK. Both CAN modules are
brought under CAN in the configuration scheme and you can open out the
configuration tree up to the information about the IEC address by making a
mouse click on the plus sign.
This is the way in which the connection of our program to the IEC addresses
%IB0 and %QB0 is achieved. Our project also requires, however, that we
are able to address the digital input and outputs individually. This is
achieved by making a declaration of the variables as %QX0.x and %IX0.x.
TRAFFICSIGNAL
simulation
Now test your program. For this you must compile it ("Project" "Rebuild
all") login ("Online" "Login" and then load it "Online" "Download"). If
you now select "Online" "Run", the chronological order of the individual
steps of your main program can be followed. The window of the POU
PLC_PRG has now changed to the monitor window. Click twice on the plus
sign in the declaration editor, the variable display drops down, and you can
see the values of the individual variables.
With the visualization of PROSYD 1131 you can quickly and easily bring
project variables to life. You find an complete description of the
visualization in chapter 0. We will now plot two traffic signals and an ON-
Switch for our traffic light unit which will illustrate the switching process.
Creating a new
visualization
In order to create a visualization you must first select the range of
Visualization in the Object Organizer. First click on the lower edge of the
window on the left side with the POU on the register card with this symbol
and the name Visualization. If you now choose the command "Project"
"Object Add", then a dialog box opens.
Enter here any name. When you confirm the dialog with OK, then a window
opens in which you can set up your new visualization.
Insert element in
Visualization
For our TRAFFICSIGNAL visualization you should proceed as follows:
• Give the command "Insert" "Ellipse" and draw a medium sized circle
(∅2cm). For this click in the editor field and draw with pressed left mouse
button the circle in its length.
• Now doubleclick the circle. The dialog box for editing visualization
elements opens
• Choose the category Variables and enter in the field Change color the
variable name .L1_red or choose this variable using the input assistance
(button <F2>). This addresses the variable RED of the function block
instance TRAFFICSIGNAL1 of the POU PLC_PRG.
• Then choose the category Color and click on the button Inside in the
area Color. Choose as neutral a color as possible, such as black.
• Now click on the button within in the area Alarm color and choose the
red which comes closest to that of a red light.
The resulting circle will normally be black, and when the variable RED from
TRAFFICSIGNAL1 is TRUE, then its color will change to red. We have
therefore created the first light of the first traffic signal !
The TRAFFICSIGNAL
case
Now enter the command "Insert" "Rectangle", and insert in the same way
as the circle a rectangle which encloses the three circles. Once again choose
as neutral a color as possible for the rectangle and give the command
"Extras" "Send to back" so that the circles are visible again.
If simulation mode1 is not yet turned on, you can activate it with the
command "Online" "Simulation".
If you now start the simulation with the commands "Online" "Login" and
"Online" "Run", then you can observe the color change of the first traffic
signal.
The ON switch
Insert a rectangle and award it, as described above, a colour for a traffic light
of your choice and enter .ON at Variables for the Change color. Enter
”ON” in the input field for Content in the category Text.
In order to set the variable ON to TRUE with a mouse click on the switch,
the variable .ON must be entered into the category Variables. Also select
the Option Variable keying and enter the variable .ON at this point. Variable
1
The simulation mode is active if a check mark (!) appears in front of the
menu item "Simulation" in the "Online" menu..
keying means that when a mouse click is made on the visualization element
the variable .ON is set to the value TRUE but is reset to the value FALSE
when the mousekey is released again (we have created hereby a simple
switch-on device for our traffic lights program).
Font in the
visualization
In order to complete the visualization you should first insert two more
rectangles which you place underneath the traffic signals.
In the visualizations dialog box set white in the category Color for Frame
and write in the category Text in the field Contents "Light1" or "Light2".
Now your visualization looks like this:
The following elements are found in the main window of PROSYD 1131
(from top to bottom):
• The menu bar
• The Tool bar (optional); with buttons for faster selection of menu
commands.
• The Object Organizer with register cards for POUs, Data types,
Visualizations, and Resources
• A vertical screen divider between the Object Organizer and the Work
space of PROSYD 1131
• The Work space in which the editor windows are located
• The message window (optional)
• The Status bar (optional); with information about the current status of
the project
Menu bar
The menu bar is located at the upper edge of the main window. It contains
all menu commands.
Tool bar
By clicking with the mouse on a symbol you can select a menu command
more quickly. The choice of the available symbols automatically adapts
itself to the active window.
The command is only carried out when the mouse button is pressed on the
symbol and then released.
If you hold the mouse pointer for a short time on a symbol in the tool bar,
then the name of the symbol is shown in a Tooltip.
In order to see a description of each symbol on the tool bar, select in Help
the editor about which you want information and click on the tool bar
symbol in which you are interested.
The display of the tool bar is optional (see "Project" "Options" category
Desktop).
Object Organizer
The Object Organizer is always located on the left side of PROSYD 1131.
At the bottom there are four register cards with symbols for the four types of
objects POUs, Data types, Visualizations and Resources.
In order to change between the respective object types click with the mouse
on the corresponding register card or use the left or right arrow key.
You will learn in chapter Creating and Deleting Objects, etc.how to work
with the objects in the Object Organizer.
Screen divider
The screen divider is the border between two non-overlapping windows. In
PROSYD 1131 there are screen dividers between the Object Organizer and
the Work space of the main window, between the interface (declaration part)
and the implementation (instruction part) of POUs and between the Work
space and the message window.
You can move the screen divider with the mouse pointer. You do this by
moving the mouse with the left mouse button pressed.
Make sure the screen divider always remains at its absolute position, even
when the window size has been changed. If it seems that the screen divider
is no longer present, then simply enlarge your window.
Work space
The Work space is located on the right side of the main window in
PROSYD 1131. All editors for objects and the library manager are opened
in this area.
You find the description of the editors in the chapter Editors in PROSYD
1131
Under the menu item "Window" you find all commands for window
management.
Message window
The message window is separated by a screen divider underneath the work
space in the main window.
It contains all messages from the previous compilations, checks , or
comparisons.
If you doubleclick with the mouse in the message window on a message or
press <Enter>, the editor opens with the object. The relevant line of the
object is selected. With the commands "Edit" "Next error" and "Edit"
"Previous error" you can can quickly jump between the error messages.
The display of the message window is optional (see "Window"
"Messages").
Status bar
The status bar at the bottom of the window frame of the main window in
PROSYD 1131 gives you information about the current project and about
menu commands.
If an item is relevant, then the concept appears on the right side of the status
bar in black script, otherwise in gray script.
When you are working in online mode, the concept Online appears in black
script. If you are working in the offline mode it appears in gray script.
In Online mode you can see from the status bar whether you are in the
simulation (SIM), the program is being processed (RUNS), a breakpoint is
set (BP), or variables are being forced (FORCE).
With text editor the line and column number of the current cursor position is
indicated (e.g. Line:5, Col.:11). In online mode 'OV' is indicated black in
the status bar. Pressing the <Ins> key switches between Overwrite and Insert
mode.
If the mouse point is in a visualization, the current X and Y position of the
cursor in pixels relative to the upper left corner of the screen is given. If the
mouse pointer is on an Element, or if an element is being processed, then its
number is indicated. If you have an element to insert, then it also appears
(e.g. Rectangle).
If you have chosen a menu command but haven't yet confirmed it, then a
short description appears in the status bar.
The display of the statusbar is optional (see "Project" "Options" category
Desktop).
Context Menu
Shortcut: <Shift>+<F10>
Instead of using the menu bar for executing a command, you can use the
right mouse button. The menu which then appears contains the most
frequently used commands for a selected object or for the active editor. The
choice of the available commands adapts itself automatically to the active
window. The choice of the available commands adapts itself automatically
to the active window.
4.2 Options
"Project" "Options"
With this command the dialog box for setting options is opened. The options
are divided into different categories. Choose the desired category on the left
side of the dialog box by means of a mouse click or using the arrow keys
and change the options on the right side.
You have at your disposal the following categories:
• Load & Save
• User information
• Editor
• Desktop
• Color
• Directories
• Build
• Passwords
Image 4.5: Option dialog box of the category Load & Save
You can now decide whether you want to open the original file or the auto
save file.
If you request the option Ask for project info, then when saving a new
project, or saving a project under a new name, the project info is
automatically called. You can visualize the project info with the command
"Project" "Project info" and also process it.
If you choose the option Auto Load, then at the next start of PROSYD 1131
the last open project is automatically loaded. The loading of a project at the
start of PROSYD 1131 can also take place by entering the project in the
command line.
User information
If you choose this category , then you get the following dialog box:
To User information belong the Name of the user, his Initials and the
Company for which he works. Each of the entries can be modified.
Editor
If you choose this category , then you get the following dialog box:
Autodeclaration
If you have chosen the Autodeclaration, then (following the input of a not-
yet-declared variable) a dialog box will appear in all editors with which this
variable can be declared.
Autoformat
If the option Autoformat in the category Editor of the options dialog box
has been chosen, then PROSYD 1131 executes automatic formatting in the
IL editor and in the declaration editor. When you finish with a line, the
following formatting is made:
• Operators written in small letters are shown in capitals;
• Tabs are inserted to that the columns are uniformly divided.
Declarations as tables
If the option Declarations as tables in the Editor category in the Options
dialog box is selected, then you can edit variables in a table instead of using
the usual declaration editor (see chapter The Declaration Editor). This table
is arranged as a card-index box in which there are register cards for input,
output, local, and input/output variables. For each variable you have
available the fields Name, Address, Type, Initial, and Comment.
Tab-Width
In the field Tab-Width in the category Editor of the Options dialog box
you can determine the width of a tab as shown in the editors. The default
setting is four characters, whereby the character width depends upon the font
which is chosen.
Font
By clicking on the button Font in the category Editor of the Options dialog
box you can choose the font in all PROSYD 1131 editors. The font size is
the basic unit for all drawing operations. The choice of a larger font size
thus enlarges the printout, even with each editor of PROSYD 1131.
After you have entered the command, the font dialog box opens for choosing
the font, style and font size.
Mark
When choosing Mark in the Editor category in the Options dialog box you
can choose whether the current selection in your graphic editors should be
represented by a dotted rectangle (Dotted), a rectangle with continuous lines
(Line) or by a filled-in rectangle (Filled). In the last case the selection is
shown inverted.
The selection is activated in front of which a (•) point appears.
Bitvalues
When choosing Bitvalues in the category Editor of the Options dialog box
you can choose whether binary data (type BYTE, WORD, DWORD) during
monitoring should be shown Decimal, Hexadecimal, or Binary.
The selection is activated in front of which a (•) point appears. If you choose
this category , then you get the following dialog box:
If the option Tool bar has been chosen, then the tool bar with the buttons
for faster selection of menu commands becomes visible underneath the
menu bar.
If the option Status bar has been chosen, then the status bar at the lower
edge of the PROSYD 1131 main window becomes visible.
If the option Online in Security mode has been chosen, then in Online
mode with the commands "Run", "Stop", "Reset", "Toggle Breakpoint",
"Single cycle", "Write values", "Force values" and "Release force", a
dialog box appears with the confirmation request whether the command
should really be executed. This option is saved with the project.
In language you can define, in which language the menu and dialog texts
are displayed.
Note: Please note, that the language choice is only possible under
Windows NT !
Colors
If you choose this category , then you get the following dialog box:
You can edit the default color setting of PROSYD 1131. You can choose
whether you want to change the color settings for Line numbers (default
setting: light gray), for Breakpoint positions (dark gray), for a Set
breakpoint (light blue), for the Current position (red), for the Reached
Positions (green) or for the Monitoring of Boolean values (blue).
If you have chosen one of the indicated buttons, the dialog box for the input
of colors opens.
Directories
If you choose this category , then you get the following dialog box:
In the input fields Libraries and Compilation Files you can indicate
directories from which PROSYD 1131 should extract the libraries or
compilation files. If you activate the button (...) behind a field, then the
dialog box for selecting a directory opens.
Build
If you choose this category , then you get the following dialog box:
If the option Debugging has been chosen, then the code can significantly
increase in size. Choosing this option makes it possible to generate
additional debugging codes. This is necessary in order to use the PROSYD
1131 debugging functions. If you deactivate this option, then you make
possible faster processing and a smaller code. This option is saved with the
project.
If the option Online Changes has been chosen, then your project can be
changed in the Online mode. With this new compilation only the changed
POUs are loaded into the PLC. (See "Project" "Build")
If the option Save before compile, then your project will be saved every
time before compilation.
With the indication of the Number of data segments you can determine
how much space is reserved in the PLC for the data of your project. If during
Build you get the message: "The global variables need too much memory",
then increase the number of segments in "Project" "Build" ", which increases
the number of the data segments.
These options are saved with the project.
Passwords
If you choose this category , then you get the following dialog box:
To protect your files from unauthorized access PROSYD 1131 offers the
option of using a password to protect against your files being opened or
changed.
Enter the desired password in the field Password. For each typed character
an asterisk (*) appears in the field. You must repeat the same word in the
field Confirm Password. Close the dialog box with OK. If you get the
message:
"The password does not agree with the confirmation",
then you made a typing error during one of the two entries. In this case
repeat both entries until the dialog box closes without a message.
If you now save the file and then reopen it, then you get a dialog box in
which you are requested to enter the password. The project can then only be
opened if you enter the correct password. Otherwise PROSYD 1131 reports:
`"Sourcedownload"
The following dialog will be opened when you select this category:
You can choose to which Timing and what Extent the project is loaded into
the controller system. The option Sourcecode only exclusively involves just
the PROSYD 1131 file (file extension .pro). The option All files also
includes files such as the associated library files, visualization bitmaps,
configuration files, etc.
Using the option Implicit at load allows the selected file range to be
automatically loaded into the controller system on the command "Online"
"Load".
Using the option Notice at load offers a dialog, when the command
"Online" "Load" is given, with the question ”Do you want to write the
source code into the controller system?”. Pressing Yes will automatically
load the selected range of files into the controller system, or you can
alternatively finish with No.
When using the option On demand the selected range of files must be
expressly loaded into the controller system by giving the command "Online"
"Sourcecode download".
The project which is stored in the controller system can be retrieved by
using "File" "Open" with Open project from PLC. The files will be
unpacked in the process.
See Chapter 4.3, "File" "Open" for details !
The commands which refer to entire project are found under the menu items
"File" and "Project". Some of the commands under "Project" deal with
objects and are therefore described in the chapter Creating and Deleting
Objects, etc..
"File" "New"
Symbol:
With this command you create an empty project with the name "Untitled".
This name must be changed when saving.
"File" "Open"
Symbol:
With this command you open an already existing project. If a project has
already been opened and changed, then PROSYD 1131 asks whether this
project should be saved or not.
The dialog box for opening a file appears, and a project file with the
extension "*.pro" or a library file with the extension "*.lib" must be chosen.
This file must already exist. It is not possible to create a project with the
command "Open".
To upload a project from the PLC, press PLC at Open project from PLC.
If there is no current connection to the PLC, the dialog Communication
parameters appears to define the transmission parameters. If an online
connection is made, there will be checked whether there are already project
files with equal names in the local PC directories. In this case the dialog
Load project from PLC is opened where you can decide to replace or not
to replace the local files by that used in the PLC.
Note: Please note, that you in any case have to give a new name to a
project, when you load it from the PLC to your local directory, otherwise it
is unnamed.
If there has not yet been loaded a project to the PLC, you get an error
message.
(See also "Project" "Options" category "Sourcedownload").
Image 4.17: Standard dialog box for opening a file in PROSYD 1131
The most recently opened files are listed under the command "File" "Exit".
If you choose one of them, then this project is opened.
If Passwords or User groups have been defined for the project, then a
dialog box appears for entering the password.
"File" "Close"
With this command you close the currently-open project. If the project has
been changed, then PROSYD 1131 asks if these changes are to be saved or
not.
If the project to be saved carries the name "Untitled", then a name must be
given to it (see "File" "Save as").
"File" "Save"
If the project is to be saved under a new name, then choose the file type
PROSYD 1131 Project (*.pro).
If you choose the file type Project Version 1.5 (*.pro), respectively
Project Version 2.0 (*.pro) then the current project is saved as if it were
created with the version 1.5 respectively 2.0. Specific data of the version 2.0
can thereby be lost! However, the project can be executed with the version
1.5 or 2.0.
You can also save the current project as a library in order to use it in other
projects. Choose the file type Internal library (*.lib) if you have
programmed your POUs in PROSYD 1131.
Choose the file type External library (*.lib) if you want to implement and
integrate POUs in other languages (e.g. C). This means that another file is
also saved which receives the file name of the library, but with the extension
"*.h". This file is constructed as a C header file with the declarations of all
POUs, data types, and global variables. Is external libraries are used, in the
simulation mode the implementation, written for the POUs in PROSYD
1131, will be executed. Working with the real hardware the implementation
written in C will be executed.
Then click OK. The current project is saved in the indicated file. If the new
file name already exists, then you are asked if you want to overwrite this
file.
When saving as a library, the entire project is compiled. If an error occurs
thereby, then you are told that a correct project is necessary in order to create
a library. The project is then not saved as a library.
"File" "Print"
Shortcut: <Ctrl>+<P>
With this command the content of the active window is printed.
After the command has been chosen, then the Print dialog box appears.
Choose the desired option or configure the printer and then click OK. The
active window is printed.
You can determine the number of the copies and print the version to a file.
With the button Properties you open the dialog box to set up the printer.
You can determine the layout of your printout with the command "File"
"Printer Setup".
During printing the dialog box shows you the number of pages already
printed. When you close this dialog box, then the printing stops after the
next page.
In order to document your entire project, use the command "Project"
"Document".
If you want to create a document frame for your project, then open a global
variables list and use the command "Extras" "Make Docuframe file".
In the field File you can enter the name of the file with the extension ".dfr"
in which the page layout should be saved. The default destination for the
settings is the file DEFAULT.DFR.
If you would like to change an existing layout, then browse through the
directory tree to find the desired file with the button Browse
You can also choose whether to begin a new page for each object and for
each subobject. Use the Printer Setup button to open the printer
configuration.
If you click on the Edit button, then the frame for setting up the page layout
appears. Here you can determine the page numbers, date, filename and POU
name, and also place graphics on the page and the text area in which the
documentation should be printed.
Image 4.21: Window for pasting the placeholders on the page layout
2
Drawing a rectangle on the layout by dragging the mouse diagonally while
pressing the left mouse button.
If the template was changed, then PROSYD 1131 asks when the window is
closed if these changes should be saved or not.
"File" "Exit"
Shortcut: <Alt>+<F4>
With this command you exit from PROSYD 1131.
If a project is opened, then it is closed as described in "File" "Save".
"Project" "Build"
With this command all changed POUs are built. When loading the program,
only the modified POUs are sent to the PLC. The rest of the program
remains unchanged in the PLC.
Image 4.22: Message window of a project with three POUs and two error messages
Note: The cross references are created during compilation and are not
saved in the project! In order to use the commands "Show call tree”,
"Show cross reference list, and "Show unused variables the project must
be rebuilt after loading and after a modification.
"Project" "Document"
This command lets you print the documentation of your entire project. The
elements of a complete documentation are:
• The POUs,
• the contents of the documentation,
• the data types,
• the visualizations
• the resources (Access variables, global variables, variables
configuration, the Sampling Trace, the PLC Configuration, the Task
Configuration, the Watch and Receipt Manager)
• the call trees of POUs and data types, as well as
• the cross reference list.
For the last two items the project must have been built without errors.
Only those areas in the dialog box are printed which are highlighted in blue.
If you want to select the entire project, then select the name of your project
in the first line.
If, on the other hand, you only want to select a single object, then click on
the corresponding object or move the dotted rectangle onto the desired
object with the arrow key. Objects which have a plus sign in front of their
symbols are organization objects which contain other objects. With a click
on a plus sign organization object is expanded, and with a click on the
resulting minus sign it can be closed up again. When you select an
organization object, then all relevant objets are also selected. By pressing the
<Shift> key you can select a group of objects, and by pressing the <Ctrl>
key you can select several individual objects.
Once you have made your selection, then click on OK. The Print dialog box
appears. You can determine the layout of the pages to be printed with
"File" "Printer setup".
"Project" "Export"
With PROSYD 1131 projects can be exported or imported. That allows you
to exchange programs between different IEC programming systems.
There is a standardized exchange format for POUs in IL, ST, and SFC (the
Common Elements format of IEC 1131-3). For the POUs in LD and FBD
and the other objects PROSYD 1131 has its own filing format since there is
no text format for this in IEC 1131-3. The selected objects are written to an
ASCII file.
POUs, data types, visualizations, and the resources can be exported.
Once you have made your selection in the dialog box window (the same way
as with "Project" "Document" ), you can decide, whether you want to
export the selected parts to one file or to export in separate files, one for
each object. Switch on or off the option One file for each object then click
on OK. The dialog box for saving files appears. Enter a file name with the
expansion ".exp" respectively a directory for the object export files, which
then will be saved there with the file name <objectname.exp>.
"Project" "Import"
In the resulting dialog box for opening files select the desired export file.
The data is imported into the current project. If an object with the same
name already exists in the same project, then a dialog box appears with the
question "Do you want to replace it?": If you answer Yes, then the object in
the project is replaced by the object from the import file. If you answer No,
then the name of the new objects receives as a supplement an underline and
a digit ("_0", "_1", ..). With Yes, all or No, all this is carried out for all
objects.
In the message window the import is registered.
"Project" "Compare"
With this command you can compare the open project with another. For
example, if you prepare to save and want to know where you have made
changes in the current project, then you can compare the open project with
the last saved version of it.
After you have given this command, then the dialog box for opening files
appears. Choose the project with which you want to compare the current
project. If you press OK, then you will see the result of the comparison in
the message window. All of the objects of the chosen project are listed and
the changes in the object are shown afterward in parentheses. There are five
possible messages:
• "Unchanged": The object was not changed.
"Project" "Merge"
With this command you can merge objects (POUs, data types,
visualizations, and resources) from other projects into your project.
When the command has been given, first the standard dialog box for
opening files appears. When you have chosen a file there, a dialog box
appears in which you can choose the desired object. The selection takes
place as described with "Project" "Document" .
If an object with the same name already exists in the project, then the name
of the new object receives the addition of an underline and a digit ("_1",
"_2" ...).
"Project" "Project
info"
Under this menu item the information about your project can be saved.
When the command has been given, then the following dialog box opens:
If you choose the option Ask for project info in the category Load & Save
in the Options dialog box, then while saving a new project, or while saving a
project under a new name, the project info is called automatically.
"Project" "Global
Search"
With this command you can search for the location of a text in POUs, data
types, or in the objects of the global variables.
When the command is entered, a dialog box opens in which you can choose
the desired object. The selection is made as in the "Project" "Document"
description.
When you have confirmed the selection with OK, then the search dialog box
appears. If a text in an object has been found, then the object is loaded into
the appropriate editor, and its location is shown.
"Project" "Global
replace"
With this command you can search for the location of a text in POUs, data
types, or the objects of the global variables and replace this text by another.
This is executed in the same way as with "Project" "Global Search" or
"Edit" "Replace".
"Project" "Register
changes"
This command is necessary when significant changes have to be made to a
project without interrupting the PLC. (Online Change).
Copy your project, make your changes, and test your changes. Select the
command "Project" "Compare" in order to compare the two projects.
With the command "Register changes" all differences between the current
project and the comparison are traced. Then, with the command "Build" the
modified POUs can be compiled. When downloading the program only the
modified POUs are sent to the PLC. The rest of the program remains
unchanged in the PLC.
User groups
In PROSYD 1131 up to eight user groups with different access rights to the
POUs, data types, visualizations, and resources can be set up. Access rights
for single objects or all of them can be established. Only a member of a
certain user group can open a project. A member of such a user group must
identify himself by means of a password.
The user groups are numbered from 0 to 7, whereby the Group 0 has the
administrator rights, i.e. only members of group 0 may determine passwords
and access rights for all groups and/or objects.
When a new project is launched, then all passwords are initially empty.
Until a password has been set for the 0 group, one enters the project
automatically as a member of the 0 group.
If a password for the user group 0 is existing while the project is loaded,
then a password will be demanded for all groups when the project is opened.
For this the following dialog box appears:
In the combobox User group on the left side of the dialog box, enter the
group to which you belong and enter on the right side the relevant
password. Press OK. If the password does not agree with the saved
password, then the message appears:
"The password is not correct."
Only when you have entered the correct password can the project be opened.
With the command "Passwords for user group" you can assign the
passwords, and with "Object" "Access rights" you can define the rights
for single objects or for all of them.
"Project""Passwords
for user groups"
With this command you open the dialog box for password assignment for
user groups. This command can only be executed by members of group 0.
When the command has been given, then the following dialog box appears:
In the left combobox User group you can select the group. Enter the desired
password for the group in the field Password. For each typed character an
asterisk (*) appears in the field. You must repeat the same password in the
field Confirm password. Close the dialog box after each password entry
with OK. If you get the message:
"The password does not agree with the confirmation",
then you made a typing error during one of the two entries. In this case
repeat both entries until the dialog box closes without a message.
Then, if necessary, assign a password for the next group by calling the
command again.
With the command "Object" "Access rights" you can assign the rights for
single objects or all of them.
Now we shall explain how to work with objects and what help is available
to keep track of a project (Folders, Call tree, Cross reference list,..).
Object
POUs, data types, visualizations and the resources (Access variables, global
variables, the variable configuration, the Sampling Trace, the PLC
Configuration, the Task Configuration, and the Watch and Receipt Manager
are all defined as "objects". The folders inserted for structuring the project
are partially involved. All objects of a project are in the Object Organizer.
If you hold the mouse pointer for a short time on a POU in the Object
Organizer, then the type of the POU (Program, Function or Function block)
is shown in a Tooltip. For the global variables the tooltip shows the keyword
(VAR_ACCESS, VAR_GLOBAL, VAR_CONFIG).
Folder
In order to keep track of larger projects you should group your POUs, data
types, visualizations, and global variables systematically in folders.
You can set up as many levels of folders as you want. If a plus sign is in
front of a closed folder symbol, then this folder contains objects and/or
additional folders. With a click on the plus sign the folder is opened and the
subordinated objects appear. With a click on the minus (which has replaced
the plus sign) the folder can be closed again. In the context menu you find
the commands "Expand nodes" and "Collapse nodes" with the same
functions.
With Drag&Drop you can move the objects as well as the folders within
their object type. For this select the object and drag it with pressed left
mouse button to the desired position.
Note: Folders have no influence on the program, but rather serve only
to structure your project clearly.
"New Folder"
With this command a new folder is inserted as a structural object. If a folder
has been selected, then the new one is created underneath it. Otherwise it is
created on the same level.
The context menu of the Object Organizer which contains this command
appears when an object or the object type has been selected and you have
pressed the right mouse button or <Shift>+<F10>.
"Expand nodes"
"Collapse nodes"
With the command expand the objects are visibly unfolded which are
located in the selected object. With Collapse the subordinated objects are no
longer shown.
With folders you can open or close them with a double mouse click or by
pressing <Enter>.
The context menu of the Object Organizer which contains this command
appears when an object or the object type has been selected and you have
pressed the right mouse button or <Shift>+<F10>.
"Project" "Object
Delete"
Shortcut: <Delete>
With this command the currently selected object (a POU, a data type, a
visualization, or global variables), or a folder with the subordinated objects
is removed from the Object Organizer and is thus deleted from the project.
For safety you are asked once more for confirmation.
If the editor window of the object was open, then it is automatically closed.
If you delete with the command "Edit" "Cut", then the object is parked on
the clipboard.
If, on the other hand, you use the command "Edit" "Paste", then the object
is pasted from the clipboard, and no dialog box appears.
"Project" "Object
Rename"
Shortcut: <Spacebar>
With this command you give a new name to the currently-selected object or
folder. Remember that the name of the object may not have already been
used.
If the editing window of the object is open, then its title is changed
automatically when the name is changed.
"Project" "Object
Convert"
This command can only be used with POUs. You can convert POUs from
the languages SFC, ST, FBD, LD, and IL into one of the three languages IL,
FBD, and LD.
For this the project must be compiled. Choose the language into which you
want to convert and give the POU a new name. Remember that the name of
the POU may not have already been used. Then press OK, and the new POU
is added to your POU list.
"Project" "Object
Copy"
With this command a selected object is copied and saved under a new name.
Enter the name of the new object in the resulting dialog box. Remember that
the name of the object may not have already been used.
If, on the other hand, you used the command "Edit" "Copy", then the
object is parked on the clipboard, and no dialog box appears.
"Project" "Object
Open"
Shortcut: <Enter>
With the command you load a selected object within the Object Organizer
into the respective editor. If a window with this object is already open, then
it gets a focus, is moved into the foreground and can now be edited.
There are two other ways of opening an object:
• Doubleclick with the mouse on the desired object
• type in the Object Organizer the first letter of the object name. Then a
dialog box opens in which all objects of the available object types with
this initial letter are shown. Select the desired object and click on the
button Open in order to load the object in its edit window. This option
is supported with the object type Resources only for global variables.
This last possibility is especially useful in projects with many objects.
"Project" "Object
Access rights"
With this command you open the dialog box for assigning access rights to
the different user groups. The following dialog box appears:
Members of the user group 0 can now assign individual access rights for
each user group. There are three possible settings:
• No Access: the object may not be opened by a member of the user
group.
• Read Access: the object can be opened for reading by a member of the
user group but not changed.
• Full Access: the object may be opened and changed by a member of
the user group.
The settings refer either to the currently-selected object in the Object
Organizer or, if the option Apply to all is chosen, to all POUs, data types,
visualizations, and resources of the project.
The assignment to a user group takes place when opening the project
through a password request if a password was assigned to the user group 0.
"Project" "View
instance"
With this command you can open and show single instances of function
blocks. The function block whose instance should be open must first be
selected in the Object Organizer before you can execute this command. In
the resulting dialog box you can choose the desired instance of this function
block.
Note: Instances can be opened only after logging in! (Project was
correctly compiled and sent with "Online" "Login" to the PLC).
"Project" "Show
unused variables"
With this command a list of variables is shown which, to be sure, have been
declared in the project but are not being used anywhere. For this the project
must be compiled (see "Rebuild all").
If there are no unused variables in your project, then that is announced.
Otherwise the following window appears:
"Extras"
Previous version
With this command you can restore the current object to the last saved state.
The restored state is either that of the most recent manual save ("File"
"Save") or that which was kept after the automatic save, depending upon
which version is most recent.
You can use the following commands in all editors and some of them in the
Object Organizer. All of the commands are locted under the menu item
"Edit".
"Edit" "Undo"
Shortcut: <Ctrl>+<Z>
This command undoes the action which was most recently executed in the
currently-open editor window or in the Object Organizer.
By repeatedly selecting this command, all actions can be undone back to the
point at which the window was opened. This applies to all actions in the
editors for POUs, data types, visualizations, and global variables and in the
Object Organizer.
With "Edit" "Redo" you can restore an action which you have undone.
"Edit" "Redo"
Shortcut: <Ctrl>+<Y>
With the command in the currently-open editor window or in the Object
Organizer you can restore an action you have undone ("Edit" "Undo").
As often as you have previously executed the command "Undo" , you can
also carry out the command "Redo".
"Edit" "Cut"
Symbol:
Shortcut: <Ctrl>+<X> or <Shift>+<Delete>
This command transfers the current selection from the editor to the
clipboard. The selection is removed from the editor.
In the Object Organizer this similarly applies to the selected object, whereby
not all objects can be deleted, e.g. the PLC Configuration.
Remember that not all editors support the cut command, and that its use can
be limited in some editors.
The form of the selection depends upon the respective editor:
In the text editors (IL, ST, and declarations) the selection is a list of
characters.
In the FBD and LD editors the choice is a number of networks which are
indicated by a dotted rectangle in the network number field or a box with all
preceding lines, boxes, and operands.
In the SFC editor the selection is a part of a series of steps surrounded by a
dotted rectangle.
In order to paste the content of the clipboard you use the command "Edit"
"Paste". In the SFC editor you can also use the commands "Extras"
"Insert parallel branch (right)" or "Extras" "Paste after".
In order to copy a selection onto the clipboard without deleting it, use the
command "Edit" "Copy".
In order to remove a selected area without changing the clipboard, use the
command "Edit" "Delete".
"Edit" "Copy"
"Edit" "Paste"
With the text editors (IL, ST, Declarations) the current position is that of the
blinking cursor (a vertical line) which you place by clicking with the
mouse).
In the FBD and LD editors the current position is the first network with a
dotted rectangle in the network number area. The contents of the clipboard
are inserted in front of this network. If a partial structure has been copied,
then it is inserted in front of the selected element.
In the SFC editor the current position is determined the selection which is
surrounded by a dotted rectangle. Depending upon the selection and the
contents of the clipboard, these contents are inserted either in front of the
selection or into a new branch (parallel or alternative) to the left of the
selection.
In SFC the commands "Extras" "Insert parallel branch (right)" or
"Extras" "Paste after" can be used in order to insert the contents of the
clipboard.
"Edit" "Delete"
Shortcut: <Delete>
Deletes the selected area from the editor window. This does not change the
contents of the clipboard.
In the Object Organizer this applies likewise to the selected object, whereby
not all objects can be deleted, e.g. the PLC Configuration.
For the type of selection the same rules apply as with "Edit" "Cut".
In the library manager the selection is the currently selected library name.
"Edit" "Find"
Symbol:
With this command you search for a certain text passage in the current
editor window. The Find dialog box opens. It remains opens until the button
Cancel is pressed.
In the field Find what you can enter the series of characters you are looking
for.
In addition, you can decide whether the text you are looking for Match
whole word only or not, or also whether Match case is to be considered,
and whether the search should proceed Up or Down starting from the
current cursor position.
The button Find next starts the search which begins at the selected position
and continues in the chosen search direction. If the text passages is found,
then it is highlighted. If the passage is not found, then a message announces
this. The search can be repeated several times in succession until the
beginning or the end of the contents of the editor window has been reached.
Remember that the found text can be covered up by the Find dialog box.
"Edit" "Replace"
With this command you search for a certain passage just as with the
command "Edit" "Find", and replace it with another. After you have
chosen the command the dialog box for find and replace appears. This
dialog box remains open until the button Cancel or Close is pressed.
The button Replace replaces the current selection with the text in the field
Replace with.
The button Replace all replaces every occurrence of the text in the field
Find next after the current position with the text in the field Replace with.
At the end of the procedure a message announces how many replacements
were made.
"Edit" "Input
Assistant"
Shortcut: <F2>
This command provides a dialog box for choosing possible inputs at the
current cursor position in the editor window. In the left column choose the
desired input category, select the desired entry in the right column, and
confirm your choice with OK. This inserts your choice at this position.
The categories offered depend upon the current cursor position in the editor
window, i.e. upon that which can be entered at this point (e.g. variables,
operators, POUs, conversions, ...).
In some positions (e.g. in the watch list) multilevel variable names are
necessary. At first the Input Assistant dialog box contains a list of all POUs
along with a single point for the global variables. After each POU name
there is a point. Doubleclicking with the mouse or pressing <Enter> opens a
list of the variables for a selected POU. Instances and data types can, when
appropriate, be opened again. By pressing OK you accept the selected
variable.
Image 4.42: Input Assistant dialog box with multilevel variable names
Note: Some entries (e.g. global variables) are only brought up to date in
the Input Assistant after a compilation run.
"Edit" "Declare
Variable"’
Shortcut: <Shift>+<F2>
This command opens the dialog for the declaration of a variable. This dialog
also opens automatically when the option 'Project' 'Options' 'Editor'
'Autodeclaration' is switched on and when a new undefined variable is used
the declaration editor.
"Edit" "Previous
error"
Shortcut: <Shift>+<F4>
After the incorrect compilation of a project this command shows the
previous error. The corresponding editor window is activated and the
incorrect place is selected. At the same time in the message window the
corresponding error message is shown.
The available online commands are assembled under the menu item
"Online". The execution of some of the commands depends upon the active
editor.
The online commands become available only after logging in.
"Online" "Login"
run). Monitoring and debugging is therefore not possible. You can either
choose "No," logout, and open the right project, or use "Yes" to load the
current project in the PLC.
"Online" "Logout"
"Online" "Download"
This command loads the compiled project in the PLC.
If you use C-Code generation, then prior to the download, the C-Compiler is
called up, which creates the download file. If this is not the case, then the
download file is created during the compiling.
"Online" "Run"
"Online" "Stop"
"Online" "Reset"
If you have initialized the variables with a specific value, then this command
will reset the variables to the initialized value. All other variables are set at a
standard initialization (for example, integers at 0). As a precautionary
measure, PROSYD 1131 asks you to confirm your decision before all of the
variables are overwritten.
Use the "Online" "Run" command to restart the program.
"Online" "Toggle
Breakpoint"
Online "Breakpoint
Dialog Box"
This command opens a dialog box to edit breakpoints throughout the entire
project. The dialog box also displays all breakpoints presently set.
In order to set a breakpoint, choose a POU in the POU combobox and the
line or the network in the Location combobox where you would like to set
the breakpoint; then press the Add button. The breakpoint will be added to
the list.
In order to delete a breakpoint, highlight the breakpoint to be deleted from
the list of the set breakpoints and press the Delete button.
The Delete All button can be used to delete all the breakpoints.
"Online" "Single
Cycle"
Shortcut: <Ctrl>+<F5>
This command executes a single PLC Cycle and stops after this cycle.
This command can be repeated continuously in order to proceed in single
cycles.
The Single Cycle ends when the "Online" "Run" command is executed.
"Online" "Write
Values" or "Force
Values"
Shortcut: <Ctrl>+<F7> (Write values)
Shortcut: <F7> (Force values)
In order to change the value of a variable containing a single element, you
must first use the mouse to doubleclick on the line in which the variable is
declared, or alternatively you can use <Enter>. Next you can enter the new
value of the variable in the dialog box that pops up. In the case of Boolean
variables, the value is toggled without the dialog box appearing. The new
value is displayed in red.
"Online" "Release
Force"
Shortcut: <Shift>+<F7>
This command ends the forcing of variables in the PLC. All forced variables
once again change their values normally.
If no forced values are available, the command will have no effect.
"Online""Show Call
Stack"
You can run this command when the Simulation Mode stops at a breakpoint.
You will be given a dialog box with a list of the POUs currently in the Call
Stack.
The first POU is always PLC_PRG, because this is where the executing
begins.
The last POU is always the POU being executed.
After you have selected a POU and have pressed the Go to button, the
selected POU is loaded in its editor, and it will display the line or network
being processed.
"Online" "Flow
Control"
If you have selected the flow control, then a check(!) will appear in front
of the menu item. Following this, every line or every network will be
marked which was executed in the last PLC Cycle.
The line number field or the network number field of the lines or networks
which just run will be displayed in green. An additional field is added in the
IL-Editor in which the present contents of the accumulator are displayed. In
the graphic editors for the Function Block Diagram and Ladder Diagram, an
additional field will be inserted in all connecting lines not transporting any
Boolean values. When these Out- and Inputs are verified, then the value that
is transported over the connecting line will be shown in this field.
Connecting lines that transport only Boolean values will be shaded blue
when they transport TRUE. This enables constant monitoring of the
information flow.
"Online" "Simulation"
If Simulation Mode is chosen, then a check(!) will appear in front of the
menu item.
In the simulation mode, the user program runs on the same PC under
Windows. This mode is used to test the project. The communication
between the PC and Simulation Mode uses the Windows Message
mechanism.
If the program is not in simulation mode, then the program will run on the
PLC. The communication between the PC and the PLC typically runs over
the serial interface.
The status of this flag is stored with the project.
"Online"
"Communication
Parameters"
The parameters for transferring through the serial interface can be entered in
a dialog box. It is important that these parameters agree with those entered
in the PLC.
"Online"
"Communications
Parameters" for the
use of Gateway
You are offered a special dialog for setting communications parameters
when the communication between the local PC and the run-time system is
running over a gateway server in your system.
Let us examine the principle of the gateway system before explaining the
operation of the dialog:
A gateway server can be used to allow your local PC to communicate with
one or more run-time systems. The setting concerning which run-time
systems can be addressed, which is specifically configured for each gateway
server, and the connection to the desired gateway server, is made on the
local PC. Here it is possible that both the gateway server and the run-time
system(s) can run together on the local PC. If we are dealing with a gateway
server which is running on another PC we must ensure that it has been
started there. If you are selecting a locally installed gateway server, it
automatically starts when you log onto the target run-time system. You can
recognise this through the appearance of a PROSYD 1131 symbol on the
bottom right in the task bar. This symbol lights up as long as you are
connected to the run-time system over the gateway. The menu points Info
and Finish are obtained by clicking with the right mousekey on the symbol.
Finish is used to switch off the gateway.
See the following scheme for presenting a gateway system:
PC_local is your local PC, PC_x is another PC, which gateway addresses.
PC_gateway is the PC on which the gateway server is installed, PC_PLC1
through to PC_PLC4 are PCs on which the run-time systems are running.
The diagram shows the modules as separated but it is fully possible for the
Gateway server and / or run-time systems to be installed together on the
local PC.
Let us now return to the communications parameters dialog on the local PC:
It shows the current situation on the selected gateway server, which can be
called up at any time using the button Update.
The dialog will appear as follows if the communications parameters have
already been configured according to the example shown above:
Image 4.48: Dialog for setting the gateway communications parameters, example
of the local computer (PC_local). Below, indented to the right, are three
addresses of run-time computers to which the gateway channels are set-up to
(PC_PLC1 to 3). They could have been configured both from the local PC
or from the other PCs (PC_x) which are or were connected to the gateway
server.
The second category of the channels includes all connections to the gateway
which can be set up from your local PC, over this configuration dialog for
example. They create the ”branch” which leads from the minus sign directly
below to PC_PLC1 and PC_PLC4. These channel addresses do not
necessarily have to be known yet at the gateway. For PC_PLC4 in the
example described above, the configuration parameters are stored locally in
the project but they will first be known to the gateway the next time log-in to
the run-time system occurs. This has already occurred for PC_PLC1 since
the associated gateway address has appeared as an additional ”sub-branch”
to the ”channel tree”.
In the central part of the dialog one finds the designation, in each case, of the
left selected channel and the associated parameter under Name, Value and
Comment.
Let us now turn to the way the communications parameters themselves can
be set in dialog:
To define the connection to the desired gateway we open the dialog
Communication Parameters Gateway by pressing the button Gateway.
Image 4.49: Example dialog, definition of the local connection to the gateway
Here it is possible to enter or edit the name of the computer on which the
gateway server is running as well as its Dataport and Serviceport. By first
activation 'localhost' is offered by default as the name of the computer. You
can also enter an IP address instead of the computer name. The name
'localhost' is usually identical to the local IP address 127.0.0.1 in most cases
but you may have to enter this directly into the field Address. Suitable
values for the selected Gateway are usually already present in the fields
Dataport and Serviceport.
By ending the dialog with OK the appropriate input appears in the title
Channels of the dialog Communications Parameters, in the upper position.
A sign in brackets showing ”not connected” appears behind the address
when it is not possible to establish a connection to the selected gateway
address, either because it is not running or because the address is incorrect.
Press the button New if you wish to install a new channel on the gateway
server. You are offered the following dialog.
The input field Name always contains the name used for the last inputted
channel. The current gateway name e.g. ‘localhost_’ appears if a connection
has not been entered yet. You can edit the channel name at this point. The
channel name is purely informative, it does not have to be a unique name
but it is recommended to use one. Select a driver which is offered in the
column Name with a mouse click (the offering depends on your individual
installation conditions) and the commentary to it may possibly be shown in
the column Info if one exists.
If you now close the dialog with OK, the newly defined channel appears in
the communications parameter dialog as a further entry for Channels at the
lowest position under the minus sign. It is only stored locally in the project
at first (see above). It is still possible to edit the column Value while it is in
this condition (see tips below); confirm the parameters with OK thereby
leaving the dialog.
To make the newly established connection known in the gateway, and thus
to make it generally available, it necessary for you to log-on into the run-
time system. When you open the communications parameter dialog again
the new channel, apart from being in its former position, also appears
indented under the address/name of the gateway computer. If a
communications error occurs when logging in, the interface cannot be
"Online" "Sourcecode
download"
This command loads the source code for the project into the controller
system. See also "Project" "Options" "Sourcecode download"
Under the "Window" menu item you will find all commands for managing
the windows. There are commands both for the automatic set up of your
window as well as for opening the library manager and for changing
between open windows. At the end of the menu you will find a list of all
open windows in the sequence they were opened. You can switch to the
desired window by clicking the mouse on the relevant entry. A check will
appear in front of the active window.
"Window" "Tile
Horizontal"
With this command you can arrange all the windows horizontally in the
work area so that they do not overlap and will fill the entire work area.
"Window" "Tile
Vertical"
With this command you can arrange all the windows vertically in the work
area so that they do not overlap and will fill the entire work area.
"Window" "Cascade"
With this command you can arrange all the windows in the work area in a
cascading fashion, one behind another.
"Window" "Arrange
Symbols"
With this command you can arrange all of the minimized windows in the
work area in a row at the lower end of the work area.
"Window" "Messages"
Shortcut: <Shift>+<Esc>
With this command you can open or close the message window with the
messages from the last compiling, checking, or comparing procedure.
If the messages window is open, then a check (!) will appear in front of the
command.
Should you encounter any problems with PROSYD 1131 during your work,
online help is available to help to solve them. There you will find all the
information that is also contained in this handbook.
Under the Contents register card you will find the contents. The books can
be opened and closed using a doubleclick or the corresponding button.
Doubleclicking or activating the Show button on a highlighted topic will
display the topic in the main window of help or in the index window.
Click on the Index register card to look for a specific word, and click on the
Search register card to select a full-text search. Follow the instructions in
the register cards.
• << shows the help entry that comes prior in sequence to the present
entry
• >> shows the help entry that is next in sequence
In addition you can use the following menu commands:
• With "File" "'Print Topics" you can print out the present help entry.
• If you use the "Edit" "Copy" command, the selected text will be
copied into the clipboard. From here you can insert the text into other
applications and use it there.
• If you use the "Edit" "Annotate" command, a dialog box will be
opened. There is an editing field on the left side of the dialog box in
which you can enter an annotation to the help page.
On the right side there are buttons for storing the text, for canceling
the program, for deleting the notation, for copying a highlighted text
on the clipboard , and for pasting a text from the clipboard.
If you have made an annotation to a help entry, a small green paper
clip will appear in the upper left-hand corner. By clicking the mouse
on the paper clip, you can open the dialog box with the annotation that
has been made.
• If you would like to mark a page from help, then you can set a
bookmark. To do so, choose the "Define" "Bookmark" command. A
dialog box will appear in which you can enter a new name (The name
of the page can serve as a starter) or can delete an old bookmark. If
bookmarks were defined, then these will be displayed in the
"Bookmark" menu. By choosing these menu items, you can access
the desired page.
• Under "Options", you can define whether the help window always
appears in the foreground or in the background or in the standard
setting.
• With "Display previous topics" under "Options", you are furnished
with a selection window with the previously displayed help topics.
Doubleclick the entry you wish to view.
• Under "Options", you can select the desired "Font" in small,
normal, or large.
• If "Options" "Use System Color" has been chosen, help will not be
displayed in the colors that were set, but in the system colors instead.
Index Window
The index window contains explanations about the menu commands, terms,
or sequences.
The index window will always remain on the surface by default, unless the
help option is placed in the background in the main window of help.
The following buttons are available:
• Help topics opens the help topics window
• Back shows the help entry that was previously displayed
• Print opens the dialog box for printing
• << shows the help entry directly prior to the present entry
• >> shows the help entry that is next in sequence
Declaration Part
All variables to be used only in this POU are declared in the declaration part
of the POU. These can include: input variables, output variables,
input/output variables, local variables, retain variables, and constants. The
declaration syntax is based on the IEC1131-3 standard. An example of a
correct declaration of variables in PROSYD 1131-Editor:
Input Variable
Between the key words VAR_INPUT and END_VAR, all variables are
declared that serve as input variables for a POU. That means that at the call
position, the value of the variables can be given along with a call.
Example:
VAR_INPUT
in1:INT (* 1. Inputvariable*)
END_VAR
Output Variable
Between the key words VAR_OUTPUT and END_VAR, all variables are
declared that serve as output variables of a POU. That means that these
values are carried back to the POU making the call. There they can be
answered and used further.
Example:
VAR_OUTPUT
out1:INT; (* 1. Outputvariable*)
END_VAR
Input and Output
Variables
Between the key words VAR_IN_OUT and END_VAR, all variables are
declared that serve as input and output variables for a POU.
Attention: With this variable, the value of the transferred variable is
changed ("transferred as a pointer"). That means that the input value for
such variables cannot be a constant.
Example:
VAR_IN_OUT
inout1:INT; (* 1. Inputoutputvariable *)
END_VAR
Local Variables
Between the keywords VAR and END_VAR, all of the local variables of a
POU are declared. These have no external connection; in other words, they
can not be manipulated from the outside.
Example:
VAR
loc1:INT; (* 1. Local Variable*)
END_VAR
Retain Variables
Retain variables are identified by the key word RETAIN. These variables
maintain their value, even after a power failure. When the program is run
again, the stored values will be processed further. A practical example
would be an operations timer that recommences timing after a power failure.
All other variables are newly initialized, either with their initialized values
or with the standard initializations.
Example:
VAR RETAIN
rem1:INT; (* 1. Retain variable*)
END_VAR
Constants
Constants are identified by the key word CONSTANT. They can be
declared locally or globally.
Syntax:
VAR CONSTANT
<Identifier>:<Type> := <initialization>;
END_VAR
Example:
VAR CONSTANT
con1:INT:=12; (* 1. Constant*)
END_VAR
You will find a listing of possible constants here in the appendix.
Keywords
In all editors, all keywords are written in capital letters. Keywords may not
be used as variables.
Variables declaration
A variables declaration has the following syntax:
<Identifier> {AT <Address>}:<Type> {:=<initialization>};
The parts in the braces {} are optional.
The variable identifier may not contain any blank spaces or special
characters, may not be declared more than once and cannot be the same as
any of the keywords. Capitalization is not recognized which means that
VAR1, Var1, and var1 are all the same variable. The underscore character is
recognized in identifiers (e.g., "A_BCD" and "AB_CD" are considered two
different identifiers). An identifier may not have more than one underscore
character in a row. The first 32 characters are significant.
All declarations of variables and data type elements can include
initialization. They are brought about by the ":=" operator. For variables of
elementary types, these initializations are constants. The default-
initialization is 0 for all declarations.
Example:
var1:INT:=12; (* Integer variable with initial value of 12*)
If you wish to link a variable directly to a definite address, then you must
declare the variable with the keyword AT.
For faster input of the declarations, use the shortcut mode.
In function blocks you can also specify variables with incomplete address
statements. In order for such a variable to be used in a local instance, there
must be an entry for it in the variable configuration.
Pay attention to the possibility of an automatic declaration
AT Declaration
If you wish to link a variable directly to a definite address, then you must
declare the variable with the keyword AT. The advantage of such a
procedure is that you can assign a meaningful name to an address, and that
any necessary changes of an incoming or outgoing signal will only have to
be made in one place (e.g., in the declaration).
Notice that variables requiring an input cannot be accessed by writing. A
further restriction is that AT declarations can only be made for local and
global variables, and not for input- and output variables from POUs.
Examples:
counter_heat7 AT %QX0.0: BOOL;
lightcabinetimpulse AT %IX7.2: BOOL;
download AT %MX2.2: BOOL;
"Insert" "Declarations
keywords"
You can use this command to open a list of all the keywords that can be
used in the declaration part of a POU. After a keyword has been chosen and
the choice has been confirmed, the word will be inserted at the present
cursor position.
You also receive the list, when you open the Input Assistant and choose the
Declarations category.
"Insert" "Type"
With this command you will receive a selection of the possible types for a
declaration of variables. You also receive the list when you access the Input
Assistant.
The types are divided into these categories:
• Standard types BOOL, BYTE, etc.
• Defined types Structures, enumeration types, etc.
• Standard function blocks for instance declarations
• Defined function blocks for instance declarations
PROSYD 1131 supports all standard types of IEC1131-3:
Examples for the use of the various types are found in the appendix.
Syntax Coloring
In all editors you receive visual support in the implementation and
declaration of variables. Errors are avoided, or discovered more quickly,
because the text is displayed in color.
A comment left unclosed, thus annotating instructions, will be noticed
immediately; keywords will not be accidentally misspelled, etc.
The following color highlighting will be used:
• Blue Keywords
• Green Comments in the text editors
• Pink Special constants (e.g. TRUE/FALSE, T#3s,
%IX0.0)
• Red Input error (for example, invalid time constant,
keyword, written in lower case,...)
• Black Variables, constants, assignment operators, ...
Shortcut Mode
The declaration editor for PROSYD 1131 allows you to use the shortcut
mode. This mode is activated when you end a line with <Ctrl><Enter>
The following shortcuts are supported:
• All identifiers up to the last identifier of a line will become declaration
variable identifiers
• The type of declaration is determined by the last identifier of the line.
In this context, the following will apply:
• If no type has been established through these rules, then the type is
BOOL and the last identifier will not be used as a type (Example 1.).
• Every constant, depending on the type of declaration, will turn into an
initialization or a string (Examples 2. and 3.).
• An address (as in %MD12) is extended around the AT...
attribute(Example 4.).
• A text after a semicolon (;) becomes a comment (Example 4.).
• All other characters in the line are ignored (e.g., the exclamation point
in Example 5.).
Examples:
Shortcut Declaration
A A: BOOL;
ABI2 A, B: INT := 2;
ST S 2; A string ST:STRING(2); (* A string *)
X %MD12 R 5 Real Number X AT %MD12: REAL := 5.0;(* Real
Number *)
B! B: BOOL;
Autodeclaration
If the Autodeclaration of the Options dialog box , then a dialog box will
appear in all editors after the input of a variable that has not yet been
declared. With the help of this dialog box, the variable can now be declared.
With the help of the Class combobox, select whether you are dealing with a
local variable (VAR), input variable( (VAR_INPUT), output variable
(VAR_OUTPUT), input/output variable (VAR_INOUT), or a global
variable (VAR_GLOBAL).
With the CONSTANT and RETAIN options, you can define whether you
are dealing with a constant or a retain variable
The variable name you entered in the editor has been entered in the Name
field, BOOL has been placed in the Type field. The ... button opens the
Input Assistent dialog which allows you to select from all possible types.
In the Initial Value field you can assign a value to the variable; otherwise
the standard initial value will be used.
In the Address field you can link a variable to the address (AT declaration)
If necessary, insert a Comment.
By pressing OK you will enter the variable in the corresponding declaration
editor.
Note: The dialog box for variable declaration you also get by the
command "Edit" "Declare Variable" (see Chapter 4.5 General Editing
Functions).
Declarations as tables
If the Declarations as tables option is set in the Options dialog box in the
Editor category, the declaration editor looks like a table. As in a card-index
box, you can select the register cards of the respective variable types and
edit the variables.
For each variable you are given the following entry fields.
Both of the display types of the declaration editor can be changed without
causing any problems. In the online mode, there are no differences for the
display.
"Insert" "New
Declaration"
With this command you bring a new variable into the declaration table of
the declaration editor. If the present cursor position is located in an field of
the table, then the new variable will be pasted in the preceding line;
otherwise, the new variable is pasted at the end of the table. Moreover, you
can paste a new declaration at the end of the table by using the right arrow
key or the tab key in the last field of the table.
You will receive a variable that has "Name" located in the Name field, and
"Bool" located in the Type field, as its default setting. You should change
these values to the desired values. Name and type are all that is necessary for
a complete declaration of variables.
Declaration Editors in
Online Mode
In online mode , the declaration editor changes into a monitor window. In
each line there is a variable followed by the equal sign (=) and the value of
the variable. If the variable at this point is undefined, three question marks
(???) will appear.
In front of every multi-element variable there is a plus sign. By pressing
<Enter> or after doubleclicking on such a variable, the variable is opened
up. In the example, the traffic signal structure would be opened up.
When a variable is open, all of its components are listed after it. A minus
sign appears in front of the variable. If you doubleclick again or press
<Enter>, the variable will be closed, and the plus sign will reappear.
Pressing <Enter> or doubleclicking on a single-element variable will open
the dialog box to write a variable. Here it is possible to change the present
value of the variable. In the case of Boolean variables, no dialog box
appears; these variables are toggled.
The new value will turn red and will remain unchanged. If the "Online"
"Write values" command is given, then all variables are placed in the
selected list and are once again displayed in black.
If the "Online" "Force values" command is given, then all variables will
be set to the selected values, until the "Release force" command is given.
Comment
User comments must be enclosed in the special character string "*" and "*".
Comments are allowed in all text editors at any preferred location. These
include all declarations, the IL and ST languages, and user-defined data
types.
In FBD and LD comments can be entered into every network. In order to do
so, select the network that you wish to comment, and enable "Insert"
"Comment".
In SFC you can enter comments for the step in the dialog box for editing
step attributes.
Interlocking comments are not allowed.
In Online mode, if you place the mouse pointer briefly above a variable,
then the type and, if necessary, address and comments about the variable
will be displayed in a Tooltip.
The text editors (the Instruction List editor and the editor for ) of PROSYD
1131 offer the usual capabilities of Windows text editors.
Image 5.4: Text Editors for the Instruction List and Structured Text
The most important commands are found in the context menu (right mouse
button or <Ctrl>+<F10>).
The text editors use the following menu commands in special ways:
"Insert" "Operator"
With this command all of the operators available in the current language are
displayed in a dialog box.
If one of the operators is selected and the list is closed with OK, then the
highlighted operator will be inserted at the present cursor position.
"Insert" "Operand"
With this command all variables in a dialog box are displayed. You can
select whether you would like to display a list of the global, the local, or the
system variables.
If one of the operands is chosen, and the dialog box is closed with OK, then
the highlighted operand will be inserted at the present cursor position.
"Insert" "Function"
With this command all functions will be displayed in a dialog box. You can
choose whether to have a list displaying user-defined or standard functions.
If one of the functions is selected and the dialog box is closed with OK, then
the highlighted function will be inserted at the current cursor position.
If the With arguments option was selected in the dialog box, then the
necessary input and output variables will also be inserted.
"Insert" "Function
Block"
With this command all function blocks are displayed in a dialog box. You
can choose whether to have a list displaying user-defined or standard
function blocks.
If one of the function blocks is selected and the dialog box is closed with
OK, then the highlighted function block will be inserted at the current
cursor position.
If the With arguments option was selected in the dialog box, then the
necessary input variables of the function block will also be inserted.
"Extras" "Monitoring
Options"
With this command you can configure your monitoring window. In the text
editors, the window is divided into two halves during monitoring. The
program is located in the left half. In the right half, all variables that are
located in the corresponding program line are monitored.
You can specify the Monitor Window Width and which Distance two
variables should have in a line. An distance declaration of 1 corresponds, in
this case, to a line height in the selected font.
Image 5.6: IL Editor with Possible Breakpoint Positions (darker number fields)
Deleting Breakpoints
Correspondingly, in order to delete a breakpoint, click on the line number
field of the line with the breakpoint to be deleted.
Setting and deleting of breakpoints can also be selected via the menu
("Online" "Toggle Breakpoint"), via the function key <F9>, or via the
symbol in the tool bar.
What happens at a
breakpoint?
If a breakpoint is reached in the PLC, then the screen will display the break
with the corresponding line. The line number field of the line where the PLC
is positioned will appear in red. The user program is stopped in the PLC.
If the program is at a breakpoint, then the processing can be resumed with
"Online" "Run".
In addition, with "Online" "Step over" or "Step in" you can cause the
program to run to the next breakpoint position. If the instruction where you
are located is a CAL command, or, if there is a function call in the lines up
to the next breakpoint position, then you can use "Step over" to bypass the
function call. With "Step in", you will branch to the open POU.
All editors for POUs consist of a declaration part and a body. These are
separated by a screen divider.
The Instruction List editor is a text editor with the usual capabilities of
Windows text editors. The most important commands are found in the
context menu (right mouse button or <Ctrl>+<F10>).
For information about the IL editor in Online mode, see Text Editors in
Online Mode.
For information about the language, see the Instruction Lists.
Flow Control
With the "Online" "Flow control" command, an additional field in which
the accumulator contents is displayed is inserted in the IL editor on the left
side of every line.
All editors for POUs consist of a declaration part and a body. These are
separated by a screen divider.
The editor for Structured Text is a text editor with the usual capabilities of
Windows text editors. The most important commands are found in the
context menu (right mouse button or <Ctrl>+<F10>).
For information about the ST editor in Online mode, read Text Editors in
Online Mode.
For information about the language, read the chapter Structured Text(ST).
The editors of both of the graphically oriented languages, LD and FBD, have
many points in common. These points are summarized in the following
chapters. The editor of the Sequential Function Chart digresses from this
point and is, consequently, not described until Chapter The Sequential
Function Chart Editor.
The implementation in the graphic editors is supported by syntax coloring.
Label
Each network has a label that can optionally be left empty. This label is
edited by clicking the first line of the network, directly next to the network
number. Now you can enter a label, followed by a colon.
Network Comments
Every network can be supplied with a multi-lined comment. In "Extras"
"Options", you can enter the maximum number of lines to be made
available for a network comment. This entry is made in the maximum
comment size field. (The default value here is 4.) You can also enter the
number of lines that generally should be reserved for comments (minimum
comment size). If, for example, the number 2 is entered, then, at the start of
each network there will be two empty lines after the label line. The default
value here is 0, which has the advantage of allowing more networks to fit in
the screen area.
If the minimal comment size is greater than 0, then in order to enter a
comment you simply click in the comment line and then enter the comment.
Otherwise you must next select the network to which a comment is to be
entered, and use "Insert" "Comment" to insert a comment line. In contrast
to the program text, comments are displayed in gray.
"Insert" "Network
(after)" or "Insert"
"Network (before)"
Shortcut: <Shift>+<T> (Network after)
In order to insert a new network in the FBD or the LD editor, select the
"Insert" "Network (after)" or the “Insert" "Network (before)"
command, depending on whether you want to insert the new network before
or after the present network. The present network can be changed by
clicking the network number. You will recognize it in the dotted rectangle
under the number. With the <Shift key> and a mouse click you can select
from the entire area of networks, from the present one to the one clicked.
This is how a POU written in the FBD under the corresponding PROSYD
1131 editor looks:
The Function Block Diagram editor is a graphic editor. It works with a list
of networks, in which every network contains a structure that displays,
respectively, a logical or an arithmetical expression, the calling up of a
function block, a jump, or a return instruction.
The most important commands are found in the context menu (right mouse
button or <Ctrl>+<F10>).
Cursor positions in
FBD
Every text is a possible cursor position. The selected text is on a blue
background and can now be changed.
You can also recognize the present cursor position by a dotted rectangle.
The following is a list of all possible cursor positions with an example:
1) Every text field (possible cursor positions framed in black):
2) Every input:
6) Behind the outermost object on the right of every network ("last cursor
position," the same cursor position that was used to select a network):
"Insert" "Assignment"
"Insert" "Jump"
"Insert" "Return"
"Insert" "Operator"
If an output is selected (Cursor Position 4), then the operator is inserted after
this output. The first input of the operator is connected with the selected
output. The output of the new operator is linked to the branch with which
the selected output was linked.
If an operator, a function, or a function block is selected (Cursor Position 3),
then the old element will be replaced by the new operator. As far as
possible, the branches will be connected the same way as they were before
the replacement. If the old element had more inputs than the new one, then
the unattachable branches will be deleted. The same holds true for the
outputs.
If a jump or a return is selected, then the operator will be inserted before this
jump or return. The first input of the operator is connected with the branch
to the left of the selected element. The output of the operator is linked to the
branch to the right of the selected element.
If the last cursor position of a network is selected (Cursor Position 6), then
the operator will be inserted following the last element. The first input of the
operator is linked to the branch to the left of the selected position.
The inserted operator is always an AND. By selecting and overwriting the
text, you can convert this operator into any other operator. With the Input
Assistant, you can choose the desired operator from the list of the supported
operators. If the new operator has a different lowest number of inputs, then
these will be attached. If the new operator has a lesser highest number of
inputs, then the last inputs, including those on the branches situated in front
of them will be deleted.
All operator inputs that could not be linked will receive the text "???". This
text must be clicked and changed into the desired constant or variable.
"Insert" "Function" or
"Insert" "Function
Block"
"Insert" "Input"
"Insert" "Output"
Symbol:
This command inserts an additional assignment into an existing assignment.
This capability serves the placement of so-called assignment combs; i.e., the
assignment of the value presently located at the line to several variables.
If you select the lined cross above an assignment (Cursor Position 5) or the
output directly in front of it (Cursor Position 4), then there will be another
assignment inserted after the ones already there.
If the line cross directly in front of an assignment is selected (Cursor
Position 4), then another assignment will be inserted in front of this one.
The inserted output is allocated with the text "???". This text must be
clicked and changed into the desired variable. For this you can also use the
Input Assistant.
"Extras" "Negation"
"Extras" "Set/Reset"
Symbol:
With this command you can define outputs as Set or Reset Outputs. A grid
with Set Output is displayed with [S], and a grid with Reset Output is
displayed with [R].
An Output Set is set to TRUE, if the grid belonging to it returns TRUE. The
output now maintains this value, even if the grid jumps back to FALSE.
An Output Reset is set to FALSE, if the grid belonging to it returns FALSE.
The output maintains its value, even if the grid jumps back to FALSE.
With multiple executions of the command, the output will alternate between
set, reset, and normal output.
"Extras" "Zoom"
Shortcut: <Alt>+<Enter>
With this command a selected POU is loaded into its editor (Cursor Position
3).
If you are dealing with a POU from a library, then the library manager is
called up, and the corresponding POU is displayed.
Cutting, Copying,
Pasting, and Deleting
in FBD
The commands used to "Cut", "Copy", "Paste", and "Delete" are found
under the "Edit" menu item.
If a line cross is selected (Cursor Position 5), then the assignments, jumps,
or RETURNS located below the crossed line will be cut, deleted, or copied.
If an operator, a function, or a function block is selected (Cursor Position 3),
then the selected object itself, will be cut, deleted, or copied, along with all
of the branches dependent on the inputs, with the exception of the first
branch.
Otherwise, the entire branch located in front of the cursor position will be
cut, deleted, or copied.
After copying or cutting, the deleted or copied part is located on the
clipboard and can now be pasted, as desired.
In order to do so, you must first select the pasting point. Valid pasting points
include inputs and outputs.
If an operator, a function, or a function block has been loaded onto the
clipboard (As a reminder: in this case all connected branches except the first
are located together on the clipboard), the first input is connected with the
branch before the pasting point.
Otherwise, the entire branch located in front of the pasting point will be
replaced by the contents of the clipboard.
In each case, the last element pasted is connected to the branch located in
front of the pasting point.
The flow control is run with the "Online" "Flow control" command.
Using the flow control, you can view the present values that are being
carried in the networks over the connecting lines. If the connecting lines do
not carry Boolean values, then the value will be displayed in a specially
inserted field. If the lines carry Boolean values, then they will be shaded
blue in the event that they carry TRUE. By this means, you can accompany
the flow of information while the PLC is running.
If you place the mouse pointer briefly above a variable, then the type, the
address and the comment about the variable will be displayed in a Tooltip.
This is how a POU written in the LD appears in the PROSYD 1131 editor:
All editors for POUs consist of a declaration part and a body. These are
separated by a screen divider.
The LD editor is a graphic editor. The most important commands are found
in the context menu (right mouse button or <Ctrl>+<F10>).
For information about the elements, see Ladder Diagram (LD).
3. Every Coil
The Ladder Diagram uses the following menu commands in a special way:
"Insert" "Contact"
The contact is preset with the text "???". You can click on this text and
change it to the desired variable or the desired constant. For this you can
also use the Input Assistant.
"Insert" "Parallel
Contact"
"Insert" "Function
Block"
Shortcut: <Ctrl>+<B>
You can use this command to open a dialog box for selecting a function
block or a program. You can select between user-defined or standard
(default) POUs.
The selected POU is inserted, according to the same rules used to insert a
contact. In both cases, the first input of the POU is set on the input
connection, and the first output is set on the output connection. For this
reason both of these variables definitely must be of the BOOL type. All
other POU inputs and outputs are occupied with the text "???". These
default settings can be changed to other constants, variables, or addresses.
For this you can also use the Input Assistant.
"Insert" "Coil"
The coil is given the text "???" as a default setting. You can click on this
text and change it to the desired variable. For this you can also use the Input
Assistant.
"Insert" "Operator
with EN"
Use this command to insert an operator with EN input into a LD network.
The marked position must be the connection between the contacts and the
coils (Cursor Position 4) or a coil (Cursor Position 3). The new operator is
inserted in parallel to the coils and underneath them; it contains initially the
designation AND. If you wish, you can change this designation to another
one. For this you can also use the Input Assistant.
"Insert" "Function
Block with EN"
With this command you can insert a function block with EN input into a LD
network.
The marked position must be the connection between the contacts and the
coils (Cursor Position 4) or a coil (Cursor Position 3). The new function
block is inserted in parallel to the coils, below them. From the Input
Assistant dialog box that appears, you can select whether to insert a user-
defined, or a standard (default) function block.
"Insert" "Function
with EN"
With this command you can insert a function with EN input into an LD
network.
The marked position must be the connection between the contacts and the
coils (Cursor Position 4) or a coil (Cursor Position 3). The new function is
inserted in parallel to the coils, below them. From the Input Assistant dialog
box that appears, you can select whether to insert a user-defined, or a
standard function block.
"Insert" "Insert at
Blocks"
With this command you can insert additional elements into a POU that has
already been inserted (also a POU with EN input). The commands below
this menu item can be executed at the same cursor positions as the
corresponding commands in the Function Block Diagram (See Chapter 5.7).
With Input you can add a new input to the POU.
With Output you can add a new output to the POU.
With Operator you can add a new operator to the POU, whose output is
deposited onto the selected input.
With Assignment you can add an assignment to the selected input or output.
With Function you can add a function to the selected input.
With Function Block you can add a function block to the selected input.
"Insert" "Jump"
With this command you can insert a parallel jump in the selected LD editor,
in parallel, at the end of the previous coils. If the incoming line delivers the
value "On", then the jump will be executed to the indicated label.
The marked position must be the connection between the contacts and the
coils(Cursor Position 4) or a coil (Cursor Position 3).
The jump is present with the text "???". You can click on this text and make
a change in the desired label.
"Insert" "Return"
In the LD editor, you can use this command to insert a Return instruction in
parallel at the end of the previous coils. If the incoming line delivers the
value "On," then the processing of the POU in this network is broken off.
The marked position must be the connection between the contacts and the
coils(Cursor Position 4) or a coil (Cursor Position 3).
"Extras" "Negate"
If a jump or a return is marked, then the input of this jump or return will be
negated.
A negation can be canceled through renewed negation.
"Extras" "Set/Reset"
If you execute this command on a coil, then you will receive a Set Coil.
Such a coil never overwrites the value TRUE in the respective Boolean
variable. This means that once you have set the value of this variable to
TRUE, it will always remain at TRUE. A Set Coil is designated with an "S"
in the coil symbol.
If you execute this command once again, then you will be given a Reset
Coil. Such a coil never overwrites the value FALSE in the respective
Boolean variable. This means that once you have set the value of this
variable to FALSE, it will always remain at FALSE. A Reset Coil is
designated with an "R" in the coil symbol.
If you execute this command repeatedly, the coil will alternate between set,
reset and normal coil.
This is how a POU written in the SFC appears in the PROSYD 1131 editor:
All editors for POUs consist of a declaration part and a body. These are
separated by a screen divider.
The Sequential Function Chart editor is a graphic editor. The most important
commands are found in the context menu (right mouse button or
<Ctrl>+<F10>).
For information about the Sequential Function Chart, see Sequential
Function Chart.
The editor for the Sequential Function Chart must agree with the particulars
of the SFC. In reference to these, the following menu items will be of
service.
"Insert" "Step
Transition (before)"
"Insert" "Step
Transition (after)"
"Insert" "Alternative
Branch (right)"
Symbol:
This command inserts an alternative branch in the SFC editor as the left
branch of the marked block. For this the marked block must both begin and
end with a transition. The new branch is then made up of one transition.
"Insert" "Parallel
Branch (right)"
"Insert" "Parallel
Branch (left)"
Symbol:
This command inserts a parallel branch in the SFC editor as the left branch
of the marked block. For this the marked block must both begin and end
with a step. The new branch is then made up of one step.
"Insert" "Jump"
"Insert" "Transition-
Jump"
Symbol:
This command inserts a transition in the SFC editor, followed by a jump at
the end of the selected branch. For this the branch must be a parallel branch.
For a inserted jump then the text field 'Step' can be selected and be replaced
by the label of the step which is target of the jump.
"Extras" "Paste
Parallel Branch
(right)"
This command pastes the contents of the clipboard as a right parallel branch
of the marked block. For this the marked block must both begin and end
with a step. The contents of the clipboard must, likewise, be an SFC block
that both begins and ends with a step.
"Extras" "Zoom
Action/Transition"
Shortcut: <Alt>+<Enter>
The action of the first step of the marked block or the transition body of the
first transition of the market block is loaded into the editor in the respective
language, in which it has been written. If the action or the transition body is
empty, then the language must be selected, in which it has been written.
"Extras" "Clear
Action/Transition"
With this command you can delete the actions of the first step of the marked
block or of the transitions body of the first transition.
If, during a step, you implement either only the action, the entry-action, or
the exit-action, then the same will be deleted by the command. Otherwise a
dialog box appears, and you can select which action or actions are to be
deleted.
If the cursor is located in the action of an IEC step, then only this association
will be deleted. If an IEC step with an associated action is selected, then this
association will be deleted. During an IEC step with several actions, a
selection dialog box will appear.
"Extras" "Step
Attributes"
With this command you can open a dialog box in which you can edit the
attributes for the marked step.
You can take advantage of three different entries in the step attribute dialog
box. Under Minimum Time, you enter the minimum length of time that the
processing of this step should take. Under the Maximum Time, you enter
the maximum length of time that the processing of this step should take.
Note that the entries are of the TIME type, so you use a TIME constant (i.e.
T#3s) or a variable of the TIME type.Under Comment you can insert a
comment to the step. With "Extras" "Options" you can then adjust
whether, in the SFC editor, the comments or the time setting for the steps
should be displayed. On the right, next to the step, either the comment or the
time setting will appear.
If the maximum time is exceeded, SFC flags are set for the user to make
inquiries.
The example shows a step whose execution should last at least two, and at
the most, ten seconds. In Online mode, there is, in addition to these two
times, a display of how long the step has already been active.
"Extras""Time
Overview"
With this command you can open a window in which you can edit the time
settings of your SFC steps:
In the time boundaries overview, all steps of your SFC POU are displayed. If
you have entered a time boundary for a step, then the time boundary is
displayed to the right of the step (first, the lower limit, then the upper limit).
You can also edit the time boundaries. To do so, click on the desired step in
the overview. The name of the step is then shown below in the window. Go
to the Minimum Time or Maximum Time field, and enter the desired time
boundary there. If you close the window with OK, then all of the changes
will be stored.
In the example, steps 2 and 6 have a time boundary. Shift1 lasts at least two,
and at most, ten seconds. Shift2 lasts at least seven, and at most, eight
seconds.
"Extras" "SFC-
Overview"
With this command you are given a reduced display of the active SFC POU.
A check appears before the menu item. For better orientation you can
display the names of the steps, transitions, and jumps in tooltips by placing
the mouse pointer on an element.
In order to switch back to the normal SFC display, set a marking and then
either press <Enter> or select the command once again, and the change will
take place.
"Extras" "Options"
With this command you open a dialog box in which you can set different
options for your SFC POU.
In the SFC Options dialog box you can undertake five entries. Under Step
Height, you can enter how many lines high an SFC step can be in your SFC
editor. 4 is the standard setting here. Under Step Width, you can enter how
many columns wide a step should be. 6 is the standard setting here. You can
also preset the Display at Step. With this, you have three possibilities: You
can either have Nothing displayed, or the Comment, or the Time Limits.
The last two are shown the way you entered them in "Extras" "Step
Attributes".
"Extras" "Associate
Action"
With this command actions and Boolean variables can be associated with
IEC steps.
To the right of, and next to the IEC step, an additional divided box is
attached, for the association of an action. It is preset in the left field with the
qualifier "N" and the name "Action." Both presets can be changed. For this
you can use the Input Assistant.
New actions for IEC steps are created in the Object Organizer for an SFC
POU with the "Project" "Add Action" command.
Symbol:
If this command is activated (denoted by a check in front of the menu item
and a printed symbol in the Tool bar), then IEC steps will be inserted instead
of the simplified steps upon insertion of step transitions and parallel
branches.
If this option is switched on, the Init step is set as an IEC step when you
create a new SFC POU.
This settings are saved in the file "PROSYD 1131.ini" and are restored
when PROSYD 1131 gets started again.
The Sequential
Function Chart in the
Online Mode
With the Sequential Function Chart editor in Online mode, the currently-
active steps will be displayed as blue steps. If you have set it under
"Extras" "Options", then the time management is depicted next to the
steps. Under the lower and upper bounds that you have set, a third time
indicator will appear from which you can read how long the step has already
been active.
In the picture above the step depicted has already been active 8 seconds and
410 milliseconds. The step must, however, be active for at least 7 minutes
before the step will be left.
With "Online" "Toggle Breakpoint", a breakpoint is set at a step. The
processing then stops in front of the execution of this step. The step with the
breakpoint is colored light blue.
If several steps are active in a parallel branch, then the active step whose
action will be processed next is displayed in red.
If IEC steps have been used, then all active actions in Online mode will be
displayed in blue.
SFC also includes support for stepping a step at a time ("Online" "Step
Over"). With this stepping, the program will always proceed to the next step
whose action is to be executed.
With "Online" "Step in" you can step into actions or transitions. Within the
transitions or actions, all debugging capabilities of the corresponding editor
are at the user's disposal.
If you place the mouse pointer briefly above a variable, then the type and the
comment about the variable will be displayed in a Tooltip.
Image 5.17: Sequential Function Chart in the Online Mode with an Active Step (Shift1) and a
Breakpoint (Step10)
It looks like a block which has been produced using the continuous function
chart editor (CFC):
No snap grid is used for the continuous function chart editor so the elements
can be placed anywhere. Elements of the sequential processing list include
blocks, input, output, jump, label, return and comments. The inputs and
outputs of these elements can be connected by dragging a connection with
the mouse. The connecting line will be drawn automatically. The shortest
possible connection line is drawn taking into account existing connections.
The connecting lines are automatically adjusted when the elements are
moved. If the case arises where a connecting line cannot be drawn simply
because of lack of space, a red line will be shown between the input and the
associated output instead. This line will be converted into a connecting line
just as soon as space is available.
One advantage of the continuous function chart as opposed to the usual
function block diagram editor is the fact that feedback paths can be inserted
directly.
The most important commands can be found in the context menu
In all other cases the current cursor position is shown by a rectangle made up
of points. The following is a list of all possible cursor positions with
examples:
1. Trunks of the elements blocks, input, output, jump, label, return and
comments.
2. Text fields for the elements blocks, input, output, jump, label, return and
comments as well as text fields for connection
markers:
"Insert" "Block"
Symbol: Shortcut: <Ctrl>+<B>
This command can be used to paste in operators, functions, function blocks
and programs. It is always pasted in as an ”AND” operator. This can be
converted by Selection and Overwrite of the text into every other operator,
into every function, into every function block and every program. The input
assistance serves to select the desired block from the list of supported
blocks. If the new block has another minimum number of inputs, these will
be attached. If the new block has a smaller highest number of inputs, the last
inputs will be deleted.
"Insert" "Input"
Symbol: Shortcut: <Ctrl> + <E>
This command is used to insert an input. The text offered ”???” can be
selected and replaced by a variable or constant. The input assistance can also
be used here.
"Insert" "Output"
Symbol: Shortcut: <Ctrl>+<A>
This command is used to insert an output. The text offered ”???” can be
selected and replaced by a variable. The input assistance can also be used
here. The value which is associated with the input of the output is allocated
to this variable.
"Insert" "Jump"
Symbol: Shortcut: <Ctrl>+<J>
This command is used to insert a jump. The text offered ”???” can be
selected and replaced by the jump label to which the program should jump.
"Insert" "Label"
Symbol: Shortcut: <Ctrl>+<L>
This command is used to insert a label. The text offered ”???” can be
selected and replaced by the jump label.
"Insert" "Return"
Symbol: Shortcut: <Ctrl> + <R>
This command is used to insert a RETURN command.
"Insert" "Comment"
Symbol: Shortcut: <Ctrl> + <K>
This command is used to insert a comment.
You obtain a new line within the comment with <Ctrl> + <Enter>.
"Extras" "Negate"
Symbol: Shortcut: <Ctrl> + <N>
This command is used to negate inputs, outputs, jumps or RETURN
commands. The symbol for the negation is a small cross on the connection.
The input of the element block, output, jump or return is negated when it is
selected (Cursor position 3)
The output of the element block or input is negated when it is selected
(Cursor position 4).
A negation can be deleted by negating again.
"Extras" "Set/Reset"
Symbol: Shortcut: <Ctrl> + <T>
This command can only be used for selected inputs of the element output
(Cursor position 3).
The symbol for Set is S and for Reset is R.
"Extras" "EN/ENO"
Symbol: Shortcut: <Ctrl> + <0>
This command is used to give a selected block (Cursor position 3) an
additional Boolean enable input EN (Enable In) and a Boolean output ENO
(Enable Out).
"Extras"
"Properties..."
Constant input parameters (VAR_INPUT CONSTANT) from functions and
function blocks are not shown directly in the continuous function chart
editor. These can be shown and their value can be changed when one selects
the trunk of the block in question (Cursor position 1) and then selects the
command ‚Extras‘ ‚Properties‘ or simply double clicks on the trunk. The
following dialog opens:
Selecting elements
One clicks on the trunk of the element (Cursor position 1) to select it.
To mark more elements one presses the <Shift> key and clicks in the
elements required, one after the other, or one drags the mouse with the left
hand mousekey depressed over the elements to be marked.
The command ‘Extras’ ‘Select all’ marks all elements at once.
Moving elements
One or more selected elements can be moved with the arrow keys as one is
pressing on the <Shift> key. Another possibility is to move elements using a
depressed left mousekey. These elements are placed by releasing the left
Copying elements
One or more selected elements can be copied with the command ‘Edit’
‘Copy’ and inserted with the command ‘Edit’ ‘Paste’.
Creating connections
An input of an element can be precisely connected to the output of another
element. An output of an element can be connected to the inputs of a
number of other elements.
There are a number of possibilities to connect the input of an element E2
with the output of an element E1.
Place the mouse on the output of element E1 (Cursor position 4), click with
the left mousekey, hold the left mousekey down and drag the mouse cursor
onto the input of element E2 (Cursor position 3) and let the left mousekey
go. A connection is made from the output of element E1 to the mouse cursor
during this dragging operation with the mouse.
Place the mouse on the input of element E2, click with the left mousekey,
hold the left mousekey down and drag the mouse cursor onto the output of
element E1 and let the left mousekey go.
Move one of the elements E1 or E2 (Cursor position 1) and place it in such a
way by letting go of the left mousekey that the output of element E2 and the
input of element E1 touch.
Where element E2 is a block with a free input, a connection can also be
made by dragging the mouse from an output from E1 to the trunk of E2. A
connection with the free input at the highest position on E2 will be created
when the mousekey is released. In the case where block E2 does not have a
free input but is an operator which can have an input added to it, a new input
will be automatically generated.
The output and input of a block can be connected together (feedback path)
by using this method.
Deleting connections
There are a number of possibilities for removing the connection between the
output of an element E1 and the input of an element E2:
Select the output of element E1 (Cursor position 4) and press the <Delete>
key or execute the command ‘Edit’ ‘Delete'. Several connections will be
removed at the same if the output of E1 is connected to more than one of
inputs.
Select the input of element E2 (Cursor position 4) and press the <Delete>
key or execute the command ‘Edit’ ‘Delete‘.
Select the input of E2 with the mouse, hold the left mousekey depressed and
drag the connection from the input to E2 away. The connection is removed
when the left mousekey is released in a free area of the screen.
Changing connections
A connection between the output of an element E1 and the input of an
element E2 can easily be changed into a connection between the output of
element E1 and the input of element E3. The mouse is clicked on the input
of E2 (Cursor position 3), the left mousekey is kept depressed, the mouse
cursor is moved to the input of E3 and then released.
"Extras" "Connection
marker"
Connections can also be represented by a connector (connection marker)
instead of a connecting line. Here the output and the associated input have a
connector added to them which is given a unique name.
Where a connection already exists between the two elements which should
now be represented by connectors, the output of the connecting line is
marked (Cursor position 3) and the menu point ‚Extras‘ ‚Connection
marker‘ is selected. The following diagram shows a connection before and
after the selection of this menu point.
Order of execution
The elements block, output, jump, return and label each possess a number
indicating the order in which they are executed. In this sequential order the
individual elements are evaluated at run time.
When pasting in an element the number is automatically given according to
the topological sequence (from left to right and from above to below). The
new element receives the number of its topological successor if the sequence
has already been changed and all higher numbers are increased by one.
The number of an element remains constant when it is moved.
The sequence influences the result and must be changed in certain cases.
If the sequence is displayed, the corresponding sequential execution number
is shown in the upper right hand corner of the element.
"Extras" "Order"
"Display"‘
This command switches the display of the order of execution on and off.
The default setting is to show it (recognised by a tick (!) in front of the
menu point).
"Extras" "Order"
"Order topologically"‘
Elements are ordered in a topological sequence when the execution takes
place from left to right and from above to below, that is the number
increases from left to right and from above to below for topologically
arranged elements. The connections are not relevant, only the location of the
elements is important.
All selected elements are topologically arranged when the command
‘Extras‘ ‘Order‘ ’Order topologically‘ is executed. All elements in the
selection are taken out of the sequential processing list by this process. The
elements are then entered into the remaining sequential processing list
individually from bottom right through to upper left. Each marked element
is entered into the sequential processing list before its topological successor,
i.e. it is inserted before the element that in a topological sequencing would
be executed after it, when all elements in the editor were sequenced
according to a topological sequencing system. This will be clarified by an
example.
Image 5.20: Sequence before the topological ordering of the three elements
The elements with numbers 1, 2 and 3 are selected. If the command ’Order
topologically‘ is selected the elements are first taken out of the sequential
processing list. Var3, the jump and the AND-operator are then inserted
again one after the other. Var3 is placed before the label and receives the
number 2. The jump is then ordered and receives the number 4 at first but
this then becomes 5 after the AND is inserted. The new order of execution
which arises is:
Image 5.21: Sequence after the topological ordering of the three elements
"Extras" "Order"
"Order everything
according to data
flow"‘
This command effects all elements. The order of execution is determined by
the data flow of the elements and not by their position.
The diagram below shows elements which have been ordered
topographically.
When this command is selected the first thing to happen is that the elements
are ordered topographically. A new sequential processing list is then created.
Based on the known values of the inputs, the computer calculates which of
the as yet not numbered elements can be processed next. In the above
”network” the block AND, for example, could be processed immediately
since the values at its inputs (1 and 2) are known. Block SUB can only then
be processed since the result from ADD must be known first, etc.
Feedback paths are inserted last.
The advantage of the data flow sequencing is that an output box which is
connected to the output of a block comes immediately after it in the data
flow sequencing system which by topological ordering would not always be
the case. The topological ordering can deliver another result in some cases
than ordering by data flow, a point which one can recognise from the above
example.
Feedback paths
Feedback paths can only be displayed directly in the continuous function
chart editor and not in the usual function block diagram editor. Here it
should be observed that the output of a block always carries an internal
intermediate variable. The data type of the intermediate variable results, for
operators, from the largest data type of the inputs.
The data type of a constant is obtained from the smallest possible data type,
that is the constant ‘1’ adopts the data type SINT. If now an addition with
feedback and the constant ‘1’ is executed, the first input gives the data type
SINT and the second is undefined because of the feedback. Thus the
intermediate variable is also of the type SINT. The value of the intermediate
variable is only then allocated to the output variable.
The diagram below shows an addition with feedback and an addition with a
variable. The variables x and y should be of the type INT here.
6 The Resources
6.1 Overview of the Resources
In the Resources register card of the Object Organizer, there are objects for
configuring and organizing your project and for keeping track of the values
of the variables:
• Global Variables that can be utilized in the entire project; the global
variables of the project as well as the libraries.
• PLC Configuration for configuring your hardware
• Task Configuration for controlling your program control via tasks
• Sampling Trace for graphic logging of variable values
• Watch and Receipt Manager for indicating and presetting variable
values
Editing Global
Variables
In the Object Organizer, you will find three objects in the Resources register
card in the Global Variables folder (default names of the objects in
parentheses).
• Access Variables List (Access Variables)
• Global Variables List (Global Variables)
• Variables Configuration (Variable Configuration)
All variables defined in these objects are recognized throughout the project.
If the global variables folder is not opened up (plus sign in front of the
folder), you can open it with a doubleclick <Enter> in the line.
Select the corresponding object. The "Object Open" command opens a
window with the previously defined global variables. The editor for this
works the same way as the declaration editor.
Examples:
sensor3 : "control2.sens3": BOOL READ_ONLY;
counter2 : "control2.count2": UINT;
displaytext : "control2.text": STRING READ_WRITE;
Normal global variables are defined in an object between the key words
VAR_GLOBAL and END_VAR. In the Object Organizer in the Resources
register card, the object Global_Variables will generally be available.
The object can be renamed and further objects for global variables can be
created.
To create a new global variables list open the dialog New global variable
list by 'Project' 'Object' 'Add'. Here you insert a Name for the new list. If you
want to use an export file (*.esp) or a DCF file (*.dcf), which contains the
relevant variable, you can connect it by Link to file. Press Select to get the
standard dialog Select text file. DCF files are converted to IEC syntax when
called.
If the settings in dialog 'New global variable list' are confirmed by pressing
the OK button, the new object is created and the variables' editor opens. The
editor for global variables works just the same as the Declaration Editor.
Though if an external variable list is used, it cannot be edited in PROSYD
1131. External variable lists only can be edited external and they will be
read each time the project is opened or compiled again.
Global variables can be used in the entire project.
Syntax:
VAR_GLOBAL
(*Declaration of Variables *)
END_VAR
Global retain variables additionally receive the key word RETAIN.
Syntax:
VAR_GLOBAL RETAIN
(*Declaration of Variables *)
END_VAR
Global constants additionally receive the key word CONSTANT.
Syntax:
VAR_GLOBAL CONSTANT
(*Declaration of Variables *)
END_VAR
Example:
Assume that the following definition for a function block is given in a
program:
PROGRAM PLC_PRG
VAR
Hugo: locio;
Otto: locio;
END_VAR
Then a corrected variable configuration would look this way:
VAR_CONFIG
PLC_PRG. Hugo.loci AT %IX1.0 : BOOL;
PLC_PRG. Hugo.loco AT %QX0.0 : BOOL;
PLC_PRG. Otto.loci AT %IX1.0 : BOOL;
PLC_PRG.Otto.loco AT %QX0.3 : BOOL;
END_VAR
Document Frame
If a project is to receive multiple documentations, perhaps with German and
English comments, or if you want to document several similar projects that
use the same variable names, then you can save yourself a lot of work by
creating a docuframe with the "Extras" "Make Docuframe File"
command.
The created file can be loaded into a desired text editor and can be edited.
The file begins with the DOCUFILE line. Then a listing of the project
variables follows in an arrangement that assigns three lines to each variable:
a VAR line that shows when a new variable comes; next, a line with the
name of the variable; and, finally, an empty line. You can now replace this
line by using a comment to the variable. You can simply delete any variables
that you are unable to document. If you want, you can create several
document frames for your project.
In order to use a document frame, give the "Extras" "Link Docu Frame"
command. Now if you document the entire project, or print parts of your
project, then in the program text, there will be an insertion of the comment
produced in the docuframe into all of the variables. This comment only
appears in the printout!
"Extras" "Make
Docuframe File"
Use this command to create a document frame. The command is at your
disposal, whenever you select an object from the global variables.
A dialog box will open for saving files under a new name. In the field for
the name file, the *.txt extension has already been entered. Select a desired
name. Now a text file has been created in which all the variables of your
project are listed.
The dialog box for opening files is opened. Choose the desired document
frame and press OK. Now if you document the entire project, or print parts
of your project, then in the program text there will be an insertion of the
comment produced in the docuframe into all of the variables. This comment
only appears in the printout!
To create a document frame, use the "Extras" "Make Docuframe File"
command.
Image 6.3: PLC Configuration with a CPU Module and a CAN Module. These modules themselves
have submodules.
"Extras" "Properties"
Shortcut: <Enter>
With this command a dialog box will appear. In the PLC Configuration you
can consign further information to an input-output module. (Example: an
input module is a thermostat. The information is regulating parameters or a
comment to a simple digital input.)
You can also receive the dialog box by selecting the desired element and
then doubleclicking.
"Insert" "Insert
Element"
This command is used to insert a selected element into the PLC
Configuration in front of another selected element.
"Insert" "Append
Subelement"
This command is used to append a selected element into the PLC
Configuration as the last subelement to another selected element.
PLC Configuration in
Online Mode
In Online mode, the PLC Configuration indicates the states of the inputs and
outputs of the PLC. If a Boolean input or output has the value "TRUE", then
the box before the input or output will be displayed in blue.
The Boolean inputs can be toggled with a mouse click. With other inputs, a
dialog box appears for inputting the new value. The new value is placed in
the PLC immediately after execution through an OK.
‘Extras’ ‘Properties’
With this command a dialog box will appear where further information to an
input-output module in the PLC configuration can be consigned.
In the register card base addresses you fill in the IEC addresses for Receive
and Send and a unique node number (Node-Id) angegeben werden.
Using the selection option, set the required Baud rate which the
transmission should take place at.
One differentiates between synchronous and asynchronous transmission
modes (see PDO properties) for PDO’s (Process Data Object). The
synchronisation message is sent with a unique number Sync.COB-Id
(Communication Object Identifier) in the interval in microseconds which is
given by the Communication Cycle Period. The synchronous PDO’s are
transmitted directly after the synchronisation message in the time window
(Sync.Window Length in microseconds). No synchronisation message will
be sent if the fields Comm. Cycle Period and Sync. Window Length contain
0.
A marker address must be given at the diagnosis address of the CAN bus.
From this address onwards there is various information concerning the
structure CanOpenBusState of the library CanOpen.lib which can be read
into or written from the project:
Cmd: WORD; (* Access to write: 1 = Start, 0 = Stop *)
State: WORD; (* Access to read: 1 to 4 = Initialisation phase, 5 = Bus
running, 6 = Error *)
Error: WORD; (* Access to read: Special error number *)
Create a variable for access with the following structure:
e.g. diagnosis_bus AT %MB0 : CanOpenBusState;
The IEC addresses for the next inserted CAN modules will be awarded
automatically if the option Automatic addressing is activated, in order to
ensure that they are ordered in a row and that overlapping is avoided.
The CAN bus will automatically initialised and started when downloading is
occurring and when the controller system starts up if the option Automatic
start is activated. The CAN bus must be started up in the project if this
option is not active.
Basis parameters of a
CAN module
The configuration of an individual CAN module can be undertaken directly
after inserting the module or can be called up with the command ’Extras’
‘Properties’.
PDO mapping of a
CAN module
The tabs Receive PDO mapping and Send PDO mapping in the
configuration dialog for a CAN module allow the ”mapping” of the module,
which is described in the EDS file, to be changed.
All of the ”mappable” objects in the EDS file are located on the left side and
can be added in the right side to the PDO’s (Process Data Object) (”>>”
button) or removed again (Remove button). The StandardDataTypes can be
inserted to create empty spaces in the PDO.
The button Insert Element can be used to create further PDO’s and to add
appropriate objects to them. The allocation of inputs or outputs to the IEC
addresses can be achieved over the inserted PDO’s. The setting which have
been made in the controller system configuration will become visible when
one leaves the dialog. The individual objects can be afforded symbolic
names there.
The standard set properties of the PDO’s can be edited using Properties.
The modifiable
parameters of a CAN
module
The tab Editable Parameters in the configuration dialog of a CAN module
contains a list of all objects in the EDS or DCF file which are in the area of
the Index 0x2000 to 0x9FFF and which are marked as writable.
The properties Index, Name, Value, Type and Default are displayed for
every object. The value can be changed. Mark the value and press the
<Space bar>. After making the change confirm the new value with <Enter>
or reject it with the <Escape> key.
The set values are transmitted in the form of SDO's (Service Data Object) to
the CAN modules at the initialisation of the CAN bus.
In addition to declaring the special PLC_PRG program, you can also control
the processing of your project using the task management.
The Task Configuration is found as an object in the Resources register
card in the Object Organizer. The task editor contains a series of tasks. The
task declaration consists of the name of the task, an entry for the priority the
task is to have, and an entry for the condition under which the task is to be
executed. This requirement can either be a time interval, according to which
the task is to be executed, or a global variable that, in the event it has a
rising edge, brings about an execution.
For each task you can now specify a series of programs that will be started
by the task. If the task is executed in the present cycle, then these programs
will be processed the length of one cycle.
The Task Configuration is displayed in the following form:
• The Task Configuration is located in the first line.
• Underneath and indented from the Task Configuration, you will find a
sequence of task entries (with name, priority, interval, and
occurrence).
• Below each task entry, there is again a series of program call ups.
The dialog box will open for you to set the task attributes.
In the dialog box you can enter the desired attributes: the Name; the
Priority
(a number between 0 and 31, with the following validities: 0 has the highest,
and, 31, the lowest priority); the Interval after which the task should be
started again; or a variable that, following a raising edge, will cause an
execution of the task (in the Single field). With the Select... button, you can
open the Input Assistant to select from the declared variables.
If an entry is on hand for both the interval and for the variable, then only the
interval time will be considered for the execution requirement. If an entry
has not been made in either of the two fields, then only the priority with the
counter will be considered. This means that in every cycle the task will be
considered to be executable.It will only cease to be executed if another task
of higher priority is likewise executable.
"Insert" "Insert
Program Call" or
"Insert""Append
Program Call"
With these commands you will open the dialog box for entering a program
call to a task in the Task Configuration.
With Insert Program Call", the new program call is inserted in front of the
cursor, and with "Append Program Call", the program call is appended to
the end of the existing list.
In the field, specify a valid program name for your project, or open the Input
Assistant with the Select button to select a valid program name. If the
selected program requires input variables, then enter these in their usual
form and of the declared type (for example, prg(invar:=17)).
Sample tracing means that the progression of values for variables is traced
over a certain time frame. These values are written in a ring buffer (trace
buffer). If the memory is full, then the "oldest" values from the start of the
"Extras" "Trace
Configuration"
With this command you will be given the dialog box for entering the
variables to be traced, as well as diverse trace parameters for the Sampling
Trace. The dialog can also be opened by a double click in the grey area of
the dialog Sampling Trace.
Note: Please note that Save and Load in the configuration dialog only
relates to the configuration, not to the values of a trace recording (in contrast
to the menu commands "Extras" "Save trace" and "Extras" "Load trace").
If the field Trigger Variable is empty, the trace recording will run endlessly
and can be stopped by "Extras" "Stop Trace".
Symbol:
With this command the trace configuration is transferred to the PLC and the
trace sampling is started in the PLC.
Symbol:
With this command the present trace buffer is read from the PLC, and the
values of the selected variables are displayed.
Symbol:
This command stops the Sampling Trace in the PLC. .
Selection of the
Variables to be
Displayed
The comboboxes to the right, next to the window for displaying curves trace
variables defined in the trace configuration. If a variable is selected from the
list, then after the trace buffer has been read the variable will be displayed in
the corresponding color (Var 0 green, etc.). Variables can also be selected if
curves are already displayed.
A maximum of up to eight variables can be observed simultaneously in the
trace window.
Display of the
Sampling Trace
"Extras" "Cursor
Mode"
The easiest way to set a cursor in the monitoring area is to click there with
the left mouse button. A cursor appears and can be moved by the mouse. At
the top of the monitoring window the current x-position of the cursor is
displayed. In the fields next to 'Var 0', 'Var 1', ..., 'Var n' the value of the
respective variable is shown.
Another way is the command "Extras" "Cursor mode". With this command
two vertical lines will appear in the Sampling Trace. First they are laying
one on the other. One of the lines can be moved to the right or to the left by
the arrow keys. By pressing <Ctrl>+<left> or <Ctrl>+<right> the speed of
the movement can be increased by factor 10.
If additionally the <Shift> key is pressed, the second line can be moved,
showing the difference to the first one.
"Extras" "Multi
Channel"
With this command you can alternate between single-channel and multi-
channel display of the Sampling Trace. In the event of a multi-channel
display, there is a check (!) in front of the menu item.
The multi-channel display has been preset. Here the display window is
divided into as many as eight display curves. For each curve the maximum
and the minimum value are displayed at the edge.
In a single-channel display, all curves are displayed with the same scaling
factor and are superimposed. This can be useful when displaying curve
abnormalities.
"Extras" "Stretch"
Symbol:
With this command you can stretch (zoom) the values of the Sampling Trace
that are shown. The beginning position is set with the horizontal picture
adjustment bar. With repeated stretches that follow one-after-another, the
trace section displayed in the window will increasingly shrink in size.
This command is the counterpart to "Extras" "Compress".
"Extras" "Compress"
Symbol:
With this command the values shown for the Sampling Trace are
compressed; i.e., after this command you can view the progression of the
trace variables within a larger time frame. A multiple execution of the
command is possible.
This command is the counterpart to "Extras" "Stretch".
"Extras" "Trace in
ASCII-file"
With this command you can save a Sampling Trace in an ASCII-file. The
dialog box is opened for saving a file. The file name receives the extension
"*.txt". The values are deposited in the file according to the following
scheme:
PROSYD 1131 Trace
D:\PROSYD 1131\PROJECTS\TRAFFICSIGNAL.PRO
Cycle PLC_PRG.COUNTER PLC_PRG.LIGHT1
021
121
221
.....
If no frequency scan was set in the trace configuration, then the cycle is
located in the first column; that means one value per cycle has been recorded
at any given time. In the other respects, the entry here is for the point in time
in ms at which the values of the variables have been saved since the
Sampling Trace has been run.
In the subsequent columns, the corresponding values of the trace variables
are saved. At any given time the values are separated from one another by a
blank space.
The appertaining variable names are displayed next to one another in the
third line, according to the sequence (PLC_PRG.COUNTER,
PLC_PRG.LIGHT1).
with a mouse click or an arrow key. In the right area of the Watch and
Receipt Manager the variables applicable at any given time are indicated.
In order to work with the Watch and Receipt Manager, open the object for
the Watch and Receipt Manager in the Resources register card in the
Object Organizer.
The variables in the watch list can be preset with constant values. That
means that in Online mode you can use the "Extras" "Write Receipt"
command to write these values into the variables. To do to do must use := to
assign the constant value of the variable:
Example:
PLC_PRG.TIMER:=50
In the example, the PLC_PRG.COUNTER variable is preset with the value
6
"Extras" "Rename
Watch List"
With this command you can change the name of a watch list in the Watch
and Receipt Manager.
In the dialog box that appears, enter the new name of the watch list.
In order to input new variables, you can turn off the display by using the
"Extra" "Active Monitoring" command. After the variables have been
entered, you can use the same command again to activate the display of the
values.
In the Offline Mode you can preset variables with constant values (through
inputting := <value> after the variable). In the Online Mode, these values
can now be written into the variables, using the "Extras" "Write Receipt"
command.
With the "Extras" "Read Receipt" command you can replace the
presetting of the variable with the present value of the variable.
Note: Only those values the watch list are loaded which was selected in
the Watch and Receipt Manager!
"Extra" "Monitoring
Active"
With this command at the Watch and Receipt Manager in the Online mode,
the display is turned on or off. If the display is active, a check (!) will
appear in front of the menu item.
In order to enter new variables or to preset a value (see Offline Mode), the
display must be turned off through the command. After the variables have
been entered, you can use the same command again to activate the display of
the values.
"Extras" "Write
Receipt"
With this command in the Online Mode of the Watch and Receipt Manager,
you can write the preset values (see Offline Mode) into the variables.
"Extras" "Read
Receipt"
With the command, in the Online Mode of the Watch and Receipt Manager,
you can replace the presetting of the variables (see Offline Mode) with the
present value of the variables.
Example:
PLC_PRG.Counter [:= <present value>] = <present value>
Force values
In the Watch and Receipt Manager you can also "Force values" and
"Write values". If you click on the respective variable value, then a dialog
box opens, in which you can enter the new value of the variable. Changed
variables appear in red in the Watch and Receipt Manager.
7 Library Manager
The library manager shows all libraries that are connected with the current
project. The POUs, data types, and global variables of the libraries can be
used the same way as user-defined POUs, data types, and global variables.
The library manager is opened with the "Window" "Library Manager"
command.
library manager; and in the lower right is the graphic display in the form of a
black box with inputs and outputs.
With data types and global variables, the declaration is displayed in the right
area of the library manager.
Standard Library
The library with "standard.lib" is always available. It contains all functions
and function blocks that are required by the IEC1131-3 as standard POUs
for an IEC programming system. The difference between a standard function
and an operator is that the operator is implicitly recognized by the
programming system, while the standard POUs must be tied to the project
(standard.lib).
The code for these POUs exists as a C-library and is a component of
PROSYD 1131.
User-defined Libraries
If a project is to be compiled in its entity and without errors, then it can be
saved in a library with the "Save as" command in the "File" menu. The
project itself will remain unchanged. Subsequently, you can gain access to
the project under the entered name, just as with the standard library.
"Insert" "Additional
Library"
With this command you can attach an additional library to your project.
In the dialog box for opening a file, choose the desired library with the
"*.lib" extension. The library is now listed in the library manager, and you
can use the objects in the library as user-defined objects.
Remove Library
With the "Edit" "Delete" command you can remove a library from a
project and from the library manager.
8 Visualization
8.1 Create Visualization
Visualization
Visualizations allow you to view your project variables. With the help of the
visualization you can draw geometric elements offline. These can then
change their forms or colors, in subjection to certain variable values, in
Online mode. For example, it possible to display the tendency of a variable
to increase in a bar chart. You can also deal with input for the program by
way of the mouse and the keyboard.
Create Visualization
In order to create a visualization, you must select the register card for
Visualization in the Object Organizer.
Using the "Project" "Object Add" command, you can create a new
visualization object. A dialog box opens in which you can enter the name of
the new visualization. If you have entered a valid name, then you can close
the dialog box with OK. A window opens in which you can edit the new
visualization.
Visualization Elements,
Insert
You can insert four different geometric forms, as well as bitmaps and
existing visualizations, into your visualization.
Geometric forms at your disposal include: rectangles, rounded rectangles,
ellipses/circles, and polygons.
Go to the "Insert" menu item and select freely from the following
commands: 'Rectangle', 'Rounded Rectangle', 'Ellipse',
'Polygon',
'Line‘, 'Curve‘, 'Bitmap', 'Visualization' . A check
appears in front of the selected command. You can also use the tool bar. The
selected element appears pushed down (for example ).
If you now go to the editor window with the mouse, you will see that the
mouse pointer is identified with the corresponding symbol (for example
). Click on the desired starting point of your element, and drag the
pointer, while pressing the left mouse button, until the element reaches the
desired size.
If you want to create a polygon or a line, first click with the mouse on the
position of the first corner of the polygon resp. on the starting point of the
line, and then click on the further desired corner points. By doubleclicking
on the last corner point you will close the polygon and it will be completely
drawn respectively the line will be completed
If you want to create a curve (Bezier curves) determine the initial and two
other points with mouse clicks to define the circumscribing rectangle. An
arc is drawn after the third mouse click. You can then change the position of
the end point of the arc by moving the mouse and can then end the process
with a double click or add another arc with additional mouse clicks.
Furthermore pay attention, to the status bar and the change from select and
insert modes.
"Insert" "Rectangle"
Symbol:
With the command you can insert a rectangle as an element into your
present visualization. (Use, see Visualization Elements, Insert)
"Insert" "Rounded
Rectangle"
Symbol:
With the command you can insert a rectangle with rounded corners as an
element in your present visualization. (Use, Visualization Elements, Insert)
"Insert" "Ellipse"
Symbol:
With the command you can insert a circle or an ellipse as an element in your
present visualization. (Use, see Visualization Elements, Insert)
"Insert" "Polygon"
Symbol:
With the command you can insert a polygon as an element in your present
visualization. (Use, see Visualization Elements, Insert).
"Insert" "Line"
Symbol:
With the command you can insert a line as an element into your current
visualization. (Use, see Visualization Elements, Insert).
"Insert" "Curve"
Symbol:
With the command you can insert a Bezier curve as an element into your
current visualization. (Use, see Visualization Elements, Insert)..
"Insert" "Bitmap"
Symbol:
With the command you can insert a bitmap as an element in your present
visualization. (Use, see Visualization Elements, Insert)
While pressing the left mouse button, bring up an area in the desired size.
The dialog box is opened for opening a file. Once you have selected the
desired bitmap, it will be inserted into the area brought up.
"Insert"
"Visualization"
Symbol:
With the command you can insert an existing visualization as an element in
your present visualization. (Use, see Visualization Elements, Insert)
While pressing the left mouse button, bring up an area in the desired size. A
selection list of existing visualizations opens. After you have selected the
desired visualization, it will be inserted in the defined area.
Selecting Visualization
Elements
In order to select an element, click with the mouse on the element. You can
also select the first element of the elements list by pressing the <Tab> key
and jump to the next by each further keystroke. If you press the <Tab> key
while pressing the <Shift> key, you jump backwards in the order of the
elements list.In order to mark multiple elements, press and hold the <Shift>
key and click the corresponding elements, one after another; or, while
holding down the left mouse button, pull a window over the elements to be
selected.
In order to select all the elements, use the "Extras" "Select All" command.
Modifying
Visualization Elements
You can select an element which has already been inserted by a mouse click
on the element or by pressing the <tab> key. A small black square will
appear at each corner of each of the elements, (with ellipses at the corners of
the surrounding rectangle). Except in the case of polygons, lines or curves
further squares appear in the middle of the element edges between the corner
points.
With a selected element, the turning point (balance point) is also displayed
at the same time. You can then rotate the element around this point with a
set motion/angle. The turning point is displayed as a small black circle with
a white cross ( ). You can drag the turning point with a pressed left mouse
button.
You can change the size of the element by clicking on one of the black
squares and, while keeping the left mouse button pressed, controlling the
new outline.
With the selection of a polygon, you can drag each individual corner using
the same technique. While doing this, if you press the <Ctrl>-key then an
additional corner point will be inserted at the corner point, an additional
corner point will be inserted, which can be dragged by moving the mouse.
By pressing the <Shift>+<Ctrl>-key, you can remove a corner point.
Dragging Visualization
Elements
One or more selected elements can be dragged by pressing the left mouse
button or the arrow key.
Copying Visual
Elements
One or more selected elements can be inserted with the "Edit"
"Copy"command, the <Ctrl>+<C> key combination, or the corresponding
copy symbol, and with "Edit" "Paste".
A further possibility is to select the elements and then click the mouse in an
element once again, while pressing the <Ctrl>-key. Now you can remove the
newly copied elements from the original ones while pressing the left mouse
button.
"Extras" "Configure"
With this command you can open the dialog box to configure the selected
visualization element.
You are given the dialog box for configuration when you doubleclick on the
element.
Select a category in the left area of the dialog box, and fill out the requested
information in the right area.
Depending on the visualization element selected, various categories can be
selected:
• Shape Rectangle, Rounded Rectangle, Ellipse
• Text All
• Color Rectangle, Rounded Rectangle, Ellipse,
Polygon, Line, Curve
• Motion absolute All
• Motion relative All, except Polygon, Line, Curve
• Variables All
• Input All
• Tooltip All
• Bitmap Bitmap
• Visualization Visualization
Shape
In the visualization element configuration dialog box, you can select in the
Shape category from among Rectangle, Rounded Rectangle, and Ellipse
respectively Polygon, Line and Curve. The form will change into the size
already set.
Image 8.2: Dialog Box for Configuring Visualization Elements (Shape Category)
Text
In the visualization element configuration dialog box, in the Text category
you can set a text for the element.
Enter the text in the Content field. By pressilng <Ctrl>+<Enter> you can
insert line breaks.
If you enter "%s" into the text, then this location, in Online mode, will be
replaced by the value of the variable from the Text Output field of the
Variables category.
This text will appear in the element, according to the respective Horizontal
Left, Center, or Right positioning, and the respective Top , Center, or
Bottom positioning, that was specified in the element.
If you use the Font button, a dialog box for selection of the font will appear.
Select the desired font and confirm the dialog with OK. With the Standard
Font button you can set the font that is selected below in the "Project"
"Options". If the font is changed there, then this font will be displayed in
all elements except in those elements for which another font has explicitly
been selected by using the Font button.
Image 8.3: Dialog Box for Configuring Visualization Elements (Text Category)
Colors
In the visualization element configuration dialog box, in the Color category
you can select primary colors and alarm colors for the inside area and for the
frame of your element. Chosing the options no color inside and no frame
color you can create transparent elements.
Image 8.4: Dialog Box for Configuring Visualization Elements (Color Category)
Note: The change color function only becomes active, if the PLC is in
Online Mode!
If you want to change the color of the frame, then press the Frame button,
instead of the Inside button. In either case, the dialog box will open for
selection of the color.
Here can to choose the desired hue from the primary colors and the user-
defined colors. By pressing the Define Colors you can change the user-
defined colors.
Motion absolute
In the visualization element configuration dialog box, in the Motion
absolute category, X- or Y-Offset fields variables can be entered. These
variables can shift the element in the X or the Y direction, depending on the
respective variable value. A variable in the Scale field changes the size of
the element linear to the value of the variable.
A variable in the Angle field causes the element to turn on its turning point,
depending on the value of the variable. (Positive Value = Mathematic
Positive = Clockwise). The value is evaluated in degrees. With polygons,
every point rotates; in other words, the polygon turns. With all other
elements, the element rotates, in such a way, that the upper edge always
remains on top.
The turning point appears after a single click on the element, and is
displayed as a small black circle with a white cross ( ). You can drag the
turning point with a pressed left mouse button.
Image 8.5: Visualization Element Configuration Dialog Box (Motion absolute Category)
Motion relative
In the dialog for configuring visualization elements in the Motion relative
category, you can assign variables to the individual element edges.
Depending on the values of the variables, the corresponding element edges
are then moved. The easiest way to enter variables into the fields is the Input
Assistant.
The four entries indicate the four sides of your element. The base position of
the corners is always at zero.A new value in the variables, in the
corresponding column, shifts the boundary in pixels around this value.
Therefore, the variables that are entered ought to be INT variables.
Note: Positive values shift the horizontal edges downward, or, the
vertical edges, to the right!
Image 8.6: Dialog Box for Configuration of Visualization Elements (Motion relative Category)
Variables
You can enter the variables that describe the status of the visualization
elements in the Variable category within the dialog box for configuring
visualization elements. The simplest way to enter variables in the fields is to
use the Input Assistant.
You can enter Boolean variables in the Invisible and Change color fields.
The values in the fields determine their actions. If the variable of the
Invisible field contains the value FALSE, the visualization element will be
visible. If the variable contains the value TRUE, the element will be
invisible.
If the variable at the Change color field contains the value FALSE, the
visualization element will be displayed in its default color. If the variable is
TRUE, the element will be displayed in its alarm color.
You can enter a variable in the Textdisplay field whose value is displayed if
you have , in addition to the text, inserted %s in the Content field of the
Text category. In Online mode, "%s" is replaced by the value of the
variables found in Textdisplay.
Input
Selecting the field Toggle variable allows you, in online mode, to toggle the
value of the variables which are located in the input field with every mouse
click on the element. The value of the Boolean variable changes with each
mouse click from TRUE to FALSE and then back to TRUE again at the next
mouse click, etc.
The option Keying variable allows you, in online mode, to change the value
of the Boolean variable which is located in the input field, between TRUE
and FALSE. Place the mouse cursor on the element, press the mousekey and
hold it depressed (the value will, for example, change from TRUE to
FALSE). The variable changes back to its initial value (TRUE) as soon as
you release the mousekey.
Selecting the field Zoom to Vis... allows you, in the following field, to enter
the name of a visualization object in the same project. While in online mode
use a mouse click to change to the element in the window of the
visualization which has been entered. If a program variable of the type
STRING (e.g. PLC_PRG.xxx) has been entered, instead of a visualization
object, then this variable can be used to define the name of the visualization
object (e.g. ,visu1’) which the system should change to when a mouse click
occurs (e.g. xxx:= ,visu1).
The field Zoom to Vis... can be used to configure the return to the calling
visualization by using the command ‚ZOOMTOCALLER‘.
Selecting the option Execute program allows you to enter any executable
program in the input field and then to execute it in online mode by clicking
on the element with the mouse.
Note: The configuration field Execute program plays a major role for
the PROSYD 1131 operating version, since PROSYD 1131 program
actions can be initiated here over defined commands, which are available as
menu commands in the full version (see Special input possibilities for the
PROSYD 1131 operating version).
Selecting the option Text input of the variable ‘Text output’ allows you,
in online mode, to allocate a value to a variable over this visualization
element. The value which is located in the field Text output of the category
Variables will be written in the variable. Clicking in online mode on the
element produces an editing frame in which you can enter the new value of
the variable over the keyboard. Press the <Enter> key to accept the value.
Special input
possibilities for the
PROSYD 1131
operating version
In the operating version of PROSYD 1131 there are no menus and status
and tool bars available to the user. The most important control and
monitoring functions can, however, be attached to a visualization element
and thus be available through a mouse click or over the keyboard. The
following special input possibilities are available in the configuration dialog
for a visualization element:
Enter internal commands in the field Execute program in the category
Input according to the following syntax:
INTERN <COMMAND> [PARAMETER]*
The following internal commands which can accommodate a number of
parameters separated by the <space bar> are presently available:
Image 8.9: Dialog for the trace recording in the operation version
ToolTip
The dialog Text for Tooltip offers an input field for text which appears in a
text field as soon as the mouse cursor is passed over the object in online
mode. The text can be formatted with line breaks by using the key
combination <Ctrl> + <Enter>.
Bitmap
You can enter the options for a bitmap in the Bitmap category within the
visualization element configuration dialog box.
Enter the bitmap file and its path in the Bitmap field. You can use the ...
button to open the standard Windows Browse dialog box from which you
can select the desired bitmap.
All other entries affect the frame of the bitmap.
By selecting Anisotropic, Isotropic or Fixed you specify how the bitmap
should react to changes in the size of the frame. Anisotropic means that the
bitmap remains the same size as the frame which allows you to change the
height and width of the bitmap independently. Isotropic means that the
bitmap retains the same proportions even if the overall size is changed (i.e.,
the relationship between height and width is maintained). If Fixed is
selected, the original size of the bitmap will be maintained regardless of the
size of the frame.
If the Clip option is selected together with the Fixed setting, only that
portion of the bitmap that is contained within the frame will be displayed.
If you select the Draw option, the frame will be displayed in the color
selected in the Color and Alarm color buttons in the color dialog boxes.
The alarm color will only be used if the variable in the Change Color field
in the Variable category is TRUE.
Visualization
You can enter the options for a visualization as an element in another
visualization in the Visualization category within the visualization element
configuration dialog box. Enter the object name for the visualization in the
Visualization field. Use the ... button to open a dialog box containing the
visualizations available in this project. Any visualization may be used with
the exception of the current one.
All other entries affect the visualization frame.
If you select the Draw option, the frame will be displayed in the color
selected in the Color and Alarm color buttons in the color dialog boxes.
The alarm color will only be used if the variable in the Change Color field
in the Variables category is TRUE.
If Isotropic is selected, the proportions of the visualization will be
maintained even if the size changes (i.e., the relationship between height and
width will remain the same). Otherwise the proportions can be changed.
If the Clip option is selected in Online mode, only the original portion of the
visualization will be displayed. For example, if an object extends beyond the
original display area, it will be clipped and may disappear from view
completely in the visualization.
"Extras" "Send to
Front"
Use this command to bring selected visualization elements to the front.
"Extras" "Send to
Back"
Use this command to send selected visualization elements to the back.
"Extras" "Select
Background Bitmap"
Use this command to open the dialog box for selecting files. Select a file
with the extension "*.bmp". The selected bitmap will then appear as the
background in your visualization.
The bitmap can be removed with the command "Extras" "Clear
Background Bitmap".
"Extras" "Clear
Background Bitmap"
Use this command to remove the bitmap as the background for the current
visualization.
You can use the command "Extras" "Select Background Bitmap" to
select a bitmap for the current visualization.
"Extras" "Align"
Use this command to align selected visualization elements.
The following alignment options are available:
• Left: the left edge of each of the elements will be aligned to the
element that is furthest to the left
• the same is true for Right / Top / Bottom
• Horizontal Center: each of the elements will be aligned to the
average horizontal center of all elements
• Vertical Center: each of the elements will be aligned to the
average vertical center of all elements
"Extras" "Settings"
When this command is used, a dialog box will open in which you can make
certain settings that affect the visualization.
Note: The categories Display, Frame and Language also can be edited
in the online mode.
Enter a zoom factor into the field Zoom in the category Presentation of
between 10 and 500 % in order to increase or decrease the size of the
visualization display. Selecting Element numbers shows the numbers of the
elements in each visualization element when in offline mode.
If Auto-scrolling is selected in the Frame category, the visible portion of
the visualization window will move automatically when you reach the edge
while drawing or moving a visualization element If Best fit in Online mode
is selected, the entire visualization including all elements will be shown in
the window in Online mode regardless of the size of the window. When
Include Background Bitmap is selected, the background bitmap will be
fitted into the window as well, otherwise only the elements will be
considered.
The category Grid is used to define whether the grid points are visible in the
offline mode, whereby the spacing between the visible points is at least 10
even if the entered size is smaller than that. In this case the grid points only
appear with a spacing which is a multiple of the entered size. Selecting
Active causes the elements to be placed on the snap grid points when they
are drawn and moved. The spacing of the grid points is set in the field Size.
The category Language is used to display the text which has been assigned
to the visualization elements using the options Text and Text for Tooltip in
a desired language. You have to prepare a language file as described in the
following:
Choose option language file. In the associate input field you give in where
you want to store the file. The extension is '.vis'. You also can use the dialog
'Open' by pressing the button . If a language file is available already, it
will be offered here.
In the input field next to Language you fill in a keyword for the language,
which is currently used in the visualization, i.e. "german" (or "D"). Then
press the button Save. A file with the extension .vis is created, which now
can be edited by a normal text editor. For example you can open the file by
notepad:
You get a list of the text variables for the language currently used in the
visualization. It includes a reference to the title of this list, for example
"1=german" as reference to the title [german]. You can extend the list by
copying all lines, then replacing the German by English text and setting a
new title [english]. Beyond the line 1=german you accordingly have to add
2=english.
To view the visualization in one of the prepared languages, open the dialog
Language again. In the option field beyond Language now you can choose
between german and english (for the example described above).
9 DDE Interface
DDE Interface
PROSYD 1131 has a DDE (dynamic data exchange) interface for reading
data. PROSYD 1131 uses this interface to provide other applications that
also use a DDE Interface with the contents of control variables and IEC
addresses.
General Approach to
Data
A DDE inquiry can be divided into three parts:
1. Name of the program (here: PROSYD 1131),
2. File name and
3. Variable name to be read.
Name of the program: PROSYD 1131
File name: complete project path (c:\example\example.pro).
Variable name: The name of a variable as it appears in the Watch and
Receipt Manager .
the field with the right mouse button and select the command "Toggle Field
Codes" you can change the field function for the chosen text.In our example,
this would look as follows:
{ DDEAUTO PROSYD 1131"C:\PROSYD
1131\PROJECT\IFMBSP.PRO" "PLC_PRG.TEST" }
Click on the field with the right mouse button again, then click on "Update
Field" and the desired variable content appears in the text.
Accessing variables
with Intouch
Link with your project a DDE Access Name <AccessName> with the
application name PROSYD 1131 and the DDE topic name C:\PROSYD
1131\PROJECT\IFMBSP.PRO.
Now you can associate DDE type variables with the access name
<AccessName>. Enter the name of the variable as the Item Name (e.g.,
PLC_PRG.TEST).
10 Appendix
If you would like to run PROSYD 1131 using only the keyboard, you will
find it necessary to use a few commands that are not found in the menu.
• The function key <F6> allows you to toggle back and forth within the
open POU between the Declaration and the Instruction parts.
• <Alt>+<F6> allows you to move from an open object to the Object
Organizer and from there to the Message window if it is open. If a
Search box is open, <Alt>+<F6> allows you to switch from Object
Organizer to the Search box and from the there back to the object.
• Press <Tab> to move through the input fields and buttons in the
dialog boxes.
• The arrow keys allow you to move through the register cards and
objects within the Object Organizer and Library Manager.
All other actions can be performed using the menu commands or with the
shortcuts listed after the menu commands. <Shift>+<F10> opens the
context menu which contains the commands most frequently used for the
selected object or for the active editor.
Key Combinations
General Functions
Move between the declaration part and the <F6>
instruction part of a POU
Move between the Object Organizer, the <Alt>+<F6>
object and the message window
Context Menu <Shift>+<F10>
Shortcut mode for declarations <Ctrl>+<Enter>
Move from a message in the Message window <Enter>
back to the original position in the editor
LD Editor Commands
"Insert" "Network (after)" <Shift>+<T>
"Insert" "Contact" <Ctrl>+<O>
"Insert" "Parallel Contact" <Ctrl>+<R>
"Insert" "Function Block" <Ctrl>+<B>
"Insert" "Coil" <Ctrl>+<L>
"Extras" Paste below" <Ctrl>+<U>
"Extras" "Negate" <Ctrl>+<N>
BOOL
BOOL type variables may be given the values TRUE and FALSE. 8 bits of
memory space will be reserved.
REAL / LREAL
REAL and LREAL are so-called floating-point types. They are required to
represent rational numbers. 32 bits of memory space is reserved for REAL
and 64 bits for LREAL.
STRING
A STRING type variable can contain any string of characters. The size entry
in the declaration determines how much memory space should be reserved
for the variable.It refers to the number of characters in the string and can be
placed in parentheses or square brackets. If no size specification is given, the
default size of 80 characters will be used.
Example of a String Declaration with 35 characters:
str:STRING(35):='This is a String';
ARRAY
One-, two-, and three-dimensional fields (arrays) are supported as
elementary data types. Arrays can be defined both in the declaration part of a
POU and in the global variable lists.
Syntax:
<Field_Name>:ARRAY [<ll1>..<ul1>,<ll2>..<ul2>] OF <elem. Type>.
ll1, ll2, ll3identify the lower limit of the field range; ul1, ul2 and ul3 identify
the upper limit. The range values must be integers.
Example:
Card_game: ARRAY [1..13, 1..4] OF INT;
Initializing Arrays:
You can initialize either all of the elements in an array or none of them.
Example for initializing arrays:
arr1 : ARRAY [1..5] OF INT := 1,2,3,4,5;
arr2 : ARRAY [1..2,3..4] OF INT := 1,3(7);
(* short for 1,7,7,7 *)
arr3 : ARRAY [1..2,2..3,3..4] OF INT := 2(0),4(4),2,3;
(* short for 0,0,4,4,4,4,2,3 *)
Array components are accessed in a two-dimensional array using the
following syntax:
<Field_Name>[Index1,Index2]
Example:
Card_game [9,2]
Pointer
Variable or function block addresses are saved in pointers while a program
is running.
Pointer declarations have the following syntax:
<Identifier>: POINTER TO <Datatype/Functionblock>;
A pointer can point to any data type or function block even to user-defined
types.
The function of the Address Operator ADR is to assign the address of a
variable or function block to the pointer.
A pointer can be dereferenced by adding the content operator "^" after the
pointer identifier.
Example:
pt:POINTER TO INT;
var_int1:INT := 5;
var_int2:INT;
pt := ADR(var_int1);
var_int2:= pt^; (* var_int2 is now 5 *)
Enumeration
Enumeration is a user-defined data type that is made up of a number of
string constants. These constants are referred to as enumeration values.
Enumeration values are recognized in all areas of the project even if they
were locally declared within aPOU. It is best to create your enumerations as
objects in the Object Organizer under the register card Data types.
They begin with the keyword TYPE and end with END_TYPE.
Syntax:
TYPE <Identifier>:(<Enum_0> ,<Enum_1>, ...,<Enum_n>);
END_TYPE
A variable of the type <Identifier> can take on one of the enumeration
values and will be initialized with the first one. These values are compatible
with whole numbers which means that you can perform operations with
them just as you would with INT. You can assign a number x to the
variable. If the enumeration values are not initialized, counting will begin
with 0. When initializing, make certain the initial values are increasing. The
validity of the number will be reviewed at the time it is run.
Example:
TYPE TRAFFIC_SIGNAL: (Red, Yellow, Green:=10); (*The initial
value for each of the colors is red 0, yellow 1, green 10 *)
END_TYPE
TRAFFIC_SIGNAL1 : TRAFFIC_SIGNAL;
TRAFFIC_SIGNAL1:=0; (* The value of the traffic signal is red*)
FOR i:= Red TO Green DO
i := i + 1;
END_FOR;
You may not use the same enumeration value more than once.
Example:
TRAFFIC_SIGNAL: (red, yellow, green);
COLOR: (blue, white, red);
Error: red may not be used for both TRAFFIC_SIGNAL and COLOR.
Structures
Structures are created as objects in the Object Organizer under the register
card Data types. They begin with the keywords TYPE and STRUCT and
end with END_STRUCT and END_TYPE.
The syntax for structure declarations is as follows:
TYPE <Structurename>:
STRUCT
<Declaration of Variables 1>
.
.
<Declaration of Variables n>
END_STRUCT
END_TYPE
<Structurename> is a type that is recognized throughout the project and can
be used like a standard data type.
Interlocking structures are allowed. The only restriction is that variables may
not be placed at addresses (the AT declaration is not allowed!).
Example for a structure definition named Polygonline:
TYPE Polygonline:
STRUCT
Start:ARRAY [1..2] OF INT;
Point1:ARRAY [1..2] OF INT;
Point2:ARRAY [1..2] OF INT;
Point3:ARRAY [1..2] OF INT;
Point4:ARRAY [1..2] OF INT;
End:ARRAY [1..2] OF INT;
END_STRUCT
END_TYPE
Example for the initialization of a structure:
Poly_1:polygonline := ( Start:=3,3, Point1 =5,2, Point2:=7,3,
Point3:=8,5, Point4:=5,7, End := 3,5);
You can gain access to structure components using the following syntax:
<Structure_Name>.<Componentname>
For example, if you have a structure named "Week" that contains a
component named "Monday", you can get to it by doing the following:
Week.Monday
References
You can use the user-defined reference data type to create an alternative
name for a variable, constant or function block.
Create your references as objects in the Object Organizer under the register
card Data types. They begin with the keyword TYPE and end with
END_TYPE.
Syntax:
TYPE <Identifier>: <Assignment term>;
END_TYPE
Example:
TYPE message:STRING[50];
END_TYPE;
PROSYD 1131 supports all IEC Operators. In contrast with the standard
functions, these operators are recognized implicitly throughout the project.
Operators are used like functions in POU implemArithmetic Operators
ADD
Addition of variables of the types: BYTE, WORD, DWORD, SINT, USINT,
INT, UINT, DINT, UDINT, REAL and LREAL.
Two TIME variables can also be added together resulting in another time
(e.g., t#45s + t#50s = t#1m35s)
Example in IL:
LD 7
ADD 2,4,7
ST Var 1
Example in ST:
var1 := 7+2+4+7;
Example in FBD:
MUL
Multiplication of variables of the types: BYTE, WORD, DWORD, SINT,
USINT, INT, UINT, DINT, UDINT, REAL and LREAL.
Example in IL:
LD 7
MUL 2,4,7
ST Var 1
Example in ST:
var1 := 7*2*4*7;
Example in FBD:
SUB
Subtraction of one variable from another of the types: BYTE, WORD,
DWORD, SINT, USINT, INT, UINT, DINT, UDINT, REAL and LREAL.
A TIME variable may also be subtracted from another TIME variable
resulting in third TIME type variable. Note that negative TIME values are
undefined.
Example in IL:
LD 7
SUB 8
ST Var 1
Example in ST:
var1 := 7-2;
Example in FBD:
DIV
Division of one variable by another of the types: BYTE, WORD, DWORD,
SINT, USINT, INT, UINT, DINT, UDINT, REAL and LREAL.
Example in IL:
LD 8
DIV 2
ST Var 1 (* Result is 4 *)
Example in ST:
var1 := 8/2;
Example in FBD:
MOD
Modulo Division of one variable by another of the types: BYTE, WORD,
DWORD, SINT, USINT, INT, UINT, DINT, UDINT, REAL and LREAL.
The result of this function will be the remainder of the division. This result
will be a whole number.
Example in IL:
LD 9
MOD 2
ST Var 1 (* Result is 1 *)
Example in ST:
var1 := 9 MOD 2;
Example in FBD:
INDEXOF
Perform this function to find the internal index for a POU.
Example in ST:
var1 := INDEXOF(POU2);
SIZEOF
Perform this function to determine the number of bytes required by the
given data type.
Example in IL:
arr1:ARRAY[0..4] OF INT;
Var1 INT
LD arr1
SIZEOF
ST Var 1 (* Result is 10 *)
Example in ST:
var1 := SIZEOF(arr1);
Bitstring Operators
AND
Bitwise AND of bit operands. The operands should be of the type BOOL,
BYTE, WORD or DWORD.
Example in IL:
Var1 BYTE
LD 2#1001_0011
AND 2#1000_1010
Note: If you have a program step in the SFC like the following
and if you use 68xxx- or C-code generators, please note the following: The
allocation of the value of the second input variable at the AND operator
module to variable z will not be executed ! This is due to the optmized
processing in the SFC in case of value FALSE at the input variable.
OR
Bitwise OR of bit operands. The operands should be of the type BOOL,
BYTE, WORD or DWORD.
Example in IL:
var1 :BYTE;
LD 2#1001_0011
OR 2#1000_1010
ST var1 (* Result is 2#1001_1011 *)
Example in ST:
Var1 := 2#1001_0011 OR 2#1000_1010
Example in FBD:
Note: If you have a program step in the SFC like the following
and if you use 68xxx- or C-code generators, please note the following: The
allocation of the value of the second input variable at the AND operator
module to variable z will not be executed ! This is due to the optmized
processing in the SFC in case of value FALSE at the input variable.
XOR
Bitwise XOR of bit operands. The operands should be of the type BOOL,
BYTE, WORD or DWORD.
Example in IL:
Var1 :BYTE;
LD 2#1001_0011
XOR 2#1000_1010
ST Var1 (* Result is 2#0001_1001 *)
Example in ST:
Var1 := 2#1001_0011 XOR 2#1000_1010
Example in FBD:
NOT
Bitwise NOT of a bit operand. The operand should be of the type BOOL,
BYTE, WORD or DWORD.
Example in IL:
Var1 :BYTE;
LD 2#1001_0011
NOT
ST Var1 (* Result is 2#0110_1100 *)
Example in ST:
Var1 := NOT 2#1001_0011
Example in FBD:
Bit-Shift Operators
SHL
Bitwise left-shift of an operand : erg:= SHL (in, n)
The input variables erg, in and n should be of the type BYTE, WORD, or
DWORD. in will be shifted to the left by n bits and filled with zeros on the
right.
Note: Please note, that the amount of bits, which is regarded for the
arithmetic operation, is pretended by the data type of the input variable !. If
the input variable is a constant the smallest possible data type is regarded.
The data type of the output variable has no effect at all on the arithmetic
operation.
See in the following example in hexadecimal notation that you get different
results for erg_byte and erg_word depending on the data type of the input
variable (BYTE or WORD), although the values of the input variables
in_byte and in_word are the same.
Example in ST:
Example in FBD:
Example in IL:
LD 16#45
SHL 2
ST erg_byte
SHR
Bitwise right-shift of an operand: erg:= SHR (in, n)
erg, in and n should be of the typeBYTE, WORD or DWORD. in will be
shifted to the right by n bits and filled with zeros on the left.
See the following example in hexadecimal notation to notice the results of
the arithmetic operation depending on the type of the input variable (BYTE
or WORD).
Example in ST:
Example in FBD:
Example in IL:
LD 16#45
SHL 2
ST erg_byte
ROL
Bitwise rotation of an operand to the left: erg:= ROL (in, n)
erg, in and n should be of the typeBYTE, WORD or DWORD. in will be
shifted one bit position to the left n times while the bit that is furthest to the
left will be reinserted from the right.
Note: Please note, that the amount of bits, which is regarded for the
arithmetic operation, is pretended by the data type of the input variable !. If
the input variable is a constant the smallest possible data type is regarded.
The data type of the output variable has no effect at all on the arithmetic
operation.
See in the following example in hexadecimal notation that you get different
results for erg_byte and erg_word depending on the data type of the input
Example in FBD:
Example in IL:
LD 16#45
SHL 2
ST erg_byte
ROR
Bitwise rotation of an operand to the right: erg = ROR (in, n)
erg, in and n should be of the typeBYTE, WORD or DWORD. in will be
shifted one bit position to the right n times while the bit that is furthest to
the left will be reinserted from the left.
Note: Please note, that the amount of bits, which is regarded for the
arithmetic operation, is pretended by the data type of the input variable !. If
the input variable is a constant the smallest possible data type is regarded.
The data type of the output variable has no effect at all on the arithmetic
operation.
See in the following example in hexadecimal notation that you get different
results for erg_byte and erg_word depending on the data type of the input
Example in ST:
Example in FBD:
Example in IL:
LD 16#45
SHL 2
ST erg_byte
Selection Operators
All selection operations can also be performed with variables. For purposes
of clarity we will limit our examples to the following which use constants as
operators.
SEL
Binary Selection.
OUT := SEL(G, IN0, IN1) means:
OUT := IN0 if G=FALSE;
OUT := IN1 if G=TRUE.
IN0, IN1 and OUT can be any type of variable, G must be BOOL. The result
of the selection is IN0 if G is FALSE, IN1 if G is TRUE.
Example in IL:
LD FALSE
SEL 3,4
ST Var1 (* Result ist 3 *)
Example in FBD:
MAX
Maximum function. Returns the greater of the two values.
OUT := MAX(IN0, IN1)
IN0, IN1 and OUT can be any type of variable.
Example in IL:
LD 90
MAX 30
MAX 40
MAX 77
ST Var1 (* Result is 90 *)
Example in FBD:
MIN
Minimum function. Returns the lesser of the two values.
OUT := MIN(IN0, IN1)
IN0, IN1 and OUT can be any type of variable.
Example in IL:
LD 90
MIN 30
MIN 40
MIN 77
ST Var 1 (* Result is 30 *)
Example in FBD:
LIMIT
Limiting
OUT := LIMIT(Min, IN, Max) means:
OUT := MIN (MAX (IN, Min), Max)
Max is the upper and Min the lower limit for the result. Should the value IN
exceed the upper limit Max, LIMIT will return Max. Should IN fall below
Min, the result will be Min.
IN and OUT can be any type of variable.
Example in IL:
LD 90
LIMIT 30,80
ST Var 1 (*Result is 80 *)
MUX
Multiplexer
OUT := MUX(K, IN0,...,INn) means:
OUT := INK.
IN0, ...,INn and OUT can be any type of variable. K must be BYTE,
WORD, DWORD, SINT, USINT, INT, UINT, DINT or UDINT. MUX
selects the Kth value from among a group of values.
Example in IL:
LD 0
MUX 30,40,50,60,70,80
ST Var 1 (*Result is 30 *)
Comparison Operators
GT
Greater than
A Boolean operator which returns the value TRUE when the value of the
first operand is greater than that of the second. The operands can be BOOL,
BYTE, WORD, DWORD, SINT, USINT, INT, UINT, DINT, UDINT,
REAL, LREAL, TIME, DATE, TIME_OF_DAY, DATE_AND_TIME and
STRING.
Example in IL:
LD 20
GT 30
ST Var 1 (* Result is FALSE *)
Example in ST:
VAR1 := 20 > 30 > 40 > 50 > 60 > 70;
Example in FBD:
LT
Less than
A Boolean operator that returns the value TRUE when the value of the first
operand is less than that of the second. The operands can be BOOL, BYTE,
WORD, DWORD, SINT, USINT, INT, UINT, DINT, UDINT, REAL,
LREAL, TIME, DATE, TIME_OF_DAY, DATE_AND_TIME and
STRING.
Example in IL:
LD 20
LT 30
ST Var 1 (* Result is TRUE *)
Example in ST:
VAR1 := 20 < 30;
Example in FBD:
LE
Less than or equal to
A Boolean operator that returns the value TRUE when the value of the first
operand is less than or equal to that of the second. The operands can be
BOOL, BYTE, WORD, DWORD, SINT, USINT, INT, UINT, DINT,
UDINT, REAL, LREAL, TIME, DATE, TIME_OF_DAY,
DATE_AND_TIME and STRING.
Example in IL:
LD 20
LE 30
ST Var 1 (* Result is TRUE *)
Example in ST:
VAR1 := 20 <= 30;
Example in FBD
GE
Greater than or equal to
A Boolean operator that returns the value TRUE when the value of the first
operand is greater than or equal to that of the second. The operands can be
BOOL, BYTE, WORD, DWORD, SINT, USINT, INT, UINT, DINT,
UDINT, REAL, LREAL, TIME, DATE, TIME_OF_DAY,
DATE_AND_TIME and STRING.
Example in IL:
LD 60
GE 40
ST Var 1 (* Result is TRUE *)
Example in ST:
EQ
Equal to
A Boolean operator that returns the value TRUE when the operands are
equal. The operands can be BOOL, BYTE, WORD, DWORD, SINT,
USINT, INT, UINT, DINT, UDINT, REAL, LREAL, TIME, DATE,
TIME_OF_DAY, DATE_AND_TIME and STRING.
Example in IL:
LD 40
EQ 40
ST Var 1 (* Result is TRUE *)
Example in ST:
VAR1 := 40 = 40;
Example in FBD:
NE
Not equal to
A Boolean operator that returns that value TRUE when the operands are not
equal. The operands can be BOOL, BYTE, WORD, DWORD, SINT,
USINT, INT, UINT, DINT, UDINT, REAL, LREAL, TIME, DATE,
TIME_OF_DAY, DATE_AND_TIME and STRING.
Example in IL:
LD 40
NE 40
ST Var 1 (* Result is FALSE *)
Example in ST:
VAR1 := 40 <> 40;
Example in FBD:
Address Operators
ADR
Address Function
ADR returns the address of its argument in a DWORD. This address can be
sent to manufacturing functions to be treated as a pointer or it can be
assigned to a pointer within the project.
Example in IL:
LD Var 1
ADR
ST Var 2
man_fun1
Content Operator
A pointer can be dereferenced by adding the content operator "^" after the
pointer identifier.
Example in ST:
pt:POINTER TO INT;
var_int1:INT;
var_int2:INT;
pt := ADR(var_int1);
var_int2:=pt^;
Calling Operator
CAL
Calling a function block or a program
Use CAL in IL to call up a function block instance. The variables that will
serve as the input variables are placed in parentheses right after the name of
the function block instance.
Example: Calling up the instance Inst from a function block where input
variables Par1 and Par2 are 0 and TRUE respectively.
CAL INST(PAR1 := 0, PAR2 := TRUE)
BOOL_TO
Conversions
Conversion from type BOOL to any other type:
For number types the result is 1, when the operand is TRUE, and 0, when
the operand is FALSE.
For the STRING type the result is ‚TRUE‘ or ‚FALSE‘.
Examples in AWL:
LD TRUE (*Result is 1 *)
BOOL_TO_INT
ST i
Examples in ST:
i:=BOOL_TO_INT(TRUE); (* Result is 1 *)
str:=BOOL_TO_STRING(TRUE); (* Result is "TRUE" *)
t:=BOOL_TO_TIME(TRUE); (* Result is T#1ms *)
tof:=BOOL_TO_TOD(TRUE); (* Result is TOD#00:00:00.001 *)
dat:=BOOL_TO_DATE(FALSE); (* Result is D#1970 *)
dandt:=BOOL_TO_DT(TRUE); (* Result is DT#1970-01-01-00:00:01 *)
Examples in FUP:
(*Result is 1 *)
(*Result is 'TRUE' *)
(*Result is T#1ms *)
(*Result is TOD#00:00:00.001 *)
(*Result is D#1970-01-01 *)
(*Result is DT#1970-01-01-00:00:01 *)
TO_BOOL
Conversions
Conversion from another variable type to BOOL:
The result is TRUE when the operand is not equal to 0. The result is FALSE
when the operand is equal to 0.
The result is true for STRING type variables when the operand is "TRUE",
otherwise the result is FALSE.
Examples in AWL:
LD 0 (*Result is FALSE *)
INT_TO_BOOL
ST b
Examples in FUP:
(*Result is TRUE *)
(*Result is FALSE *)
(*Result is TRUE *)
(*Result is TRUE *)
Examples in ST:
Conversion between
Integral Number Types
Conversion from an integral number type to another number type:
When you perform a type conversion from a larger to a smaller type, you
risk losing some information. If the number you are converting exceeds the
range limit, the first bytes for the number will be ignored.
Example in ST:
si := INT_TO_SINT(4223); (* Result is 127 *)
If you save the integer 4223 (16#107f represented hexadecimally) as a
SINT variable, it will appear as 127 (16#7f represented
hexadecimally).
Example in IL:
LD 2
INT_TO_REAL
MUL 3.5
Example in FBD:
REAL_TO-/
LREAL_TO
Conversions
Converting from the variable type REAL or LREAL to a different type:
The value will be rounded up or down to the nearest whole number and
converted into the new variable type. Exceptions to this are the variable
types STRING, BOOL, REAL and LREAL.
When you perform a type conversion from a larger to a smaller type, you
risk losing some information.
Example in ST:
i := REAL_TO_INT(1.5); (* Result is 2 *)
j := REAL_TO_INT(1.4); (* Result is 1 *)
Example in IL:
LD 2.7
REAL_TO_INT
GE %MW8
Example in FBD:
TIME_TO/TIME_OF_
DAY Conversions
Converting from the variable type TIME or TIME_OF_DAY to a different
type:
The time will be stored internally in a DWORD in milliseconds (beginning
with 12:00 A.M. for the TIME_OF_DAY variable). This value will then be
converted.
When you perform a type conversion from a larger to a smaller type, you
risk losing some information
For the STRING type variable, the result is a time constant.
Examples in IL:
LD TOD#00:00:00.012 (*Result is 12 *)
TOD_TO_SINT
ST si
Examples in ST:
si:=TOD_TO_SINT(TOD#00:00:00.012); (* Result is 12 *)
Examples in FBD:
DATE_TO/DT_TO
Conversions
Converting from the variable type DATE or DATE_AND_TIME to a
different type:
The date will be stored internally in a DWORD in seconds since Jan. 1,
1970. This value will then be converted.
When you perform a type conversion from a larger to a smaller type, you
risk losing some information
For STRING type variables, the result is the date constant.
Examples in St:
b :=DATE_TO_BOOL(D#1970-01-01); (* Result is FALSE *)
i :=DATE_TO_INT(D#1970-01-15); (* Result is 29952 *)
byt :=DT_TO_BYTE(DT#1970-01-15- (* Result is 129 *)
05:05:05);
str:=DT_TO_STRING(DT#1998-02-13- (* Result is
14:20); 'DT#1998-02-13-14:20'
*)
STRING_TO
Conversions
Converting from the variable type STRING to a different type:
The operand from the STRING type variable must contain a value that is
valid in the target variable type, otherwise the result will be 0.
Examples in ST:
TRUNC
Converting from REAL to INT. The whole number portion of the value will
be used.
When you perform a type conversion from a larger to a smaller type, you
risk losingsome information
Examples in ST:
i:=TRUNC(1.9); (* Result is 1 *)
i:=TRUNC(-1.4); (* Result is 1 *)
Example in IL:
LD 2.7
TRUNC
GE %MW8
Numeric Functions
ABS
Returns the absolute value of a number. ABS(-2) equals 2.
The following type combinations for input and output variables are possible:
IN OUT
INT INT, REAL, WORD, DWORD, DINT
REAL REAL
BYTE INT, REAL, BYTE, WORD, DWORD, DINT
WORD INT, REAL, WORD, DWORD, DINT
DWORD REAL, DWORD, DINT
SINT REAL
USINT REAL
UINT INT, REAL, WORD, DWORD, DINT, UDINT,
UINT
DINT REAL, DWORD, DINT
UDINT REAL, DWORD, DINT, UDINT
Example in IL:
LD 2
ABS
ST i (*Result is 2 *)
Example in ST:
i:=ABS(-2);
Example in FBD:
SQRT
Returns the square root of a number.
IN can be type BYTE, WORD, DWORD, INT, DINT, REAL, SINT,
USINT, UINT, UDINT, OUT must be type REAL.
Example in IL:
LD 16
SQRT
ST q (*Result is 4 *)
Example in ST:
q:=SQRT(16);
Example in FBD:
LN
Returns the natural logarithm of a number.
IN can be type BYTE, WORD, DWORD, INT, DINT, REAL, SINT,
USINT, UINT, UDINT, OUT must be type REAL.
Example in IL:
LD 45
LN
ST q (*Result is 3.80666 *)
Example in ST:
q:=LN(45);
Example in FBD:
LOG
Returns the logarithm of a number in base 10.
IN can be type BYTE, WORD, DWORD, INT, DINT, REAL, SINT,
USINT, UINT, UDINT, OUT must be type REAL.
Example in IL:
LD 314.5
LOG
ST q (*Result is 2.49762 *)
Example in ST:
q:=LOG(314.5);
Example in FBD:
EXP
Returns the exponential function.
IN can be type BYTE, WORD, DWORD, INT, DINT, REAL, SINT,
USINT, UINT, UDINT, OUT must be type REAL.
Example in IL:
LD 2
EXP
ST q (*Result is 9.7448e+009 *)
Example in ST:
q:=EXP(2);
Example in FBD:
SIN
Returns the sine of a number.
IN can be type BYTE, WORD, DWORD, INT, DINT, REAL, SINT,
USINT, UINT, UDINT, OUT must be type REAL.
Example in IL:
LD 0.5
SIN
ST q (*Result is 0.479426 *)
Example in ST:
q:=SIN(0.5);
Example in FBD:
COS
Returns the cosine of number. The value is calculated in arch minutes.
IN can be type BYTE, WORD, DWORD, INT, DINT, REAL, SINT,
USINT, UINT, UDINT, OUT must be type Typ REAL.
Example in IL:
LD 0.5
COS
ST q (*Result is 0.877583 *)
Example in ST:
q:=COS(0.5);
Example in FBD:
TAN
Returns the tangent of a number. The value is calculated in arch minutes. IN
can be type BYTE, WORD, DWORD, INT, DINT, REAL, SINT, USINT,
UINT, UDINT, OUT must be type REAL.
Example in IL:
LD 0.5
TAN
ST q (*Result is 0.546302 *)
Example in ST:
q:=TAN(0.5);
Example in FBD:
ASIN
Returns the arc sine (inverse function of sine) of a number. .
IN can be type BYTE, WORD, DWORD, INT, DINT, REAL, SINT,
USINT, UINT, UDINT, OUT must be type REAL.
Example in IL:
LD 0.5
ASIN
ST q (*Result is 0.523599 *)
Example in ST:
q:=ASIN(0.5);
Example in FBD:
ACOS
Returns the arc cosine (inverse function of cosine) of a number. The value is
calculated in arch minutes.
IN can be type BYTE, WORD, DWORD, INT, DINT, REAL, SINT,
USINT, UINT, UDINT, OUT must be type REAL.
Example in IL:
LD 0.5
ABS
ST q (*Result is 1.0472 *)
Example in ST:
q:=ACOS(0.5);
Example in FBD:
ATAN
Returns the arc tangent (inverse function of tangent) of a number. The value
is calculated in arch minutes.
IN can be type BYTE, WORD, DWORD, INT, DINT, REAL, SINT,
USINT, UINT, UDINT, OUT must be type REAL.
Example in IL:
LD 0.5
ABS
ST q (*Result is 0.463648 *)
Example in ST:
q:=ATAN(0.5);
Example in FBD:
EXPT
Exponentiation of a variable with another variable:
OUT = IN1IN2.
IN1 and IN2 can be type BYTE, WORD, DWORD, INT, DINT, REAL,
SINT, USINT, UINT, UDINT, OUT must be type REAL.
Example in IL:
LD 7
EXPT 2
ST var1 (*Result is 49 *)
Example in ST:
var1 := (7,2);
Example in FBD:
LEN
Returns the length of a string. Input STR is of type STRING, the return value
of the function is type INT.
Example in IL:
LD 'SUSI'
LEN
ST VarINT1 (* Ergebnis ist 4 *)
Example in FBD:
Example in ST:
LEFT
Left returns the left, initial string for a given string. Input STR is type
STRING, SIZE is of type INT, the return value of the function is type
STRING.
LEFT (STR, SIZE) means: Take the first SIZE character from the right in
the string STR.
Example in IL:
LD 'SUSI'
LEFT 3
ST VarSTRING1 (* Ergebnis ist ‘SUS’ *)
Example in FBD:
Example in ST:
RIGHT
Right returns the right, initial string for a given string.
RIGHT (STR, SIZE) means: Take the first SIZE character from the right in
the string STR.
Input STR is of type STRING, SIZE is of type INT, the return value of the
function is of type STRING.
Example in IL:
LD 'SUSI'
RIGHT 3
ST VarSTRING1 (* Ergebnis ist ‘USI’ *)
Example in FBD:
Example in ST:
MID
MID (STR, LEN, POS) means: Retrieve LEN characters from the STR
string beginning with the character at position POS.
Example in IL:
LD 'SUSI'
RIGHT 2,2
ST VarSTRING1 (* Ergebnis ist ‘US’ *)
Example in FBD:
Example in ST:
VarSTRING1 := MID (‘SUSI’,2,2);
CONCAT
Concatenation (combination) of two strings.
The input variables STR1 and STR2 as well as the return value of the
function are type STRING.
Example in IL:
LD 'SUSI'
CONCAT ‘WILLI’
ST VarSTRING1 (* Ergebnis ist ‘SUSIWILLI’ *)
Example in FBD:
Example in ST:
INSERT
INSERT inserts a string into another string at a defined point.
The input variables STR1 and STR2 are type STRING, POS is type INT and
the return value of the function is type STRING.
INSERT(STR1, STR2, POS) means: insert STR2 into STR1 after position
POS.
Example in IL:
LD 'SUSI'
INSERT ‘XY’,2
ST VarSTRING1 (* Ergebnis ist ‘SUXYSI’ *)
Example in FBD:
Example in ST:
VarSTRING1 := INSERT (‘SUSI’,’XY’,2);
DELETE
DELETE removes a partial string from a larger string at a defined position.
The input variable STR is type STRING, LEN and POS are type INT, the
return value of the function is type STRING.
DELETE(STR, L, P) means: Delete L characters from STR beginning with
the character in the P position.
Example in IL:
LD 'SUXYSI'
DELETE 2,23
ST Var1 (* Ergebnis ist ‘SUSI’ *)
Example in FBD:
Example in ST:
REPLACE
REPLACE replaces a partial string from a larger string with a third string.
The input variable STR1 and STR2 are type STRING, LEN and POS are
type INT, the return value of the function is type STRING.
REPLACE(STR1, STR2, L, P) means: Replace L characters from STR1
with STR2 beginning with the character in the P position.
Example in IL:
LD 'SUXYSI'
REPLACE 'K', 2,2
ST VarSTRING1 (* Ergebnis ist ‘SKYSI’ *)
Example in FBD:
Example in ST:
VarSTRING1 := REPLACE (‘SUXYSI’,’K’,2,2);
FIND
FIND searches for a partial string within a string.
The input variable STR1 and STR2 are type STRING, the return value of
the function is type STRING.
FIND(STR1, STR2) means: Find the position of the first character where
STR2 appears in STR1 for the first time. If STR2 is not found in STR1, then
OUT:=0.
Example in IL:
LD 'SUXYSI'
FIND 'XY'
ST VarINT1 (* Ergebnis ist ‘3’ *)
Example in FBD:
Example in ST:
VarINT1 := FIND (‘SUXYSI’,’XY’);
SR
Making Bistable Function Blocks dominant:
Q1 = SR (SET1, RESET) means:
Q1 = (NOT RESET AND Q1) OR SET1
The input variables SET1 and RESET as well as the output variable Q1 are
type BOOL.
Declaration example:
SRInst : SR ;
Example in IL:
Example in ST:
SRInst(SET1:= VarBOOL1 , RESET:=VarBOOL2 );
VarBOOL3 := SRInst.Q1 ;
RS
Resetting Bistable Function Blocks
Q1 = RS (SET, RESET1) means:
Q1 = NOT RESET1 AND (Q1 OR SET)
The input variables SET and RESET1 as well as the output variable Q1 are
type BOOL.
Declaration example:
RSInst : RS ;
Example in IL:
LD RSInst.Q1
ST VarBOOL3
Example in FBD:
Example in ST:
RSInst(SET:= VarBOOL1 , RESET1:=VarBOOL2 );
VarBOOL3 := RSInst.Q1 ;
SEMA
A Software Semaphore (Interruptible)
BUSY = SEMA(CLAIM, RELEASE) means:
BUSY := X;
IF CLAIM THEN X:=TRUE;
ELSE IF RELEASE THEN BUSY := FALSE; X:= FALSE;
END_IF
X is an internal BOOL variable that is FALSE when it is initialized.
The input variables CLAIM and RELEASE as well as the output variable
BUSY are type BOOL.
If BUSY is TRUE when SEMA is called up, this means that a value has
already been assigned to SEMA (SEMA was called up with CLAIM =
TRUE). If BUSY is FALSE, SEMA has not yet been called up or it has been
released (called up with RELEASE = TRUE).
Declaration example:
SEMAInst : SEMA ;
Example in IL:
CAL SEMAInst(CLAIM := VarBOOL1, RELEASE := VarBOOL2)
LD SEMAInst.BUSY
ST VarBOOL3
Example in FBD:
Example in ST:
SEMAInst(CLAIM:= VarBOOL1 , RELEASE:=VarBOOL2 );
VarBOOL3 := SEMAInst.BUSY;
Trigger
R_TRIG
The function block R_TRIG detects a rising edge.
FUNCTION_BLOCK R_TRIG
VAR_INPUT
CLK : BOOL;
END_VAR
VAR_OUTPUT
Q : BOOL;
END_VAR
VAR
M : BOOL := FALSE;
END_VAR
Q0 := CLK AND NOT M;
M := CLK;
END_FUNCTION_BLOCK
The output Q0 and the help variable M will remain FALSE as long as the
input variable CLK is FALSE. As soon as S1 returns TRUE, Q will first
return TRUE, then M will be set to TRUE. This means each time the
function is called up, Q will return FALSE until CLK has falling edge
followed by an rising edge.
Declaration example:
RTRIGInst : R_TRIG ;
Example in IL:
Example in FBD:
Example in ST:
RTRIGInst(CLK:= VarBOOL1);
VarBOOL2 := RTRIGInst.Q;
F_TRIG
The function block F_TRIG a falling edge.
FUNCTION_BLOCK F_TRIG
VAR_INPUT
CLK: BOOL;
END_VAR
VAR_OUTPUT
Q: BOOL;
END_VAR
VAR
M: BOOL := FALSE;
END_VAR
Q := NOT CLK AND NOT M;
M := NOT CLK;
END_FUNCTION_BLOCK
The output Q and the help variable M will remain FALSE as long as the
input variable CLK returns TRUE. As soon as CLK returns FALSE, Q will
first return TRUE, then M will be set to TRUE. This means each time the
function is called up, Q will return FALSE until CLK has a rising followed
by a falling edge.
Declaration example:
FTRIGInst : F_TRIG ;
Example in IL:
Example in FBD:
Example in ST:
FTRIGInst(CLK:= VarBOOL1);
VarBOOL2 := FTRIGInst.Q;
Counter
CTU
The function block Incrementer:
The input variables CU and RESET as well as the output variable Q are type
BOOL, the input variable PV and the output variable CV are type WORD.
The counter variable CV will be initialized with 0 if RESET is TRUE. If CU
has a rising edge from FALSE to TRUE, CV will be raised by 1.Q will
return TRUE when CV is greater than or equal to the upper limit PV.
Declaration example:
CTUInst : CTU ;
Example in IL:
Example in FBD:
Example in ST:
CTD
Function Block Decrementer:
The input variables CD and LOAD_ as well as the output variable Q are
type BOOL, the input variable PV and the output variable CV are type INT.
When LOAD_ is TRUE, the counter variable CV will be initialized with the
upper limit PV. If CD has a rising edge from FALSE to TRUE, CV will be
Example in IL:
Example in FBD:
Example in ST:
CTDInst(CD:= VarBOOL1, LOAD:=VarBOOL2 , PV:= VarINT1);
VarBOOL3 := CTDInst.Q ;
VarINT2 := CTDInst.CV;
CTUD
Function Block Incrementer/Decrementer
The input variables CU, CD, RESET, LOAD_ as well as the output
variables QU and QD are type BOOL, PV and CV are type WORD.
If RESET is valid, the counter variable CV will be initialized with 0. If
LOAD is valid, CV will be initialized with PV.
If CU has a rising edge from FALSE to TRUE, CV will be raised by 1. If
CD has a rising edge from FALSE to TRUE, CV will be lowered by 1
provided this does not cause the value to fall below 0.
QU returns TRUE when CV has become greater than or equal to PV.
QD returns TRUE when CV has become equal to 0.
Declaration example:
CTUDInst : CUTD ;
Example in IL:
Example in FBD:
Example in ST:
Timer
TP
The function blockTimer is a trigger.
TP(IN, PT, Q, ET) means:
IN and PT are input variables of the BOOL and TIME types respectively. Q
and ET are output variables of the BOOL and TIME types respectively. If IN
is FALSE, Q is FALSE and ET is 0.
As soon as IN becomes TRUE, the time will begin to be counted in
milliseconds in ET until its value is equal to PT.It will then remain constant.
Q is TRUE if IN is TRUE and ET is less than or equal to PT. Otherwise it is
FALSE.
Q returns a signal for the time period given in PT.
Graphic Display of the TP Time Sequence:
Declaration example:
TPInst : TP ;
Example in IL:
Example in FBD:
Example in ST:
TPInst(IN := VarBOOL1, PT:= T#5s);
VarBOOL2 :=TPInst.Q;
TON
The function block Timer On Delay implements a turn-on delay.
TON(IN, PT, Q, ET) means:
IN and PT are input variables of the BOOL and TIME types respectively. Q
and ET are output variables of the BOOL and TIME types respectively. If IN
is FALSE, Q is FALSE and ET is 0.
As soon as IN becomes TRUE, the time will begin to be counted in
milliseconds in ET until its value is equal to PT.It will then remain constant.
Q is TRUE when IN is TRUE and ET is equal to PT. Otherwise it is
FALSE.
Thus, Q has a rising edge when the time indicated in PT in milliseconds has
run out.
Graphic display of TON behavior over time:
Declaration example:
TONInst : TON ;
Example in IL:
Example in FBD:
Example in ST:
TONInst(IN := VarBOOL1, PT:= T#5s);
TOF
The function block TOF implements a turn-off delay.
Declaration example:
TOFInst : TOF ;
Example in IL:
Example in ST:
TOFInst(IN := VarBOOL1, PT:= T#5s);
VarBOOL2 :=TOFInst.Q;
RTC
The function block Runtime Clock returns, starting at a given time, the
current date and time.
BCD conversion
A byte in the BCD format contains integers between 0 and 99. Four bits are
used for each decimal place. The ten decimal place is stored in the bits 4-7.
Thus the BCD format is similar to the hexadecimal presentation, with the
simple difference that only values between 0 and 99 can be stored in a BCD
byte, whereas a hexadecimal byte reaches from 0 to FF.
An example: The integer 51 should be converted to BCD format. 5 in
binary is 0101, 1 in binary is 0001, which makes the BCD byte 01010001,
which corresponds to the value $51=81.
BCD_TO_INT
This function converts a byte in BCD format into an INT value:
The input value of the function is type BYTE and the output is type INT.
Where a byte should be converted which is not in the BCD format the output
is -1.
Examples in ST:
i:=BCD_TO_INT(73); (* Result is 49 *)
k:=BCD_TO_INT(151); (* Result is 97 *)
l:=BCD_TO_INT(15); (* Output -1, because it is not in BCD
format *)
INT_TO_BCD_
This function converts an INTEGER value into a byte in BCD format:
The input value of the function is type INT, the output is type BYTE.
The number 255 will be outputted where an INTEGER value should be
converted which cannot be converted into a BCD byte.
Examples in ST:
i:=INT_TO_BCD(49); (* Result is 73 *)
Bit/byte functions
EXTRACT
Inputs to this function are a DWORD X, as well as a BYTE N. The output is
a BOOL value, which contains the content of the Nth bit of the input X,
whereby the function begins to count from the zero bit.
Examples in ST:
FLAG:=EXTRACT(X:=81, N:=4); (* Result : TRUE, because 81 is
binary 1010001, so the 4th bit is 1 *)
FLAG:=EXTRACT(X:=33, N:=0); (* Result : TRUE, because 33 is
binary 100001, so the bit ‘0’ is 1 *)
PACK
This function is capable of delivering back eight input bits B0, B1, ..., B7
from type BOOL as a BYTE.
The function block UNPACK is closely related to this function.
PUTBIT
The input to this function consists of a DWORD X, a BYTE N and a
BOOLean value B.
PUTBIT sets the Nth bit from X on the value B, whereby it starts counting
from the zero bit.
Example in ST:
A:=38; (* binary 100110 *)
B:=PUTBIT(A,4,TRUE); (* Result : 54 = 2#110110 *)
C:=PUTBIT(A,1,FALSE); (* Result : 36 = 2#100100 *)
UNPACK
UNPACK converts the input B from type BYTE into 8 output variables
B0,...,B7 of the type BOOL, and this is the opposite to PACK.
Example in FBD: Output:
DERIVATIVE
This function block approximately determines the local derivation.
The function value is delivered as a REAL variable by using IN. TM
contains the time which has passed in msec in a DWORD and the input of
RESET of the type BOOL allows the function block to start anew through
the delivery of the value TRUE.
The output OUT is of the type REAL.
In order to obtain the best possible result, DERIVATIVE approximates
using the last four values, in order to hold errors which are produced by
inaccuracies in the input parameters as low as possible.
Block in FBD:
INTEGRAL
This function block approximately determines the integral of the function.
In an analogue fashion to DERIVATIVE, the function value is delivered as a
REAL variable by using IN. TM contains the time which has passed in msec
in a DWORD and the input of RESET of the type BOOL allows the function
block to start anew with the value TRUE.
The output OUT is of the type REAL.
STATISTICS_INT
This function block calculates some standard statistical values:
The input IN is of the type INT. All values are initialised anew when the
BOOLean input RESET is TRUE.
The output MN contains the minimum, MX of the maximum value from IN.
AVG describes the average, that is the expected value of IN. All three
outputs are of the type INT.
Block in FBD:
STATISTICS_REAL
This function block corresponds to STATISTICS_INT, except that the input
IN is of the type REAL like the outputs MN, MX, AVG.
VARIANCE
VARIANCE calculates the variance of the entered values.
The input IN is of the type REAL, RESET is of the type BOOL and the
output OUT is again of the type REAL.
This block calculates the variance of the inputted values. VARIANCE can
be reset with RESET=TRUE.
The standard deviation can easily be calculated as the square root of the
VARIANCE.
Controllers
P
The P controller function block:
ACTUAL (actual value) and DESIRED (desired or nominal value) as well
as K, the proportionality coefficient, are all input values of the type REAL.
The output, the absolute control output (OUT), is also of the type REAL and
satisfies the equation:
OUT = ACTUAL + K⋅∆ , whereby ∆=DESIRED-
ACTUAL
Example in FBD:
PD
The PD controller function block:
ACTUAL (actual value) and DESIRED (desired or nominal value) as well
as KP, the proportionality coefficient, are all input values of the type REAL.
TV is of the type DWORD and contains the derivative action time in msec.
RESET is of the type BOOL and serves to reset the controller.
The output, the absolute control output (OUT), is of the type REAL, and is
calculated as follows:
δ∆
OUT = ACTUAL + K⋅ (∆ + TV⋅ ) , whereby ∆=DESIRED-
δt
ACTUAL
Example in FBD:
PID
The PID controller function block:
ACTUAL (actual value) and DESIRED (desired or nominal value) as well
as KP, the proportionality coefficient, are all input values of the type REAL.
TN, the integral action time, and TV, the derivative action time, are
delivered in msec by a DWORD. RESET is of the type BOOL and serves to
reset the controller.
The output, the absolute control output (OUT), is again of the type REAL,
and is calculated as follows:
1 δ∆
OUT = ACTUAL + K⋅ (∆ + TN ⌠∆(t)dt
⌡ + TV⋅ )
δt
The PID controller can be easily converted to a PI controller by setting
TV=0.
Example in FBD:
Signal generators
BLINK
The function block BLINK generates a pulsating signal. The input consists
of ENABLE of the type BOOL, as well as TIMELOW and TIMEHIGH of
the type TIME. The output OUT is of the type BOOL.
If ENABLE is set to TRUE, BLINK begins, to set the output for the time
period TIMEHIGH to TRUE, and then afterwards to set it for the time
period TIMELOW to FALSE.
Example in FBD:
GEN
The function generator generates typical periodic functions:
The inputs are a composition consisting of MODE from the pre-defined
counting type GEN_MODE, BASE of the type BOOL, of the PERIOD of
the type TIME, of two INT values CYCLES and AMPLITUDE and of the
BOOLean RESET input. An INT is generated with the designation OUT.
The MODE describes the function which should be generated, whereby the
enumeration values TRIANGLE and TRIANGLE_POS deliver two
triangular functions, SAWTOOTH_RISE an ascending,
SAWTOOTH_FALL a descending sawtooth, RECTANGLE a rectangular
signal and SINE and COSINE the sine and cosine:
TRIANGLE: TRIANGLE_POS:
SAWTOOTH_RISE: SAWTOOTH_FALL:
RECTANGLE: SINUS:
COSINUS:
BASE defines whether the cycle period is really related to a defined time
(BASE=TRUE) or whether it is related to a particular number of cycles,
which means the number of calls of function block (BASE=FALSE).
PERIOD or CYCLES defines the corresponding cycle period.
AMPLITUDE defines, in a trivial way, the amplitude of the function to be
generated.
The function generator is again set to 0 as soon as RESET=TRUE.
Example in FBD:
Function manipulators
CHARCURVE
This function block serves to represent values, piece by piece, on a linear
function:
IN of the type INT is fed with the value to be manipulated. The BYTE N
designates the number of points which defines the presentation function.
This characteristic line is then generated in an ARRAY P[0..10] with P of
the type POINT which is a structure based on two INT values (X and Y).
The output consists of OUT of the type INT, the manipulated value and
BYTE ERR, which will indicate an error if necessary.
The points P[0]..P[N-1] in the ARRAY must be sorted according to their X
values, otherwise ERR receives the value 1. If the input IN is not between
P[0].X and P[N-1].X, ERR=2 and OUT contains the corresponding limiting
value P[0].X or P[N-1].X.
If N lies outside of the allowed values which are between 2 and 11, then
ERR=4.
Example in ST:
First of all ARRAY P must be defined in the header:
VAR
...
CHARACTERISTIC_LINE:CHARCURVE;
KL:ARRAY[0..10] OF POINT:=(X:=0,Y:=0),(X:=250,Y:=50),
(X:=500,Y:=150),(X:=750,Y:=400),7((X:=1000,Y:=1000));
COUNTER:INT;
...
END_VAR
RAMP_INT
RAMP_INT serves to limit the ascendance or descendance of the function
being fed:
The input consists on the one hand out of three INT values: IN, the function
input, and ASCEND and DESCEND, the maximum increase or decrease for
a given time interval, which is defined by TIMEBASE of the type TIME.
Setting RESET to TRUE causes RAMP_INT to be initialised anew.
The output OUT of the type INT contains the ascend and descend limited
function value.
When TIMEBASE is set to t#0s, ASCEND and DESCEND are not related
to the time interval, but remain the same.
Example in FBD:
RAMP_REAL
RAMP_REAL functions exactly in the same way as RAMP_INT, with the
simple difference that the inputs IN, ASCEND, DESCEND and the output
OUT are of the type REAL.
HYSTERESIS
The input to this function block consists of three INT values IN, HIGH and
LOW. The output OUT is of the type BOOL.
If IN goes below the limiting value LOW, OUT becomes TRUE. If IN goes
over the upper limit HIGH, FALSE is delivered.
An illustrative example:
LIMITALARM
This function block specifies, whether the input value is within a set range
and which limits it has violated if it has done so.
The input values IN, HIGH and LOW are each of the type INT, while the
outputs O, U and IL are of the type BOOL.
If the upper limit HIGH is exceeded by IN, O becomes TRUE, and when IN
is below LOW, U becomes TRUE. IL is TRUE if IN lies between LOW and
HIGH.
Example in FBD: Result:
Constants
BOOL Constants
BOOL constants are the logical values TRUE and FALSE.
TIME Constants
TIME constants can be declared in PROSYD 1131. These are generally used
to operate the timer in the standard library. A TIME constant is always made
up of an initial "t" or "T" (or "time" or "TIME" spelled out) and a number
sign "#".
This is followed by the actual time declaration which can include days
(identified by "d"), hours (identified by "h"), minutes (identified by "m"),
seconds (identified by "s") and milliseconds (identified by "ms"). Please
note that the time entries must be given in this order according to length (d
before h before m before s before m before ms) but you are not required to
include all time increments.
Examples of correct TIME constants in a ST assignment:
TIME1 := T#14ms;
TIME1 := T#100S12ms; (*The highest component may be allowed
to exceed its limit*)
TIME1 := t#12h34m15s;
the following would be incorrect:
TIME1 := t#5m68s; (*limit exceeded in a lower component*)
TIME1 := 15ms; (*T# is missing*)
TIME1 := t#4ms13d; (*Incorrect order of entries*)
DATE Constants
These constants can be used to enter dates. A DATE constant is declared
beginning with a "d", "D", "DATE" or "date" followed by "#". You can then
enter any date with format Year-Month-Day.
Examples:
DATE#1996-05-06
d#1972-03-29
TIME_OF_DAY
Constants
Use this type of constant to store times of the day. A TIME_OF_DAY
declaration begins with "tod#", "TOD#", "TIME_OF_DAY#" or
"time_of_day#" followed by a time with the format: Hour:Minute:Second.
You can enter seconds as real numbers or you can enter fractions of a
second.
Examples:
TIME_OF_DAY#15:36:30.123
tod#00:00:00
DATE_AND_TIME
Constants
Date constants and the time of day can also be combined to form so-called
DATE_AND_TIME constants. DATE_AND_TIME constants begin with
"dt#", "DT#", "DATE_AND_TIME#" or "date_and_time#". Place a hyphen
after the date followed by the time.
Examples:
DATE_AND_TIME#1996-05-06-15:36:30
dt#1972-03-29-00:00:00
Number Constants
Number values can appear as binary numbers, octal numbers, decimal
numbers and hexadecimal numbers. If an integer value is not a decimal
number, you must write its base followed by the number sign (#) in front of
the integer constant. The values for the numbers 10-15 in hexadecimal
numbers will be represented as always by the letters A-F.
You may include the underscore character within the number.
Examples:
14 (Decimal number)
2#1001_0011 (Binary number)
8#67 (Octal number)
16#A (Hexadecimal number)
These number values can be from the variable types BYTE, WORD,
DWORD, SINT, USINT, INT, UINT, DINT, UDINT, REAL or LREAL.
Implicit conversions from "larger" to "smaller" variable types are not
permitted. This means that a DINT variable cannot simply be used as an INT
variable. You must use the type conversion (see the Type Conversions
chapter in the appendix).
REAL/LREAL
Constants
REAL and LREAL constants can be given as decimal fractions and
represented exponentially. Use the standard American format with the
decimal point to do this.
Example:
7.4 instead of 7,4
1.64e+009 instead of 1,64e+009
STRING Constants
A string is a sequence of characters. STRING constants are preceded and
followed by single quotation marks. You may also enter blank spaces and
special characters (umlauts for instance). They will be treated just like all
other characters.
In character sequences, the combination of the dollar sign ($) followed by
two hexadecimal numbers is interpreted as a hexadecimal representation of
the eight bit character code. In addition, the combination of two characters
that begin with the dollar sign are interpreted as shown below when they
appear in a character sequence:
$$ Dollar signs
$' Single quotation mark
$L or $l Line feed
$N or $n New line
$P or $p Page feed
$R or $r Line break
$T or $t Tab
Examples:
'w1Wüß?'
' Abby and Craig '
':-)'
Variables
System Flags
System flags are implicitly declared variables that are different on each
specific PLC. To find out which system flags are available in your system,
use the command "Insert" "Operand" An Input Assistant dialog box pops
up, select the category System Variable.
Addresses
Address
The direct display of individual memory locations is done through the use of
special character sequences. These sequences are a concatenation of the
percent sign "%", a range prefix, a prefix for the size and one or more
natural numbers separated by blank spaces.
The following range prefixes are supported:
I Input
Q Output
M Memory location
X Single bit
None Single bit
B Byte (8 Bits)
W Word (16 Bits)
D Double word (32 Bits)
Examples:
%QX75 and %Q75 Output bit 75
%IW215 Input word 215
%QB7 Output byte 7
%MD48 Double word in memory position 48 in the memory
location.
%IW2.5.7.1 depending on the PLC Configuration
The current PLC Configuration for the program determines whether or not
an address is valid.
Memory location
You can use any supported size to access the memory location.
For example, the address %MD48 would address bytes numbers 192, 193,
194, and 195 in the memory location area (48 * 4 = 192). The number of the
first byte is 0.
You can access words, bytes and even bits in the same way: the address
%MX5.0 allows you to access the first bit in the fifth word (Bits are
generally saved wordwise).
Functions
When PROSYD 1131 is started, you can add commands in the command
line which will be asserted during execution of the program. These
commands start with a „/“. Capitalization/Use of small letters is not
regarded. The commands will be executed sequentially from the left to the
right.
See the following table for a list of commands, which can be used in a
command file (<cmdfile>). You can call the command file by a command
line (see above). Capitalizing/Use of small letters is not regarded. The
command line will be displayed as a message in the message window and
can be given out in a message file (see below). Additionally to the command
a „@“ is prefixed. All signs after a semicolon (;) will be ignored (comment).
Commands for the control of replace of objects respectively for the control
of files for import, export, replace:
replace ok Replace
replace yes
replace no Do not replace
replace yesall Replace all
replace noall Replace none
Debug command:
watchlist load <file> The watch list saved in <file> will be loaded
Watchliste and the appropriate window will
be opened ('Extras' 'Load Watch List')
watchlist save <file> Saves the current watch list in <file> ('Extras'
'Save Watch List')
watchlist set <text> A previous loaded watch list gets the name
<text> ('Extras' 'Rename Watch List')
watchlist read The values of the watch variables are updated
('Extras' 'Read Receipt')
watchlist write The values of the watch list are written to the
watch variables ('Extras' 'Write Receipt')
A command file like shown below will open the project file ampel.pro, will
then load a watch list, which was stored as w.wtc, will then start the
application program and write – after 1 second delay - the values of the
variables into the watch list watch.wtc (which will be saved) and will finally
close the project.
file open C:\work\projects\PROSYD 1131_test\ampel.pro
query off ok
watchlist load c:\work\w.wtc
online login
online run
delay 1000
watchlist read
watchlist save c:\work\watch.wtc
online logout
file close
Here you will find the error messages that the parser displays (italics) and
possible causes.They are shown in alphabetical order:
Check to see how many operands the operator <operator> requires and insert
the ones that are missing.
Check to see how many operands the operator <operator> requires and
remove those that aren't needed.
Change the first word in the line to a valid operator or a valid function.
The POU ends with an incomplete expression. Add the correct ending or
delete it.
Check the number of input variables this POU requires, then add or remove
them as needed.
"Identifier expected"
Declare an instance for the function block that you would like to call up.
The result of the previous instruction is not a BOOL type variable. Insert an
operator or a function whose result is BOOL.
Rename your POU with the menu command "Project" "Object Rename"
or change the name of the POU in its declaration part. The name must
appear directly after the keywords, PROGRAM, FUNCTION or
FUNCTIONBLOCK.
Insert the name of the desired instance or remove the call for the function
block.
"END_STRUCT or identifier
expected"
"Expression expected"
Remove EXIT
Enter a constant (constants) for the initial value which corresponds to the
declaration type.
Change the text of the instance for function block <name> (initialized with
"Instance") in the identifier of a valid instance declaration.
Only integers or symbolic constants can be used as the condition for a CASE
instance. Change the incorrect condition.
Change <identifier> into one of the functions from the libraries that are
linked to the project or into one of the function declared in the project.
Change the operands into a function block instance. To do this, declare the
operand as a function block or use a previously declared function block, or
use a data unit type instance.
"LD expected"
Enter an instruction.
Check over the input variables for the called function block and change
<name> into one of these variables.
Change the text of the function block instance (initialized with "Instance")
into an identifier for a valid function block instance declaration.
Remove the N and negate the operand explicitly with the NOT operator
Replace the first operand with a variable that has write permission
"Operand expected"
Check the number of operands for this operator and remove the surplus
operands.
Check the type of the operand with the number <number> of this operator,
function or function block. Change the type of the variable that caused the
error to a type that is allowed or select a new variable of an allowed type.
Change <name> into the name of an existing step or add a step named
<name>.
This watch variable is not declared in the project. Press <F2> to access help
with declared variables.
"Unexpected End"
In the declaration part: Add the keyword END_VAR to the end of the
declaration part.
In the text editor: Insert instructions that end the last instruction sequence
(e.g., ST).
Check the required types of operators (search for Operator in your help file)
and change the variable type that produced the error into a type that is
allowed or select another variable.
Check in your PLC Configuration to see which addresses are allowed and
replace the addresses with permissible addresses or change the PLC
Configuration.
Use a <Type2> type variable for the assignment to the <name> parameter or
change the type of assigned variable to <Type1>.
Declare this variable in the declaration part of the POU or in the global
variable list.
The first line after the name of the POU must contain one of these
keywords.
The identifier to the left of '.' is not a structure variable or instance for a
function block. Change the identifier into a structure variable or into a
instance for a function block or remove the period and the identifier to its
right.
Check how many indices are declared for the array(1, 2, or 3) and remove
the extra ones.
You must learn to restrain yourself, no more than 64000 identifiers are
allowed.
"Out of Memory"
Leave the system by saving. Close Windows, restart it and then restart the
compilation.
M
Main Help Window 4-60
N
Main program 2-9 NE 10-24
Mark 4-9 Negation in FBD 5-23
Marking in SFC 5-33 Negation in LD 5-31
MAX 10-20 Network 5-17, 5-19
Memory location 10-73 Network Comment 5-17
Menu Bar 4-2 Network in FBD 2-28, 3-3
Menü Edit Network in LD 2-30
Declare Variable 4-46 Network in SFC 3-7
Menu Extras Network number field 4-49, 4-52
Connection marker 5-50 New Folder 4-32
Display order 5-51 Next error 4-46
EN/ENO 5-47 NOT 10-15
Negate 5-46 Note in Help 4-61
Order - One backwards 5-53 Notice at load 4-15
Order - One forwards 5-53 Number Constants 10-70
Order – To the beginning 5-53 Number of data segments 4-13
Order – To the end 5-53
Order everything according to data flow 5-54
Order topologically 5-51 O
Properties 5-47, 6-11, 6-13 Object 2-1, 4-31
Select All 5-48 Object Organizer 4-2
Select Mode 8-18 Online 1-2, 5-11, 5-17, 6-32
Set/Reset 5-46 Online Change 4-13, 4-22, 4-29
Menü Extras Online functions 4-47
Properties 6-10 Online in Security mode 4-10
Menu Insert
Window Menu
Arrange symbols 4-59
Cascade 4-59
Close all 4-59
Library Manager 7-1
Messages 4-59
Tile Horizontal 4-59
Tile Vertical 4-59
WORD 10-5
WORD Constants 10-70
Work space 4-3
Write protection password 4-14
Write Receipt 6-34
X
XOR 10-15
Y
Y Scaling 6-28
Z
Zoom 5-23
Zoom Action 5-36
Zoom Transition 5-36