for
A
User’s Guide
Version 2.05
Disclaimer
Every effort has been made to ensure the accuracy of the information in this guide. However, SEMAPHORE assumes
no responsibility for the accuracy of the information. Product information is subject to change without notice.
Copyright
2004-2009 by
1. PROGRAMS - BASIC................................................................................................ 9
To see an example, load the TWinSoft document 'MSBASIC.tws' that you find in the
'Samples' directory of TWinSoft.
Example:
' This is my first program
If (Temperature > 70) or (Emergency=1) then
Pump=1
Alarm=1
endif
1.2.1. Case
BASIC is not case sensitive.
A variable must be declared either in the list of Tags (=global Tag), in the list of POU Tags
or with a Dim statement (=local Tag)
1.2.4. Colors
Comment : the comments appear in green color
Constant : a constant appears in red color
Keyword : a keyword appears in blue color (see the list at chapter 1.18)
Variable : a variable appear in black color
The cycle time is available from the ‘RTU Identification’, accessible in the main menu
'Communication'.
Examples:
dim Temperature as integer
if Temperature@ > 20 then
if triggerpos(prgrun!) then
......
Temperature@ is the global Tag, if it exists, otherwise the
compiler returns an error. It will not use the local Tag.
Examples:
If A=0 Or B=0 Or C=0 Or D=0 Or E=0 Or F=0 Or G=0 Or H=0 Or_
I=0 Or J=0 Or K=0 Or L=0 Or M=0 Or N=0 Or O=0 Or_
P=0 Or Q=0 Or R=0 Or S=0 Or T=0 then
output=0
endif
1.3. Comment
• Rules
A comment can start with the keyword REM or with the single apostrophe '
REM : is considered as a statement. It can then only be used at the beginning of a
line.
' : is not a statement. It can then be placed anywhere in the line.
• Examples
REM this is a comment
' this is a comment
var1=var2 ' var2 is assigned to var1
1.4. Constant
• Rules
Constant statement can be expressed in:
decimal
hexadecimal (with prefix &H)
floating point
• Limits
To be accepted, the constant must hold into a INT 32 bits or into a IEEE 32 bits Floating.
• Examples
decimal: a=123456 In an arithmetic operation, a constant is always
hexadecimal: a=&H1E240 converted into the format of the Tag it is associated to.
Floating point: a=123.456 Integer/2.5
Constant will be converted to Integer, it means 2.
[x] is the index of the variable in the table. Only square brackets [ ] can be used.
• Indexing
With a local variable 'simple', indexing is not allowed.
With a local variable 'array', index must be specified with the Dim statement.
With a global variable, indexing is allowed. The variable is then considered as the first of a
virtual table composed of successive ModBus addresses. See For...next statement. with
Global Tags.
• Examples
Temperature=Setpoint
Delay=5
LET StartPump[2]=1
• Syntax
Variable
Dim MyVar
Dim MyVar as <Type> ' See types below
Table (array)
Dim Table[n] <as Type> ' Table is an array of n elements (1 to n)
' The types of the elements can also be declared
Each variable of the table can be represented with the name of the table and its index:
Table[1]
Table[2]
....
• Types available
Types Description
BOOL 1 bit - Digital
BYTE 8 bits - Unsigned
INTEGER 16 bits - Signed
WORD 16 bits - Unsigned
LONG 32 bits - Signed
DWORD 32 bits - Unsigned
SINGLE 32 bits - Float IEEE
• Examples
Dim Temperature as Single
Dim input2 as Bool
Dim table[4] as Word
= : equal to
< : smaller than
<= : smaller than equal to
> : larger than
>= : larger than or equal to
<> : different
The comparison returns a Boolean result. It can be used to compare 2 numbers and get the
result in a Bool, or in a sequence as condition; for instance if ..then.
• Syntax
if (expression1 operator expression2) then
• Arguments
result :Bool
expression :any expression composed of Bool, Byte, Word, Long, Float
• Examples
Status=Value<>0
if (level<=125) then
Pump=1
endif
• Syntax
Classical syntax: with Statements on different lines:
If Condition1 then
Statement1 In this example:
Statement2 If Condition1 is TRUE, Statement 1 and 2 are
elseif Condition2 then executed.
Statement3 If Condition1 is FALSE, Condition2 is tested.
else
If Condition2 is TRUE, Statement3 is
Statement4
endif executed otherwise Statement4 is executed
Several Statements on the same line: the Statements must be separated by colons:
If Condition then
Statement1 : Statement2
endif
• Arguments
Condition
The condition is Boolean. It can be any expression resulting in TRUE or FALSE status.
Examples:
If Button then ‘(is equivalent to: if Button=1 then)
Example:
INT * LONG calculated in LONG
Float √ √ √ √ √ √ -
√ means automatic casting at compilation
1.9.4. + (Addition)
Sums several numbers
• Syntax
result=expression1+expression2+ expression3 ...
• Arguments
result :Byte, Word, Long, Float
expression :any expression composed of Bool, Byte, Word, Long, Float
You can mix several types of variables in the 'expressions': it is automatically converted to
the type of the variable 'result'
• Examples
Word1=Word2+Float2+Float3 'Result in 'Word' format with Float rounded
Float1=Word2+(Float2*2) 'Result in Float
• Syntax
result=expression1-expression2-expression3 ...
result=-number
• Arguments
result :Byte, Word, Long, Float
expression :any expression composed of Bool, Byte, Word, Long, Float
You can mix several types of variables in the 'expressions': it is automatically converted to the
type of the variable 'result'
• Examples
Word1=Word2-Float2-Float3 'Result in 'Word' format with Float rounded
Float1=Word2-(Float2*2) 'Result in Float
1.9.6. * (Multiplication)
Multiplies numbers.
• Syntax
result=expression1*expression2*expression3 ...
• Arguments
result :Byte, Word, Long, Float
expression :any expression composed of Bool, Byte, Word, Long, Float.
You can mix several types of variables in the 'expressions': it is automatically converted to
the type of the variable 'result'
• Examples
Word1=Word2*Float2*Float3 'Result in 'Word' format with Float rounded
Float1=Word2*Float2*2 'Result in Float
• Syntax
result=expression1/expression2/expression3 ...
• Arguments
result :Byte, Word, Long, Float
expression :any expression composed of Bool, Byte, Word, Long, Float
You can mix several types of variables in the 'expressions': it is automatically converted to
the type of the variable 'result'
When a divisor=0 (zero) the result is unpredictable and
depends on the type of 'result' variable.
To avoid any problem, you have to check the divisor(s) before
executing the division(s)
• Examples
if (Float2>0) and (Float3>0) then
Word1=Word2/Float2/Float3 'Result in Word with Float rounded
endif
if (Float2>0) then
Float1=Word2/Float2/2 'Result in Float
endif
• Syntax
result=number1 % number2
• Arguments
result :Word, Long, Float
numbers :Word, Long
You can mix numbers of 'Word' and 'Long' types together: the type of the numbers are
automatically converted to the type of the 'result'
• Examples
Remainder=47 % 15 'Remainder=2
Boolean operators
This is probably the more usual way to use the logical operators: in an expression you execute
Boolean operations between several Tags.
Example:
if ((Var1>=150) And (Var2<=200)) Or ((Emergency=1) And (not Button))
Bitwise operators
Those operators are used between 2 Tags and execute Bitwise operations on each bit of the
Tags:
AND Operator
OR Operator
XOR Operator
NOT Operator When using several operators, be careful to the priority of the
operations. We advise to use brackets to separate clearly
the operations.
Example: A=2 And B <>3
Without brackets, will be calculated as follows:
(A=((2 And B)<>3))
With brackets, like it is probably required:
(A=2) And (B<>3)
1.10.2. AND
Performs a Bitwise AND operation on 2 expressions.
00110101
11010110
00010100
• Syntax
result=expression1 And expression2
• Arguments
result :Word or Long
expression :any expression composed of Bool, Byte, Word, Long
You can mix several types of variables in the 'expressions': it is automatically converted to the
type of the variable 'result'
• Examples
MyVal=Word1 And 255 'Mask to erase the MSB
MyVal=(Word1*2) And Word2
• Syntax
result=expression1 Or expression2
• Arguments
result :Word or Long
expression :any expression composed of Bool, Byte, Word, Long
You can mix several types of variables in the 'expressions': it is automatically converted to
the type of the variable 'result'
• Examples
MyVal=Word1 Or Word2
MyVal=(Word1*2) Or Word2
1.10.4. XOR
Performs a Bitwise XOR operation on 2 expressions.
00110101
11010110
11100011
• Syntax
result=expression1 XOR expression2
• Arguments
result :Word or Long
expression :any expression composed of Bool, Byte, Word, Long
You can mix several types of variables in the 'expressions': it is automatically converted to
the type of the variable 'result'
• Examples
MyVal=Word1 XOR Word2
MyVal=(Word1 XOR Word2) And Word2
Notes:
1. The NOT function is a complement to 1
2. An inversion (a=-b) is a (complement to 1) + 1
Examples:
Value NOT Inversion
-2 1 2
-1 0 1
0 -1 0
1 -2 -1
2 -3 -2
• Syntax
result=expression1 Not expression2
• Arguments
result :Word or Long
expression :any expression composed of Bool, Byte, Word, Long
You can mix several types of variables in the 'expressions': it is automatically converted to
the type of the variable 'result'
• Examples
MyVal=Word1 Not Word2
Dim i as Word
For i=1 to 4
Start1[i]=1
next i
• Example
For...Next statements nested
• Syntax
Classical syntax
While condition
statement1
statement2
Wend
• Argument
condition : Bool, Tag or expression
• Example
While level>150
call Alarms
Wend
• Syntax
Result=Sin(x)
Result=Cos(x)
Result=Tan(x)
Result=ArcSin(x)
Result=ArcCos(x)
Result=ArcTan(x)
• Argument
x : Single or constant
result : Single
• Examples
‘Calculation of pi
Dim a as Single
Dim Pi as Single
a=arcsin(1)
Pi=a*2
‘Implementation of a sinusoid
if triggerpos (PrgRun) then Radian=0
if Radian < (Pi*2) then 'Pi*2 = 360 degrees
Radian=Radian + (Pi/180) 'Pi/180 = 1 degree
else
Radian=0
endif
Sine=sin(Radian)
Sinusoid=(sine*90) + 200
Degree=(Radian*180)/pi
• Syntax
Result=Log(x)
Result=Ln(x)
• Argument
x : Single or constant
result : Single
1.13.3. Exponential
Exponential function returns e (the base of natural logarithm) raised to a power
The constant e is approximately 2.718282
The Exp function is the complement to natural logarithm function (see above)
• Syntax
Result=Exp(x)
• Argument
x : Single or constant
result : Single
• Syntax
Result=Pow(base, exponent)
• Argument
base : Single or constant
exponent : Single or constant
result : Single
• Example
Power=Pow(10, 3) ‘returns 1000 (10^3)
Power=Pow(0, 0) ‘returns 1
Power=Pow(1, 0) ‘returns 1
• Syntax
Result=Sqrt(x)
• Argument
x : Single or constant
result : Single
• Example
MySquar=Sqrt(4) ‘returns 2
MySquar=Sqrt(9) ‘returns 3
MySquar=Sqrt(23) ‘returns 4.796
MySquar=Sqrt(0) ‘returns 0
• Syntax
inc(Var)
• Argument
Var :must be any Integer variable: Byte, Word, Long
• Example
If TriggerPos(Pump_0) then
inc(Counter_0)
endif
1.14.2. DEC
The DEC function decrements a variable (-1)
• Syntax
dec(Var)
• Argument
Var :must be any Integer variable: Byte, Word, Long
• Example
If TriggerPos(Pump) then
dec(PumpActive)
endif
1.14.3. ABS
The ABS function returns the absolute value of any variable.
• Syntax
Result=abs(Var)
• Argument
Var :any format: Byte, Word, Long, Float
• Syntax
Result=LoByte(Var)
• Argument
Var :Word (16 bits)
Result :Byte or Word
1.14.5. HIBYTE
Mask on the highest Byte of a Word variable.
Example:
Variable: 0010010101101011
Mask: 1111111100000000
Result: 0010010100000000
• Syntax
Result=HiByte(Var)
• Argument
Var :Word (16 bits)
Result :Byte or Word
1.14.6. LOWORD
Mask on the lowest Word of a DWord variable.
Example:
Variable: 00100101011010110010001100111101
Mask: 00000000000000001111111111111111
Result: 00000000000000000010001100111101
• Syntax
Result=LoWord(Var)
• Argument
Var :DWord (32 bits)
Result :Word
• Syntax
Result=HiWord(Var)
• Argument
Var :DWord (32 bits)
Result :Word
• Example
HighestWord=HiWord(Long)
1.14.8. SWAPBYTES
Invert the bytes of a Word variable.
Example: inversion
Variable: 01111100 11000011
Result: 11000011 01111100
• Syntax
Result=SwapBytes(Var)
• Argument
Var :Word
Result :Word
1.14.9. SHL
Shift to the left of x bits (without roll over).
Example: Shift left of 4
Variable: 00001111 00011000
Result: 11110001 10000000
• Syntax
Result=SHL(Var,shift)
• Argument
Var :Word or DWord use the same format for Var and Result
Shift :Word or Constant
Result :Word or Dword
• Syntax
Result=SHR(Var,shift)
1.14.11. Bit
This function allows reading a bit in an analog register. The bit number starts at ‘bit0’ (lsb).
Example:
… 0 1 1 0 1 0 1 1
bit # .. 7 6 5 4 3 2 1 0
.
• Syntax
Result=Bit(Register, BitNumber)
• Argument
Result :Bool
Register :Word, DWord
BitNumber :Constant, Byte, Word, DWord
• Example
If bit(PumpList,4) then
Lamp4=1
endif
1.14.12. SetBit
This function allows forcing a bit in an analog register. The bit number starts at ‘0’ (lsb)
• Syntax
SetBit(Register, BitNumber, Value)
• Argument
Register :Word, DWord
BitNumber :Constant, Byte, Word, DWord
Value :Bool
• Example
'Inversion of bit 8.
Setbit(Register,8,not bit(Register,8))
• Syntax
Byte_register = PackBits8(Value)
Word_register = PackBits16(Value)
DWord_register = PackBits32(Value)
• Argument
Register : depending of the function it is a Byte, Word, or DWord
Value : it is the ModBus address of the first bit. The value at this address becomes the
lsb of the analog register
• Example
'Putting Digital DIR_0 to DIR_15 to register ANA_16
'ModBus address of DIR_0 = 20480
ANA_16 = PackBits16(20480)
DIR_0 0 1 1 1
DIR_1 0 1 0 1
DIR_2 0 1 0 1
DIR_3 0 1 0 1
DIR_4 0 1 0 1
DIR_5 0 1 0 1
DIR_6 0 1 0 1
DIR_7 0 1 0 1
DIR_8 1 0 0 1
DIR_9 0 0 0 1
DIR_10 0 0 0 1
DIR_11 0 0 0 1
DIR_12 0 0 0 1
DIR_13 0 0 0 1
DIR_14 0 0 0 1
DIR_15 0 0 1 1
SplitBits8: extract the 8 bits of a Byte to 8 successive ModBus addresses of digital Tags.
SplitBits16: extract the 16 bits of a Word to 16 successive ModBus addresses of digital
Tags.
SplitBits32: extract the 32 bits of a DWord to 32 successive ModBus addresses of digital
Tags.
• Syntax
SplitBits8(Byte_register, Value)
SplitBits16(Word_Register, Value)
SplitBits32(DWord_Register, Value)
• Argument
Register : depending of the function it is a Byte, Word, or DWord
Value : it is the ModBus address of the first bit. The value at this address
corresponds to the lsb of the analog register
• Example
'Extracting bits of ANA_16 to DIR_0 ... DIR_15
'ModBus address of DIR_0 = 20480
SplitBits16(ANA_16,20480)
DIR_0 0 1 1 1
DIR_1 0 1 0 1
DIR_2 0 1 0 1
DIR_3 0 1 0 1
DIR_4 0 1 0 1
DIR_5 0 1 0 1
DIR_6 0 1 0 1
DIR_7 0 1 0 1
DIR_8 1 0 0 1
DIR_9 0 0 0 1
DIR_10 0 0 0 1
DIR_11 0 0 0 1
DIR_12 0 0 0 1
DIR_13 0 0 0 1
DIR_14 0 0 0 1
DIR_15 0 0 1 1
This can be useful if you have to transfer 32 bits register, using a unique transaction including
16 bits and 32 bits registers. The 32 bits registers will be seen as 2 x 16 bits registers.
• Syntax
Split32(32bitsReg, Hword, Lword)
• Arguments
32bitsReg : Register to split into 2 Words (DWord or Float)
Hword : High 16 bits of the 32 bits register (Word)
Lword : Low 16 bits of the 32 bits register (Word)
• Example
'Converting the Floating register Temperature to TempHigh and TempLow
1.14.16. Pack32
This function converts two 16 bits registers into one 32 bits register.
• Syntax
Pack32(32bitsReg, Hword, Lword)
• Arguments
32bitsReg : Register receiving the 2 Words following (DWord or Float)
Hword : High 16 bits of the 32 bits register (Word)
Lword : Low 16 bits of the 32 bits register (Word)
• Example
'Converting the Temperature consisting of 2 Words
1.14.17. TriggerPos
It informs on the transition '0' to '1' of a digital Tag.
• Syntax
X = TriggerPos(expression)
X = 1 at changing of the expression (FALSE to TRUE) during one cycle of the program.
• Argument
X :Bool
Expression :any expression composed of Bool, Byte, Word, Long
• Examples
'To Set an Output when pressing a start button
if TriggerPos(Start) then
Output=1
endif
1.14.18. TriggerNeg
It informs on the transition '1' to '0' of a digital Tag.
• Syntax
X = TriggerNeg(expression)
X = 1 at changing of the expression (TRUE to FALSE) during one cycle of the program.
• Argument
X : Bool
Expression : any expression composed of Bool, Byte, Word, Long
• Example
'To Reset an Output when pressing a Stop button
if TriggerNeg(Stop) then
Output=0
endif
• Syntax
PutChrono(variable)
• Argument
variable : Tag to insert into the chronology
digital Tag (Bool) writing to Digital chronology
analog Tag (Byte, Word, Long, Single) writing to Analog chronology
• Examples
if Button=1 then
PutChrono (Button)
PutChrono (Level)
PutChrono (Temperature)
Endif
1.14.20. Truncate
This function extracts the whole number from a Tag in Single format.
• Syntax
Long_register=Truncate(Single_register)
• Argument
Long_register : Long
Single_register : Single
• Examples
Whole_value = Truncate(Floating_reg)
1.14.21. Odd
This function indicates whether an analog Tag is ODD or EVEN.
• Syntax
Bool_register=odd(analog_register)
• Argument
Bool_register : Bool
analog_register : Byte, Word, Long, Single
• Examples
Output=odd(Analog)
• Syntax
Word_output=bcd(Word_input)
• Arguments
Word_output : Word
Word_input : Word
• Examples
Output=bcd(Word)
decimal: 4660
binary: 0001 0010 0011 0100
BCD 1234
• Syntax
tablesize(index) to check the size of a table
samplebyte(index,offset) to access data of a Tag in Byte format
sampleword(index,offset) to access data of a Tag in Word format
sampledword(index,offset) to access data of a Tag in 32 bits format
samplesingle(index,offset) to access data of a Tag in Float format
• Arguments
index: index of the sampling table (see list of sampling tables)
offset: sample you want to access. Offset=0 means the last sample
• Examples
Imagine you want to calculate the arithmetic average of a value based on a period of 15
minutes. You could do it using Ladder or BASIC. But you can make it much more easily using
a sampling table and one of those functions.
You then use the function appropriate to the format of the Tag as follows:
Average=sampleword(1,0)
To prevent it, we have implemented Type Casting functions that make you be sure of the
type used in the Functions.
• Syntax
CBool(Var) Type casting to Boolean format
CByte(Var) Type casting to Byte format
CDWord(Var) Type casting to DWord format
CInt(Var) Type casting to Integer format
CLng(Var) Type casting to Long format
CSng(Var) Type casting to Single (Float) format
CWord(Var) Type casting to Word format
• Examples
To avoid this situation, we have implemented a dedicated function to retrieve time using an
atomic operation (all operations without interruption)
• Syntax
GetRtuTime(MyHour, MyMinute, MySecond)
GetRtuDate(MyDay, MyMonth, MyYear)
• Arguments
Myxxx: Byte, Word (internal variables)
• Example
Text Functions can be used in any type of POU (Program, FB or F) and when used in FB or F,
'Text' arguments are supported in BASIC as well as in Ladder.
if (T1 < T2) returns true if T1 is lesser than T2., otherwise false
Comparison stops at the first difference between characters
if (T1 > T2) returns true if T1 is greater than T2, otherwise false.
Comparison stops at the first difference between characters
T1 = T2 Copies T2 to T1.
To copy a text directly to T1, use the double quotes.
Example: T1="ABCDEF"
T3 = Cat(T1, T2) Concatenates T1 and T2 into T3.
n = CBool (T) returns a BOOLEAN corresponding to the number found at the start of T
n = CByte (T) returns a BYTE corresponding to the number found at the start of T
n = CInt (T) returns an INTEGER corresponding to the number found at the start of T
n = CWord (T) returns a WORD corresponding to the number found at the start of T
n = CLng (T) returns a LONG corresponding to the number found at the start of T
n = CDWord (T) returns a DWORD corresponding to the number found at the start of T
n = CSng (T) returns a SINGLE corresponding to the number found at the start of T
T = CStr (n) creates a Text Tag T corresponding to the given number n. Type is implicit
and corresponds to the one of the Tag or constant n.
• Arguments
Pointer : Word register containing the ModBus address of the variables.
Digital : Boolean variable to receive the status at the address of 'Pointer'.
Analog16 : Analog variable to receive the value at the address of 'Pointer'.
FLOAT : We advise to use a type of variable equivalent to the one of
Analog32 :
the address read (Float when addressing a Float, Long when
addressing a Long, ...).
• Arguments
Pointer :Word register or Expression containing the ModBus address of the variables.
State :Value (0 or 1) to write in the address of 'Pointer'
Value :Value or Expression to write in the address of 'Pointer'
• Syntax
Pointer=AdrOf(Tag)
Working with Function or Function Block, if you need the ModBus address of an input
argument, you will have first to extract it using BASIC Function Adrof(Tag) (see above).
Working with the former TBox (CPU-3), the ModBus address of the argument is passed
to the Function or Function block.
Working with TBOX MS or TBOX LITE, the value of the Tag is passed to the Function or
Function block (in fact, the argument is copied into an intermediate variable. Then the link
with the real Tag is lost).
1.18. GOTO
• Label
A label can be defined anywhere in a program as follows:
Alarms:
Pumps:
The colon " : " indicates it is a label. The name of a label must use the following rules:
characters accepted are letters, numbers and underscore.
the name cannot start with a number.
the maximum length is 15 characters.
BASIC is not case sensitive.
To avoid confusion, do not use keywords (see chapter 1.18) or Tag names.
• Syntax
Goto Label
% (modulo) LoByte
_ (underscore = break line) Log
Long
Abs LoWord
AdrOf Ln
And
ArcCosine Mid
ArcSine
ArcTangent Next
As Not
Bcd Odd
Bit Or
Byte
PackBit
Call PeekBool
Cat PeekFloat
CBool PeekLong
CByte PeekWord
CDword Pow
CHex PutChrono
CInt
CLong Right
Cosine Rem
CountDown
CountUp Samplebyte
CountRing Sampleword
CountReset Sampledword
CSng Samplesingle
CStr SetBit
CWord Shl
Dec Shr
Dim Sine
DWord Single
SplitBit
Else Sqrt
Elseif Step
Endif SwapByte
Exp
Tablesize
For Tan
Then
GetRTUTime TimerSS
GetRTUDate TimerMS
Goto TimerIN
TimerOD
HiByte TimerReset
HiWord To
Integer TriggerNeg
TriggerPos
If Truncate
Inc
InStr Xor
LCase UCase
Len
Left Wend
Let While
Word
Programs give you the possibility to divide your project into several sub-
programs (pump management, alarms, intrusion, ...)
Each sub-program is POU Program.
Functions give you the possibility to create your own function.
It is a piece of program leading to one result. Useful when there
are repetitive calculations.
Function Blocks give you the possibility to create your own 'applet' or procedure
(starting a pump, regulating temperature).
It is a piece of program composed of input and output arguments.
Useful when the same process is applied to different sets of I/O
(eg. Management of a pump in an application handling 4 pumps).
A Program can call another Program that can call another Program etc...
If you use Programs that call other Programs, be careful to avoid loops: Programs 1 calling
Program 2 calling Program 3 that calls Program 1.
The program ‘Main’ supports LADDER or BASIC language. The language can be changed,
provided that the Program is empty.
Right click ‘main’, select ‘Properties’ and choose a language.
Double click 'Add a POU', type a Name (No accent, space or keywords (see chapter
1.18)) and check the type 'Program'.
Click OK.
When you double click the name of the Program in the list, the window for BASIC edition
appears with a new Tab for the current program.
• Syntax
To call a Program, use the syntax:
call Alarms 'Alarms is the name of the POU Program
Double click 'Add a POU', type a Name (No accent, space or keywords (see chapter
1.18)) and check the type 'Function'.
Select the type of the output (result of the calculation): BOOL, WORD, LONG or FLOAT.
Click OK.
Example of Function
The following Function is an analog Function (it means the output is analog). It performs
the percentage of an input value.
• The Tags
When creating a Function, TWinSoft automatically creates the 'Output' Tag. It is the unique
Output allowed.
'Inputs' and 'Outputs' of the Function are the arguments that will be replaced when calling
the Function (see next).
You create then the 'Inputs', corresponding to the arguments of the Function.
Be careful with the 'type' associated to the arguments.
If you need 'local' Tags, you can create them from the list, or using the DIM statement.
The way a POU Function works, involves that one can define only local Tags in a POU
Function.
Percent: the output of the Function. It is unique and is the result of the
calculation.
MAX, MIN, VAL: are the Inputs of the Function.
Delta, scale: local analog Tags used as temporary variables necessary to calculate the
percentage.
• Syntax
Result=Function(Arg1, Arg2, Arg3, ...)
• Arguments
Result the Tag receiving the result of the Function
Function the name of the Function
Arg the input arguments (Tags or constant)
The Arguments have to be entered in the order they have been
created in the list of Tags of the Function.
Example:
Arg1 = Input
Arg2 = MIN
Arg3 = MAX
....
Example
'Call of Function: output=Percent(max,min,input)
AIR0 = Percent(maximum, minimum, ana_0)
eg.: The TBox needs to handle 4 identical pumps. No need to copy the same program 4
times.
You call a Function Block from a Program every time you need to execute the process and
you assign Tags to it.
We advise you against using Functions in a Function Block. In fact, a Function exists
only once and uses always the same internal variables when it is called.
A Function Block uses new Tags (local and global) every time it is called from a Program.
Double click 'Add a POU', type a Name (No accent, space or keywords (see chapter
1.18)) and check 'Function Block'.
Click OK.
You have created a Function Block and it appears in the 'Programs' folder.
This Function Block implementation describes the inputs and outputs involved in the
management of the delay. It also specifies how the dcelay is applied to the ouput.
It does not specify which Tags are physically connected to the ‘delay’: this is the job of the
FB calling in a program (see below).
• The Tags
Inputs and Outputs of a Function Block are the arguments to be replaced when calling the
Function Block.
You create then the 'Inputs' and 'Outputs' in the list of POU Tags of the Function Block.
If you need 'local' Tags, you can create them from the list, or using the DIM statement.
INPUT is a digital input that will activate the OUTPUT after the DELAY.
• The programming
You use standard BASIC language for programming.
Example of Instantiation:
• Arguments
Instance the name given to the local Tag used as Instantiation
Arg the input arguments (Tags or constant)
The Arguments have to be entered in the order they have
been created in the list of Tags of the Function Block
Example
'The function block [Start_w_Delay] activates an output after a entered
'delay in seconds; Arguments: (Input,Delay,Output).
call Motor1(DI_4, 6, DO_3, COUNT)
To see an example, load the TWinSoft document 'MSLadder.tws' that you find in the
'Samples' directory of TWinSoft.
2.2.1. Inputs
All inputs, whether digital or analog, can be combined to create logical equations:
<AND> using several inputs on the same line
<OR> using several inputs one above each other.
All analog comparison functions and/or digital inputs on the same program line will represent
true or false. The result defines the actions of the output (will or will not be performed).
The different types of Input conditions are accessible in the LD Toolbar.
2.2.2. Outputs
Digital output functions are engagements (SET relay) or disengagement (RESET relay), they
can be the image or the opposite of the result of the tested input conditions (OUTPUT relay
and NEGATIVE relay). Other functions have been introduced proper to telemetry like
transmission of alarms, data logging, … To process analog variables, many mathematical
functions and POU (Program Organization Units ) functions have been implemented, but
you might find easier to use BASIC for making calculation (see chapter 1: BASIC )
The selection of different types of Output is accessible in the LD Toolbar.
Example of Ladder
The first is display mode, which allows you to see the entire program, one page at a time.
It is in this mode that you can see the state or the value of variables in real time.
The second mode is edit mode, which allows inserting a new line anywhere in the Ladder,
at the beginning, at the end or between two existing lines. This mode also allows modifying
an existing line.
To see an example program, open the TWinSoft document ‘MSLadder.tws’ from the directory
‘Samples’ of TWinSoft.
The Ladder diagram is drawn in red lines with the Tags associated at each input contact,
output relay or IN/OUT of functions.
When a jump (JUMP) is programmed, the jump’s mnemonic appears at the right side of a
double arrow. The mnemonic is a LABEL that appears in black text.
A call to another program appears in a red block with one IN/OUT line.
The state of the Boolean objects (input contacts, analog comparison, output relays) is
displayed as a green overlay if the condition represented by the contact is true (in the case
of a trigger input contact, the result represents the current state of the Tag.
When moving the cursor on analog Tags in Functions or Math blocks, the current value is
displayed in the bottom left corner of the screen. For digital Tags the display indicates
<On> or <Off> according to the current value.
The Ladder diagram is made of several lines that are numbered starting at 1. Only one line at a
time can be edited with only one rung (a rung is a set of Input conditions connected to only
one set of Outputs). When editing is finished, the line must be compiled to proceed with the
next one:
To save and compile a line. If an error occurs, a dialog box informs you on the
error. The key <+> can also be used to save and compile a line.
If you were editing an existing line, you return to display mode.
If you were inserting a new line, you stay in edit mode.
To quit editing and discard changes. The key <ESC> can also be used.
To select any item (line, contact, relays or Functions) of a Ladder line. Once
selected it can be edited by a double click to replace Tags. You can also erase the
selected item by pressing the key <Delete> or insert a new contact, relay or
Function by selecting the proper icon in the LD Toolbar.
To Save and Compile a line. If an error occurs, a dialog box informs you of the
error. The key <+ >can also be used to save and compile a line.
To Quit editing and discard changes. The key <ESC> can also be used.
To insert a Normal input contact for digital input. The condition will be true if
the input is active.
To insert an Invert input contact for digital input. The condition will be true if
the input is inactive.
To insert a Positive input trigger for digital input. The condition will be true only
once when the input passes from an inactive level to an active level.
To insert a Negative input trigger for digital input. The condition will be true
only once when the input passes from an active level to an inactive level.
To insert a Digital output normal. Output is activated if the results of the input
condition(s) are true.
To insert a Digital output inverted. Output is activated if the results of the input
condition(s) are false.
To insert a Digital output set. Output is set and memorized if the result of the
input condition(s) are true; this type of output is typically used with a 'trigger'
input
To insert a Digital output reset. Output is reset and memorized if the result of
the input condition(s) are true; this type of output is typically used with a 'trigger'
input
Initiates a Jump to the line whose label corresponds to the one that is entered
here (to enter a label, see above in the list of icons of 'Display mode').
Local Tags are only used in the POU where they have been created.
They appear in the list of Local Tags, above the Ladder diagram of the POU (see next).
Global Tags can be used in any POU Program and Function Block (see next).
In the LD Toolbar click - - to insert a new Ladder Line. In the window of Ladder
programming, a rectangle appears with a line number. Only one line at a time can be
edited with only one rung (a rung is a set of Input conditions connected to only one set of
Outputs). The grid shows you the places where you can place contacts, relays and
functions.
The Ladder is executed from left to right and from top to bottom.
Each input is read before executing the Program and the value stored to be used all along
the Program.
In the same way, each output is saved and executed only at the end on the Program.
Be careful when using an output at different places in the Program, unless you do
SET and RESET. To help you, check the Cross reference of the Tags.
According to the item you wish to use, select the proper icon in the Toolbar.
You type its name and press <ENTER> to create it. The Tag can be
The Tag does not exist
either Local Tag or Global Tag (see previous chapter ‘Variables’).
Suppose we are controlling a Reservoir LEVEL. When it reaches the value 150, we start the
PUMP to remove water. At the same time, we start a Timer INTEGRAL that memorizes the
number of minutes the pump has been working.
The PUMP can also be started manually.
When 100 hours are reached (360000 seconds), the status of the timer changes to 1 and
activates the output MAINTENANCE.
We use the following Tags (see TBOX MS or TBOX LITE manual chapter: Tags ):
Level analog input (Float)
Manual digital input.
Pump digital output.
Timer_Status digital internal variable associated to the timer ‘Qty_minutes’
Maintenance digital output.
Reset digital input.
3. Click the icon to insert the function A>B and then click next to the left Rail.
4. Enter the Tag LEVEL or select it from the list of Tags and then enter the constant 150.
5. Click the icon to insert a digital contact, then click below the comparison Function
close to the left rail.
7. Click the icon and draw a horizontal and vertical line to join the output of the
comparison Function.
8. Click the icon to insert an output relay, then click on the output of the comparison
Function. A horizontal line including the relay is automatically drawn to the right rail.
11. Type the name of the Timer (instance name), or if it exists, you can browse it from the
button
12. Type the Preset of 360000 (= 100 hours). Preset is always expressed in seconds.
13. Click the icon and draw a horizontal and vertical line to join the timer Function to
the right rail and to the output of the comparison Function.
14. Press the key <+>, or click the icon to compile the line. Doing this, the edition block
is ready to create the third line.
17. Click the icon to insert a SET output relay, then click next to the right side of the
contact TIMER_STATUS. A horizontal line including the relay is automatically drawn to the
right rail.
18. Enter the Tag MAINTENANCE or select it from the list of Tags.
19. Press the key <+>, or click the icon to compile the line. Doing this, the edition block
is ready to create the fourth line.
21. Enter the Tag RESET or select it from the list of Tags.
22. Click the icon to insert the reset timer Function, then click next to the contact
RESET.
23. Type the name of the Timer or select it from using the browse button .
24. Click the icon and then click the reset timer Function; drag it one step to the right.
25. Click the icon and draw a horizontal line between the RESET contact and the reset
timer Function.
26. Click the icon to insert a output relay associated to the Tag MAINTENANCE, then click
under the reset timer Function. A horizontal line is automatically drawn to the right rail.
27. Enter the Tag MAINTENANCE or select it from the list of Tags.
28. Click the icon and draw a horizontal and vertical line to join the input contact to
the output relay MAINTENANCE.
29. Press the key <+>, or click the icon to compile the line. Doing this, the edition block
is ready to create the next line.
That’s it !
- EN: Enable Input: Connection to the Ladder line. EN must be TRUE to perform
the Function.
- ENO: Enable Output: it is the image of EN. If EN is TRUE, ENO is TRUE. It can
be connected to a contact or a relay, a Mathematical block or another
Function.
To insert a Function, in the edit mode of Ladder Programming, click the icon of the LD
Toolbar.
The output is TRUE when the input values fit with the comparison, otherwise it is FALSE.
The output can be connected to a relay, a Math Block, another Function or a POU. The
parameters are:
- EN: Connection to the Ladder line. EN must be TRUE to perform the Function.
- A, B: Inputs : analog Tags (Byte, Word, Long or Float) or constant.
- OUT: Digital Output of the Function: TRUE when A & B fit with the Function
selected and EN is TRUE.
It can be connected to a relay, a function or a mathematical block
Q = A: the Tag 'anaOUT' contains a copy of the value of the Tag anaIN'
Q = -A: the Tag 'anaOUT' contains the inverse value of the Tag 'anaIN'
The Tag 'anaOUT' is the addition of the Tags 'ana0' and 'ana1'
The Tag 'anaOUT' is the subtraction of the Tags 'ana0' and 'ana1'
The Tag 'anaOUT' is the multiplication of the Tags 'ana0' and 'ana1'
The Tag 'anaOUT' is the division of the Tags 'ana0' and 'ana1'
The Tag 'anaOUT' is the rest after the division of the Tags 'ana0' and
'ana1'.
Example: 2 = 17 MOD 3
'anaOUT' is the result of the logical AND between 'ana0' and 'ana1'
Example: 0001000011111111
AND 0001100000001111
0001000000001111
'anaOUT' is the result of the logical XOR between 'ana0' and 'ana1'
Example: 0000000011111111
XOR 1111000000001111
1111000011110000
The status of the bit of the analog Tag 'ana0' indicated by the
Index will be copied in the digital Tag 'digOUT'.
Example: ana0: 1100101000010010
Index: 5
dig0: 0
'anaOUT' has the number of 'Bit' shift to the left (max. 15) of the
Word analog Tag 'ana0'
(without wraparound).
'anaOUT' has the number of 'Bit' shift to the right (max. 15) of the
Word analog Tag 'ana0'
(without wraparound).
'anaOUT' has the number of 'Bit' shift to the left (max. 7) of the Byte
analog Tag 'ana0'
(with wraparound).
'anaOUT' has the number of 'Bit' shift to the right (max. 7) of the
Byte analog Tag 'ana0'
(with wraparound).
'anaOUT' has the number of 'Bit' shift to the left (max. 15) of the
Word analog Tag 'ana0'
(with wraparound).
'anaOUT' has the number of 'Bit' shift to the right (max. 15) of the
Word analog Tag 'ana0'
(with wraparound).
To insert a Math block, in the edit mode of Ladder Programming, click the icon of the
LD Toolbar.
2.10.1. Introduction
There are 7 categories of mathematical functions available (to use in math blocks):
• Assignments
• Arithmetic operations.
• Comparisons.
• Bit manipulations.
• Boolean Operations.
• Conversion + Indirect addressing.
• Miscellaneous.
In the functions, the Arguments to be replaced by Tags (or constants) are represented as
follows:
An assignment operation is always executed from the right to the left. In other words, we
have: result = operation
or: output = input (meaning the value of Input variable is copied in the
Output variable).
To insert a 'Math function' between 2 existing functions in a Math block, edit the line,
place the cursor at the position you want to insert the function, and press the key <Insert>
of keyboard.
2.10.3. Assignments
A = B 'A' contains a copy of the value of 'B'
A = -B 'A' contains the inverse value of 'B'
A = Low(B) If B is a WORD: 'A' contains a copy of the 8 lowest bits of 'B'
If B is a LONG: 'A' contains a copy of the 16 lowest bits of 'B'
A = High(B) If B is a WORD: 'A' contains a copy of the 8 highest bits of 'B'
If B is a LONG: 'A' contains a copy of the 16 highest bits of 'B
A = Abs (B) 'A' contains a copy of the absolute value of 'B'
A = Swap(B) 'A' contains the inversion of the 8 highest bits and the 8 lowest bits
of 'B'
Examples: B = 256 (00000001 00000000)
A=1 (00000000 00000001)
inc (A) increase the value of Tag 'A' by 1 unit
dec (A) decrease the value of Tag 'A' by 1 unit
When doing logical operations, check you don’t work with Float
variable.
There is no linear sequence in the binary format of Float register,
like with Word or Long.
bit (A,BitNb) = BOOL The status of digital 'BOOL' will be copied in the analog 'A' at the
position indicated by 'BitNb', starting with ' 0 ' for Lsb.
Example: Bit: 1
BitNb: 3
A: 0011010011001001
BOOL = bit( A,BitNb) The status of the bit of the analog 'A' indicated by 'BitNb' will be
copied in the digital 'BOOL', starting with ' 0 ' for Lsb.
Example: A: 1100101000010010
BitNb: 5
Bit: 0
A = shl(B,shift) 'A' has the number of Bits indicated by 'shift' shift to the left
(max. 15) of the Word 'B'
(without wraparound).
Example: B: 0000000011111111
Shift: 4
A: 0000111111110000
A = shr(B,shift) 'A' has the number of Bits indicated by 'shift' shift to the right
(max. 15) of the Word 'B'
(without wraparound).
Example: B: 0000000011111111
Shift: 4
A: 0000000000001111
A = rol byte(B,shift) 'A' has the number of Bits indicated by 'shift' shift to the left
(max. 7) of the Byte 'B'
(with wraparound).
A = ror byte(B,shift) 'A' has the number of Bits indicated by 'shift' shift to the right
(max. 7) of the Byte 'B'
(with wraparound).
16 x (BOOL) = A places the 16 bits of the Word 'A' in the 16 digital variables of
successive addresses, starting with the digital Tag 'BOOL'.
Example:
to SET or RESET 16 DO of an extension card using an analog variable.
A = FloatToInt (Flt * 10 E Const) conversion from the Float 'Flt' to the Integer 'A' ,
with a possible scaling from 10E-4 to 10E+4. The
exponent must be a constant:'Const'.
Flt = IntToFloat (A) * 10 E Const conversion from the Integer 'A' to the Float 'Flt',
with a possible scaling from 10E-4 to 10E+4. The
exponent must be a constant:'Const'.
BOOL = indirect (Ptr) the Tag or Constant 'Ptr' contains the ModBus address of the digital
variable that will have its status assigned to the digital Tag 'BOOL'.
Example:
to read the status of an output 'Q0' having ‘32’ as ModBus address:
DIV0 = indirect (Pointer). (Pointer = 32)
Indirect (Ptr) = BOOL the status of the digital Tag 'BOOL' will be copied in the digital variable
whose ModBus address is defined in the Tag or Constant 'Ptr'.
Example:
to write the status of DIV0 to the output 'Q2' having ‘34’ as ModBus
address:
Indirect (Pointer) = DIV0. (Pointer = 34)
2.10.9. Miscellaneous
Adr = Tag (Tag) Gives you the ModBus address of the ‘Tag’.
Number between 1 and 65535 (see note below)
put Bit in dig chrono Writing of the digital Tag 'Bit' in the Digital Chronology.
put A in ana chrono Writing of the analog Tag 'A' in the Analog Chronology.
Working with Function or Function Block, if you need the ModBus address of an input
argument, you will have first to extract it using Math. Function Adr = Tag(Tag) (see above).
Working with the former TBox (CPU-3), the ModBus address of the argument is passed to the
Function or Function block.
Working with TBOX MS or TBOX LITE, the value of the Tag is passed to the Function or
Function block (in fact, the argument is copied into an intermediate variable. Then the link with
the real Tag is lost).
Three types of POU are available, all of which use the same Ladder programming tools and
BASIC instructions:
List of POU
POU program: sub-program that is called in the ‘Main’ program or any other POU program.
POU function: standard functions (comparison, math. Functions, timers,...) or user defined
functions.
POU function block: user defined small 'applet' that performs a function (start of a pump,
regulating temperature...)
A POU program can call another POU Program that can call another POU Program etc...
If you use POU Programs that call other POU Programs, be careful to avoid loops: like
Program 1 calling Program 2 calling Program 3 that calls Program 1.
The program ‘Main’ supports LADDER or BASIC language. It can be changed at the
condition the program is empty.
Right click ‘main’, select ‘Properties’ and choose a language.
Click OK.
You have created a POU Program and it appears in the 'Programs' folder.
When you double click the name of the Program in the list, the window for Ladder
programming appears with a new Tab for the current Program.
Now you can create a Ladder Diagram for the Program you have defined.
- EN: Enable Input: Connection to the Ladder line. EN must be TRUE to run the
Program. If it is connected directly to the left rail, it will be executed at each
cycle of the Ladder, otherwise it can be connected to an input condition.
Calling a POU Program is like calling a sub-routine. The program associated to it is executed
at the position where it is called.
Example:
You need regularly to execute the calculation: y= [(a+b) * (c+d)] /2.
You will not find this formula in the Standard Functions or in the Mathematical Function
block. You will then create your own Function that will execute your calculation every time
you call it.
Select the type of the output (result of the calculation): BOOL , WORD, LONG or FLOAT.
Click OK.
You have created a POU Function and it appears in the 'Programs' folder.
When you double click the name of the Function in the list, the window for Ladder
programming appears with a new Tab for the current Function.
Now you can create Ladder Diagram for the Function you have defined.
The Tags :
When creating a Function, TWinSoft automatically creates the 'Output' Tag. It is the unique
Output allowed.
Inputs and the Output of a Function are the arguments to be replaced when calling the
Function.
The way a POU Function works, involves that one can define only local Tags in a POU
Function.
Percent: the output of the Function. It is unique and is the result of the
calculation.
MAX, MIN, VAL: are the Inputs of the Function.
Delta, scale: local analog Tags used as temporary variables necessary to calculate the
percentage.
The Ladder :
- EN: Enable Input: Connection to the Ladder line. EN must be TRUE to perform the
Function. If it is connected directly to the left rail, it will execute at each cycle
of the Ladder, otherwise it can be connected to an input condition.
When calling the Function in a POU Program, you must assign a Tag to the (unique)
Output, and a Tag or constant to each input.
All inputs are at the left side of the Function; the output at the right side.
In this example, we wish to have the percentage of input ‘ANA_0’ in the range between 0
and 500.
When starting TWinSoft the first time, the only one is the POU Program 'main'.
Double click 'Add a POU', type a Name (No accent, space or keywords (see BASIC))
and check 'Function Block'.
Click OK.
You have created a POU Function Block and it appears in the 'Programs' folder.
Now you create Ladder Diagram for the Function Block you have defined.
The Tags:
Inputs and Outputs of a Function Block are the arguments to be replaced when calling the
Function Block.
INPUT is a digital input that will activate the OUTPUT after the DELAY.
The Ladder :
The DELAY is copied in the preset of the timer and multiplied by 1000 (the timer
preset is expressed in milliseconds).
When INPUT changes to 1, it starts the timer Single Shot
Note: when working with an external Preset (the local variable 'Timer_preset'), the
Preset of the timer can be set to any value; it is not used. Here = 0
When the timer has finished counting AND INPUT is still active, the output is set.
A negative edge on INPUT resets the OUTPUT.
- EN: Enable Input: Connection to the Ladder line. EN must be TRUE to perform the
Function Block. If it is connected directly to the left rail, it will execute at each
cycle of the Ladder, otherwise it can be connected to an input condition.
- ENO: Enable Output: it is the image of EN. If EN is TRUE, ENO is TRUE. It is usually
connected to the right rail but can be also connected to a contact or a relay, a
Mathematical block or another Function.
When Calling the Function Block in a POU Program, you are asked to enter an 'FB Instance
name' (in this example ‘Motor1’).
This name allows TWinSoft to distinguish between Function Blocks, when multiple calls of
similar Function Blocks are defined.
Afterwards you must assign to the Output(s) and Input(s) Tags or constant. All inputs are at
the left side of the Function Block, all outputs at the right side.
In this example, the FB is called ‘Motor1’, the input ‘D0’ activate the output ‘Q2’ with a delay
of 5 seconds.
Each call of Function Block is unique and different from each other; local Tags of the
Function Block as well as timer and counter, will be assigned to free registers,
timers and counters when compiling.
IMPORTANT:
1. The document must have been sent to TBox with the last changes
2. If TWinSoft is opened after the document has been sent, the document must be
compiled, to allow TWinSoft assigning registers to the local Tags.
3. The complete path from the Program 'main' must be followed to access the FB.
Example: 'Main' -> 'Motors' -> FB 'Motor1'.
To debug the FB, while in 'Visualization mode', double click the call of the FB from the POU
program in which it is used:
The source code (Ladder) of the FB is then opened and dynamized according to its instance.
In the list of POU Tags, the column 'Value' displays values of each local Tag.
3.1. Presentation
Timers are used for counting a time, a delay.
The mechanism of both functions is similar, the way they are used and the variable
associated.
The difference is that when a timer has been launched, it runs on its own until a defined
preset of time when a counter increments every time it receives a pulse.
The way of using timer in Ladder is discussed in chapter 3.5 and in BASIC chapter 3.6.
Each model is presented with a diagram in chapters 3.8, 3.9, 3.10 and 3.11
For each timer (regardless of type), there are two analog variables and one digital variable
associated with it:
These three variables can be assigned as Tags and used in the BASIC or Ladder diagram
(example: an automatic modification of a process at timed intervals).
To see an example of using Timers, load the document 'MSTimer.tws' that you find in the
sub-directory of TWinSoft 'Samples'.
Those variables are standard internal variables, with a free name. Once created in the
list of Tags they can be associated to a timer.
Probably status will need to be created, as it will be required to control the timer: timer
still running or period elapsed.
Preset and Value are optional and only required if they need to be monitored from the
process or from external software.
When Tags are available, the current values appear in the list of Timers:
Once you have selected the type of timer, it appears in the Ladder line.
Example: Fan1
Dynamic Preset
If you want to work with a dynamic preset, you will use a Tag (format DWord 32 bits)
associated to the Preset (see chapter 3.4. above).
You still have to indicate a constant here, it will not be used but is mandatory when calling
the function.
If you want to clear a timer, you select the Function 'ResetTimer' associated to its name.
3.6.2. Syntax
Single Shot: TimerSS (Name, Start, Preset)
MonoStable: TimerMS (Name, Start, Preset)
Integral: TimerIN (Name, Start, Preset)
On Delay: TimerOD (Name, Start, Preset)
• Arguments
Name : It is the name of the timer you have created (see chapter 3.3. above)
Preset: INPUT. Constant giving the preset of the timer in sec. using a Floating register.
Example: 10.5 (= 10 seconds and 500 ms.)
To access other variables of a Timer (Status and Value), or to work with dynamic Preset,
you have to create Tags and associate them to the timer while creating it (see chapter 3.3.
and 3.4. above)
• Syntax
TimerReset (Name)
• Argument
Name : It is the name of the timer you have created (see chapter 3.3. above)
3.6.4. Examples
How to manage time sequences using a Timer.
Upon a given event, one needs to start the following sequence:
- 1 minute after event, execute Prog1
- 5 minutes after event, execute Prog2
- 10 minutes after event, execute Prog3
You create a Monostable Timer from the list of Timers. You name it for instance MyTimer.
You create 2 Single Shot Timers, each of them with a ‘Status’ Tag and a ‘Preset’ Tag.
You name the timers, for instance MyTimer1. and MyTimer2
TimerSS (MyTimer1,not(Status2),2.5)
TimerSS (MyTimer2,not(Status1),2.5)
Program: you use Global Timers (the ones you declare in the folder ‘Timers’)
Function: you cannot use Timer
Function Block: you use Local Timers (you declare them in the list of local Tags of the
POU)
A rising edge on the Tag INPUT starts the timer for the PRESET time period (5sec.). The
Tag STATE (which corresponds to the digital state of the timer) changes to 1 as soon as a
rising edge of the Tag INPUT appears and changes to 0 when the PRESET time expires, or
upon activation of a 'Reset Timer' Function associated with the timer.
If a new rising edge of the Tag INPUT appears before the end of the Preset time the
cycle is re-started
A rising edge on Tag INPUT starts the timer for the PRESET time period (5sec.). The Tag
STATE (which corresponds to the digital state of the timer) changes to 1 as soon as a rising
edge of the Tag INPUT appears and changes to 0 when the PRESET time expires, or upon
activation of the Timer Reset function associated with the timer.
If a new rising edge appears before the end of the PRESET time, it has no effect on the
cycle
The re-activation of the Tag INPUT allows the timer continuing and completes the cycle.
If the Tag INPUT remains at 1 for the duration of time defined in PRESET, the Tag STATE
(which reflects the digital state of the timer) changes to 1. This Tag returns to 0 as soon as
INPUT changes to 0.
If INPUT is deactivated before the end of the time cycle, the value of the timer is
reset to 0.
There is no accumulation.
4.1. Presentation
Counters are used for counting pulses
The mechanism of both functions is similar, the way they are used and the variable
associated too.
The difference is that when a timer has been launched, it runs on its own until a preset
when a counter increments every time it receives a pulse.
The way of using counter in Ladder is discussed chapter 4.5 and in BASIC chapter 4.6.
Each model is presented with a diagram in chapters 4.8, 4.9 and 4.10
For each counter (regardless of type), there are two analog variables and one digital variable
associated with it:
These three variables can be assigned as Tags and used in the BASIC or Ladder diagram
(example: an automatic process at intermediate values).
A Counter can also be created while editing a Ladder diagram, but for BASIC the Counter
must be created before it can be declared in a program.
Those variables are standard internal variables, with a free name. Once created in the
list of Tags they can be associated to a counter.
Probably Status will need to be created, as it will be required to control the counter:
maximum number of pulses reached or not.
Preset and Value are optional and only required if they need to be monitored from the
process or from external software.
When Tags are available, the current values appear in the list of Counters:
Once you have selected the type of counter, it appears in the Ladder line.
Example: Pump1_Hours
If you want to clear a counter, you select the Function 'ResetCount' associated to its name.
4.6.2. Syntax
CountUP (Name, Start, Preset)
CountDown (Name, Start, Preset)
CountRing (Name, Start, Preset)
• Arguments
Name : It is the name of the counter you have created (see chapter 4.3. above)
Start : INPUT Bool. The Tag or expression that increments the counter.
• Syntax
CountReset (Name)
• Arguments
Name : It is the name of the counter you have created (see chapter 4.3. above)
Program: you use Global Counters (the ones you declare in the folder ‘Counters’)
Function: you cannot use Counter
Function Block: you use Local Counters (you declare them in the list of local Tags of the
POU)
4.8. Counter - UP
At any given time, you can reset the counter with the help of the function CounterReset,
activated in this example by the Tag RESET.
You can pre-position the current value of the counter (using the
Ladder diagram and the variable associated to the value) if you
do not want the counting to start at zero, but at another value.
At each rising edge of the Tag PULSE, the value of the counter is decremented.
The Tag STATE (which represents the digital state) remains at 1 as long as the current value
is greater than the pre-selection.
When the current value becomes less than the pre-selection, the Tag STATE changes to 0
and the counting continues to 0.
At any given time, you can reset the counter with the help of the function ResetCount,
activated in the example by the Tag RESET.
If the Tag RESET is associated to a ‘normal contact’, the counter is blocked until the
contact opens again and releases the counter (see notes below).
A library is a file with the extension .LIB, saved by default in the directory of TWinSoft.
Export is necessary if you wish to edit a POU in the current document that has been saved in
a Library.
You open a library (‘File’ ‘Open’); the POUs appear in the top window.
You select the POU and export it (‘Edit’ ‘Export’); you repeat this operation for each POU.
The POUs are then available in the list of 'Programs', in the Project Workspace.
The ‘Available Libraries’ are the ones present in the directory of the current TWinSoft
document or in the directory of TWinSoft.
When a library appears in the list, all its POU Functions, and POU Function Blocks are
available to be used in Ladder programming: in the list of Functions, the Libraries appear as
Folders, each containing their own POUs.
To add a Library to the current TWinSoft document, select it from the list of ‘Available
Libraries’ and click ‘Add: ’.
When you have selected the library(ies) you need, click ‘Close’.
To remove a Library from the current TWinSoft document, select the Library and click
'Remove'. This operation is available only if you don’t use POU of the concerned library in the
current document.
BASIC (next)
A SplitBits, 37
square root, 30
Address of (function), 47, 83 suffix, 11
Tags, 11
B Text Functions, 44
trigger, 39
BASIC, 9 trigonometry, 28
- (subtraction), 20 Truncate, 40
* (multiplication), 20 types of variable, 14
/ (division), 21 while...wend, 27
+ (addition), 19 XOR, 23
abs, 32 Break line, 11
AND, 22
assignment, 13 C
BCD, 41
bit manipulation, 35 Case, 10
break line, 11 Colors
byte manipulation, 33 BASIC, 10
case, 10 Ladder, 65
colors, 10 Constant
comment, 12 BASIC, 10, 12
comparison, 15 in timer (BASIC), 102
constant, 12 in timer (Ladder), 101
dec, 32 type casting, 19
Dim, 14 Counters, 109
exponential, 29 Down, 116
for...next...step, 25 in BASIC, 114
for...nextcycle, 25 in Ladder, 112
functions, 31 in POU, 114
general, 10 Ring, 118
GetRtuDate, 43 Up, 115
GetRtuTime, 43 variables, 111
Goto, 47 Cycle
if...then...else…elseif, 16 sequence of tasks, 9
inc, 32 Cycle time, 11, 12, 61
indirect addressing, 46
keywords, 10, 48 I
label, 47
line feed, 10 Indirect Addressing, 46
logarithms, 29
ModBus address function, 47 K
modulo, 21
NOT, 24 Keywords, 10, 48
Odd, 40
OR, 23 L
Pack32, 38
PackBit, 36 Ladder, 59
Peek, 46 arithmetic (math.block), 79
Poke, 46 arithmetic functions, 76
POU, 49 assignement functions, 75
power, 30 assignments (math.block), 79
precautions, 12 bit manipulations (math.block), 80
putchrono, 40 Bitwise functions, 76
sampling tables, 41 boolean operations (math.block), 81
SetBit, 35 color of Tags, 65
shift, 34 comparison (math.block), 80
Split32, 38 comparison functions, 74
P U
Peek, 46 Underscore
Poke, 46 break line (BASIC), 11
POU, 49, 84
Function, 52, 88 W
Function block, 55, 92
Function block debugging, 96 Watchdog, 11
'main', 50, 85