Um String Code 2 0 e

Stringcoding
Manual with Examples
v2.0
Contents
Contents
Contents ............................................................................ 2
Definition and Options ..................................................... 4
Syntax ................................................................................ 6
3.1
Keywords ..................................................................................... 6
3.1.1
3.1.2
3.1.3
3.1.4
3.1.5
3.1.6
3.1.7
3.2
3.3
3.4
3.5
3.6
3.7
Formatting Options ..................................................................... 9

Example: Input of an Output File Name ................................... 11
Data Access to Numerical Variable as well as Time Access . 13
Example: Extended Text Analysis Functionality .................... 14
Example: Element Name Automatic Incrementing ................. 15
Example: Read in Nominal Values (Fixed Format) ................. 16
3.7.1
3.7.2
3.7.3
3.7.4
3.7.5
3.8
Access Time Data ............................................................................... 6

Access Variables................................................................................. 6
Functions of string coding ................................................................... 7
Access Part Programs Information ..................................................... 8
Access Sublot ..................................................................................... 9
Access Head Data .............................................................................. 9
Access Path Data................................................................................ 9
Read in File ....................................................................................... 16

Read Out Values ............................................................................... 17
Filter Section ..................................................................................... 17
In the Formula Calculation ................................................................ 17
Section of the Part Program .............................................................. 18
Example: Read in Nominal Values (Free Format, CSV) .......... 19
3.8.1
3.8.2
3.8.3
3.8.4
3.8.5
3.8.6
3.8.7
ASCII Files with several Lines........................................................... 19

Read in File ....................................................................................... 19
Read Out Values ............................................................................... 20
Variable into Loop Instruction and Buffer .......................................... 20
Filter a Section .................................................................................. 21
Abridge First Part .............................................................................. 22
Variable as Position .......................................................................... 23
3.9
Example: Dimensional Control via External ASCII File .......... 24

3.9.1 Repeat Mode not with all Elements ................................................... 24
3.9.2 Load Control File ............................................................................... 25
3.10 Example: Format Descriptions or Formula Collections ......... 28

3.10.1 Read in Contents as Result .............................................................. 28
3.10.2 Set in Result Then Analysis ........................................................... 28
History ............................................................................. 29
Examples of Numeric & String Variables ..................... 30
5.1
Differentiation between Numeric & String Variables .............. 30
5.1.1
5.1.2
5.1.3
5.1.4
E.g. 1 ................................................................................................. 30
E.g. 2 ................................................................................................. 30
E.g. 3 ................................................................................................. 31
E.g. 4 ................................................................................................. 31
5.2
External Input of Numeric & String Variables ......................... 32

5.2.1 E.g. 5 ................................................................................................. 32
5.2.2 E.g. 6 ................................................................................................. 33
v2.0
11.12.08
Contents
5.2.3 E.g. 7................................................................................................. 33
5.2.4 E.g. 8................................................................................................. 34
5.2.5 E.g. 9................................................................................................. 34
5.3
5.4
When to use Parentheses and Brackets ................................. 36

Formatting of Numeric Variables ............................................. 37
5.4.1 E.g. 10............................................................................................... 37

5.4.2 E.g. 11............................................................................................... 37
5.4.3 E.g. 12............................................................................................... 38
5.5
5.6
Worked Example Program Using Numeric Variables............. 38

Handling String Variables ......................................................... 40
5.6.1
5.6.2
5.6.3
5.6.4
5.6.5
5.6.6
5.6.7
5.7
11.12.08
E.g. 13............................................................................................... 40
E.g. 14............................................................................................... 40
E.g. 15............................................................................................... 40
E.g. 16............................................................................................... 41
E.g. 17............................................................................................... 42
E.g. 18............................................................................................... 42
E.g. 19............................................................................................... 42
Potential Uses ........................................................................... 46
v2.0
Definition and Options
In GEOPAK, you can insert different information of a part program in a text line.
To do so, use the @-symbol followed by the special symbol.
It is also possible to issue the value of a variable or the content of a

text variable
Furthermore, there are some formatting instructions, such as e.g.

the
determination of the total length

the number of decimal digits after the comma,
the left justification output or
The output with leading zeros.
You can use the text analysis for most of the text inputs, such as
e.g.
file identifications,
element names,
formula calculation,
text output,
proposals for input in UDL-Dialogs (since v2.1R1)
The text analysis in a formula calculation is realized before the actual

calculation.
Example:
In the formula calculation, you find

...
Var1 = @StrLen(Text)+1
First, the text analysis is executed
Var1 = 4+1
last, the calculation is performed
Var1 = 5
v2.0
11.12.08

Hint
It can be helpful to open or to keep open one or several commentary-dialogues
while learning string variables in command to have a look at the values of the
string variables (see picture below).
In addition since the v2.1.R1 stands in the command "Define Text Variable" a
complete list "Stringcoding" at disposal.
11.12.08
v2.0
Syntax
Syntax
3.1
Keywords
Keywords are not case sensitive (since v 1.5).

Since v3.1 the string coding allows white space (blank characters) between
function identifier, braces and function parameter e.g.:
Old style
New additional style
@ElementName[PT,1]
@ElementName [PT, 1]
@ElementName [ PT , 1 ]
etc.
@StrGetNum("x;y;Z",";","1")
@StrGetNum ("x;y;Z", ";", "1")

@StrGetNum ( "x;y;Z" , ";" , "1" )
etc.
3.1.1
Access Time Data
@Time:#:#:#
Actual time in the defined system format
@Date:#:#:#
Actual date in the defined system short format
@Hour:#:z
Actual hour
@Minute:#:z
Actual minute
@Second:#:z
Actual seconds
@MilliSecond:#:z
Actual milliseconds
@Year:#:z
Actual year
@Month:#:z
Actual month
@Week:#:z
Actual week
@DayOfYear:#:z
Actual day of the year
@DayOfWeek:#:z
Actual day of the week
@Day:#:z
Actual day
@TimeCode:#:#:#
Creates act. time coded string with 6 characters
@SecToTime(xxx) :#:#:#
Convert sec. value xxx in the defined system

format
3.1.2
Access Variables
@(VarName):#:#:z
@(VarName:#:#:z)
@[TxtVarName]:#:#:#
@[TxtVarName:#:#:#]
@Formula(x):#:#:z
Value of a variable
Result from text variable
@Formula(x):#:#:z
Calculation as the Formula-Calculation

function in GEOPAK
v2.0
11.12.08
Syntax
Controlled if a variable exist.
@ResVarExist("VarNam")
Return 1 if the variable exist, otherwise 0.

Controlled if a string variable exist.
@StrVarExist("VarNam")
3.1.3
Return 1 if the string variable exist,

otherwise 0.
Functions of string coding
@StrLen(Text):#:z
@StrLen(Text):#:z
@StrPos(Text,Such-Text):#:z
@StrPos(Text,SuchText):#:z
Get the length of the Text in the parenthesis
Get the position of the Search Text in the Text

or 0
@StrLeft("Text","Pos")
Returns left Side of a string (Text) up to a

position (Pos)
E.g.: Str1 = @StrLeft("Hello","3") = He
@StrRight("Text","Pos")
Returns right Side of a string (Text) up from a

position (pos)
E.g.: Str1 = @StrLeft("Hello","3") = lo
@SubStr("xxx","no1","no2")
Substitute and return a string from a position

no1 to a position no2 from string xxx.
e.g. @SubStr("Hallo","2","4") = all
@StrChg("Text","from","to")
Change the first found string (from) in a string

(Text) to a new string (to)
E.g.: Str1 = @StrChg("Hello","l","f") = Heflo
@StrChgAll("Text","from","to")
Change all found string (from) in a string (Text) to

a new string (to)
E.g.: Str1 = @StrChgAll("Hello","l","f") = Heffo
Separate and returns a string from a CSV string
(comma separated value).
E.g.:
@StrGetStr("Text","sep","num")
Str1 = @StrGetStr("Thomas;Peter;Frank",";","1")
= Thomas
= Peter
= Frank
Separate and returns a number string from a
CSV string.
E.g.:
Str1 = @StrGetNum("0.123;4.567;8.900",";","1")
@StrGetNum("Text","sep","num
= 0.123
")
Str1 = @StrGetNum("0.123;4.567;8.900",";","2")
= 4.567
Str1 = @StrGetNum("0.123;4.567;8.900",";","3")
= 8.900
11.12.08
v2.0
Syntax
Test if a file, specified by FileName, exists or
not. Returns 1 in case of existing and 0 in
case of not existing.
@FileExist("FileName")
E.g.:
Str1 =
@FileExist("C.\Cosmos\Temp\Variable.Res")
Compares two strings (case sensitive). The
return value for each of these functions indicates
the lexicographic relation of xxx to yyy.
@StrCmp("xxx","yyy")
Return < 0 => xxx less than yyy

Return 0 => xxx identical to yyy
Return > 0 => xxx greater than yyy
Compares two strings (not case sensitive). The
return value for each of these functions indicates
the lexicographic relation of xxx to yyy.
@StrICmp("xxx","yyy")
Return < 0 => xxx less than yyy

Return 0 => xxx identical to yyy
Return > 0 => xxx greater than yyy
3.1.4
Access Part Programs Information
@Partname:#:#:#
Name of actual part
@PartProgname:#:#:#
Name of actual part program
@Revision:#:z
The actual revision number
@Operator:#:#:#
Name of actual user (operator)
@OperatorLevel:#:z
The actual user (operator) right level
@RC:#:z
Repeat counter
@LC:#:z
Loop counter
@NoOfLC:#:z
The maximum number of executions of the actual

loop
@LoadedVars
Number of variables or string variables loaded at

last
@ErrNoText[x]:#:#:#
Gives back the error text which belongs to "x". "x"

can be determined e.g. by the command
"Sys.Err" from the formula calculation.
@ElementName[type,x]:#:#:#
Returns the name of an element. The requested

type must be defined by type and the number
by x. The type can be: Point "PT"; Line "LN",
Circle "CR", Ellipse "EL", Plane "PL", Cone "CO",
Sphere SP", Cylinder "CY", Angle "ANG",
Distance "DI", Contour "CONT", Surface "SURF",
Rectangle "RE", Square "SQ", Triangle "TR",
Trapeze "TZ", Hexagon "HX", Slot "SL" and Drop
"DR".
v2.0
11.12.08
Syntax
@OutText[x]:#:#:#
3.1.5
Returns the text which is created by the Output

text function. The number x represents the
number of creation.
Access Sublot
@SubLot:#:#:#
Sublot
@SubLotF*:#:#:#
Sublot field where * is the field no (e.g. SublotF5)
3.1.6
Access Head Data
@HeadDataF*:#:#:#
Head data field where * is the field no.
@HeadData[*]:#:#:#
User defined head data, where * is the user

defined head data field type
3.1.7
Access Path Data
@PartDrive:#:#:#
Drive of part program, e.g. C:
@PartDirectory:#:#:#
Directory of part program, e.g.

\DATA\CUSTOMER\
@PartPath:#:#:#
Path of part program and directory name of

part program, e.g. C:\DATA\CUSTOMER\
@PartSubDirectory
Sub directory for the actual part, e.g.

PV123456\
@CosmosDrive:#:#:#
Drive of the COSMOS programs, e.g. C:
@CosmosDirectory:#:#:#
Directory the COSMOS programs, e.g.

\COSMOS\
@CosmosPath:#:#:#
Path of the COSMOS programs; e.g.

C:\COSMOS\
@CosmosTempPath:#:#:#
COSMOS temporary file path
@CosmosAudioPath:#:#:#
COSMOS Audio-Path
@CosmosPicturePath:#:#:#
COSMOS Picture-Path
@CosmosProbePath:#:#:#
COSMOS Probe- Path
@CosmosProbeArchivPath:#:#:#
COSMOS Probe- Archive- Path
@CosmosCoordPath:#:#:#
COSMOS Co-ordinate-System- Path
@CosmosCoordArchivPath:#:#:#
COSMOS Co-ordinate-System - ArchivePath
@CosmosLayoutPath:#:#:#
COSMOS Layout- File- Path
@CosmosTransferPath:#:#:#
COSMOS File- Transfer- Path
3.2
11.12.08
Formatting Options
v2.0
Syntax
:#:z
:# min. total length (neg. for left bounded

possible)
:z leading zero are possible
:#:#:z
:#
number of decimal places
:#:# 1.# min. total length 2.# number of decimal

places
:z
:#:#:#
leading zero are possible:
:# min. total length

:# number of characters
:# pos. of first character:
10
v2.0
11.12.08
Syntax
3.3
Example: Input of an Output File Name
In the following you can see an example for the real application of a text variable.
The user has the task to enter the name of an output file. This can
be done when starting the part program.
In the Input String Variable function, you define e.g. the

FileName string variable.
As a proposal, we take here the name of the part program.

This can be achieved via the @PartProgName key word that
returns the name of the part program.
The function call could be as follows:
After that, follows a display for input:
To continue the run of the part program, the defined string variable FileName
can be used in the File Format Specification function.
11.12.08
v2.0
11
Syntax
This way, the C:\COSMOS\TEMP\NEUES PROGRAMM.ASC file is opened and

the task is finished.
Then, the cut-out of the part program looks as follows:
12
v2.0
11.12.08
Syntax
3.4
Data Access to Numerical Variable as well as

Time Access
Instructions:
11.12.08
v2.0
13
Syntax
Result:
3.5
Example: Extended Text Analysis Functionality

Instructions:
@[str1]#:#:#
:# minimum total length

:# number of signs
:# position of the first sign
14
v2.0
11.12.08
Syntax
Result:
3.6
Example: Element Name Automatic Incrementing
Here, the name of circle elements should be continually generated in a selfacting way for example Kr001, Kr002, Kr003 etc..
What do we have at our disposal?
The formula calculation keyword CR.MaxNo returns the highest

number of the element circle.
The text keyword @FORMULA( ) realizes a calculation as in the

formula calculation.
The formatting instructions, such as :3:0:z when applied with

@FORMULA( ) means: A minimum of three signs without digits
after the comma and leading zeros.
The element name input would be as follows:

Kr@Formula(CR.MaxNo+1):3:0:z
And when inserted:
11.12.08
v2.0
15
Syntax
3.7
Example: Read in Nominal Values (Fixed Format)
In this example, suppose that we read in an ASCII-file with three lines containing
per line three values for one measurement point, namely X, Y and Z. The three
measurement points are supposed to be measured.
The fixed format is as follows (also refer to help line below):
01. to 10. sign contains the X-value
11. to 20. sign contains the Y-value
21. to 30. sign contains the Z-value
The ASCII file that must be read in could be as follows:
10.01
11.02
0.03
20.01
12.02
0.03
30.01
13.02
0.03
123456789012345678901234567890 <-- only one help
3.7.1
Read in File
First, the file with the Load String Variables function must be read in. The string
variable name is specified with ReadData (also see chapter 5.5):
This has the following string variables as a result:
16
ReadData0=
10.01
11.02
0.03
ReadData1=
20.01
12.02
0.03
ReadData2=
30.01
13.02
0.03
v2.0
11.12.08
Syntax
3.7.2
Read Out Values
Now, the single values are read from within the string variables. Because several
lines must be evaluated, the best would be to use a loop.
Terms like @FORMULA(@LC-1):0 would have in the first loop flow a return 0,
in the second 1 and in the third 2. Access to a name-incremental string
variable should therefore look as follows:
@[ReadData@FORMULA(@LC-1):0]
Since the version v2.3.R1 you can use the command
"@StrGetStr("Text","sep","num")".
3.7.3
Filter Section
Now, we know the contents of the read in string variable and we only must filter a
specific section:
@[ReadData0]:0:10:1
for the first value
@[ReadData0]:0:10:11
for the second value
@[ReadData0]:0:10:21
for the third value
The resulting terms would be as follows:

@[ReadData@FORMULA(@LC-1):0]:0:10:1
3.7.4
11.12.08
In the Formula Calculation
v2.0
17
Syntax
Now, you can use these variables as usual for the position
in a measurement as well as
you can complete the loop (see dialogue below):
3.7.5
18
Section of the Part Program
v2.0
11.12.08
Syntax
3.8
Example: Read in Nominal Values (Free Format,

CSV)
3.8.1
ASCII Files with several Lines
In this example, an ASCII file with several lines must be read in containing three
values per line for one measurement point, namely X, Y and Z. The three values
are separated from one another by a separation sign.
The format is as follows and has a semicolon as a separation sign:
X-value; Y-value; Z-value
10.01;11.02;0.03
20.1;12.2;0.3
30.01;13.02;0.03
40.1;14.2;0.3
50.01;15.02;0.03
3.8.2
Read in File
First, the file with the Load String Variables function must be read in. The string
variable name is specified with ReadData (also see chapter 1.3.6):
The following string variables result:

ReadData0=10.01;11.02;0.03
ReadData1=20.01;12.02;0.03
ReadData2=30.01;13.02;0.03
ReadData3=40.01;14.02;0.03
ReadData4=50.01;15.02;0.03
11.12.08
v2.0
19
Syntax
3.8.3
Read Out Values
Now, the single values within the string variables are read. Because several lines
must be evaluated, the best would be to use a loop.
Because the number of the lines already read in has not been specified, this is
determined through the @LOADEDVARS keyword:
3.8.4
Variable into Loop Instruction and Buffer
To get a clear overview, the line, which was read in is buffered. Terms like
@FORMULA(@LC-1):0 would occasion the return 0 in the first loop flow, in
the second 1 and in the third 2 etc..
Access to a name-incremental string variable should therefore look as follows:
@[ReadData@FORMULA(@LC-1):0]
Since the version v2.3.R1 you can use the command
"@StrGetStr("Text","sep","num")".
20
v2.0
11.12.08
Syntax
3.8.5
Filter a Section
Now, we have the total contents of the string variable, which was read in, and
only another specified section must be filtered. To achieve this, we must locate
the positions of the first separation sign:
@STRPOS(@[Dummy],;)
Now, the first value can be filtered. Direct inserting of the CutPos string variable
would certainly provide one sign too much:
@[Dummy:0:@[CutPos]]
->
10.01;
->
So, one sign must be subtracted:

@FORMULA(@[CutPos]-1)
What results as:
@[Dummy:0:@FORMULA(@[CutPos]-1):0] ->
11.12.08
v2.0
10.01
21
Syntax
3.8.6
Abridge First Part
Now, we must abridge the first part of the string variable that was read in.
The formatting part must cut the rest of the term beginning from the separation
sign plus one:
:0:@STRLEN(@[Dummy]):@FORMULA(@[CutPos]+1):0
-> :0:16:7
And inserted:
@[Dummy:0:@STRLEN(@[Dummy]):@FORMULA(@[CutPos]+1):0]
Now, the same procedure is realized, as above, extract and cut once again:
It is possible to directly assign the last value:
22
v2.0
11.12.08
Syntax
3.8.7
Variable as Position
Now , these variables can be used, as usual, as a position in a measurement:
11.12.08
v2.0
23
Syntax
3.9
3.9.1
Example: Dimensional Control via External ASCII

File
Repeat Mode not with all Elements
In a fully automatic operation, a part program must be repeated. However, not all
elements in the part program must be measured. This must be decided via a
central server. The server writes a single-line file for each repetition. In the file,
identifiers such as A, B, C and D determine what must be measured.
ABCD
or
BCD
or
ACD
or
ABC
etc.
First, a part program is learned that can look like below:
24
v2.0
11.12.08
Syntax
3.9.2
Load Control File
The rest is only done in the editor. Because the control file contains the singleline information, what is to be measured, it is loaded at the beginning of the part
program with the command
Load String Variables as well as the options
Wait for File and
Delete File.
The result is e.g. the following string variable:

Cx0=ABD
In an IF branch, it is possible to access this string variable via the
@STRPOS()-functionality. This means: If e.g. in the string variables, the
character A exists, @STRPOS() will return a >0 value.
@STRPOS(@[Cx0],A)
11.12.08
-> e.g.: 1
v2.0
25
Syntax
26
@STRPOS(@[Cx0],B)
-> e.g.: 2
@STRPOS(@[Cx0],C)
-> e.g.: 0
@STRPOS(@[Cx0],D)
-> e.g.: 3
v2.0
11.12.08
Syntax
11.12.08
v2.0
27
Syntax
3.10 Example: Format Descriptions or Formula

Collections
3.10.1
Read in Contents as Result
The Load String Variable function is suitable for format descriptions, formula
collections or similar. This is due to the read in particularity. The read in contents
are not directly analysed, but rather is taken as a result.
If e.g. the following is read in:
String=@(Value):8:3:z
Here, String is the Variable and @(Value):8:3:z the content.
Later, this variable is set in a function:
Output Text Function: @[String]
3.10.2
Set in Result Then Analysis
First of all, and not visible for the user, the result is inserted. In this case:
Output Text function: =@(Value):8:3:z
Only then, analysis continues (e.g. value = 0.01):
Output Text Function: =0000.010
Knowing this, material collections, formula collections or format descriptions are
assembled now.
E.g. for correction data:
XvalStr=@(CalcX):8:3:z
YvalStr=@(CalcY):8:3:z
ZvalStr=@(CalcZ):8:3:z
EOutPut=E-@PartProgName:-20 X@[XvalStr] Y@[YvalStr]
Z@[ZvalStr]
Here, you must specify that the correction data are calculated in CalcX, CalcY
and CalcZ in the part program.
28
v2.0
11.12.08
History
History
Report
What?
Version
V 2.0
Add new features of the v3.1
GEOPAK v3.1.R1
V 1.9
Chapter. 2
@ElementName[et,x],
@OutText[x]
GEOPAK v3.0.R1
V 1.8
Chapter. 2
@StrCmp("xxx","yyy"),
@StrICmp("xxx","yyy"),
@SubStr("xxx","no1","no2")
GEOPAK v2.4.R1
V 1.8
Chapter. 2
@FileExist("FileName")
GEOPAK v2.4.R1
V 1.70
Chapter. 2
@StrLeft("Text","Pos"),
@StrRight("Text","Pos"),
@StrChg("Text","from","to"),
@StrChgAll("Text","from","to"),
@StrGetStr("Text","sep","num"),
@StrGetNum("Text","sep","num")
GEOPAK v2.3.R1
V 1.60
Chapter. 2
@Week, @DayOfYear,
@ErrNoText[No]
GEOPAK v2.1.R1
V 1.50
Chapter 3
Chapter changed
V 1.50
Chapter 2
@PartSubDirectory,
@LoadedVars
GEOPAK v1.5.R1
V 1.10
Chapter 2
@StrLen(x) , @StrPos(x,y),
@Formula(x), @Formula(x),
@SecToTime(x), @PartDrive,
@PartDirectory, @PartPath,
@CosmosDrive,
@CosmosDirectory,
@CosmosPath,
@CosmosAudioPath,
@CosmosPicturePath,
@CosmosProbePath,
@CosmosProbeArchivPath,
@CosmosCoordPath,
@CosmosCoordArchivPath,
@CosmosLayoutPath,
@CosmosTransferPath,
@CosmosTempPath
GEOPAK v1.5.B2
V 1.04
Chapter 2
@StrLen(x), @StrPos(x,y)
GEOPAK v1.5.A17
V 1.03
Chapter 2
Extract out of a text variable
GEOPAK v1.5.A16
V 1.02
Chapter 2
@Hour, @Minute, @Second,

@MilliSecond, @Year, @Month,
@DayOfWeek, @Day
GEOPAK v1.5.A13
V 1.01
Chapter 2
@PartProgName, @Operator,
@[String], @HeadDataF#,
@HeadData[#]
GEOPAK v1.5.A2
V 1.00
Chapter 2
@Time, @Date, @TimeCode,

@PartName, @RC, @LC,
@SubLot, @SubLotF, @(Result)
GEOPAK v1.5.A14
11.12.08
v2.0
29
Examples of Numeric & String Variables
5.1
Differentiation between Numeric & String

Variables
Numeric Variables are handled by Parentheses ( )

String Variables are handled with Brackets [ ]
If you want to include a variable in something you precede it by the
commercial at @
5.1.1
E.g. 1
Assume a numeric variable called Number containing the value of 0.12345

Assume a string variable called Word containing Hello
<Text to Screen> @(Number) displays 0.12345
<Text to Screen> @[Word] displays Hello
Numeric variables can only contain values

String variables can contain any character, with the exception of a colon : or
the equals sign = or the comma , because they are used for processing
variables.
A numeric variable can be changed to a string variable
A string variable can be changed to a numeric variable, so long as it contains
a value
5.1.2
E.g. 2
Assume a numeric variable called Number containing the value of 1.000

We want to change it to a string variable called Word
Select the function <Define String Variable> and give the following information...
Name of variable = Word
Contents of variable = @(Number)
The command <Text to Screen> @[Word] displays 1.000
Similarly, to now transfer the contents of the string variable Word to a numeric
variable Count
Select the function <Formula Calculation> and give the following information...
Name of variable = Count
Formula = @[Word]
The command <Text to Screen> @(Count) now displays 1.000
However, if we have a string variable called Word containing Hello and we
attempt to change it to a numeric variable called Number, then the formula
Number = @[Word] will produce an error, because Hello does not contain a
numeric value and so, cannot be contained within a numeric variable.
30
v2.0
11.12.08

Why, therefore, is it useful to be able to convert numeric variables into string
variables, or reverse the procedure and convert numeric variables into string
variables?
5.1.3
E.g. 3
Assume that we need to deal with a component serial number of the following
format...
000123456
Trying to handle this as a numeric variable would remove the leading zeros, so
that the sequence: <Formula Calculation>
Name of variable = Number
Formula = 000123456
<Text to Screen> @(Number) now displays 123456
5.1.4
E.g. 4
Assume we received a string variable, from an external source, containing the

statement
Run the loop 8 times
Although it is possible to extract the character 8 from the entire statement
(described later), as a variable called How Many this character was received as a
string variable and so, could not be used to run the loop unless it were converted
to a numeric variable first.
11.12.08
v2.0
31
5.2
External Input of Numeric & String Variables
Variables can be obtained from external sources by reading them into GeoWin from a file.
The mechanism employed for reading in string variables is basically identical
to that for reading in numeric variables.
Care should be taken to ensure that the format of the file contents is well
defined, prior to using this form of input.
Care should be taken to ensure that the variables are read in as the correct
type (string or numeric).
All of the files contents are taken in during the read operation, partial input is
not possible.
A file can only be read in as all string or all numeric, the types of input
cannot be mixed within one file.
The variables names may be assigned within the file, determined
automatically by Geo-Win, or sequentially assigned during the read in
operation.
Geo-Win assumes the following extensions for variable files, but will accept
any filename and extension
Numeric VariablesRES
String Variables
STR
5.2.1
E.g. 5
Assume a file of the following path and filename C:\Data\MyData.ASC

Assume the contents of the file are as follows
1111
02222
3333
4444
ABCD
The sequence <Calculate> <Load Variables from File> will prompt for the file
to be used for input. Simple entry of C:\Data\MyData.ASC as the path and
filename will automatically read in the file contents as numeric variables of the
following names
RES0 = 1111.000 RES1 = 2222.000 RES2 = 3333.000 RES3 = 4444.000
The operation will conclude with a variable not defined error.
Notice the following points;
1. The name RES has been automatically assigned
2. The name RES has been automatically appended with a sequential
number
3. The sequential numbering always starts from zero
4. The leading zero has been dropped from RES1 to make a valid number
5. All values are displayed to the set number of decimal places
6. The variable not defined error occurred due to the fifth piece of data in
the file ABCD, which was not numeric and therefore failed to be assigned
to RES4
32
v2.0
11.12.08
5.2.2
E.g. 6
Assume the same path and filename C:\Data\MyData.ASC

Assume the same file contents
1111
02222
3333
4444
ABCD
The sequence <Calculate> <Load String Variables> will again prompt for the
file to be used for input. Simple entry of C:\Data\MyData.ASC as the path and
filename will automatically read in the file contents as String variables of the
following names
STR0 = 1111 STR1 = 02222 STR2 = 3333 STR3 = 4444 STR4 = ABCD
1. The same data file was used for both types of input, but achieved different
results
2. No error was reported at conclusion of the operation
3. The name STR has been automatically assigned
4. The name STR has been automatically appended with a sequential
number
5. The sequential numbering always starts from zero
6. All data has been taken in, exactly as contained in the file
7. Decimal places have not been appended, because the data is not
numeric
5.2.3
E.g. 7

Assume the same file contents
1111
02222
3333
4444
ABCD
The sequence <Calculate> <Load Variables from File> will prompt for the
file to be used for input. Entry of C:\Data\MyData.ASC as the path and filename
followed by selection of <Load Filter>, with an entry of Figure will automatically
read in the file contents as numeric variables of the following names
Figure0 = 1111.000 Figure1 = 2222.000 Figure2 = 3333.000 Figure3 = 4444.000
The operation will again conclude with a variable not defined error due to the
fifth piece of data not being numeric.
Repetition of the preceding sequence, with substitution of Figure7 for Figure
will modify the resultant data as follows
11.12.08
v2.0
33

Figure70 = 1111.000 Figure71 = 2222.000 Figure72 = 3333.000 Figure73 =
4444.000
1. The default name assigned to variables can be overridden by assigning a
name within the Load Filter
2. The sequential numbering still always starts from zero
3. Appending a number to the Load Filter name allows definition of the
point from which sequential numbering starts
4. The same mechanism of assigning a Load Filter name is also applicable
to string variables
5.2.4
E.g. 8
Assume the same path and filename

Assume the file contents are
C:\Data\MyData.ASC
Feature1 = 1111
Feature2 = 02222
TestOut
Size = 3333
Weight = 4444
Name = ABCD
EFGH
The sequence <Calculate> <Load String Variables> will again prompt for the
file to be used for input. Simple entry of C:\Data\MyData.ASC as the path and
filename will automatically read in the file contents as String variables of the
following names
Feature1 = 1111 Feature2 = 02222 STR2 = TestOut Size = 3333 Weight = 4444
Name = ABCD STR6 = EFGH
1. The variables name may be assigned within the file, using the = symbol
2. Numbering may also be attached to the name
3. Variable names may be mixed within one file
4. Although not recommended, it is possible to have some of the variables
named within a file and others not. In this case, those named have the
name assigned within the file, those not named within the file are
assigned the default name (STR for strings or RES for numerics) with a
count appended equal to its position within the file (starting from position
zero)
5. The same mechanism, of applying the variables name within the file, is
also applicable to numeric variables
5.2.5
E.g. 9

Assume the file contents are in serial format as follows
a) Feature1 = 1111; Feature2 = 02222; Size = 3333; Weight = 4444; Name =
ABCD
or
34
v2.0
11.12.08

b) 1111;02222;3333;4444;ABCD
Attempting to read in the files contents as numeric data will result in a Syntax
Error being reported. However, the contents may be read in as string variable
data.
In this case, the resultant variables would be
a) Feature1 = 1111; Feature2 = 02222; Size = 3333; Weight = 4444;
Name = ABCD
a string variable called Feature1 containing the data
1111;Feature2=02222;Size=3333;Weight= 4444;Name=ABCD
or
b) STR0 = 1111;02222;3333;4444;ABCD
a string variable called STR0, by default, containing the data
1111;02222;3333;4444;ABCD
11.12.08
v2.0
35
5.3
36
When to use Parentheses and Brackets
In simple terms, Geo-Win requires the use of parentheses ( ) and brackets [ ],

when a variable is being used within a function, to let Geo-Win know whether
it is being asked to deal with a numeric ( ) or a string [ ] variable. Broadly
speaking, Geo-Win tends to assume numeric variables, unless told otherwise
and therefore, if usage of a numeric variable is already clear to Geo-Win,
parentheses ( ) may not be required whereas brackets [ ] denoting a string
variable invariably are required.
The user may correctly deduce from the preceding statement that, although
not recommended as good programming practice, it is entirely possible to
have a numeric variable and a string variable assigned the same name. In
this event, it is simply the correct use of parentheses ( ) and brackets [ ] that
allows Geo-Win to correctly determine which is being used at any one time.
As a broad rule-of-thumb the majority of system variables and user-defined
numeric variables are generally accessible without the use of parentheses ( )
and brackets [ ], whereas the use of string variables, conversion of one
variable type to another, or formatting of variables (discussed later) tends to
predetermine that parentheses ( ) and brackets [ ] will be required.
The use of numeric variables within a numeric function (position, size,
calculation etc.) invariably determines that parentheses ( ) will not be
required, unless to determine execution order of a formula, whereas the use
of numeric or string variable within a non-numeric function (text output etc.)
will require the correct application of parentheses ( ) or brackets [ ].
Almost without exception, the usage of either numeric or string variables
within most functions requires that the variable name, and the parentheses ( )
or brackets [ ] if applicable, must be preceded by the commercial at symbol
@, to let Geo-Win know that what follows is the name of a variable and not
just a simple text entry.
v2.0
11.12.08
5.4
Formatting of Numeric Variables
By default, a numeric variable will be presented, transferred or output using

the prevailing numerical format that is currently set within Geo-Win, i.e. No
leading zeroes, number of decimal places set, etc.
The output of the presentation format may be modified, for that variable at
that point in time, via the use of formatting options
These options consist of one or two numerical values and a possible control
character that succeed the name of the numeric variable
5.4.1
E.g. 10
Assume a numeric variable, called Number containing the value of 0.12345 and
the system is set for resolution to three decimal places.
Giving the commands <Machine> - <Move Machine> and entering the X value as
Number will show that it has moved the machine 0.123.
Similarly, giving the command <Text to Screen> and entering the text as I
moved @(Number)
Displays I moved 0.123 on the screen.
Formatting the numeric variable by succeeding the name, in parentheses ( ), with
a colon : and a value # overrides the number of decimal places the variable is
displayed at as per the following table
Displayed Text
Text to Screen Input

I moved @(Number):0
I moved @(Number):1
I moved @(Number):3
I moved @(Number):5
I moved @(Number):11
no decimal places
1 decimal place
3 decimal places
5 decimal places
11 decimal places
I moved 0
I moved 0.1
I moved 0.123
I moved 0.12345
I moved 0.12345000000
The formatting option is not accepted within a numeric field input (e.g. Move
Machine) as the number of decimal places is governed by system resolution.
Placing the value # inside the parentheses ( ) will give the same effect, i.e.
I moved @( Number:11) 11 decimal places
I moved 0.12345000000
Placing a second colon : and value # within the parentheses ( ) allows the text
output to be formatted with leading spaces prior to the display of the value
and number of decimal places
5.4.2
E.g. 11
Displayed Text
I moved @(Number:7:5)
places
I moved 0.12345 use 7 spaces to 5 decimal places

I moved 0.12345 use 8 spaces to 5 decimal places
I moved 0.12345 use 20 spaces to 5 decimal
11.12.08
v2.0
37

Adding a further formatting option, colon : and character z to our output
requests that any leading spaces are used to display leading zeroes, as
follows
5.4.3
E.g. 12
Displayed Text
I moved @(Number:9:6:z)
use leading zeroes
use leading zeroes
& leading zeroes
I moved 00.123450
9 spaces 6 decimal places
I moved 00.12345
8 spaces 5 decimal places
I moved 00000.12345 11 spaces 5 decimal places

1. A colon and one value :# denotes number of decimal places
2. In the case of 2 values, separated by colons :#:#, the first value denotes
how many character spaces to use for the total length of the displayed
figure, the second value then becomes how many decimal places to
display the figure to
3. Appending a colon and the character z to the end, :#:#:z, informs the
system to use up any remaining character spaces with leading zeroes
4. In the first instance of example 12 (above) the variable was closed up to
the text. In the second instance, one character space was used between
the text and the specification of the variable. This ensured that any
leading zeroes did not close up to the end of the text, for a more
readable output
5. For a numeric variable the statements @(Number:11:5:z) and
@(Number):11:5:z formatting within or without the parentheses, are
treated identically
6. The above techniques of formatting numeric variables can be usefully
employed if text or file output of numeric data needs to be carefully
controlled for either transmission to an external system, that requires a
constant number of characters, or to pre-define exact character spacing
for the generation of result output, layout files, spread-sheet formats etc.
5.5
Worked Example Program Using Numeric

Variables
Following is an example Generic Hole program using only numeric variables.

The program has no in-built coding that pre-determines how many holes are to
be measured, their size or position, it is all determined from the contents of a
data file that is provided for the holes to be measured. This file could be one of a
set, residing on the system, or externally provided from a network or serial
connection on an automated system.
Each hole is automatically named within the program and, as such, is provided
as a set of embedded examples of numeric variable usage that the reader may
employ individually.
The program lines have been numbered, within the following listing, to hopefully
assist in clarification of the provided explanations.
For further reference of available system variables, reference should be made to
existing documentation within Geo-Win help (Programming Tools) and the User
Manual for Geopak-Win String Coding (English) Strcod_e.pdf dated 14.03.2001.
Listing (with explanations) of Generic Hole Program
38
v2.0
11.12.08

File Contents:
An example file called C:\COSMOS\TEMP\MEASURE.RES contains data in the format of
The contents could be 16 sets of data, for 4 holes, as follows .
X position hole 1
Y position hole 1
Z position hole 1
Diameter hole 1
X position hole 2 etc.
-10.000
-10.000
-1.000
14.000
-10.000
10.000
-2.000
20.000
10.000
10.000
-3.000
25.400
10.000
-10.000
-4.000
34.925
Part - Program:
1.
Change Probe
Load or use any suitable probe.
2.
Load Coordinate System
Where n equals any suitable coordinate system, possibly location fixturing.
3.
Load Variables from file
C:\COSMOS\TEMP\MEASURE.RES
The path and filename are totally user defined however, it is good practice to use the dot RES extension for numeric variable files. A Load
Filter was set to Feature so that the contents are automatically named as Feature0, Feature1 Feature8 etc. as they are read into Geo-Win.
4.
CNC on/off
ON
CNC machine operation is used/simulated, but also applicable to manual.
5.
Clearance Height
Clearance height ON
Z axis = 10.000
An example arbitrary clearance height has been set, to eliminate intermediate points and reduce program size.
6.
Formula Calculation
Count = @LoadedVars/4
The @LoadedVars is a system variable that automatically keeps count of how many variables have been read in from the file. Knowing that there
are 4 entries in the file for each hole, dividing this figure by 4 means that the variable Count can be used to determine how many holes have to be
measured.
7.
Loop Start
No. of executions = Count
Start the loop, to run the same number of times as there are holes.
8.
Formula Calculation
PosX
= @(Feature@Formula(@LC*4-4):0)
The variable PosX is calculated as follows;

@LC is the system variable of how many times the loop has run.
Multiply this by 4 gives which group of 4 variables belong to the current hole, however, we have to allow that the loop starts from 1, whereas the
variables are numbered from zero, hence saying LC*4-4 is the same as saying LC*0 (you cant actually multiply something by zero).
Preceding this by the @Formula statement is a way of building a calculation within the statement. It effectively says work this bit out first. So
@Formula(@LC*4-4) gives the result 0.000
We want to add this as a numeric part of a name but decimal places are not allowed in names (or decimal points) so, appending the statement :0
says No decimal places. This turns the result into 0.
Feature was the load filter applied when we read the data in from the file so, appending our previous result (0) onto the end of @Feature gives
us the statement @Feature0.
Therefore, our Formula Calculation equates to PosX = Feature0 The name of the first variable read in from the file.
9.
Formula Calculation
PosY
Variable PosY was the second piece of data in each group of 4 variable sets.
Therefore, the only difference is the statement @LC*4-3 (one less) which therefore gives us the answer 1.000
The remainder of the statement is as explained above, so that our formula is PosY = Feature1 The second variable.
10. Formula Calculation
PosZ
If you have followed the above, you will see that in the first run of the loop the statement gives .
PosZ = Feature2 The third variable.
When the loop runs the second time LC = 2, so @LC*4-2 comes out as
2 times 4 equals 8, minus 2 equals 6
so the statement gives PosZ = Feature6 the seventh variable and Z position for the second hole.
11. Formula Calculation
Diam
Same technique as above, but for the diameters. First loop run gives Feature3, second gives Feature7, fourth gives Feature15 to extract the
diameters.
12. Drive to Clearance Height

This line saves intermediate points between holes, for a smaller program.
13. Circle
Mean
Hole@Formula(CR.MaxNo+1):3:0:z
(1)
CR.MaxNo is always the number of the last circle measured.

+1 adds 1 to it each time.
@Formula says Work this bit out first, but it ends up with decimal places.
:3 says Use three character spaces.
:0 says No decimal places.
:z says Put in leading zeroes
Append all this to the name Hole and we end up with Hole001, Hole002, . Hole043 etc.
Note: This has no input from the file, it is calculated real time so could be used to auto-name any feature.
14. Autom. Element measurement No.of Pts. = 8

Projection / meas. Plane = XY plane Circle
X = PosX, Y = PosY, Z = PosZ, Diameter = Diam
The normal automatic measurement line of a program, it just has the variables inserted that were derived from the data file.
15. Element Finished

End of the measurement.
16. Loop End

End of the loop.
17. Move Machine

CMM in home position
It is always good practice to park the CMM safely when finished.
18. CNC on/off
OFF
It is recommended, by CTL-G, to remember to switch OFF CNC at the end of every part program.
11.12.08
v2.0
39
5.6
Handling String Variables
We are already aware that we can read in, or display string variables, in a similar
manner to numeric variables. It is also possible to concatenate string variables
(concatenation simply means join together).
5.6.1
E.g. 13
Assume a string variable called Str0

Assume the contents of Str0 to be World
<Text to Screen> Hello@[Str0] shows Hello World (no space between words)
<Text to Screen> Hello @[Str0] shows Hello World (correctly spaced)
5.6.2
E.g. 14
Assume a string variable called Str0 containing Fred

Assume a string variable called Str1 containing rick
Assume a string variable called Str2 containing son
<Text to Screen>@[Str0]@[Str1]@[Str2] shows Fredrickson (concatenated)
Similarly, the statement <Define String Variable>
Str4 = @[Str0]@[Str1]@[Str2] sets Str4 to permanently equal Fredrickson
Concatenating strings within a text output format joins the strings together
temporarily
Concatenating strings as the definition of another string variable creates a
new, longer string
Spaces, left in between the concatenated strings, will be automatically
included within the new string
The keyword @StrLen returns a numeric variable that allows the user to find
the length of a string variable
5.6.3
E.g. 15
Assume a string variable called Str4 containing Fredrickson

<Formula Calculation>
Name of numeric variable = Length
Formula = @StrLen(@[Str4])
Puts the result 11 into the numeric variable Length, which is the number of
characters in the name Fredrickson
1. The variable Str4 is within square brackets [ ] denoting a string.
2. It is preceded by the @ symbol and encased within parentheses ( )
because it must return a numeric variable.
3. The parentheses are preceded by @StrLen to state how the value is
derived.
It is also possible to find the position of one, or more sequential characters within
a string variable, by using the @StrPos keyword.
40
In its simplest form, the statement @StrPos(ABCDE,C) will return the value 3
(the first position of C within the string).
The statement @StrPos(ABCDEC,C) will still return the value of 3, the first
position of C found, any subsequent occurrences are ignored.
v2.0
11.12.08
The statement @StrPos(ABCDE,F) will return the value 0 (the character F

does not occur within the string).
It is often useful to search for a sequence of more than one character, where
possible, to help eliminate possible errors from the critical character occurring
more than once.
Ie.
@StrPos(Succeed,c) will return the value 3, the first c
@StrPos(Succeed,ceed) will return the value 4, where ceed starts
Whereas @StrPos(Succeed,cead) will return the value 0, because cead
does not exist
Also @StrPos(Succeed,C) will return the value 0, because strings are Case
Sensitive
Obviously, the string to be searched and the character, or characters, to be

searched for could be replaced within the parentheses by declared string
variables instead. For an example of this, lets rework the above examples
5.6.4
E.g. 16
<Define String Variable> Str0 = Succeed

<Define String Variable> Str1 = ceed
<Define String Variable> Str2 = cead
<Define String Variable> Str3 = C
<Define String Variable> Str4 = c
<Text to Screen>
The position of @[Str1] within @[Str0] is @StrPos(@[Str0],@[Str1])
Displayed result is
The position of ceed within Succeed is 4
<Text to Screen>
Displayed result is
The position of cead within Succeed is 0
<Text to Screen>
Displayed result is
The position of C within Succeed is 0
<Text to Screen>
Displayed result is
The position of c within Succeed is 3
The ability to use @StrPos to find the position of a character, or series of
characters within a string means that the user can test for legality and spelling
mistakes within messages, automatically assemble messages internally, test for
completion of external messages and generate 2-way communication and control
with external devices.
Taking this concept a stage further, we can use a similar form of formatting on
string variables.
11.12.08
v2.0
41
5.6.5
E.g. 17
<Define String Variable> Str0 = Succeed
<Text to Screen>
The portion is@[Str0:3:2:3]
Displayed result is
The portion is cc
This has simply told Geo-Win to display the word Succeed (@[Str0]) using 3
character places (@[Str0:3]) and display just 2 of its characters (@[Str0:3:2])
starting from character number 3 (@[Str0:3:2:3]) so it has displayed the
characters cc appended straight onto the end of The portion is but effectively
leaving one space, because it was told to use 3 character spaces.
If the statement had been @[Str0:2:2:3] it would have displayed The portion
iscc, closed up without spaces, alternatively if the statement read @[Str0:8:2:3]
the corresponding display would have used 8 character spaces for the string
portion displayed thus The portion is
cc leaving 5 blank spaces in between.
Going back to the original statement @[Str0:3:2:3], if it is modified at the second
formatting value thus @[Str0:3:1:3] the resultant display would append only the
character c, whereas changing the statement to @[Str0:3:4:3] would append
the characters ccee.
Finally, from the original statement @[Str0:3:2:3], if the last formatting value is
modified so the statement reads @[Str0:3:2:1] it would append the characters
Su, whereas altering the statement to @[Str0:3:2:6] would append the
characters ed.
Explanation has already been given of string concatenation and now string
formatting. The formatting functions are, as with numeric variables, useful for
generating output in given text or file formats. The basic understandings of
formatting options are however much more useful if applied to extracting substrings from a parent string variable.
5.6.6
E.g. 18
Let
Str0 = Fredrickson
Then the statement Str1 = @[Str0:0:1:4] gives d
Similarly
Str2 = @[Str0:0:3:6] gives ick
Therefore, using the above sub-string extraction technique along with
concatenation
The statement
Str3 = @[Str0:0:1:4]@[Str0:0:3:6] gives dick
Whilst the above may be considered agreeable options, merely of interest for
output, it should be realised that they provide the user with a very powerful set of
tools that expand on the capability of just using numeric variables manifold.
5.6.7
E.g. 19
Lets reconsider the serial file format of example 9. The contents of the file were
as follows;
1111;02222;3333;4444;ABCD
42
v2.0
11.12.08

Attempting to read in as a numeric variable would fail.
Reading in as a string variable returns the result
Str0 = 1111;02222;3333;4444;ABCD
Now consider the following process .
<Define String Variable>
Pointer = @StrPos(@[Str0],;) (Equals 5, the position of the first colon ;)
Res0 = @[Str0:0:@Formula(@[Pointer]-1):0] (extracts the first value
1111)
Str0 = @[Str0:0:@StrLen(@[Str0]):@Formula(@[Pointer]+1):0]
This has reduced string to Str0 = 02222;3333;4444;ABCD so we can repeat the
process to extract the next value, as follows;
Pointer = @StrPos(@[Str0],;) (Equals 6, the position of the next colon ;)
Res1 = @[Str0:0:@Formula(@[Pointer]-1):0]
(Extracts the next value 02222 and drops leading zero to give 2222)
This has reduced string to Str0 = 3333;4444;ABCD so we repeat the
process to extract the next value;
Pointer = @StrPos(@[Str0],;) (Equals 5, the position of the next colon ;)
Res2 = @[Str0:0:@Formula(@[Pointer]-1):0] (extracts the next value
3333)
This has reduced string to Str0 = 4444;ABCD so we repeat the process to
extract the next value;
Pointer = @StrPos(@[Str0],;) (Again equals 5, the position of the last
colon ;)
Res3 = @[Str0:0:@Formula(@[Pointer]-1):0] (extracts the next value
4444)
This has reduced string to Str0 = ABCD which can now be directly
assigned as follows;
Name = @[Str0]
Lets explain the statements:
Str0 starts off containing 1111;02222;3333;4444;ABCD
It is not known how many characters are in each embedded portion, but it
is known that they are separated by a colon ;
11.12.08
v2.0
43
44
A string variable Pointer is used to locate the position of the first colon in
the string. A string, rather than a numeric variable, is used because we
need to embed the result within a formatting statement and such
statements are not numeric, so would cause a failure.
Pointer = @StrPos(@[Str0],;) simply says Find the position of the colon
within Str0 and assign that value, as a string, to Pointer.
Res0 = @[Str0:0 says Assign a portion of string Str0 to numeric Res0, as
a numeric variable with no decimal places.
We next need to know how many characters it consists of.
We have the position of the colon in the string variable Pointer so the
number of characters must be one less than this value.
(@[Pointer]) converts the string to a numeric so that we can subtract one
from it, with the statement (@[Pointer]-1).
This statement however is a numeric calculation that must take place
within a string, so we precede it with the keyword @Formula to allow this
to happen, making the statement
Res0 =
@[Str0:0:@Formula(@[Pointer]-1).
Knowing how many characters to collect is fine but, we need to know
where to start to collect them from.
As its from the start of the string, appending the statement :0 says Start
from position zero and the closing ] is needed because it is a string we
are evaluating.
So, the whole statement is Res0 = @[Str0:0:@Formula(@[Pointer]-1):0].
Substituting the values for the first portion we are extracting would show
the statement as Res0 = @[1111;02222;3333;4444;ABCD:0:4:0] =
1111. The statement, in this exact format, would not work. It is presented
in this manner to aid clarification of meaning only.
The preceding operation has not removed 1111 from Str0, it has simply
made a copy of that portion. As searching the string only comes up with
the first occurrence of what is being searched for, we need to remove the
first portion of the original string up to, and including the first colon, so that
it will successfully find the next.
The statement Str0 = @[Str0] would say Modify Str0 to contain what is in
Str0, a pointless statement in itself, because it changes nothing.
However, if we were to say Modify Str0 to contain what is in Str0 less
some portion of it the effect would be to reduce its contents. This is what
we want to do but, which portion and how to do it?
Remember, strings are not numeric so you can not add them, or take
them away from each other, you can only concatenate (join them), or
extract sub-strings (cut them). We need to extract a sub-string that is
equal to what is left after the first colon. We already know the position of
the colon (Pointer), so lets see how we do it.
The
statement
Str0
=
@[Str0:0:@StrLen(@[Str0]):@Formula(@[Pointer]+1):0] does just that
job.
Str0 = @[Str0:0 says some portion of Str0 with a minimum of zero
spaces (use what space is needed).
How many characters? The full length of Str0 (:@StrLen(@[Str0])).
Starting from which character? One after the colon (@[Pointer]+1), but
this needs to be calculated within the formatting statement, so precede it
with @Formula and put it in parentheses to make it numeric
(:@Formula(@[Pointer]+1)).
v2.0
11.12.08
Why the last :0 ? Because :@Formula(@[Pointer]+1) has worked out a

numeric variable to the default number of decimal places and, before we
convert it to a string, we need to tell it No decimal places, hence the last
:0.
Finally, we need to include the closing bracket ] because the whole is a
string statement we are evaluating.
Note the following points;

1. We used numeric and string variables to automatically locate the
separator, between individual bits of data within a string variable, and
used this information to extract the required sub-string.
2. We have converted strings to numerics and numerics to strings, including
evaluating calculations within a string first.
3. The statements, for determining each of the variables used, were identical
at each usage so could be included once, within a loop.
4. We can now see how to take in data, from a file, in serial format. This
data, although originally accessed as one string for each line, can have
the relevant string and numeric components extracted.
11.12.08
v2.0
45
5.7
Potential Uses
Following are some obvious, and some less obvious, application uses. It is up to
the individual, with reference to the guidance documentation mentioned earlier, to
put it to practical use.
a) A program could be generated, consisting of a subroutine for each element or
operation. A string could be sent, at the start of the program, which could be
evaluated and tested for which feature (part derivative to measure). I.e. String
1 says measure A B C F G
String 2 says measure C G H
b) The earlier example generic hole program which used only numeric
variables, could be modified to take the data in serial format. Now, each line
could contain the data for the complete hole (including name, tolerances
etc.). One line per feature would eliminate the need to calculate the number
of features for the loop, it would correspond to the number of lines within the
file.
c) Control and communication with external devices is easily realised, with
message test capabilities embedded within the part program.
d) It should now be possible, with some time and effort invested, to produce a
generic virtual part program.
Create sub-routines for each CMM operation or command
Create a data file that includes, on each single line, not only the relevant
data but the type of CMM command to be used (IP, CR, TO, CP, IH etc.)
Create a virtual part program that reads each line of the file, as a string
Extract the type of command from the start of the string
Extract the relevant components for that command, call the sub-routine
and apply them (you may never have to program again!)
Note: Although it must be stressed that the author has had no opportunity to
attempt the following suggestion, it is quite probable that the format of
simple CAD files could be successfully directly processed, within a GeoWin part program, by absorbing and processing as string variables.
46
v2.0
11.12.08

Um String Code 2 0 e

Загружено:

Сведения о документе

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Um String Code 2 0 e

Загружено:

Авторское право:

Доступные форматы

Stringcoding

Manual with Examples

Definition and Options ..................................................... 4

Formatting Options ..................................................................... 9

Access Time Data ............................................................................... 6

Read in File ....................................................................................... 16

Example: Read in Nominal Values (Free Format, CSV) .......... 19

ASCII Files with several Lines........................................................... 19

Example: Dimensional Control via External ASCII File .......... 24

3.10 Example: Format Descriptions or Formula Collections ......... 28

Examples of Numeric & String Variables ..................... 30

Differentiation between Numeric & String Variables .............. 30

External Input of Numeric & String Variables ......................... 32

When to use Parentheses and Brackets ................................. 36

5.4.1 E.g. 10............................................................................................... 37

Worked Example Program Using Numeric Variables............. 38

Potential Uses ........................................................................... 46

Definition and Options

Definition and Options

To do so, use the @-symbol followed by the special symbol.

It is also possible to issue the value of a variable or the content of a

Furthermore, there are some formatting instructions, such as e.g.

determination of the total length

The text analysis in a formula calculation is realized before the actual

In the formula calculation, you find

First, the text analysis is executed

last, the calculation is performed

Definition and Options

Keywords are not case sensitive (since v 1.5).

New additional style

@StrGetNum ("x;y;Z", ";", "1")

Access Time Data

Actual time in the defined system format

Actual date in the defined system short format

Actual day of the year

Actual day of the week

Creates act. time coded string with 6 characters

Convert sec. value xxx in the defined system

Result from text variable

Calculation as the Formula-Calculation

Return 1 if the variable exist, otherwise 0.

Return 1 if the string variable exist,

Functions of string coding

Get the length of the Text in the parenthesis

Get the position of the Search Text in the Text

Returns left Side of a string (Text) up to a

Returns right Side of a string (Text) up from a

Substitute and return a string from a position

Change the first found string (from) in a string

Change all found string (from) in a string (Text) to

Return < 0 => xxx less than yyy

Return < 0 => xxx less than yyy

Access Part Programs Information

Name of actual part

Name of actual part program

The actual revision number

Name of actual user (operator)

The actual user (operator) right level

The maximum number of executions of the actual

Number of variables or string variables loaded at

Gives back the error text which belongs to "x". "x"

Returns the name of an element. The requested

Returns the text which is created by the Output

Sublot field where * is the field no (e.g. SublotF5)