J-3675-6, AutoMax Enhanced BASIC Language

J-3675-6, AutoMax Enhanced BASIC Language
r
The information in this user's manual is subject to change without notice.
DANGER
ONLY QUALIFIED PERSONNEL FAMILIAR WITH THE CONSTRUCTION AND
OPERATION OF THIS EQUIPMENT AND THE HAZARDS INVOLVED SHOULD
INSTALL, ADJUST, OPERATE, OR SERVICE THIS EQUIPMENT. READ AND
UNDERSTAND THIS MANUAL AND OTHER APPLICABLE MANUALS IN THEIR
ENTIRETY BEFORE PROCEEDING. FAILURE TO OBSERVE THIS PRECAUTION
COULD RESULT IN SEVERE BODILY INJURY OR LOSS OF LIFE.
WARNING
PROGRAMS INSERTED INTO THE PRODUCT SHOULD BE REVIEWED BY
QUALIFIED PERSONNEL WHO ARE FAMILIAR WITH THE CONSTRUCTION AND
OPERATION OF THE SYSTEM AND THE POTENTIAL HAZARDS INVOLVED.
FAILURE TO OBSERVE THIS PRECAUTION COULD RESULT IN BODILY INJURY
OR DAMAGE TO EQUIPMENT.
WARNING
THE USER MUST PROVIDE AN EXTERNAL, HARDWIRED EMERGENCY STOP
CIRCUIT OUTSIDE THE CONTROLLER CIRCUITRY. THIS CIRCUIT MUST
DISABLE THE SYSTEM IN CASE OF IMPROPER OPERATION. UNCONTROLLED
MACHINE OPERATION MAY RESULT IF THIS PROCEDURE IS NOT FOLLOWED.
FAILURE TO OBSERVE THIS PRECAUTION COULD RESULT IN BODILY INJURY.
WARNING
ONLY QUALIFIED PERSONNEL WHO HAVE READ AND UNDERSTOOD ALL
APPLICABLE AUTOMAX INSTRUCTION MANUALS AND ARE THOROUGHLY
FAMILIAR WITH THE PARTICULAR APPLICATION MAY UTILIZE THE ONĆLINE
PROGRAMMING OPTION PROVIDED IN THE AUTOMAX PROGRAMMING
SOFTWARE. FAILURE TO OBSERVE THIS PRECAUTION COULD RESULT IN
BODILY INJURY OR DAMAGE TO EQUIPMENT.
Nortonr is a registered trademark of Peter Norton Computing, Inc.
MODBUSr is a registered trademark of Gould, Inc.
Data Highwayt is a trademark of Rockwell International.
VT100t is a trademark of Digital Equipment Corporation (DEC).
IBMĆXTt and ATt are trademarks of International Business Machines.
Toshiba is a trademark of Toshiba America.
Microsoftr, Windowsr, and MSĆDOSr are trademarks of Microsoft.
Reliancet, AutoMaxt, and AutoMatet are registered trademarks of Rockwell
International.
Sharkt, ReSourcet, and RĆNett are trademarks of Reliance Electric Company
ąąor its subsidiaries.
E Copyright Reliance Electric Industrial Company 1998.
Table of Contents
1.0
Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.1 Compatibility with Earlier Versions . . . . . . . . . . . . . . . . . . . . . . . . .
1.2 Additional Information . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.3 Related Hardware and Software . . . . . . . . . . . . . . . . . . . . . . . . . . .
1Ć1
1Ć1
1Ć2
1Ć2
2.0
Programming For AutoMax Systems . . . . . . . . . . . . . . . . . . . . . . . . .
2.1 Configuration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Version 3.0 and Later Systems . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Version 2.1 and Earlier Systems . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2 AutoMax Application Tasks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.3 Universal Drive Controller Application Tasks . . . . . . . . . . . . . . . . .
2Ć1
2Ć1
2Ć1
2Ć1
2Ć2
2Ć3
3.0
Structure Of An AutoMax Enhanced BASIC Program . . . . . . . . . .
3.1 Line Format . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.2 MultiĆStatement Lines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.3 MultiĆLine Statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3Ć1
3Ć1
3Ć2
3Ć3
4.0
Variables and Constants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.1 Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.1.1 Simple Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.1.1.1 Single Integer Variables . . . . . . . . . . . . . . . . . . . . . .
4.1.1.2 Double Integer Variables (Long Integers) . . . . . . .
4.1.1.3 Real Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.1.1.4 Boolean Variables . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.1.1.5 String Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.1.2 Subscripted Variables (Arrays) . . . . . . . . . . . . . . . . . . . . . . .
4.1.3 Variable Control Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.1.4 PreĆdefined Common Memory Variables . . . . . . . . . . . . . .
4.2 Constants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2.1 Integer Constants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2.2 Hexadecimal Constants . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2.3 Real Constants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2.4 String Constants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2.5 Boolean Constants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4Ć1
4Ć1
4Ć1
4Ć2
4Ć3
4Ć3
4Ć4
4Ć4
4Ć4
4Ć6
4Ć8
4Ć8
4Ć8
4Ć9
4Ć10
4Ć10
4Ć11
5.0
Expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.1 Arithmetic Expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.2 String Expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.3 Boolean Expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.4 Relational Expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.5 Mixed Mode (Integers and Reals) Arithmetic . . . . . . . . . . . . . . . . .
5Ć1
5Ć1
5Ć3
5Ć4
5Ć6
5Ć7
6.0
AutoMax Enhanced Basic Statement Types . . . . . . . . . . . . . . . . . . .
6.1 Defining Variable Control . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.1.1 LOCAL Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.1.2 COMMON Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.2 Program Documentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.3 Variable Assignment (LET/SET_MAGNITUDE) . . . . . . . . . . . . . . .
6.4 Transferring Program Control . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6Ć1
6Ć1
6Ć1
6Ć3
6Ć4
6Ć6
6Ć7
I
II
6.4.1 GOTO (GO TO) Statement . . . . . . . . . . . . . . . . . . . . . . . . . .
6.4.2 ON GOTO Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.4.3 GOSUB, ON GOSUB, and RETURN Statements
(Subroutines) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.4.4 IFĆTHENĆELSE Statement . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.5 Program Looping . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.6 Statements Used for MultiĆTasking Applications . . . . . . . . . . . . . .
6.6.1 EVENT NAME Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.6.2 SET and WAIT ON Statements . . . . . . . . . . . . . . . . . . . . . . .
6.6.3 OPEN CHANNEL Statement . . . . . . . . . . . . . . . . . . . . . . . . .
6.7 Real Time Enhancements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.7.1 DELAY Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.7.2 START EVERY Statement . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.8 Communication Capabilities . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.8.1 OPEN Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.8.2 CLOSE Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.8.3 INPUT Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.8.4 PRINT/PRINT USING Statements . . . . . . . . . . . . . . . . . . . . .
6.8.5 IOWRITE Statement (Accessing Foreign I/O) . . . . . . . . . . .
6.8.6 GET Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.8.7 PUT Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.8.8 READ Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.8.9 DATA Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.8.10 RESTORE Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.9 Error Handling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.9.1 ON ERROR Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.9.2 RESUME Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.9.3 CLR_ERRLOG . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.10 INCLUDE Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.11 Stopping Execution (STOP and END Statements) . . . . . . . . . . . .
6Ć10
6Ć12
6Ć13
6Ć17
6Ć17
6Ć19
6Ć20
6Ć22
6Ć22
6Ć23
6Ć24
6Ć24
6Ć33
6Ć33
6Ć35
6Ć41
6Ć42
6Ć42
6Ć43
6Ć43
6Ć44
6Ć45
6Ć45
6Ć46
6Ć46
6Ć46
6Ć47
7.1 SIN Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.2 COS Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.3 TAN Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.4 ATN (ATAN) Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.5 LN Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.6 EXP (e**x) Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.7 SQRT Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.8 ABS Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.9 CHR$ Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.10 ASC% Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.11 LEN% Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.12 STR$ Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.13 BINARY$ Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.14 HEX$ Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.15 LEFT$ Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.16 RIGHT$ Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.17 MID$ Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.18 VAL% Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.19 VAL Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7Ć2
7Ć2
7Ć2
7Ć2
7Ć3
7Ć3
7Ć3
7Ć3
7Ć3
7Ć4
7Ć4
7Ć4
7Ć5
7Ć5
7Ć5
7Ć6
7Ć6
7Ć6
7Ć7
6Ć7
6Ć9
8.0
7.20 FIX Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.21 CURPOS$ Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.22 CLRSCR$ Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.23 CLRLINE$ Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.24 IOREAD% Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.25 [email protected] Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.26 [email protected] Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.27 [email protected] Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.28 SHIFTL% Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.29 SHIFTR% Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.30 ROTATEL% Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.31 ROTATER% Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.32 BCD_OUT% Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.33 BCD_IN% Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.34 [email protected] Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.35 [email protected] Function . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.36 VARPTR! Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.37 [email protected] Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.38 READVAR% Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.39 WRITEVAR% Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.40 FINDVAR! Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.41 CONVERT% Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.42 [email protected] Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.43 [email protected] Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.44 WRITE_TUNE Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7Ć7
7Ć7
7Ć8
7Ć8
7Ć9
7Ć10
7Ć10
7Ć10
7Ć11
7Ć12
7Ć12
7Ć13
7Ć13
7Ć13
7Ć14
7Ć15
7Ć16
7Ć17
7Ć17
7Ć18
7Ć19
7Ć19
7Ć20
7Ć21
7Ć21
Ethernet Communication Functions . . . . . . . . . . . . . . . . . . . . . . . . . .
8.1 ENI_INIT% Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.2 SOCKET% Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.3 BIND% Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.4 CONNECT% Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.5 ACCEPT% Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.6 SEND% Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.7 SENDL% Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.8 RECV% Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.9 RECVL% Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.10 SETSOCKOPT% Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.11 GETSOCKOPT% Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.12 SHUTDOWN% Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8Ć1
8Ć1
8Ć2
8Ć2
8Ć3
8Ć4
8Ć5
8Ć6
8Ć7
8Ć8
8Ć9
8Ć10
8Ć11
III
Converting a DCS 5000 BASIC Task to AutoMax . . . . . . . . . . . . . . . . AĆ1
BASIC Compiler and Run Time Error Codes . . . . . . . . . . . . . . . . . . . . BĆ1
Hardware Interrupt Line Allocation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . CĆ1
BASIC Language Statements and Functions Supported
in UDC Control Block Tasks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . DĆ1
AutoMax Processor Compatibility with Versions
of the AutoMax Programming Executive . . . . . . . . . . . . . . . . . . . . . . . . EĆ1
New Features . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . FĆ1
IV
Table 5.1
Table 5.2
Table 5.3
Table 5.4
Ć
Ć
Ć
Ć
Arithmetic Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Relative Precedence of Arithmetic Operators . . . . . . . . . . . . . .
Truth Table for Boolean Operators . . . . . . . . . . . . . . . . . . . . . . . .
Relational or Comparison Operators . . . . . . . . . . . . . . . . . . . . .
5Ć2
5Ć2
5Ć5
5Ć6
V
fafadfdfdasfdsfdsdsdfdsfdsfdsfsdfdsa
afdfdsfdsfdfdsfdsfsadfda
asfdfaddfdd
1.0 INTRODUCTION
The products described in this instruction manual are manufactured
by Reliance Electric Industrial Company.
The AutoMax Programming Executive software includes the
software used to create and compile Enhanced BASIC programs.
This instruction manual describes AutoMax Enhanced BASIC
language for Version 2.0 and later AutoMax Programming Executive
software.
Features that are either new or different from those in the previous
version of the AutoMax Programming Executive software are so
noted in the text. Appendix F lists the differences between versions
of the software.
This instruction manual is organized as follows:
1.0 Introduction
2.0 General information about programming for AutoMax
systems
3.0 General information about programming in BASIC
4.0 Variables and Constants
5.0 Expressions
6.0 Statements
7.0 Functions
8.0 Ethernet Communication Functions
1.1
Appendix A
Converting tasks created with previous versions
of the Executive software to the current version
Appendix B
BASIC compiler and run time error codes
Appendix C
Hardware Interrupt Line Allocation
Appendix D
BASIC Language Statements and Functions
Supported in UDC Control Block Tasks
Appendix E
AutoMax Processor Compatibility with Versions
of the AutoMax Programming Executive
Appendix F
New Features in this Release
Compatibility with Earlier Versions
Version 2.0 of the AutoMax Programming Executive requires
AutoMax Processor M/N 57C430A or 57C431; Version 3.0 and later
require AutoMax Processor M/N 57C430A, 57C431, or 57C435.
M/N 57C430 cannot coĆexist in the same rack with M/N 57C430A,
57C431, or 57C435. Refer to Appendix E for a listing of the AutoMax
Processors that are compatible with Version 2 and later of the
AutoMax Programming Executive software.
The thick black bar shown at the rightĆhand margin of this page
will be used throughout this instruction manual to signify new or
revised text or figures.
1Ć1
You should be familiar with the instruction manuals which describe
your system configuration. This may include, but is not limited to,
the following:
D JĆ3618
NORTON EDITOR REFERENCE MANUAL
D JĆ3649
AutoMax CONFIGURATION TASK INSTRUCTION
MANUAL
D JĆ3650
AutoMax PROCESSOR INSTRUCTION MANUAL
D JĆ3676
AutoMax CONTROL BLOCK LANGUAGE
INSTRUCTION MANUAL
D JĆ3677
AutoMax LADDER LOGIC INSTRUCTION MANUAL
D J2Ć3018 AutoMax Remote I/O Shark Interface Instruction
Manual
D J2Ć3093 AutoMax Ladder Language Editor
D J2Ć3094 AutoMax Enhanced Ladder Language
D Your ReSource AutoMax PROGRAMMING EXECUTIVE
INSTRUCTION MANUAL
D Your personal computer, DOS, and Windows instruction manuals
D IEEE 518 GUIDE FOR THE INSTALLATION OF ELECTRICAL
EQUIPMENT TO MINIMIZE ELECTRICAL NOISE INPUTS TO
CONTROLLERS
The AutoMax Programming Executive software is used with the
following hardware and software, which is sold separately.
1. M/N 57C430A, M/N 57C431, or M/N 57C435 AutoMax
Processor.
2. IBMĆcompatible 80386Ćbased personal computer running DOS
Version 3.1 or later. Version 4.0 and later Executive software
requires an 80486Ćbased personal computer (or higher) running
Windows 95.
3. M/N 61C127 RSĆ232C ReSource Interface Cable. This cable is
used to connect the personal computer to the Processor
module.
4. M/N 57C404A (and later) Network Communications module.
This module is used to connect racks together as a network and
supports communication with all racks on the network that
contain 57C404A modules through a single Processor module.
M/N 57C404 can be used to connect racks on a network;
however, you cannot communicate over the network to the
racks that contain M/N 57C404 Network modules. You must
instead connect directly to the Processors in those racks.
5. M/N 57C440 Ethernet Network Interface module. This module is
used to connect AutoMate Processors to TCP/IP Ethernet local
area networks.
1Ć2
6. M/N 57C413 or 57C423 Common Memory module. This module
is used when there is more than one Processor module in the
rack.
7. M/N 57C492 Battery BackĆUp. This unit is used when there is a
M/N 57C413 Common Memory module in the rack.
8. M/N 57C384 Battery BackĆUp Cable. This cable is used with the
Battery BackĆUp unit.
9. M/N 57C554 AutoMax Remote I/O Shark Interface Module. This
module is used to connect a Shark remote rack to the AutoMax
Remote I/O network.
10. B/M 57552 or B/M 57652 Universal Drive Control module. This
module is used for drive control applications.
11. M/N 57C560 AutoMax PC3000 Processor/Scanner module. This
module is a fullĆsize ISA module that mounts in the personal
computer.
12. M/N 57C565 AutoMax PC3000 Serial Interface module. This
module is a fullĆsize ISA module that mounts in the personal
computer.
13. M/N 57C570 Industrial AutoMax PC300. This unit consists of a
panelĆmount, industrial grade enclosure containing an AutoMax
PC3000 Processor/Scanner module, an AutoMax PC3000 Serial
Interface Module, and a power supply.
1Ć3
fafadfdfdasfdsfdsdsdfdsfdsfdsfsdfdsa
afdfdsfdsfdfdsfdsfsadfda
asfdfaddfdd
2.0 PROGRAMMING FOR
AutoMax SYSTEMS
In AutoMax systems, application programs, also referred to as tasks,
can be written in Ladder Logic/PC language, Control Block
language, and Enhanced BASIC language. Enhanced BASIC
language is modeled after standard BASIC. It consists of simple
statements, functions, and math notation to perform operations.
Refer to JĆ 3676, JĆ3677, and J2Ć3094 for more information about
Control Block and Ladder Logic/PC programming.
In addition to multiĆprocessing, AutoMax systems incorporate
multiĆtasking. This means that each AutoMax Processor (up to four)
in a rack allows realĆtime concurrent operation of multiple
application tasks.
MultiĆtasking features allow the programmer's overall control
scheme to be separated into individual tasks, each written in the
programming language best suited to the task. This simplifies
writing, checkĆout, and maintenance of programs; reduces overall
execution time; and provides faster execution for critical tasks.
Programming in AutoMax systems consists of configuration, or
defining the hardware, systemĆwide variables, and application tasks
in that system, as well as application programming.
2.1
Configuration
Version 3.0 and Later Systems
If you are using AutoMax Version 3.0 or later, you configure the
system within the AutoMax Programming Executive. See the
AutoMax Programming Executive for information about configuration
if you are using V3.0 or later.
The information that follows is applicable only if you are using
AutoMax Version 2.1 or earlier. If you are using AutoMax Version 3.0
or later, you can skip over the remainder of this section and continue
with 2.2.
Version 2.1 and Earlier Systems
AutoMax Version 2.1 and earlier requires a configuration task in
order to define the following:
1. All tasks that will reside on the Processors in a rack.
2. All variables that equate to physical I/O in the system.
3. All other variables that must be accessible to all Processors in
the rack.
One configuration task is required for each rack that contains at
least one Processor. The configuration task must be loaded onto the
Processor(s) in the rack before any application task can be
executed because it contains information about the physical
organization of the entire system.
2Ć1
The configuration task does not actually execute or run; it serves as
a central storage location for systemĆwide information. Note that
local variables, those variables that do not need to be accessible to
more than one task, do not need to be defined in the configuration
task. Refer to JĆ3649 for more information about configuration tasks.
AutoMax Processors allow realĆtime concurrent operation of multiple
programs, or application tasks, on the same Processor module. The
tasks are executed on a priority basis and share all defined system
data. Application tasks on different Processor modules in the rack
are run asynchronously.
Each task operates on its own variables. The same variable names
may be used in different tasks, but each variable is only recognized
within the confines of its task unless it is specifically designated a
COMMON variable. Changing local variable ABC% (designated
LOCAL) in one task has no effect on variable ABC% in any other
task.
MultiĆtasking in a control application can be compared to driving a
car. The programmer can think of the different functions required as
separate tasks, each with its own priority.
In driving a car, the operator must monitor the speedometer,
constantly adjust the pressure of his foot on the gas pedal, check
the rearview mirror for other traffic, stay within the boundaries of his
lane, etc., all while maintaining a true course to his destination. All of
these functions have an importance or priority attached to them,
with keeping the car on the road being the highest priority. Some
tasks, like monitoring the gasoline gauge, require attention at
infrequent intervals. Other tasks require constant monitoring and
immediate action, such as avoiding obstacles on the road.
In a control application the Processor needs to be able to perform
calculations necessary for executing a control scan loop, monitor an
operator's console, log error messages to the console screen, etc.
Of these tasks, executing the main control loop is obviously the
most important, while logging error messages is the least important.
MultiĆtasking allows the control application to be broken down into
such tasks, with their execution being dependent upon specified
events," such as an interrupt, operator input, or the expiration of a
time interval.
The following table is a representation of typical tasks found in a
control application and the kind of event that might trigger each.
Triggering Event
Task
2Ć2
Execute main control loop
Expiration of a hardware
timer that indicates the
interval at which to
begin a new scan
Respond to external I/O input
Generation of a hardware
interrupt by an input module
Read operator data
Input to an operator panel
Log information
Expiration of a software timer
Each of these tasks would be assigned a priority level (either in the
specific configuration task for the rack, or in later versions of the
Programming Executive software, through the configuration option).
The priority determines which task should run at any particular
instant. The more important the task, the higher the task priority.
Universal Drive Controller (UDC) modules can be used in an
AutoMax Version 3.3 (or later) system for drive control applications.
Only UDC Control Block tasks can be run on a UDC module; BASIC
tasks cannot be run.
UDC Control Block tasks can use some of the statements and
functions in the AutoMax Enhanced BASIC language. See
Appendix D for a list of the BASIC language statements and
functions that are allowed in UDC Control Block tasks.
2Ć3
fafadfdfdasfdsfdsdsdfdsfdsfdsfsdfdsa
afdfdsfdsfdfdsfdsfsadfda
asfdfaddfdd
3.0 STRUCTURE OF AN
AutoMax ENHANCED BASIC
PROGRAM
BASIC programs, or tasks, are created using a text editor.
Note the following naming convention. Application task names in
AutoMax are limited to 8 characters. The initial character must
always be a letter. Following the initial character can be letters (AĆZ),
underscores (ă), and numbers (0Ć9). Spaces and other characters
are not permitted. The file extension is used to identify the task.
Extension .CNF identifies configuration tasks. Extension .BAS is
used for BASIC tasks. AutoMax Control Block tasks use extension
.BLK. UDC Control Block tasks also use extension .BLK. PC/Ladder
Logic tasks have a .PC extension.
An AutoMax Enhanced BASIC program consists of a set of
statements using certain language elements and syntax (rules for
the form of each statement). Each line begins with a number that
identifies the line as a statement and indicates the order of
statement execution. Each statement starts with a word specifying
the type of operation to be performed, such as PRINT, GOTO, and
READ. For a BASIC program to compile correctly, all text except
print list items delimited by quotation marks must be in upper case.
The following symbols have special meaning for the duration of this
manual:
<CR> = Carriage return, sometimes marked RETURN" or
ENTER" on keyboards. You should assume that
all BASIC statements end with a <CR> unless
otherwise noted. Some statements used in
examples may explicitly use the <CR> notation at
the end of a statement to make the example easier
to understand.
_
=
Underscore character used to make variable
names more readable (for example,
MOTOR_SPEED, LINE_REFERENCE).
Note that the underscore is not a dash or minus character, which
appears on the same key as the underscore on most standard
keyboards.
3.1
Line Format
The format of a statement in a BASIC program is as follows:
line
number
10
statement
keyword
LET
statement
body
line
terminator
SPEED%=(GAIN%+3)
<CR>
The line number is a label that distinguishes one line from another
within a program. Consequently, each line number must be unique.
The line number must be a positive integer within the range of 1 to
32767 inclusive.
Line numbers are required for the following reasons:
1. To determine the order in which to execute the program.
3Ć1
2. To provide a reference for conditional and unconditional
transfers of control (GOTO,GOSUB, etc).
Line numbers can be consecutive numbers:
1ăLET M%=23
2ăLET Z%=11
3ăLET K%=Z%+M%
4ăEND
However, writing line numbers in increments of 10 allows for
inserting additional statements between existing lines:
10ăLET M%=23
20ăLET Z%=11
30ăLET K%=Z%+M%
40ăEND
In BASIC, one line can be either one statement or several
statements, always terminated by pressing the RETURN <CR> key.
A single statement line consists of:
1. A line number from 1 to 32767
2. A statement keyword
3. The body of the statement
4. A line terminator
10
PRINT
A%+B%
<CR>
Example of a single statement line:
10 LET SPEED%=(GAIN%+3)/12
<CR>
A multiĆstatement line (more than one statement on a single line)
requires a backslash (\) or a colon (:) to separate each complete
statement. The backslash or colon statement separator must be
typed after every statement except the last one. For example, the
following line contains three complete PRINT statements:
10 PRINT A$\PRINT B$\PRINT C$
<CR>
10 PRINT A$:PRINT B$:PRINT C$
<CR>
or
There is only one line number for a multiĆstatement line. You should
take this into consideration if you plan to transfer control to a
particular statement within a program. For instance, in the above
example, you cannot execute just the statement PRINT B$ without
executing PRINT A$ and PRINT C$ as well.
3Ć2
In BASIC, a statement can continue onto another line. When a
statement is to be continued, the line is terminated with an
ampersand (&) followed by a <CR>. After the ampersand, only
spaces or tabs are allowed. Other characters will cause compiler
errors. The following is an example of a multiĆline statement.
20
LET MOTOR_REF%=MOTOR_REF%+
& <CR>
SYSTEM_GAIN% Ć OLDGAIN%/2+FACTOR% <CR>
The ampersand tells the compiler that the statement is continuing
on the next line. <CR> without the ampersand before it signifies
that the entire statement is complete. When a statement is continued
on a second line, that line should begin with a tab to provide
maximum readability. The statement below is confusing because the
30 looks like a line number instead of part of an equation.
20 LET MOTOR_REF%=MOTOR_REF%+OLDGAIN%+ & <CR>
30+GAINFACTOR%+VALUE%
<CR>
3Ć3
fafadfdfdasfdsfdsdsdfdsfdsfdsfsdfdsa
afdfdsfdsfdfdsfdsfsadfda
asfdfaddfdd
4.0 VARIABLES AND
CONSTANTS
All operations performed in BASIC use constants or variables.
Constants are quantities with fixed value represented in numeric
format. Variables are names that represent stored values or physical
I/O. These values may change during program execution. BASIC
always uses the current value of a common (i.e., systemĆwide)
variable in performing calculations.
Note that Control Block and PC/Ladder Logic tasks capture (latch)
the values of all common simple double integer, integer, and
boolean variables at the beginning of the task scan. Strings, reals,
and array variables of any type are not latched. This means that
Control Block and PC/Ladder Logic tasks do not see the most
current state of common simple double integer, integer, and boolean
variables; instead, they see the state of these variables at the
beginning of the scan. Any changes made to these variable values
by Control Block or PC/Ladder Logic tasks are written to the variable
locations at the end of the scan of the particular task. See section
4.1.3 for more information about common variables.
4.1
Variables
The following sections describe the use of variables in AutoMax
Enhanced BASIC.
4.1.1
Simple Variables
Variable names in AutoMax tasks must meet the following
conditions:
1. They must ALWAYS start with a letter or an underscore.
2. Following the letter/underscore can be letters, digits, or an
underscore.
3. They must not include spaces.
4. The maximum length for any variable in BASIC or Control Block
tasks is 16 characters (letters, underscore, or digits), not
including the type character attached at the end (%,!,@,$). Note
that PC/Ladder Logic tasks variables are limited to 14 characters
(16 in V4.0 and later). This is important if variables that are used
in BASIC or Control Block tasks must also be used in Ladder
Logic tasks, i.e., if the variables are common.
This variable length (16) permits meaningful and understandable
names. Avoid cryptic variable names.
Meaningful
Variable Names
MOTOR_SPEED%
GAIN%
CURRENT_GAIN%
DROP_1_REFERENCE%
Unintelligible
Variable Names
MSPD%
G%
CGN%
D1RF%
4Ć1
AutoMax Enhanced BASIC has variable types" just as standard
BASIC does. The variable type indicates the kind of information the
variable is representing (numeric data, characters, etc.). The
variable type is specified by a terminator or ending character.
BASIC uses five types of variables:
1. Single integer variables (values -32768 to +32767)
2. Double integer variables (values -2147483648 to
+2147483647)
3. Real variables (values 9.2233717E+18 to -9.2233717E+18).
Note that the E+(n)" is read as an exponent in BASIC.
4. Boolean variables [values TRUE (ON) or FALSE (OFF)]
5. String variables.
A single integer variable is a named location in which an integer
value can be stored. It is called a single" integer because it requires
a single 16Ćbit word to represent its current value in the range
+32767 to -32768 (a 16Ćbit signed number). It is named using the
rules listed in section 4.1.1 are terminated with a percent sign (%).
If you include an integer variable in a program, its value can be an
integer (no fractional part) or a real (decimal) number. If you assign
a decimal number to an integer variable, the fractional part will be
truncated or ignored. For example, if the statement attempts A% =
3.6574, the value 3 will be assigned to A%.
If an attempt is made to assign a value larger than the range
+32767 to -32768 to a single integer variable, BASIC will log this
condition into the error log and will load the largest possible single
integer value into the variable. For example, if the statement
attempts A% = 43987, BASIC will log this as an error and set a A%
= 32767; if the statement attempts A% = -53667, Basic will log an
error and A% will be set to = -32768.
The following are valid single integer variables:
MOTOR_SPEED%
FREQUENCY%
ROLL_WIDTH%
VOLTAGE_REF%
The following are invalid single integer variables and the reasons
that they are invalid:
GAIN GAIN%2 55SPEED% All internal integer calculations are in double precision, or 32 bits.
4Ć2
4.1.1.2
Double Integer Variables (Long Integers)
A double integer variable is a named location in which an integer
value can be stored. It is called a double" integer because it
requires two 16Ćbit words, or 32 bits, to represent its value in the
range +2147483647 to -2147483648 (a 32Ćbit signed number). It is
named using the rules listed in section 4.1.1 and terminated with an
exclamation point (!). If you include an integer variable in a program,
its value can be an integer (no fractional part) or a real (decimal)
number. If you assign a decimal number to a double integer
variable, the fractional part will be truncated or ignored. For
example, if the statement attempts A! = 3.6574, the value 3 will be
assigned to A!.
If an attempt is made to assign a value larger than the range
-214783648 to +214783647 to a double integer variable, BASIC will
log this condition into the error log and will load the largest possible
double integer value into the variable. For example, if the statement
attempts A! = +2157483647, BASIC will log this as an error and set
a A! = +2147483647; if the statement attempts A! = -214783649,
Basic will log an error and A! will be set to = -214783648.
The following are valid double integer variables:
RESOLVER_ADDRESS!
LARGE_COUNTER!
FOREIGN_CARD_ADR!
All internal integer calculations are in double precision, or 32 bits.
4.1.1.3
Real Variables
A real variable is a named location in which a decimal value can be
stored. It is named using the rules listed in section 4.1.1. Unlike the
other variable data types, a real variable has no terminating
character, such as % or !.
A real variable can have the following values:
9.2233717 x 1018 > positive value > 5.4210107 x 10-20
-9.2233717 x 1018 > negative value > -2.7105054 x 10-20
Note: When entering real variable values in your program, use
scientific notation. See section 4.2.3 for more information on real
constant formats.
The following are examples of valid real variables:
ROLL_RATIO
GAIN_ADJUST
WINDUP_FRACTION
Only eight digits of significance are used when entering a real
number, thus 9.4481365 and 9.4481365200178 would be treated the
same way. The 200178 at the end of the second number would be
ignored. Real or decimal numbers require more time to process
while BASIC is running due to the increased accuracy and additional
internal calculations required.
It is legal to assign an integer to a real variable (REAL=45).
However, if the integer is greater than 224 (16777216), the real
value into which it is converted will be imprecise because of the
format in which the real numbers are manipulated (24Ćbit mantissa).
4Ć3
4.1.1.4
Boolean Variables
A boolean variable is a named location which represents a
TRUE/FALSE or ON/OFF value. It is named using the rules listed in
section 4.1.1 and terminated with an at" symbol (@).
The following are valid boolean variable names:
[email protected]
[email protected]
[email protected]
The following are invalid boolean variable names and the reasons
that they are invalid:
SYSTEM_READY (Variable not terminated with @)
[email protected]@ (Two @s backĆtoĆback are illegal)
[email protected] (Variable starts with a digit rather than
Ăa letter or an underscore)
As with integer and real variables, boolean variables form
expressions. With boolean variables you use the boolean operators
NOT, AND, OR, and XOR and boolean constants TRUE, FALSE, ON,
and OFF in forming these expressions:
[email protected] = NOT([email protected] AND [email protected])
RUN [email protected] = TRUE
SECTION_ [email protected] = FALSE
CRT [email protected] = OFF
IF [email protected] OR ([email protected] AND [email protected]) THEN 1350
Refer to section 5.3 for more information about boolean
expressions.
4.1.1.5
String Variables
String variables are used to store any alphanumeric sequence of
printable characters, including spaces, tabs, and special characters.
The terminating character is $.
The sequence in a string variable cannot include a line terminator
(<CR>). When defined, the sequence must be enclosed either in
single or double quotes. If one type of quotes is used in the
sequence itself, the other type must be used to enclose the
sequence.
Version 1.0 Executive software allowed a fixed maximum length of
31 characters for string variables. Version 2.0 and later allows string
variables of variable length, from 1 to 255 characters. To specify the
maximum size of a string variable, add a colon and a number
(1Ć255) immediately after the $ character. For example, defining
A$:50 as a local variable in an application task will reserve space for
50 characters. Note that if no length is specified, the default length
is 31.
4.1.2
Subscripted Variables (Arrays)
Array variables are used to store a collection of data all of the same
data type. Arrays are permitted for all data types. Arrays are limited
to four dimensions, or subscripts. The number of elements in each
dimension is limited to 65535. This size is further limited by available
memory. The term array is used to denote the entire collection of
data. Each item in the array is known as an element.
4Ć4
Array variables are specified by adding a subscript(s) after the
variable name, which includes the appropriate terminating character
to denote the type of data stored in the array. The terminating
character is followed by a left parenthesis (or bracket), the
subscript(s), and a right parenthesis (or bracket). Multiple subscripts
are separated by commas. Note that subscripts can be integer
constants as well as arithmetic expressions that result in integer
values.
array variable name
A% (5)
subscript
terminating character
(denotes variable
type)
An array with one dimension, i.e., one subscript, is said to be
oneĆdimensional. An array with two subscripts is said to be
twoĆdimensional, etc. The first element in each dimension of the
array is always element 0. Therefore, the total number of elements in
each dimension of the array is always one more than the largest
subscript. For example, array A%(10) is a oneĆdimensional array
containing eleven integer values.
Example 1 Ć OneĆdimensional array
0
1
2
185
2
53 79 99 122
A%
3
4
5
value of A
Example 2 - TwoĆdimensional array
B% (6, 3)
0
1
0 185 2
B%
2
3
4
5
6
53 79 99 122 40
1
70
36 46 31
2
77
73 21 365 476 51 47
3
18
23 53 342 39 224 107
34 85
6
In the case of string arrays, Version 1.0 Executive software always
allocated the maximum amount of memory for each element in the
array, regardless of whether the string stored in that element was of
the maximum length, 31 characters. Version 2.0 (and later)
Executive software allows the programmer to specify the maximum
size of elements in the array, from 1 to 255 characters.
To specify the maximum size of string variables in an array, add a
colon and a number (1Ć255) immediately after the $ character when
declaring the variable in an application task or defining it during
configuration. For example, defining A$:10(20) as a local variable in
4Ć5
an application task allocates space for 21 string values of 10
characters each. Note that if no length is specified in the initial array
reference, the default maximum is 31.
To define an array that will be common, i.e., accessible to all tasks in
the rack, you need to first define the variable. If you are using
AutoMax Version 2.1 or earlier, this is done with a MEMDEF or
NVMEMDEF statement in the configuration task for the rack. If you
are using AutoMax Version 3.0 or later, common variables are
defined within the Programming Executive. For example,
[email protected](10) will allocate space for 11 boolean variables. Then, in
an application task for the rack, you declare the array a COMMON
variable as follows:
COMMON [email protected](10). Each element of the array that will be
used in the task can be defined with LET statements as follows:
LET [email protected](0) = TRUE (boolean values can only be
TRUE/FALSE or ON/OFF). Other application tasks in the rack can
access the value in variable [email protected](0) simply by declaring it a
COMMON variable.
The control type of a variable refers to the way the variable is
declared or defined in the configuration and application tasks. There
are two control variable types in AutoMax systems, local and
common.
1. Local variables are variables that are not defined in the rack
configuration and are therefore accessible only to the
application task in which they are defined. BASIC and Control
Block tasks must define the variables with a BASIC LOCAL
statement. For Ladder Logic/PC tasks, the editor prompts for
whether the variable is local or common when the task is being
created.
In BASIC and Control Block tasks, local variables can be
defined as tunable. Tunables are variables whose value can be
tuned, i.e., changed within limits, by the operator through the
OnĆLine menu of the Executive software. The value of tunable
variables can also be changed by application tasks by using the
BASIC languange WRITE_TUNE function. BASIC and Control
Block tasks must define tunable variables with a variation of the
BASIC LOCAL statement that includes the tuning parameters.
Ladder Logic/PC tasks cannot use tunable variables.
The value of local variables at the time of initial tasks installation
is always 0. The effect of a Stop All or a power failure on variable
values in the rack depends on the variable type. Local tunable
variable values in both AutoMax and UDC application tasks is
always retained. Local variable values are retained for AutoMax
tasks, but not for UDC tasks.
AutoMax Processors will retain the last values of all local
variables. UDC modules will retain the variable values for the
following: parameter configuration data, UDC test switch
information, and D/A setup configuration. The variable values of
the following input data will also be retained: feedback registers,
UDCĆPMI communication status registers, and UDC task error
log information. UDC modules will NOT retain local variable
values and data found in the following registers, which are
4Ć6
considered outputs: command registers, application registers,
the ISCR (interrupt status and control register), scans per
interrupt register, and scans per interrupt counter register. See
the AutoMax Programming Executive for more information on
the STOP ALL and system reĆinitialization conditions.
2.
Common variables are variables that are defined in the rack
configuration and are therefore accessible to all application
tasks in the rack. There are two types of common variables,
those that refer to memory locations, and those that refer to
actual physical I/O locations. The two types are defined
differently in the configuration for the rack.
Common memory variables can be of any data type. They may
be read to or written from. Common I/O variables are long
integer, integer, or boolean variables that represent actual
physical I/O locations. Common I/O variables that represent
inputs may be read but not written to. I/O variables that
represent outputs may be read or written to.
All BASIC and Control Block tasks that need to access common
variables can do so by using the BASIC statement COMMON (or
GLOBAL). For Ladder Logic/PC tasks, the editor prompts for
whether the variable is local or common when the task is being
created. At least one task in the rack should also initialize
common memory variables, i.e., assign values to them, if they
need to be at a known state other than 0.
The value of common variables at the time of initial task
installation depends upon whether the variable references
memory or physical I/O locations. Common memory variables
are always 0 at task installation. Common I/O variables that
represent outputs are always 0. Common I/O variables that
represent inputs are always at their actual state.
After a STOP ALL condition or a power failure followed by a
systemĆrestart, common memory variables that are defined as
volatile memory statements in the configuration are 0. Common
memory variables that are defined as nonĆvolatile memory in the
configuration retain their last value. Common variables that
represent I/O locations are at 0 for outputs and at their actual
state for inputs. Note that the UDC dual port memory is treated
like I/O variables. See the AutoMax Programming Executive for
more information on the STOP ALL and systemĆrestart
conditions.
4Ć7
The following common memory variables are preĆdefined for every
rack. However, they do not appear on the form for common memory
variables. You must enter these variable names on the form if you
want to use these variables in application tasks.
[email protected] Ć True when AUTO RUN is enabled for the
rack; false if AUTO RUN is not enabled
[email protected] Ć True when a variable is forced in the rack;
false when no variables are forced in the
rack
[email protected] Ć True when the onĆboard battery of the
Processor module or Common Memory
module in slot 0 is OK
[email protected] Ć
[email protected] Ć
[email protected] Ć
[email protected] Ć
ăIăIăIăIăIăIăIăIăIăIăIăIă1ăIăIăI
ăIăIăIăIăIăIăIăIăIăIăIăIă2ăIăIăI
ăIăIăIăIăIăIăIăIăIăIăIăIă3ăIăIăI
ăIăIăIăIăIăIăIăIăIăIăIăIă4ăIăIăI
A constant, also known as a literal, is a fixed value that is not
associated with a variable name. Listed below are the five types of
constants that can be used in AutoMax, along with their size
limitations.
1. Single and double integer constants (whole numbers)
2. Hexadecimal constants (whole numbers in base 16 or hex"
format)
3. Real (decimal) constants
4. String constants (alphanumeric and/or special characters)
5. Boolean constants
An integer constant is a whole number with no fractional part. For
example, the following numbers are all integer constants:
29
3432
12345
-8
1
205
The following are not integer constants:
1.6
754.2
341/2
.08
5.2041E+06
95.3
Recall that BASIC integer constants must fall in the range -32768 to
+32767 when used as single 16Ćbit integer variables (ending in %),
or in the range -2147483648 to +2147483647 when used as
double (32Ćbit) integer variables (ending with !). If you specify a
number outside the appropriate range, BASIC prints a compiler
error message telling you to replace the number with one within the
proper limits.
4Ć8
A hexadecimal constant also specifies an integer value in base 16 or
hex" (hexadecimal) format. A hexadecimal number has three parts:
0NNNNNNNNH
where:
1. A leading zero (0) is required if the first digit of the hexadecimal
number is an alphabetical character (A through F) so that BASIC
can distinguish it as a number and not a variable name. A
leading zero may also be used in front of a numeric character in
the hexadecimal number just as in a normal integer constant
(0987H = 987H)
2. The eight Ns represent the 8 hexadecimal (hex) digits in the
range 0 through F.
3. The trailing character H" indicates that the number is
hexadecimal and is always required.
The following are correct hexadecimal numbers:
098FCE2H
0BEEFC2H
99987H
0FFEEC1H
400B3C2H
The following are invalid hexadecimal numbers and the reasons that
they are invalid:
FEC002H (Does not start with zero in front of the alpha hex
character F.)
9800BE Does not end with H.)
3FFFFE342H (Larger than maximum double integer.)
BASIC hexadecimal numbers must fall in the range from zero to
0FFFFFFFFH. Hexadecimal constants are stored by BASIC exactly
as they are specified, with leading zeros filling in any of the eight hex
digits not specified for a double word or 32Ćbit format. This means
the numbers must be specified as 2's complement signed numbers.
For example, BASIC will load the hex constant 0F371H as
0000F371H. It will not signĆextend the number to 0FFFFF371H. If the
number 0FFFFF37H is desired, the entire 8 hex digits must be
specified. If you specify a number outside the appropriate range
(0FFFFFFFFH), the compiler will print an error on the screen.
4Ć9
A real constant is a number with a decimal point. For large numbers,
use scientific notation in the following general format: a sign, digits,
a decimal point, digits, an E," a sign, and digits. Take, for example,
the following real constant example:
-1234.5678E+11
The E" is a real constant which means times ten to the" followed
by the power" or exponent. In the real constant 34.99876E+07, the
E" means times ten to the 7th. There must always be a number in
front of the E" when the E" is used (E+13 by itself is illegal.). Only
8 digits of significance are used to store the number. The total
number of digits on the left and right side of the decimal point must
be less than or equal to 8.
As with the real variable, the real constant can have a value in the
range:
9.2233717 x 1018> positive value > 5.4210107 x 10-20
-9.2233717 x 1018 < negative value <-2.7105054 x 10-20
All of the values listed below represent the number one hundred
twenty:
120
120.
+120.
ă0000120.00
1200000.00EĆ0004
ă120E3
+.120E+03
0.000120E6
1200000EĆ4
String constants are sequences of alphanumeric and other printable
characters. Line terminators (<CR>) are not allowed. String
constants must be enclosed either in single or double quotes. If one
type of quotes is used in the sequence itself, the other type must be
used to enclose the sequence. String constants may be up to 132
characters long.
A BASIC string prints every character between quotation marks
exactly as you type it into the source program. This includes the
following:
1. Letters (A-Z)
2. Leading, trailing, and embedded spaces
3. Tabs
4. Special characters (\, ?, !, etc.)
Note, however, that the actual BASIC string does not contain the
delimiting quotation marks.
The following are valid string constants:
THIS IS A STRING CONSTANT."
SO IS THIS."
THIS IS A MESSAGE!*/??"
HERE IS A `QUOTE' FROM SOMEONE'" `HE SAID GOODBYE" TODAY' 4Ć10
The following are invalid string constants and the reasons that they
are invalid:
WRONG TERMINATOR' (Surrounding quotes must be of same
type.)
`SAME HERE" (Surrounding quotes must be of same type.)
NO TERMINATOR (No closing double quote.)
The following are examples of valid string constants assigned to
string variables and string constants used as intermediate values in
expressions:
MESSAGE$ = GEAR BOX FAULT"
MESSAGE$ = SECTION 12 AIR PRESSURE SAFETY VALVE
FAULT"
PART_MESSAGE$ = LEFT$(SECTION 12 AIR PRESSURE
SAFETY VALVE FAULT", 12)
(Valid string constant not assigned to a variable directly but used
an an intermediate value to a function.)
PRINT SECTION 12 AIR PRESSURE SAFETY VALVE FAULT"
(Valid string constant used in a print statement.)
With integers and strings, a constant is used in initializing or
assigning a value to a variable. Boolean variables must be assigned
the values of true or false. The two boolean constants are TRUE" or
ON" and FALSE" or OFF."
The following are valid boolean constants:
[email protected] = TRUE
[email protected] = OFF
4Ć11
fafadfdfdasfdsfdsdsdfdsfdsfdsfsdfdsa
afdfdsfdsfdfdsfdsfsadfda
asfdfaddfdd
5.0 EXPRESSIONS
An expression is a symbol or a group of symbols that BASIC can
evaluate. These symbols can be numbers, strings, constants,
variables, functions, array references, or any combination of these.
The following are the different types of operations which can be
performed:
1. Arithmetic expressions/operators
2. String expressions/operators
3. Boolean expressions/operators
4. Relational expressions/operators
5.1
Arithmetic Expressions
BASIC allows you to perform addition, subtraction, multiplication,
division, and exponentiation with the following operators:
**
Exponentiation
*
Multiplication
/
Division
+
Addition, Unary+
-
Subtraction, Unary-
The unary plus and minus are different from the other operators
because they operate on only one operand, not two. The standard
operators (binary operators) require two operands.
The following expressions use binary operators:
MOTOR_SPEED% + JOG_SPEED%
GAIN% Ć GAIN_CHANGE%
GAIN% * GAIN_FACTOR%
The following expressions use unary operators:
GAIN - SPEED (Legal but results in a positive value)
-MOTOR_SPEED%
-(GAIN%+GAIN FACTOR%)
+MOTOR_SPEED% (This form is not typically used because
it is assumed that the absence of an operator in front of a
variable means plus or positive)
Unary minus makes a positive expression negative. Unary plus does
not make a negative expression positive. A unary minus applied to a
variable already having a negative value will, of course, make the
variable (or expression) positive.
The symbols for unary plus and minus (+ and -)are the same as
the binary plus and minus, but the operation is different. For
example, A% - B% means subtract B% from A%, whereas -(A%)
means negative the value of A%.
Performing an operation on two arithmetic expressions of the same
data type yields a result of that same data type. For example, A% +
B% yields an integer, and K$ + M$ yields a string.
When a real value (constant or variable) is used in an expression
with any other numeric data type (single integer, double integer, or
real) the result is always real. When a boolean value is used in an
5Ć1
expression with a single or double integer variable, the result is
always integer.
Table 5.1 lists the arithmetic operators and their meanings. In
general, you cannot place two arithmetic operators consecutively in
the same expression. The exception is the unary minus and plus
and the exponentiation symbol **. For example, A* -B is valid, and
A/(-B) is valid, but A+*B is not valid.
Table 5.1 Ć Arithmetic Operators
Operator
Example
Meaning
+
A+B
Add B to A
-
A-B
Subtract B from A
*
A *B
Multiply A by B
/
A/B
Divide A by B
**
A**B
Calculate A to the power B
BASIC evaluates expressions according to arithmetic operator
precedence or priority. Each arithmetic operator has a
predetermined position in the hierarchy or importance of operators.
This priority tells BASIC when to evaluate the operator in relation to
the other operators in the same expression. Refer to table 5.2.
Table 5.2 Ć Relative Precedence of Arithmetic Operators
Symbol
Operation
Relative Precedence
()
Parentheses
-
Unary minus
1 (Highest, evaluated first)
+
Unary plus
**
Exponentiation
3
*
Multiply
4
/
Divide
+
Add
-
Subtract
2
5 (Lowest, evaluated last)
Operators shown on the same line have equal precedence. BASIC
evaluates operators of the same precedence level from left to right.
Note that BASIC evaluates A**B**C as (A**B) **C.
In the case of nested parentheses (one set of parentheses within
another), BASIC evaluates the innermost expression first, then the
one immediately outside it, and so on. The evaluation proceeds
from the inside out until all parenthetical expressions have been
evaluated. For example, in the expression B = (25+(16*(9**2))),
(9**2) is the innermost parenthetical expression and BASIC
evaluates it first. Then it calculates (16*81), and finally (25+1296).
5Ć2
BASIC evaluates expressions enclosed in parentheses before the
operator immediately outside the parentheses, even when the
operator enclosed in parentheses is on a lower precedence level
than the operator outside the parentheses. In the statement A = B*
(C - D), BASIC evaluates the (C - D) first, and then multiplies B by
the result of (C - D).
BASIC will still evaluate other expressions before those in
parentheses if the other expressions come first in the statement and
have a higher precedence. In the statement below, however, the
parenthetical expression occurs later in the overall expression. The
exponentiation operation is performed first (before the parentheses)
because it is encountered first in the leftĆtoĆright evaluation and, at
the time it is encountered, is a higher precedence than any operator
before it.
BASIC evaluates the expression A = B - C**5 + (X*(Z - 17)), in
the following sequence:
C%
B - C%
Z - 17
X * (Z - 17)
[B - C%] + [X*(Z - 17)]
Exponentiation
Subtraction with first term
Innermost parenthetical expression
Next level of parentheses
Combination of the two expressions
Arithmetic mixing of both single and double precision integers along
with real variables and constants is permitted in a BASIC statement.
The rules regarding truncation and the maximum size integerĆtoĆreal
conversion still apply.
The following are valid arithmetic mixing examples:
20 GAIN = MOTOR_SPEED%*(OLDGAIN!*13.8876)
or
20 GAIN! = GAIN! + REFERENCE%
The following example could cause an overflow if the resultant value
is larger than 16 bits of precision. In such a case, the largest
possible single positive or negative integer would be loaded into the
variable GAIN%. The program would continue to run, and an error
would be logged to notify the user of the problem.
20 GAIN% = REFERENCE! + GAIN%
BASIC provides three operations for use with string expressions.
These are the assignment operation (=), the concatenation
(addition of strings) operation (+), and the equality/inequality
comparison operations (=, < >, or > < ).
By using the assignment operator, you can equate or assign one
string variable or constant to another string variable. In the
statement below, the character sequence THIS IS A MESSAGE" is
assigned to the string variable C$:
C$ = THIS IS A MESSAGE"
The concatenation operator (+) combines string variables and
constants to form a new string expression:
C$ = HI" + B$ + D$ + STRING"
5Ć3
The relational operators="and < >" or > <" are used when
there is a relational or comparison expression, such as that found in
an IF"statement. The statement below tests the value of the
boolean which is the result of the string comparison. If the result is
true and the two strings are not equal (< >), the program transfers
control to line 250. The relational operator =" is used in the same
way to test strings:
20 IF C$ < > MESSAGE" THEN GOTO 250
When strings are concatenated (added) and the result is stored in a
string variable (A$ = B$ + TEXT"), the resultant length of the
computed string expression still must not exceed the maximum
length for a string (255 characters if specified in the variable
definition, 31 as a default if no size is specified). If it is longer than
the maximum, it is truncated to the maximum and loaded.
If the string expression is used in a relational expression or PRINT
statement where it is not assigned to a variable but only exists as a
temporary entity, the string expression may be as large as 132
characters.
The following are strings used as intermediate values. In both cases,
the string expression enclosed within the parentheses may be as
large as 132 characters. If it exceeds that length, it is truncated to
132 characters. This means that BASIC will allow string expressions
to be as large as 132 characters while the expression is being
computed; however, at the time it is to be assigned to a string
variable, it must be able to fit the string into the allocated variable
space (31 default, 1Ć255 if specified in the variable definition):
IF (A$ + C$) < > (B$ + TEXT") THEN 200
PRINT (HI"+ A$ + B$ + C$),N%,XYZ
A boolean expression, just like a boolean variable, evaluates to a
true/false value. Refer to table 5.3 for the truth table. Boolean
expressions use the following boolean operators:
AND
OR
XOR
NOT
(performs logical AND" function)
(performs logical OR" function)
(performs logical exclusiveĆOR" function)
(unary boolean operator performs a boolean
complement)
The following are boolean expressions:
[email protected] (Simple boolean variable, TRUE or FALSE)
[email protected] AND [email protected] (ANDs two
boolean results together)
NOT (([email protected] [email protected] AND [email protected]) 5Ć4
Table 5.3 Ć Truth Table for Boolean Operators
0
0
0
0
0
1
0
1
0
1
1
1
1
0
0
1
1
0
1
1
1
1
0
0
1= TRUE; 0 = FALSE
The AND boolean operator has a higher precedence than the OR or
XOR operators, which have equal precedence. Thus, in a boolean
expression, the AND operator will be evaluated before the OR
operator. The NOT operator is always applied immediately to the
expression (which is the same as the unary minus operator). The
following examples show a boolean expression and the order of
evaluation of the operators:
[email protected] = [email protected] OR [email protected] AND [email protected]
1. [email protected] AND [email protected]
2. [email protected] OR [[email protected] AND [email protected]]
[email protected][email protected] AND NOT [email protected] OR [email protected] AND [email protected]
1. NOT [email protected]
2. [email protected] AND [NOT [email protected]]
3. [email protected] AND [email protected]
4. [[email protected] AND (NOT [email protected])] OR [[email protected] AND [email protected]]
[email protected] = NOT([email protected] OR [email protected] [email protected]) OR [email protected] AND NOT [email protected] OR
[email protected]
1. [email protected] AND [email protected]
2. [email protected] OR [[email protected] AND [email protected]]
3. NOT [[email protected] OR ([email protected] AND [email protected])]
4. NOT [email protected]
5. [email protected] AND [NOT [email protected]]
6. [NOT ([email protected] OR ([email protected] AND C @))] OR [[email protected] AND (NOT [email protected])]
7. [(NOT ([email protected] OR ([email protected] AND [email protected]))) OR ([email protected] AND (NOT [email protected]))] OR
[email protected]
Boolean values can be combined with integer values by using either
boolean or arithmetic operators. In combining the two data types,
note the following guidelines:
D When a boolean value is combined with an integer value using
boolean operators or arithmetic operators, the result is always in
integer.
5Ć5
D When a boolean value is combined with an integer value, the
boolean is always treated as the value zero (0) if it is FALSE and
one (1) if it is TRUE.
The following statement illustrates these rules:
A% = SYSTEM [email protected]*(SPEED_REFERENCE - 2.3376)
The value of this statement will be 0 if [email protected] is FALSE
or (SPEED_REFERENCE - 2.3376) if [email protected] is TRUE.
When a boolean operator is used to combine the two different data
types, it performs a bitĆwise or bitĆforĆbit operation on the two values,
treating the boolean as either an integer one (1) or zero (0):
LOWER_BYTE% = ANALOG_IN% AND OFFH
This operation will mask" off the upper 8 bits of the value
ANALOG_IN%, which can be useful when manipulating integers as
binary data.
5.4
Relational Expressions
It is often necessary in BASIC to compare different values and,
based on the result of that comparison, perform one of several
actions. These comparisons are done with relational operators and
are usually used in conjunction with the IFĆTHEN statement to create
conditional transfers or conditional executions of different parts of a
program. Table 5.4 lists the valid relational or comparison operators
and their meanings.
In forming relational expressions, similar data types must be
compared, i.e., numeric types must be compared to other numeric
types. It would be illegal to compare a boolean or integer
expression to a string expression using a relational operator.
Table 5.4 Ć Relational or Comparison Operators
5Ć6
Operator
Example
=
A=B
A is equal to B
Meaning
<
A<B
A is less than B
A is greater than B
>
A>B
<=
A<=B
A is less than or equal to B
>=
A>=B
A is greater than or equal to B
<>
A<>B
A is not equal to B
><
A><B
A is not equal to B
The following are relational expressions:
A% > B%
((A%+3)/16) < > 32
(((A%/25) +13)+B%) >= SPEED%
(A% < > B%) OR (GAIN => 3.58867) OR (FAULTS% = 0)
(MESSAGE$ = SYSTEM DOWN")
(SPEED > OLD_SPEED + 23.8876/GAIN)
Since the result of a relational expression is a true or false value
(boolean result), several relational subĆexpressions may be
combined by using the boolean operators AND, OR, and XOR.
The following are statements using relational expressions:
10 IF (A% > B%) THEN 200
10 IF (SPEED < 32.887) AND (SECTION [email protected]) THEN
GOSUB 12000
10 IF SYSTEM [email protected] OR [email protected] OR (ROLL_
WIDTH% <23) THEN 240
In performing mixed mode arithmetic (expressions in which integers
and reals are intermixed), BASIC must always convert the integer
value to a real or decimal number internally to be able to operate on
the two quantities.
The integer must be converted to a real to maintain the maximum
amount of precision possible. (Converting the real to integer and
doing all integer arithmetic obviously is not feasible because all the
fractional parts would be lost; A=2.37764+4 should result in
6.37764 not 6.) This integerĆtoĆreal conversion happens only,
however, at the point where the integer value or subĆexpression
value is combined with a real value in an operation.
When BASIC evaluates an expression. it follows certain rules which
determine the order of evaluation in the expression. When using
mode arithmetic, use caution to assure the desired results.
If there are integer parts to the expression, BASIC will use integer
arithmetic until it encounters a real value and then convert the
integer partial result to real. For example, the following expression is
evaluated exactly as seen, left to right (because there are not
parentheses and all the operators are of the same precedence or
importance):
REAL3 = B% * C% * D% * REAL1 * REAL2
The above statement is evaluated as follows:
1. B% * C% will be calculated in integer arithmetic.
2. The intermediate value of (B% * C%) is then multiplied by D%
using integer arithmetic because both quantities are still
integers.
3. The intermediate value of [(B% * C%) * D%] is now multiplied by
REAL1, but since one of the values is real and one is integer, the
intermediate value of [(B% * C%) * D%] must be converted to a
real value before the multiplication by REAL1.
5Ć7
4. The intermediate value of ([B% * C%) *D%] * REAL1), which is
in real format, is now multiplied by REAL2, also in real format.
The result is then a real value which is loaded into variable
REAL3.
Note: If the variable on the left side of the equal sign were an
integer, the resultant real value would be truncated first and then
loaded into the variable.
The mixing of integers and reals in the previous example does not
result in a problem because, although there are intermediate integer
values, multiplication operators do not intermediate integer values,
multiplication operators do not cause any loss of precision as the
operations are performed (4 * 5.334 is the same as 4.00 * 5.334).
Problems may, however, occur when mixed mode arithmetic
involves division. Consider the following example in which the
operation (A%/B%) must occur first because of the parentheses:
10 A%=17:B%=3:REAL=13.7889
20 REAL2=(A%/B%) * REAL
The partial result of the first expressions is 5 (17 : 3 = 5.66666; the
fractional part 0.66666 is ignored because it is integer division). The
5 is then multiplied by 13.7889, yielding 68.9445 (5 x 13.7889), not
78.1370 (5.66666 x 13.7889).
Once an intermediate result in a BASIC expression is evaluated as a
real, the rest of the expression will also be done as real arithmetic.
The above expression could be modified as follows to get the full
precision from the division:
10 A% = 17:B%=3:REAL = 13.7889
20 REAL2=(1.0*A%/B%) *REAL
Multiplying the 1.0 (which is a real number) by the variable A%
forces A% to be converted to real. The result of (1.0 * A%) is then a
real value. Since (1.0 * A%) is real, B% must be converted to real to
be used in the division.
The following is a comparison of the execution times for different
arithmetic modes doing the same expression. Notice that the third
example, combining integer and real values, is the most time
consuming because of the conversion required on the integer
before the addition can be performed. It is, therefore, faster to do
arithmetic in either all real or all integer. If possible:
REAL = REAL + REAL1
INT% = INT% + INT1%
REAL = REAL + INT%
5Ć8
250msec
210msec
362msec
6.0 AutoMax ENHANCED BASIC
STATEMENT TYPES
As described in section 3.1, each BASIC statement begins with a
line number followed by a keyword. The keyword determines what
information will follow on the line. This section describes all the
keywords used in AutoMax Enhanced BASIC grouped by statement
type as follows:
6.1 Defining Variable Control
6.2 Program Documentation
6.3 Variable Assignment
6.4 Transferring Program Control
6.5 Program Looping
6.6 Statements Used for MultiĆTasking Applications
6.7 RealĆTime Control
6.8 Communication
6.9 Error Handling
6.10 Including Other Files
6.11 Stopping Execution
The format of all statements is defined, along with the parameters
required and the permitted variable types. Parameters that are
optional are so noted.
6.1
Defining Variable Control
AutoMax Enhanced BASIC requires that all variables be defined in
the task, i.e., initialized, prior to their use in the task if they must be
at a known state other than 0. See section 4.1.3, Variable Control
Types, for more information about variable control and the initial
state of variables. Arrays must always be defined prior to their use.
Variables are defined using either a LOCAL or COMMON statement.
The storage area required for the variables is automatically set aside
by these two statements.
6.1.1
LOCAL Statement
The LOCAL statement is used to define three kinds of variables, all
of which are local", or accessible to, only the task in which they are
defined. This means that even if the same variable name is used in
another task the values of the two variables are totally independent
of each other. Any operation performed within a task on the variable
has no effect on the variable in the other task. The following types of
variables are defined using the LOCAL statement:
1. Simple variables used only by the task. These variables can be
of any data type and can be written to or read from.
2. Subscripted (array) variables used only by the task. These
variables can be of any data type and can be written to or read
from.
6Ć1
3. Tunable variables. These variables can be double integer,
integer, or real type and can be read from, but cannot be written
to by any means except through the Programming Executive
software running on the personal computer. Note that tunable
variables used to define gain parameters affected by autoĆtuning
on the Universal Drive Controller (UDC) module will also be
written to by the operating system on the UDC. See instruction
manual SĆ3006 for more information on UDC tasks.
LOCAL variable
where:
variable =
simple variable of any type, i.e., double integer,
integer, real, string, or boolean; more than one
variable can be defined with one statement by
separating the variables with commas
examples:
10 LOCAL [email protected]
20 LOCAL LIMIT%, TEMPERATURE, MESSAGE$
LOCAL variable(size_list)
where:
variable =
simple variable of any type, i.e., double integer,
integer, real, string, or boolean
size_list =
up to five integer constants or integer variables
separated by commas, each value defining the
limit of the dimension of the array; expressions
that result in integer values are also permitted;
see section 4.1.2 for more information about
memory allocation for arrays; note that the first
item in every dimension is indicated in location
0, not 1
examples:
10 LOCAL A%(25) [reserves space for 26 integer
ąĂelements]
20 LOCAL [email protected](2,5) [reserves space for 18 boolean
ąĂelements]
Tunable variables provide a method of adjusting values within a
certain range through the Programming Executive software while the
application task is running. Tunable variables can only be read by
the application task itself. They cannot be written to, except in the
case of tunable variables in UDC tasks, which are also written to by
the operating system on the UDC. Tunable variables can never
occur on the left side of a LET (assignment) statement.
6Ć2
LOCAL variable [CURRENT=val1, HIGH=val2, LOW=val3, &
ăăăăă ăĂ STEP=val4]
where:
variable =
simple variable of double integer, integer, or real
type
val1 =
a constant of integer, double integer, or real
type representing the value of the variable when
the task is first downloaded to the Processor; if
the variable is modified when the task is
running, it assumes the new value as the
CURRENT" value. If the task is reconstructed
(uploaded from the Processor to the personal
computer), instead of val1, the CURRENT"
value at the time will be printed following the
keyword CURRENT".
val2 =
a constant of integer, double integer, or real
type representing the highest value that the
operator can assign to the variable
val3 =
a constant of integer, double integer, or real
type representing the lowest value that the
operator can assign to the variable
val4 =
a constant of integer, double integer, or real
type representing the amount (step) by which
the operator can adjust the value by
decrementing or incrementing the variable
examples:
50 LOCAL TENSION_GAIN%[ăCURRENT=25,HIGH=50, &
ąąąąąąąąăLOW=10,STEP=5]
60 LOCAL RANGE%[ CURRENT=2500,HIGH=3500, &
ąąąąăLOW=2000,STEP=50]
The COMMON or (GLOBAL) statement is used to define two kinds of
variables, both of which will be, common, i.e., accessible to all tasks
in the rack. The value of the variable is made accessible to all tasks
by defining it in the configuration task for the rack and then
declaring the same variable common in tasks that need to reference
the variable. If you are using AutoMax Version 2.1 or earlier, see
JĆ3649 for more information. If you are using AutoMax Version 3.0 or
later, see the AutoMax Programming Executive for more information.
A change in the value of a common variable in one application task
will be seen by all application tasks that reference that variable
name as a common variable. The following variables are defined
using the COMMON (or GLOBAL) statement:
1. Memory variables (variables that are assigned to memory
locations) that must be accessible to all tasks in the rack. These
variables can be of any data type. They can be read to or written
from.
2. I/O variables (variables that that refer to actual physical I/O
locations). These variables can be double integer, integer, or
boolean variables. Common I/O variables that represent inputs
may be read but not written to. Common I/O variables that
represent outputs may be read or written to.
6Ć3
Recall that BASIC tasks always use the most current value of
common variables when performing calculations, while Control
Block and PC/Ladder Logic tasks latch the value of all simple
double integer, integer, and boolean variables. See section 4.0 for
more information.
Note that in the following examples, GLOBAL can be substituted for
COMMON.
COMMON variable
where:
variable =
simple variable of double integer, integer, real,
string, or boolean type for common memory
locations; simple variable of double integer,
integer, or boolean type for common I/O
locations; more than one variable can be
defined with one statement by separating the
variables with commas
examples:
10 COMMON SPEED%
20 COMMON LIMIT%, [email protected], PROMPT$
COMMON Subscripted (Array) Variable Format
COMMON variable(size_list)
where:
variable =
simple variable of any type, i.e., double integer,
integer, real, string, or boolean
size_list =
up to five integer constants or integer variables
separated by commas, each value defining the
limit of the dimension of the array; expressions
that result in integer values are also permitted;
see section 4.1.2 for more information about
memory allocation for arrays; note that the first
item in every dimension is indicated in location
0, not 1
examples:
10 COMMON A%(10) [reserves space for 11 integer
ă ăelements]
20 COMMON B$:15(2,10) [reserves space for 33 string
ăăelements of 15 characters each maximum]
BASIC allows you to insert notes and comments in a task. BASIC
provides two statements for this purpose, the REM and ! statements.
REM comment
OR
! comment
where:
comment = any text
6Ć4
The ! format is interchangeable with the REM format for a comment;
however, the statements are treated differently by the compiler.
The ! format comments are downloaded with a task onto the
Processor module. Consequently, when that task is uploaded to the
operator's terminal at a later time, the comments can be
reconstructed along with the other program statements.
When the REM format comments are compiled, they are discarded
and consequently, they are not downloaded with the task. They are
not reconstructed and cannot be referenced with a GOTO or
GOSUB type transfer of control because they will not exist in the
executable task. The REM format comments serve only to document
the source file.
When programming critical applications, note that the ! format
comments use memory on the Processor module. ! statements
require a small amount of execution time even though they do not
actually execute.
The remark (REM) statement must be the only statement on a
program line. The remark (!) statement can be either the only
statement on a line or it can be one of several statements in a
multiĆstatement line as long as it is the last statement. REM and !
statements may be continued onto more than one line just like any
other statement:
10 !
THIS IS AN EXTREMELY LONG COMMENT & <CR>
SHOWING JUST HOW IT IS POSSIBLE TO & <CR>
CONTINUE A REMARK ACROSS SEVERAL LINES
10 !
20 !
30 !
40 !
This is an example of a series of several consecutive
! statements used to form a block of comments.
These comments may contain any character except
a carriage return, for example: [email protected]$%^&*() &
+~][}{`".,??&?>%$
10 REM
20 REM
30 REM
40 REM
50 REM
60 REM
This is an example of a series of several
consecutive REM statements used to form a
block of comments. These comments may
contain any character except a carriage
return, for example: [email protected]$%&*()
+~][}{`",:/.,?\/%[email protected]%%#'
The following is a valid remark statement because the remark is at
the end:
10 A% = B% -23: PRINT A%:! A REMARK
The following is an invalid remark statement because the remark is
not at the end of the statement:
10 REAL = 3.57: ! NEW REMARK: PRINT
The line number of a ! remark statement can be used in a reference
from another statement, such as a GO TO statement. BASIC only
displays the remarks on the personal computer when you edit the
program. See the GOTO (GO TO) statement in section 6.4.
6Ć5
6.3
Variable Assignment
(LET/SET_MAGNITUDE)
There are two formats for assigning a value to a variable: the LET
statement and the SET_MAGNITUDE statement. TheLET" in an
assignment is optional. In actuality tasks are more readable without
LET" in front of the assignment. Its use is left to the discretion of the
programmer.
The following is the LET statement format:
LET variable = expression
where:
variable =
simple (A%) or subscripted [A%(5)]; variable of
any data type.
expression =
can be as simple as a constant or as involved
as a complex arithmetic expression. (See
section 5.0).
The following are valid LET statements:
10
15
95
25
10
22
LET SPEED%=25
LET MESSAGE$=SYSTEM FAILURE"
[email protected]=TRUE
GAIN_CHANGE!=GAIN%*13
A% = B% + C% - (D% / 234) + 15 -F%
TENSION = TENSION - ((19.7765 * &
GAIN%)/78 - 12.3) + OLD_REFERENCE
The following are invalid LET statements:
10 LET =
ĂA% (no variable specified on the left side of the
Ăequal sign)
10 LET A%Ă=
THIS IS A MESSAGE" (a string value cannot
be assigned to an integer variable)
10 LET A% =
6+22-(B%-34)+(missing term) (Invalid
expression)
The purpose of the SET_MAGNITUDE statement is to allow the
programmer to enter 16Ćbit hexadecimal values without having to
worry about sign extending the numbers into a 32Ćbit form. The
following is the SET_MAGNITUDE statement format:
SET_MAGNITUDE (variable, value)
where:
variable =
a numeric simple variable (integer, double
integer) (not an array)
value =
a numeric constant or expression of same type
as variable
If the variable specified in the statement is a single integer variable,
the value loaded will be only the lower 16Ćbits of the value field with
no sign extension:
10 SET_MAGNITUDE(A%,0FFFFH)
(A% is replaced by 0FFFFH)
10 SET_MAGNITUDE(A%,0C249H OR 1234H)
(A% is replaced by 0D23DH)
6Ć6
10 SET_MAGNITUDE(A%,0FEFE2222H)
Even if the result of the value field is more than 16 bits of
significance (all integer arithmetic is done internally as 32 bits), only
the lower 16 bits are loaded into the variable (single integer
variable). If the variable is a double integer variable, all 32 bits of the
value field are loaded into the variable.
Without the SET MAGNITUDE statement, the programmer would
need to sign extend 16Ćbit hex values into a 32Ćbit form.
For example, when the statement A% = 0FFFFH executes, BASIC
attempts to put the value 0000FFFFH into the variable A%. This
causes an overflow because the hex number is greater than 32767,
the largest single integer. When this happens, BASIC logs an error
and loads the variable A% with the greatest possible value (32767).
The variable A%, since it is a 16Ćbit value, will hold the quantity
0FFFFH, but it must be sign extended into a 32Ćbit form to be
handled internally and look like a number in the range 32767 to
Ć32768. Since all hex constants are not sign extended but assumed
to have leading zeros in the leading hex digits, 0FFFFH is too large.
Sign extending 0FFFFH would result in 0FFFFFFFFH, which is
expressed in 2's complement decimal format as the number -1.
Therefore, the statement A% = - 1 or A% = 0FFFFFFFFH would
properly load the value 0FFFFH into the variable A%.
6.4
Transferring Program Control
At times it may be necessary to transfer control to different sections
of a task depending on certain conditions (the value of a variable,
the occurrence of an event, etc.). BASIC provides the following
statements to accomplish this:
1. GOTO (GO TO) statement
2. ON/GOTO statement
3. GOSUB statement/RETURN statement
4. ON/GOSUB statement
6.4.1
GOTO (GO TO) Statement
The GOTO statement causes the statement that it identifies by line
number to be executed next, regardless of that statement's position
within the program. BASIC executes the statement at the line
number specified by GOTO and continues the program from that
point.
The following is the GOTO statement format:
GOTO line_number
or
GO TO line_number
where:
line number=
next program line to be executed; can be an integer constant or
integer expression. The specified line number can be smaller
(go backward) or larger (go forward) than the line number of the
GOTO statement.
6Ć7
In the following example:
30 GOTO 110
BASIC branches control to line 110. BASIC interprets the statement
exactly as it is written: go to line 110. There are no rules or
conditions governing the transfer.
In the sample program below, control passes in the following
sequence:
D BASIC starts at line 10 and assigns the value 2 to the variable
A%.
D Line 20 sends BASIC to line 40.
D BASIC assigns the value A% + B% to variable C%
D BASIC ends the program at line 50.
D Line 30 is never executed.
D 10 LET A% = 2
20 GOTO 40
30 LET A% = B% + 13
40 LET C% = A% + B%
50 END
The GOTO statement must be either the only statement on the line
or the last statement in a multiĆstatement line. If you place a GOTO
in the middle of a multiĆstatement line, BASIC will not execute the
rest of the statements on the line:
25 LET A% = B% + 178\ GO TO 50\ PRINT A%
In the above statement, BASIC does not execute the PRINT
statement on line 25 because the GOTO statement shifts control to
line 50.
If a ! remark statement is specified in the line number to which
control is transferred, BASIC will branch to that statement even
though it does no direct processing:
10 LET A% = 2
20 GO TO 40
30 A% = B% + 13
40 ! THIS IS ANY COMMENT
50 LET C% = A% + B%
60 END
At line 20, BASIC transfers control to line 40. No processing is
required for line 40, although some time is required to read the line.
BASIC then executes the next sequential statement, line 50.
6Ć8
GOTO statements can use integer expressions instead of a constant
as the transfer line number; however, the expression must have an
integer as its final data type. For example, in your task, you are
reading data from DATA statements and, depending on the value of
variable OPTION%, you want to execute a specific routine. Assume
the values of OPTION% are 0 thru 10. In this example, the routines
or option handlers are located at line numbers 1000, 1100, 1200,
etc. (they are 100 apart for the starting line number). This GOTO
statement multiplies the value of OPTION % by 100 to get the
hundreds" value of the routine (100, 200, 300, etc.). This
hundreds" value is then added to the base value of all the option
handlers, which is 1000:
10 BASE_VALUE% = 1000
15 INPUT OPTION%
20 GOTO (BASE_VALUE% + (OPTION% * 100))
ąąă.
ąąă.
ąąă.
1000 !ĆĆĆroutine for handling option #0
1010...
1020...
1100!ĆĆĆroutine for handling option #1
1110...
1120...
1200!ĆĆĆroutine for handling option #2
1210...
1220...
If the value resulting from the integer expression does not match any
line number in the task, the execution of the task will fall through to
the next statement and an error will be logged in the task error log.
The above operation can be performed more efficiently using the
ON GOTO" statement.
The ON GOTO statement is also a means of transferring control
within a program to another line, depending on the result of an
integer expression.
The ON GOTO statement has the following format:
ON integer_expression GOTO line_number_1,..., line_number_N
or
ON integer_expression GO TO line_number_1,...,
line_number_N
where:
integer_expression =
any arithmetic expression that
results in an integer value
6Ć9
line_number_1 through line_number_N =
line numbers to which control is
transferred depending on the
evaluated expression
The line numbers always correspond to the value of the expression.
If the expression evaluates to 1, control is transferred to
line_number_1. If the expression evaluates to 2, control is
transferred to line_number_2, and so on to line_number_N.
There is no corresponding line number for zero (0). Fractional
numbers are truncated to an integer value.
For example, if A%=5, the result of the integer expression A%/3
would truncate from 1 2/3 to a value of 1. If there is no
corresponding line number, the next sequential statement after the
ON GOTO is executed.
The following are valid ON GOTO statements:
20 ON A% GO TO 100, 200, 300, 400
20 ON ((A%) -5)GOTO 100, 205, 300,515
6.4.3
GOSUB, ON GOSUB, and RETURN Statements
(Subroutines)
A subroutine is a block of statements that performs an operation
and returns control of the program to the point from which it came.
Including a subroutine in a program allows you to repeat a
sequence of statements in several places without writing the same
statements several times.
In BASIC, you can include more than one subroutine in the same
program. Subroutines are easier to locate and edit if they are
located together, usually near the end of the program.
The first line of a subroutine can be any legal BASIC statement,
including a remark statement. You can nest subroutines (one
subroutine within another) up to the point that memory becomes
insufficient to keep the return information for the subroutines.
The GOSUB statement has the following format:
GOSUB line_number
where:
line_number =
line number of the entry point in the subroutine;
can be an integer constant or integer
expression.
If the result of the expression value does not match a line number in
the task, execution falls through to the next sequential statement
after the GOSUB. No error is reported.
When BASIC executes the GOSUB statement, it stores internally the
location of the next sequential statement after the GOSUB and
transfers control to the line specified. BASIC executes the subroutine
until it encounters a RETURN statement, which causes BASIC to
transfer control back to the statement immediately following the
calling GOSUB statement. A subroutine called by a GOSUB must
exit by a RETURN statement.
The RETURN statement has the following format:
RETURN
6Ć10
When BASIC executes a GOSUB, it stores the return location of the
statement following a GOSUB.
Each time a GOSUB is executed, BASIC stores another location.
Each time a RETURN is executed,BASIC retrieves the last location
and transfers control to it. In this way, no matter how many
subroutines there are or how many times they are called, BASIC
always knows where to transfer control.
100 IF MOTOR_SPEED%<JOG_SPEED% THEN 80
110 GOSUB 200
120...
130...
140...
.
.
.
200 ! THIS IS A COMMENT
210 MOTOR_SPEED%=MOTOR_SPEED%+(GAIN%/2)
.
.
.
290 RETURN
The has the following format:
ON integer_expression GOSUB line number_1,...,line number_N
where:
integer_expression =
any arithmetic expression that results in an
integer value
line_number_1,..., line_number_N =
line numbers to which control is transferred
depending on the evaluated expression
Line numbers always correspond to the value of the expression. The
value 1 transfers control to the first line number listed. The value 2
transfers control to the second line number listed, etc. There is no
corresponding line number for zero (0). Fractional numbers are
truncated to an integer value. If no corresponding line number exists
for the result of the integer expression, control falls to the next
sequential statement after the ON GOSUB. When a RETURN is
executed from one of the subroutines referenced in the ON GOSUB,
it returns to the next statement after the ON GOSUB.
The following are valid ON GOSUB statements:
20 ON (A% + B% + C%) GOSUB 103,220,475,650
30 ON GAIN% GOSUB 200,300,400,500
6Ć11
The IFĆTHENĆELSE statement provides a transfer of control based
on the result of a relational or comparison expression. It is one of the
most frequently used statements in a BASIC application task.
The IFĆTHENĆELSE statement has the following format:
IF expression THEN
ąąstatement(s)
ELSE
ąąstatement(s)
END_IF
where:
expression = boolean variable or valid relational expression
statement =
statement or series of statements separated by
backslashes or colons, or a line number to
which to transfer control. If a line number is
used, it must be defined by a GOTO statement.
If the expression following IF is evaluated as
true, all statements are executed. If a line
number is used instead of a statement, it can be
larger or smaller than the line number of the
IFĆTHENĆELSE statement.
The IFĆTHENĆELSE statement does not allow the line continuator
symbol (&). Any number of IFĆTHENĆELSE statements can be
nested if they are balanced properly. If there is no alternative to
follow the statement following THEN, do not use the ELSE keyword.
The following are valid IFĆTHENĆELSE statements:
50 IF MOTOR_SPEED% = 50 THEN
PRINT JOG_SPEED%
ELSE
PRINT MOTOR_SPEED%
END_IF
300 IF MOTOR_SPEED% > JOG_SPEED% THEN
GOTO 700
ELSE
GOTO 600
END_IF
400 IF (A > 3) THEN
A = A -12
ELSE
IF (B > C) THEN
ăă ĂC = D - 33.2
ELSE
ăă ĂC = D + 12.998
END_IF
B=B*A
END_IF
The following are invalid IFĆTHENĆELSE statements:
130 IF SWITCH_34% THEN
GOTO 300
ELSE
GOTO 500
END_IF
6Ć12
(SWITCH_34% is not a boolean variable or a valid
Ărelational expression)
150 IF A% > B% THEN GOTO 700
ELSE GOTO 400
END_IF
(The keyword THEN must be the last item on the first line)
Note that Version 2.0 and later of the AutoMax Programming
Executive supports both the IFĆTHENĆELSE format described above
and the IFĆTHEN format used in Version 1.0 of the AutoMax
Programming Executive (M/N 57C304Ć57C307). Version 1.0,
however, supports only the IFĆTHEN format.
A loop is the repeated execution of a set of statements. Placing a
loop in a program saves you from duplicating routines and
enlarging a program unnecessarily.
For example, the following two programs will print the numbers from
1 to 10:
10 PRINT 1
20 PRINT 2
30 PRINT 3
40 PRINT 4
50 PRINT 5
60 PRINT 6
70 PRINT 7
80 PRINT 8
90 PRINT 9
100 PRINT 10
110 END
10 I% =1
20 PRINT I%
30 I% = I% +1
40 IF I% < = 10 THEN 20
50 END
Both of these programs would result in the following being printed:
1
2
3
4
5
6
7
8
9
10
The program with a loop first initializes a control variable, I%, in line
10. It then executes the body of the loop, line 20. Finally, it
increments the control variable in line 30 and compares it to a final
value in line 40.
Without some sort of terminating condition, a program can run
through a loop indefinitely. The FOR and NEXT statements set up a
loop wherein BASIC tests for a condition automatically each time it
runs through the loop. You decide how many times you want the
loop to run and you set the terminating condition.
The FOR statement has the following format:
FOR variable = expression_1 TO expression_2 {STEP
expression_3}
6Ć13
where:
variable = simple numeric variable known as the loop index.
expression_1 = initial value of the index; can be any
numeric expression.
expression_2 = terminating condition; can be any
numeric expression.
expression_3 = incremental value of the index; the STEP size
is optional. If specified, it can be positive or
negative; if not specified, the default is +1.
Expression_3 can be any numeric expression.
The NEXT statement has the following format:
NEXT variable
where:
variable = same variable named in the corresponding FOR
statement
The FOR and NEXT statements must be used together. You cannot
use one without the other. If you do, the program cannot be
compiled. The FOR statement defines the beginning of the loop; the
NEXT statement defines the end. Place the statements you want
repeated between the FOR and NEXT statements. You are actually
building a counter in your program to determine the number of
times the loop is to execute when you use FOR and NEXT.
Here is a simple FORĆNEXT statement example:
20 FOR M% = 30 TO 90 STEP 3
30...
40...
50 NEXT M%
M% is given the initial value of 30, and BASIC tests to determine if
M% is less than or equal to the terminating value of 90. The loop is
executed because M% is less than 90. When the NEXT statement is
encountered, the value of M% is incremented by 3. BASIC goes
back to line 20 and tests again to see if M% is greater than 90. When
BASIC reaches the NEXT statement and M% has a value of 87,
BASIC adds 3 to M% and tests the result against the terminating
value. The result, 90, is not greater than the terminating value of 90,
so BASIC executes the loop again. When BASIC reaches the NEXT
statement again, it adds 3 to M%, producing 93. Because this is
greater than the terminating value, BASIC terminates the loop by
transferring control to the next sequential statement after the NEXT
statement.
The following program will print the numbers 1 through 11 as shown
below the program listing:
10 FOR I% = 1 TO 10
20 PRINT I%
30 NEXT I%
40 PRINT I%
50 END
1
2
3
6Ć14
4
5
6
7
8
9
10
11
In the above program, the initial value of the index variable is 1. The
terminating value is 10, and the STEP size is + 1(the default). Every
time BASIC goes to line 30, it increments the loop index by 1 (the
STEP size) until the terminating condition is satisfied. The
terminating condition is satisfied when the control variable is greater
than 10. Therefore, this program prints the values of I% ten times.
When the loop is completed, execution proceeds to line 40 and
prints I% again which has been incremented already to 11. When
control passes from the loop, the last value of the loop variable is
retained. Therefore, I% equals 11 on line 40.
You can modify the index variable within the loop. The loop in the
program below only executes once because at line 20 the value of
1% is changed to 44 and the terminating condition is reached.
10 FOR I% = 2 TO 44 STEP 2
20 LET I% = 44
30 NEXT I%
40 END
If the initial value of the index variable is greater than the terminal
value, the loop is never executed. The loop below on the left cannot
execute because you cannot decrease 20 to 2 with increments of
+2. You can, however, accomplish this with increments of -2 as
shown in the right loop.
10 FOR 1 = 20 TO 2 STEP 2
10 FOR 1 = 20 TO 2
ąąąąąąąąąąąąąąSTEP -2
It is possible to jump out of a FOR loop that has been started or
executed at least once, but you should not transfer control into a
FOR loop that has not been initialized by executing the FOR
statement. It will result in a fatal error during run time and the task
will be stopped. The following is illegal in a BASIC task because line
20 shifts control to line 40, bypassing line 30:
10 ! THIS IS ILLEGAL
20 GO TO 40
30 FOR I=1 TO 20
40 PRINT I
50 NEXT I
60 END
FOR and NEXT statements can be placed anywhere in a
multiĆstatement line:
10 FOR I%=1 TO 10 STEP 5\ PRINT I%\ NEXT I%
20 END
6Ć15
A loop can contain one or more loops provided that each inner loop
is completely contained within the outer loop. Using one loop within
another is called nesting. Each loop within a nest must contain its
own FOR and NEXT statements. The inner loop, the one that starts
first, must terminate before the outer loop, which must be completed
last. Loops cannot overlap.
The following are two legal nested loops:
10 FOR A%=1% TO 10%
10 FOR A%=1 TO 10
20 FOR B=2 TO 20
20 FOR B=2 TO 20
30 NEXT B
30 NEXT B
40 NEXT A%
40 FOR C%=3 TO 30
50 FOR D=4 TO 40
60 FOR E=5 TO 50
70 NEXT E
80 NEXT D
90 NEXT C%
100 NEXT A%
The following is a program with a legal nested loop:
10 PRINT I", J"
15 PRINT
20 FOR I%=1 TO 2
30 FOR J%=1 TO 3
35 !
40 PRINT I%,J%
45 !
50 NEXT J%
60 NEXT I%
70 END
Inside
Loop
Outside
Loop
Running the above program would display:
ăăĂĂĂĂI J
11
12
13
21
22
23
Inside
Loop
The following is an illegal nested loop because the inner loop does
not terminate first:
10 FOR M=1 TO 10
20 FOR N=2 TO 20
30 NEXT M
40 NEXT N
FOR and NEXT statements are commonly used to initialize arrays.
As illustrated in this example, line 5 defines a local array with 6 rows
and 11 columns. For more information, see section 6.1.1.
ă5 LOCAL X%(5,10)
10 FOR A%=1 TO 5
6Ć16
20 FOR B%=2 TO 10 STEP 2
30 X%(A%,B%)=A% + B%
40 NEXT B%
50 NEXT A%
60 END
The typical control application has a variety of functions to perform
and monitor. All of these functions require the attention of the CPU,
or Processor module. To better service these different functions,
BASIC provides a number of multiĆtasking capabilities. MultiĆtasking
is a scheme whereby the operations requiring service are grouped
into separate pieces called tasks.
AutoMax Enhanced BASIC provides the following statements to
allow the user to break the control application into tasks and then
synchronize those tasks:
1. EVENT statement
2. SET statement
3. WAIT statement
4. OPEN CHANNEL statement (INPUT/PRINT channel).
An event can be thought of simply as a flag or indicator that one
task can set or raise and another task can wait for. There are two
types of events used in a BASIC task:
1. Hardware events
2. Software events
Hardware events are generated by an actual external condition,
such as an interrupt from a Resolver module (M/N 57C411).
Hardware events cannot be used on the AutoMax PC3000. See
Appendix C for information on allocating hardware interrupt lines. A
software event is simply a flag set by an application task.
An EVENT NAME statement defines a specific event and is used in
conjunction with the SET and WAIT statements. The EVENT
statement defines a symbolic name for an event. The SET and WAIT
statements act on that event. The EVENT statement has two
formats, one for a hardware event and one for a software event:
Software Event
EVENT NAME = event_name
Hardware Event
EVENT NAME = event_name,
INTERRUPT_STATUS = I/O_variable_name,
TIMEOUT = timeout_count
&
&
6Ć17
where:
event_name =
symbolic name given to that particular event and the
handle" for further references to that event; not followed
by a terminating character.
I/O_variable_name =
name of a symbol referenced as common in the
application task and defined in the configuration task by
an IODEF statement. This variable is defined in the
configuration task to point to the address of an interrupt
register on a hardware module that supports hardware
interrupts.
timeout_count =
the longest time that should pass before a hardware event
occurs. This is used as a safeguard in the case where
something has happened to the piece of hardware that
generates the event. If this timeout period is exceeded
before the event is triggered, the system will automatically
stop the task. The number specified for the timeout period
must be an integer in the range 1Ć32767 and will always
refer to the number of TICKS. The tick rate is
userĆdefinable for each Processor being used. The range
is 0.5 milliseconds to 10 milliseconds. The default tick rate
is 5.5 milliseconds.
The following example defines a hardware event where slot 8,
register 2, defines the address of an interrupt register on a resolver
module in the main chassis:
10 IODEF RESOLVER_INTREG%[SLOT=8,REGISTER=2]
:
10 COMMON RESOLVER_INTREG%
.
.
.
95 EVENT NAME=MARKER_PULSE,
INTERRUPT_STATUS=RESOLVER_INTREG%,
TIMEOUT=100
.
.
.
255 IF [email protected] THEN
WAIT ON MARKER PULSE
.
.
.
&
&
&
The following example defines a software event for a local
BASIC task:
95 EVENT NAME=SW_EVENT1
.
.
.
255 IF [email protected] THEN WAIT ON SW_EVENT1
6Ć18
Note that it is possible to disable the timeout period for a hardware
event. Disable the timeout for I/O modules that, unlike the Resolver
module, do not generate a periodic interrupt. This format of the
event definition should be used carefully since the timeout provides
an extra level of protection in the event of a hardware failure. The
following is the alternate hardware EVENT NAME format:
EVENT NAME=event_name,
&
INTERRUPT_STATUS = I/O_variable_name,
&
TIMEOUT = DISABLED
Example:
10 COMMON IO_INT_REG%
.
.
.
90 EVENT NAME=HW_EV1,
INTERRUPT_STATUS=IO_INT_REG%,
TIMEOUT=DISABLED
&
&
The format is identical to that for a hardware event except that the
word DISABLED" is entered in place of an integer constant for the
timeout period. The timeout field cannot be left off or set to zero (0).
This forces the user to turn off the timeout by entering the word
DISABLED".
Note that the limit on the number of hardware and software events in
all tasks in a rack is 32.
The SET statement is used to set an event or indicate that it has
occurred. Executing this statement makes any other tasks that were
suspended while waiting for that event to occur (or setting of that
event) eligible to run. WAIT ON causes task execution to stop until
the EVENT NAME is set by the SET statement. The format of the
SET statement is:
SET event_name
where:
event_name =
name of the hardware or software event previously defined by at
least one task
The format of the WAIT ON statement is:
WAIT ON event_name
where:
event_name =
previously defined by at least one task; same as the
corresponding SET statement.
The following is an example of EVENT NAME, SET, and WAIT ON
statements. Task ABC is performing a calculation every 40
milliĆseconds. Task XYZ is suspended waiting for event GAIN_OVER
to occur so that it can perform some calculations of its own. Task
XYZ needs to run only when event GAIN_OVER occurs, which, in
this example, will indicate that the variable GAIN is beyond a certain
maximum.
6Ć19
Task ABC
10 EVENT NAME=GAIN_OVER
.
.
.
90 IF GAIN>MAX_GAIN THEN SET GAIN_OVER
.
.
.
Task XYZ
30 EVENT NAME=GAIN_OVER
.
.
.
105 WAIT ON GAIN_OVER
.
.
.
The OPEN CHANNEL statement equates a logical name with a data
channel between two application tasks in the system. This statement
enables tasks to communicate with each other using INPUT and
PRINT statements. When a channel is opened between two tasks
and one task PRINTs to the other, the information is going to the
waiting task, not to a printer or serial port. When one task INPUTs
data from another, the data is being read from the other task that
has opened the channel.
The OPEN CHANNEL statement has two formats depending upon
which task it is being used in. The task sending data through the
channel must use the OPEN CHANNEL FOR OUTPUT format. The
task reading data from the channel must use the OPEN CHANNEL
FOR INPUT format. Multiple tasks can open the same channel for
output purposes and write data to it, but only one channel may open
the channel for input purposes and read from it.
Format for task writing to a channel:
OPEN CHANNEL FOR OUTPUT AS FILE #n, TYPE = (type)
Format for task reading from a channel:
OPEN CHANNEL FOR INPUT AS FILE #n, TYPE = (type), DEPTH = depth
n
= logical number assigned to the channel; range = 1Ć255;
the PRINT and INPUT statements must reference the same
number to identify this particular channel.
type = variable type or list of types that are to be passed through
the channel; multiple types must be separated by a
comma; this information allows the system to format each
piece of data when it passes it from one task to another.
I = single integer
D = double integer
R = real
S = string
B = boolean
6Ć20
Any combination of the above variable types is permitted;
however, a PRINT to or INPUT from this specific channel
must always pass the same number and type of variables
and in the same order that the type field specifies.
depth = how many messages this channel can hold before it is
considered full; this value must be an integer constant or
expression; specified only for the OPEN CHANNEL
statement in the task that is reading from the channel.
The task that is reading data (i.e., that contains the OPEN CHANNEL
FOR INPUT statement), creates the channel. If a task that is writing
data to a channel runs before the task that is reading data from the
channel, the task writing data is suspended until the task that is
reading data runs.
If a task tries to write data to a channel that is full (has reached the
maximum DEPTH), then that task will be suspended until one of the
queued messages is read by the task reading from the channel. If a
task attempts to read from a channel which is empty, that task will
be suspended until a message has been placed in the channel.
Note that the INPUT statement has a parameter (EMPTY) that allows
the task reading from the channel to transfer control to another line if
the channel is empty. The PRINT statement has a parameter (FULL)
that allows the task writing to the channel to transfer control to
another line if the channel is full.
Reading and writing to a channel can be used to synchronize
activities between two or more tasks. For example, task 1 could
perform some initialization and then INPUT from a channel. If the
channel is empty the task will be suspended until another task
PRINTs to the channel. Task 1 could then become active again when
one of several other tasks PRINTs information into the channel (such
as error or warning conditions). Task 1 could then record this
information and INPUT from the channel again, suspending the task
until more information is available.
The following are two examples of OPEN CHANNEL statements and
the corresponding INPUT and PRINT statements from that channel:
Task ABC
10 OPEN CHANNEL FOR OUTPUT AS FILE #1, TYPE = (I,I,S,R)
ąąă.
ąąă.
ąąă.
95 PRINT #1,(GAIN%*13),SPEED%,MESSAGE$,RATIO
ąąă.
ąąă.
ąąă.
Task XYZ
15 OPEN CHANNEL FOR INPUT AS FILE #1, TYPE = (I,I,S,R), DEPTH = 10
ąąă.
ąąă.
ąąă.
75 INPUT#1,NEW_GAIN%,CALC_SPEED%,TEXT$,RATIO
ąąă.
ąąă.
ąąă.
Note that the PRINT and INPUT statements have the same format
here as when they are used to access a device, except that OPEN
CHANNEL is used to define the logical channel number instead of
OPEN device_name." See section 6.8.
6Ć21
Tasks do not have to call the variables by the same names when
reading and writing to the channel; they simply write an integer
quantity (for an integer position in the template) and read an integer
quantity into an integer variable. Note that, just like the normal print
operation, the print list of items may contain any kind of expression,
which will be evaluated first and then printed. The number of items
and their data types used in a print or input to a channel must match
the OPEN CHANNEL definition; otherwise, an error will occur.
A CLOSE statement is not used with a channel because once it is
opened, it remains open. There is no provision to open and then
close channels.
6.7
Real Time Enhancements
BASIC provides two statements that allow specified sections of
tasks to be executed at a known time.
1. DELAY statement
2. START statement
6.7.1
DELAY Statement
The DELAY statement provides for a simple time delay in a task.
The following is the DELAY statement format:
DELAY n time_units
where:
n = any arithmetic expression or constant that evaluates to
an integer result
time_units = unit of time to be delayed
The possible time units for both the DELAY and the START
statement are TICKS, SECONDS, MINUTES, and HOURS. The tick
rate is userĆdefinable for each Processor being used. The range is
0.5 milliseconds to 10 milliseconds. The default tick rate is 5.5
milliseconds. The plural form of the time unit must always be used,
even when referring to one unit, e.g., DELAY 1 HOURS.
The following are valid DELAY statements:
30 DELAY 255 TICKS
80 DELAY ((OLD_TICKS%-2)*5) SECONDS
15 DELAY (1ST_SHIFT_LNG%) HOURS
40 DELAY 1 HOURS
In each of the above examples, when the DELAY statement
executes, the task will be suspended at that point for the specified
amount of time and then be eligible to run when the time interval
expires. At that time, the task begins execution at the line following
the DELAY statement.
6Ć22
The START EVERY statement format is similar to the DELAY
statement format but is used to do a periodic reĆstart or scan of the
task. The format of the START statement is:
START EVERY n time_units
where:
n = any arithmetic expression or constant that evaluates to
an integer result
time_units = unit of time to be delayed before starting
The possible time units for both the START and the DELAY
statements are ticks, seconds, minutes, and hours. The tick rate is
userĆdefinable for each Processor being used. The range is 0.5
milliseconds to 10 milliseconds. The default tick rate is 5.5
milliseconds. The plural form of the time unit must always be used,
e.g., DELAY 1 HOURS.
When a START EVERY statement executes, it notifies the operating
system that the task needs to be reĆstarted n time units" from now,
starting with the statement following the START EVERY statement.
After notifying the operating system, control is passed back to the
task, which continues to execute. The task will eventually execute an
END statement, which causes that task to relinquish control. When
the time interval in the START EVERY statement expires, the
operating system makes that task eligible to run. It will run unless
there is a higher priority task eligible to run.
The point in time when the task begins executing again is based on
how long the task runs after the START is encountered and before
an END statement is executed. Consider the following example:
10 . . .
20 . . .
ąąă.
ąąă.
ąąă.
200 START EVERY 20 TICKS
ąąă.
ąąă.
ąąă.
850 END
This body of the proĆ
gram will be eligible
to run every 20 ticks
starting after the START
EVERY statement.
The DELAY statement tells the operating system to stop the task
where it is and continue running it after a certain length of time.The
START EVERY statement effectively defines for the operating system
a reĆstart point and a time interval. The operating system will
automatically start the task at the next statement after the START
EVERY when that time period expires. The execution time required
for program body between the START EVERY and the END
statements must not be longer than the specified time period or an
overlap error will occur.
By using the START EVERY statement, the programmer can
program tasks to be scanned at a certain frequency, enabling him to
do the slower control loop functions in BASIC if he desires.
However, BASIC may be too slow to accommodate some high
speed control requirements. For most applications Control Block
language should be used. For more information, refer to the
AutoMax Control Block Language Instruction Manual (JĆ3676).
6Ć23
6.8
Communication Capabilities
BASIC communicates with other processing elements in a system,
including operator's terminals and other application tasks, using the
following statements. A number of these statements access
Processor serial ports.
1. OPEN statement
2. CLOSE statement
3. INPUT statement
4. PRINT/PRINT USING statement
5. IOWRITE statement
6. GET statement
7. PUT statement
8. READ statement
9. DATA statement
10. RESTORE statement
6.8.1
OPEN Statement
The OPEN statement allocates a Processor port to allow application
tasks to communicate with an external device such as a personal
computer. Once you allocate a port, you can use the INPUT, PRINT,
GET, or PUT statements to communicate through the port.
Depending on the port you are allocating, you may also need to use
the CLOSE statement in conjunction with the OPEN statement.
You can allocate a port only in a task running on the Processor that
contains the port. The OPEN statement cannot be used to
communicate with other tasks. See the OPEN CHANNEL statement
description in section 6.6.3 for information about interĆtask
communication.
Ports You Can Use for Serial Communication
Multibus rackĆbased Processor modules have two serial ports,
labeled PROGRAMMER/PORT B" and PORT A", reading top to
bottom. Use the PROGRAMMER/PORT B port for connecting the
Processor to the personal computer running the AutoMax
Programming Executive software. The other port, PORT A, is
available for use by application tasks. If there are multiple Processor
modules in the rack, only the leftmost PROGRAMMER/PORT B port
is reserved for communicating with the Executive software. All other
Processor ports in the rack are available for use by application
tasks.
The PC3000 Processor also has two serial communication ports.
The 25Ćpin DĆshell port works exactly like the PROGRAMMER/PORT
B port on the rackĆbased Processor described above. The 9Ćpin port
works like the
PORT A port on the rackĆbased Processor. On the PC3000, however,
both ports may be available for communication with external
devices, depending on the setting of jumper JP2. Refer to the
PC3000 User Manual, J2Ć3096, for more information on setting the
jumper.
6Ć24
How you use the OPEN statement depends on whether it is being
used with port A or port B. For port A, the OPEN statement is only
used to change the default setup and baud rate for the port. For port
B, the OPEN statement is used to change the default setup and
baud rate and to allocate the port. Port B must be allocated using
the OPEN statement prior to using any of the serial port statements
to communicate through the port.
OPEN device_name" AS FILE #logical_device_number,
SETUP=specs, baud_rate
OPEN device_name" AS FILE #logical_device_number,
ACCESS=status
where:
device_name =
The preĆassigned name of the port; PORTA for port A or PORTB
for port B.
logical_device_number =
The number assigned to the port in the OPEN statement. The #
symbol is required. Range: 1Ć255.
The number used when referencing port A or port B in the
CLOSE statement. See Configuring and Using Port A and
Configuring and Using Port B, below.
The number used when referencing port B in the INPUT, PRINT,
GET, and PUT statements. See Configuring and Using Port B,
below.
specs =
A hexadecimal single word constant or integer expression bit
pattern that defines various characteristics for the port. The bit
positions are defined below. The parameters SETUP and
ACCESS cannot be specified in the same OPEN statement.
The default setting is 0D00 (hex). Bits 0Ć7 of the word specify the
terminating character for the INPUT statement as a hex value for
the ASCII character. The specified terminating character must be
an ASCII value between 20 hex and 7E hex. Using an ASCII
value outside this range causes the error message Invalid
string character received" to be logged when the INPUT
statement reads data from the serial port. If these bits are left at
zero (0), the default input termination character, a carriage return
( 0D hex), is used.
When software handshaking (XĆON, XĆOFF) is enabled, XĆOFF
(CTRLĆS, 13 hex) will be sent when more than nine characters
are in the receive buffer. When a task (INPUT or GET statement )
empties the receive buffer, XĆON (CTRLĆQ, 11 hex) will be sent.
The ASCII characters XĆOFF or XĆON can not be transmitted as
user data because they would be interpreted as flow control
commands, not user data.
6Ć25
When hardware handshaking is enabled for a port, the DTR
(Data Terminal Ready) pin on the Processor port is false when
more than 53 characters are in the receive buffer. The DTR pin
on the Processor port is true when the receive buffer is emptied.
Refer to the appropriate Processor manual for the port wiring
required for hardware handshaking.
Note: The DSR pin on the Processor port must be true when
hardware handshaking has been enabled. True is defined as +5
to +12 volts and false is defined as -5 to -12 volts.
The RTS (Transmit Status, Modem Enable) pin on the Processor
port can be controlled in an application task by using the
[email protected] function or by the operating system if
hardware handshaking has been enabled.
The purpose of the RTS signal is to bracket" the character
transmission. To bracket a character transmission, RTS must be
set true prior to the first character being transmitted and remain
true until all of the characters have been transmitted. The RTS
signal can be used to enable/disable any type of external
equipment, such as a triĆstate transmit modem, which requires
an enable signal to output characters.
When hardware handshaking has been enabled for a port, the
operating system will automatically bracket the character
transmission. RTS is set true when data is loaded into the
transmit buffer and remains true until all the characters have
been transmitted.
If the external equipment being controlled requires an
enable/disable time of more than 1 msec, RTS must be
controlled in an application task using the
[email protected] Refer to the [email protected]
function for a description of the operation and an example
program.
If hardware handshaking is enabled and RTS is set true using
[email protected], RTS will remain true after all the characters
have been transmitted so that the application task can use
[email protected] to set it false.
6Ć26
hex number
0
15
14
D
13
12
11
10
0
9
8
7
6
0
5
4
3
2
1
0
OPTIONAL TERMINATION CHARACTER
FOR INPUT STATEMENTS
(D) = default
1:
0:
XĆON,XĆOFF HANDSHAKE ENABLED (D)
XĆON, XĆOFF HANDSHAKE DISABLED
1:
0:
HARD COPY DEVICE
NONĆHARD COPY DEVICE (D)
1:
0:
ECHO ON (D)
ECHO OFF
1:
0:
8 BIT CHARACTERS (D)
7 BIT CHARACTERS
1:
0:
EVEN PARITY
ODD PARITY (D)
1:
0:
PARITY ENABLED
PARITY DISABLED (D)
1:
0:
2 STOP BITS
1 STOP BIT (D)
1:
0:
HARDWARE HANDSHAKING ENABLED
HARDWARE HANDSHAKING DISABLED (D)
baud_rate =
134, 150, 200, 300, 600, 1200 (default), 1800, 2400, 4800, 9600,
and 19200 (19,200 for Processor module M/N 57C435 and
PC3000 Serial Option card). The baud rate must be specified if
the SETUP parameter is specified.
status =
Required only when using port B on a Processor. See
Configuring and Using Port B, below, for details. An optional
parameter. Specify as NON_EXCLUSIVE when more than one
task in the Processor must have access to port B. The
parameters SETUP and ACCESS cannot be specified in the
same OPEN statement.
If the ACCESS parameter is not specified, the access status is
EXCLUSIVE. If the status is EXCLUSIVE, no other task can read
or write to the port until the port is closed. Refer to Configuring
and Using Port B, below, for details.
For port A, the Processor's operating system allocates and
deĆallocates the port for access by any task in the Processor without
using an OPEN statement in any task. The operating system will
automatically allocate the port before executing the INPUT, PRINT,
GET or PUT statements and deĆallocate the port after executing the
statements. It will manage the port allocation and error handling
between tasks without any software interlocking being added in any
of the tasks.
If the operating system default port setup and baud rate described
are acceptable for your application, you can simply use the INPUT,
PRINT, GET, or PUT statements in any task on the Processor to
communicate through port A.
6Ć27
If the default setup or baud rate are not suitable for your application,
use the following OPEN statement format to temporarily allocate the
port for EXCLUSIVE access to change the default setup or baud
rate. This changes the default characteristics of the port until the
next power cycle or StopĆAllĆClear occurs. Use the CLOSE
statement to deĆallocate the port. The CLOSE statement must follow
the OPEN statement with no intervening INPUT, PRINT, GET or PUT
statements. The CLOSE statement must use the same device
number assigned in the OPEN statement.
OPEN PORTA" AS FILE #logical_device_number, SETUP=specs,
baud_rate \&
CLOSE #logical_device_number
Note: When an OPEN statement has a setup parameter, the port is
opened with EXCLUSIVE access. Therefore, specifying
ACCESS=NON_EXCLUSIVE causes a compile error to be logged. It
is not necessary to OPEN port A for NON_EXCLUSIVE access; this is
the default mode of operation. Do NOT use the device number
assigned in the OPEN statement to access the port in any
subsequent INPUT, PRINT, GET or PUT statements because the port
has been deĆallocated by the CLOSE statement above.
Examples:
INPUT INP%
INPUT:EMPTY=line_no, INP%
PRINT MSG$
GET CHAR$
GET:EMPTY=line_no, CHAR$
PUT CHAR$
1. Use port A instead of port B when port A is available because
the operating system manages port allocation and error
handling between tasks.
2. OPEN" the port to set required port characteristics, CLOSE"
the port, then use INPUT, PRINT, GET and PUT statements
without a device number in any task to access port A.
3. All tasks have only NON_EXCLUSIVE access to the port.
4. The port is opened and closed after each operation.
5. StopĆAllĆClear commands and power cycle close all ports. The
port characteristics are set to OS default. The user must set the
port to the required characteristics.
6. Stopping a task does not change the port setup and baud rate.
7. Errors logged to task information (for example, Framing,
Overrun, etc.) will have no major effect because the port is
opened and closed after each operation.
8. The serial port statements Print, Input, Put, and Get will operate
after an error has been logged because the port is opened and
closed after each operation.
The following example uses two tasks on the Processor to transmit
and receive data from port A. KYBD.BAS sets the characteristics for
6Ć28
port A and then closes the port. If USERNAME$ is blank, KYBD.BAS
prompts the user to enter his name. DISPLAY.BAS displays the
message Hello World" and the user name if USERNAME$ is not
blank. Because KYBD.BAS closes the port after setting the port
characteristics, any task in the Processor can access (read from or
write to) the port without using a logical device number with the
INPUT, PRINT, GET or PUT statements.
100 COMMON USERNAME$
:
900 USERNAME$ = "
:
1000
OPEN PORTA" AS FILE #1, SETUP=(0800H,
9600) \ CLOSE #1
:
2000
IF USERNAME$ = " THEN
PRINT ; CLRSCR$(2); CURPOS$( 10,10);
Please enter your name ;
INPUT USERNAME$
END_IF
2100
DELAY 10 TICKS \ GOTO 2000
:
32767
END
100
COMMON USERNAME$
:
900
USERNAME$ = "
:
2000
IF USERNAME$ <> " THEN
PRINT ; CURPOS$(20,10); Hello World, my
name is ; USERNAME$;
DELAY 5 SECONDS \ USERNAME$ = "
END_IF
2100
DELAY 10 TICKS \ GOTO 2000
:
32767
END
6Ć29
For port B, you must use the OPEN statement in a task to allocate
the port before the task can communicate through the port, even if
the default port setup and baud rate are acceptable for your
application.
If the default setup or baud rate are not suitable for your application,
use the following OPEN statement format to temporarily allocate the
port for EXCLUSIVE access to change the default setup or baud
rate. This changes the default characteristics of the port until the
next power cycle or StopĆAllĆClear occurs. Use the CLOSE
statement to deĆallocate the port. The CLOSE statement must follow
the OPEN statement with no intervening INPUT, PRINT, GET or PUT
statements. The CLOSE statement must use the same device
number assigned in the OPEN statement.
OPEN PORTB" AS FILE #logical_device_number,
SETUP=specs, baud_rate \&
CLOSE #logical_device_number
Note: When an OPEN statement has a setup parameter, the port is
opened with EXCLUSIVE access. Therefore, specifying
ACCESS=NON_EXCLUSIVE causes a compile error to be logged. A
second OPEN statement must be added after the port is closed as
shown below.
If the default or configured port setup and baud rate are proper for
your application, use the following OPEN statement format to
allocate the port for NON_EXCLUSIVE access so the task can
communicate through the port. The port must remain open to
execute subsequent INPUT, PRINT, GET, or PUT statements.
OPEN PORTB" AS FILE #logical_device_number,
ACCESS=NON_EXCLUSIVE
The format of the INPUT, PRINT, GET, or PUT statements used to
communicate through the port is INPUT #, PRINT #, GET # or PUT
#, where # is the device number assigned to the port in the OPEN
statement. Whenever you refer to the port in subsequent
statements, always use the device number assigned to the port in
the OPEN statement.
In addition, if you want to make the port accessible to multiple tasks
in the Processor at the same time, you must add an OPEN
statement with the ACCESS parameter specified as
NON_EXCLUSIVE in each task that must communicate through the
port using the same logical_device_number that was used to identify
the port in the first task.
You must add software interlocking to each task attempting to
allocate the port to ensure that the task can determine whether the
port setup and baud rate have been initialized prior to opening the
port for NON_EXCLUSIVE access. Only one task needs to allocate
the port and define the setup and baud rate initially. Software
interlocking is also needed for port error handling. Tasks may need
to close and reĆopen the port on error conditions.
6Ć30
Port B Application Notes
1. Port B requires port allocation and error handling to be handled
by the application tasks.
2. OPEN" the port to set the required port characteristics, then
CLOSE" the port.
3. OPEN" the port for NON_EXCLUSIVE access in each task that
needs access to the port. Use the same device number to open
the port in all tasks.
4. Use INPUT #, PRINT #, GET #, and PUT # statements with the
device number used in the OPEN statement to access port B.
5. StopĆAllĆClear commands and power cycle close all ports. Port
characteristics are set to the OS default; the user must set the
port to the required characteristics.
6. Stopping a task does not change the port setup and baud rate.
7. Stopping a task that has EXCLUSIVE access to the port closes
the port on the Processor.
8. Stopping a task that has NON_EXCLUSIVE access only disables
access to the port for the task that was stopped. The other tasks
referencing the port can still transmit or receive data.
9. The operating system does not deĆallocate the port (make the
port available for EXCLUSIVE access) until all tasks referencing
the port have closed the port.
10. Port errors logged to task information (for example, Framing,
Overrun, etc.) will close the port that logged the error.
11. If the port is closed via CLOSE or error, then port statements
PRINT, INPUT, PUT and GET will fail. They will log a Port Not
Open (properly)" error message and abort the operation. No
data will be sent for PRINT and PUT. INPUT and GET will not
suspend the task but will proceed to the next statement on the
current line or next line number. INPUT:EMPTY= and
GET:EMPTY= will not branch to the specified EMPTY line
number, but will operate like the INPUT and GET statements
described above.
Programming Example
The following example uses two tasks on the processor to transmit
and receive data from port B. Software interlocking must be added
to each task attempting to allocate the port to ensure that the tasks
can determine whether the port setup and baud rate have been
initialized prior to opening the port for NON_EXCLUSIVE access.
KYBD.BAS sets the characteristics for port B, closes the port,
reĆopens the port for NON_EXCLUSIVE access, and then sets the
software interlocking flag [email protected] TRUE so that DISPLAY.BAS
can open the port for NON_EXCLUSIVE access.
If USERNAME$ is blank, KYBD.BAS prompts the user to enter his
name. DISPLAY.BAS displays the Hello World" message and the
user name if USERNAME$ is not blank. Because the port must be
opened by each task that needs access to the port, the logical
device number used in the OPEN statement must be used with the
INPUT, PRINT, GET or PUT statements.
6Ć31
100
COMMON USERNAME$
110
COMMON [email protected],
[email protected]
:
900
USERNAME$ = "
910
[email protected] = FALSE
:
1000
IF [email protected] THEN DELAY 10 TICKS \ GOTO
1000
1100
OPEN PORTB" AS FILE #2, SETUP=(0800H,
9600) \ CLOSE #2
1110
OPEN PORTB" AS FILE #2,
ACCESS=NON_EXCLUSIVE
1120
! Add initialization code as required
:
1200
[email protected] = TRUE
1210
IF NOT [email protected] THEN DELAY 10 TICKS \
GOTO 1210
:
2000
IF USERNAME$ = " THEN
PRINT #2; CLRSCR$(2); CURPOS$( 10,10);
Please enter your name ;
INPUT #2 USERNAME$
END_IF
2100
DELAY 10 TICKS \ GOTO 2000
:
32767
END
100
110
:
900
910
1000
1010
:
1200
1210
1220
:
2000
2100
:
32767
6Ć32
COMMON USERNAME$
COMMON [email protected],
[email protected]
USERNAME$ = "
[email protected] = FALSE
IF [email protected] THEN DELAY 10 TICKS \ GOTO
1000
! Add initialization code as required
IF NOT [email protected] THEN DELAY 10 TICKS \
GOTO 1200
OPEN PORTB" AS FILE #2,
ACCESS=NON_EXCLUSIVE
[email protected] = TRUE
IF USERNAME$ <> " THEN
PRINT #2 ; CURPOS$(20,10); Hello World,
my name is ; USERNAME$;
DELAY 5 SECONDS \ USERNAME$ = "
END_IF
DELAY 10 TICKS \ GOTO 2000
END
6.8.2
CLOSE Statement
The CLOSE statement is used to deĆallocate a channel or port to
allow other application tasks to have access to it. The CLOSE
statement has the following format:
CLOSE #logical_device_number, #logical_
device_number,...
where:
logical_device_number = number assigned to device by OPEN
statement (1 to 255)
The following are valid CLOSE statements:
20 CLOSE #1,#2
99 CLOSE #3
The number symbol (#) must always be present in front of the
logical device number assigned to the device.
If PRINT or INPUT statements use the default port (e.g., PRINT F%
or INPUT M$), there is no need for either an OPEN or CLOSE
statement.
Channels that are opened, as opposed to devices, remain opened
until the task is restarted.
Refer to the OPEN statement description (6.8.1) for more informtion
on how the CLOSE statement is used with the OPEN statement.
6.8.3
INPUT Statement
The INPUT statement is used to prompt an operator to input data
from a device or channel. It has the format:
INPUT #logical_device_number, input_list
where:
logical_device_number =
number assigned to device or channel by OPEN statement (1 to
255). Not used if default device is used.
input_list =
list of variables to be read. Variables can be simple or
subscripted (no expressions).
The optional parameter :EMPTY=n can be used to transfer control
of the program in the event that the channel is empty. This option is
only allowed for channels and not devices. The parameter is added
immediately after the device number; n is the line number to which
to transfer control.
If more than one variable is to be read, the fields must be separated
by commas when entered. Any extra spaces or tabs between the
input fields are ignored.
When an INPUT statement is executed in BASIC, an input prompt is
printed to the device to indicate that the system is waiting for
something to be entered. The input prompt is a question mark
followed by a space (?).
The number of fields requested in the INPUT statement are then
entered at the device, followed by the terminator character (<CR>).
If all of the requested fields are not entered prior to the (<CR>), the
6Ć33
system will prompt again, indicating that it is waiting for more data.
The system will also prompt again if the operator enters just a
<CR> by itself. It will reprompt after every <CR> until all the
expected data is received. Note that the receive FIFO queue will
accept a maximum of 64 bytes. If more than 64 bytes are
received without the queue being emptied, the additional data is
discarded.
In the following example, 3 integer fields are expected by the INPUT
routine, but only 2 are entered the first time. BASIC prompts again
for the third number to be entered. The fields can be separated with
commas or spaces if the prompt is off. If the prompt is on, each field
is separated with <CR>.
In the task:
10 INPUT A%, B%, C%
On the display screen:
?34,56
<CR>
?46
?
<CR>
If you make a mistake while entering data, use the backspace key to
back up the cursor and enter the correct data. Enter <CrtlĆU> to
cancel any data on the line. If the data entered is totally incorrect,
enter <CtrlĆC> to cancel the INPUT completely. If this is done, none
of the variables in the INPUT statement will be updated and
execution will continue with the next statement after the INPUT.
When the prompt is enabled, certain error messages are displayed
to the user if his input data is invalid. For example, if the statement is
INPUT A% and the value entered is either out of range (not +32767
to -32768) or of the wrong type (string instead of integer), the
system will prompt:
>>>>>INVALID DATA TYPE Ć INPUT AGAIN<<<<<<
and reĆprompt for data that will fit into a single integer (+32767 to
-32768).
You can enable or disable the input prompt by writing to the variable
[email protected]". This symbol is automatically allocated as a local
variable when the task is created. At powerĆup, it has the value
TRUE (print a prompt character during input). If the value of this
variable is changed to FALSE, the prompt is disabled.
You may find it desirable to disable the prompt when you are
soliciting input from a personal computer and do not wish to have
the prompt character appear on the display. However, when the
prompt is disabled, any input errors that occur will result in a
runĆtime error. Program execution will continue with the next
statement. Therefore, when you disable the prompt, you should use
the ON ERROR GOTO statement to initiate an errorĆhandling routine.
The following are valid INPUT statements:
20 INPUT #1,A%,B%
30 INPUT A%,B%
40ăINPUT #3:FULL=80, C%
It is possible to define a character other than carriage return
(<CR>)as the terminator for data in an INPUT statement. This is
done by loading the ASCII value of the character into the lower 8
6Ć34
bits of the device characteristics word in the SETUP portion of the
OPEN statement. For example, if you wanted to use a question mark
(hexadecimal 3F in ASCII) as the terminating character, you would
open the device as follows:
OPEN PORTA" AS FILE #2, SETUP=(OD3FH,1200)
The same rules apply to inputs not terminated by a carriage return
as to the disabled prompt input: no error messages and all data
must be entered at the same time.
Using a different terminator is more useful for those tasks
communicating to other devices or computers where the data
transmitted is not terminated with <CR> but another character. This
allows reading data from one of those devices without having to
accumulate the characters one at a time with a GET statement.
Refer to the OPEN statement description (6.8.1) for more information
on how the INPUT statement is used with the OPEN statement.
6.8.4
PRINT/PRINT USING Statements
The PRINT and PRINT USING statements are used to communicate
with I/O devices, such as a personal computer, or a line printer, or
another BASIC task. The OPEN statement is used to select to which I/O
port the PRINT/INPUT applies. Refer to the OPEN statement description
(6.8.1) for more information on how the PRINT statement is used with
the OPEN statement. The PRINT statement has the following basic
format (PRINT USING is defined separately in this section):
PRINT #logical_device_number, print_list
where:
logical_device_number =
logical number (1 to 255) assigned to a device
or channel during an OPEN statement. If no
device number is given, the default device is
PORTA on the Processor module on which this
tasks resides. Most application task I/O will be
handled through this default port.
print_list =
list of data items to be printed, such as:
DąInteger variables and integer expressions
DąReal variables and real expressions
DąBoolean variables and boolean expressions
DąString variables and string expressions
The optional parameter :FULL=n can be used to transfer control of
the program in the event that the channel is full. This option is only
allowed for channels and not devices. The parameter is added
immediately after the device number; n is the line number to which
to transfer control.
If the logical_device_number specifies a channel and not a device,
the number and type of items printed must match exactly the
channel template as specified in the OPEN CHANNEL statement.
6Ć35
The following is a typical PRINT statement using the default port
(PORTA):
40 PRINT A%,B%, MESSAGE$,C% + D%
The output line would be 13 29 MOTOR 53, assuming the following
values for this statement:
A%=13
B%=29
C%=36
D%=17
MESSAGE$ = MOTOR"
The following are all valid PRINT statements:
5ăOPEN CHANNEL FOR OUTPUT AS FILE #6 , TYPE=(S)
10ăPRINT #6:FULL=30, STRING$
20 PRINT SPEED%,[email protected],5,7,19*B%
30 PRINT THIS IS THE REFERENCE",REFERENCE%
40 PRINT ((SPEED% + GAIN%)/14),B%,C%,GAIN [email protected]
50 PRINT #2,A$ +STUFF"+LEFT$(A$,4)
Note that when a boolean variable is printed, it is displayed as
TRUE" or FALSE".
When printing items in BASIC, the individual fields can be separated
in one of two ways: with a comma or a semicolon. If the fields are
separated by a comma, the items will be printed rightĆjustified in
print zones" of 15 character positions wide. The following is an
example:
10 PRINT A%,C!,[email protected]
This prints as follows:
298ąąąąąąą12376ąąąąąąFALSE
123456789012345 123456789012345 123456789012345*
* Used in this example only to show print zones.
The only exception to this is when a string that is greater than 15
characters is printed. The print zone for that string will be the next
integral multiple of 15 greater than the string length. If the string is 1
to 15 characters, the print zone is 15. If the length is 16 to 30
characters, the print zone is 30 characters, and so on.
If the items in the print list are separated by a semicolon, the print
fields are separated by a single space unless they are string fields. If
they are string fields, there are no spaces between them:
10 PRINT ABC%;STRING_1$;STRING_2$,XYZ%;[email protected]
6Ć36
This prints as follows:
567THIS IS STRING1THIS IS STRING2 98 FALSE
1 SPACE BEFORE BOOLEAN
1 SPACE BEFORE NUMERIC
NO SPACES BEFORE STRING FIELD
NO SPACES BEFORE STRING FIELD
The semicolon can be used at the beginning of a statement to
prevent zoning of the first item printed. The semicolon can also be
used at the end of a PRINT statement to tell BASIC not to advance
the print pointer to the next line after the print occurs but to leave it
at the end of the line. This is useful when an INPUT statement
immediately follows the PRINT statement.
In Enhanced BASIC, all decimal numbers have 8 digits of
significance. Therefore, only 8 digits can be printed for the number,
whether it is very small or very large. To print very large numbers or
very small numbers, a scientific or exponential format must be used.
For example, the numbers 1.7634736E+17 and 2.8876582E-09
only have 8 digits of precision printed but use scientific notation to
show the number of decimal places to the right or left where the real
decimal point would be placed.
In BASIC, unformatted (using the PRINT statement instead of the
PRINT USING statement) decimal numbers are printed according to
the following rules:
1. BASIC will attempt to locate the decimal point such that there is
no need for an exponent.
Example: 123.45678 or 0.12345678 or 1234567.8
2. If this is not possible, the number will arbitrarily be printed with
one number to the left of a decimal point and an exponent or
scientific notation will be used.
Example: 3.7836524E+12 or 4.8873633E-17
3. If the number is a true fraction and requires no exponent, there
will always be a leading zero in front of the decimal point.
Example: 0.98272635 or 0.18735354 or -0.87725433
PRINT USING allows you to print numeric fields with a specific
number of decimal places and field width:
PRINT USING #logical_device_number,formatted_ print_ list
where:
logical_device_number =
the logical number assigned to a device(PRINT
USING to a channel is not permitted) during an
OPEN statement. If no device number is given,
default device is PORTA on the Processor
module on which the task resides. Most
application task I/O can be handled through
the default port.
6Ć37
formatted_print_list =
list of formatted data fields
The individual formatted data fields have the following form:
<format_type> <field_width> : <variable>
where:
<format_type> =
L
R
C
Z
format
<field_width> =
D
LeftĆJustify the print expression
RightĆJustify the print expression
Center the print expression in the field
Load leading zeros in front of the print
expression
Print the numeric field in a decimal
The field width has only one part if the format
type is L/R/C/Z, in which case the field width is
an integer or integer expression from 1 to 132.
If the decimal format D is used, the field width
has 2 parts: <integer1>.<integer2>
Integer1 is the total field width for the result.
This includes the minus sign (if any), the
number part to the left of the decimal point, the
decimal point, and any number on the right of
the decimal point. This total field may be in the
range 3 to 132.
Integer2 specifies the number of decimal
places to the right of the decimal point to be
printed. This number may be in the range 0 to
26.
Integer1 and integer2 may be either integer
literals or integer expressions. If expressions
are used, they must be enclosed in
parentheses.
<variable> =
Data item to be printed. Multiple items are
separated by commas or semiĆcolons. See the
PRINT statement for more information on
commas and semiĆcolons when printing.
The following are PRINT USING examples using the L/R/C/Z
FORMATS:
ă2 A% = 14 \ B% = 26 \ [email protected] = TRUE
ă5 STRING$ = CHARACTERS"
10 PRINT USING L40:STRING$
20 PRINT USING R40:STRING$
30 PRINT USING C(A% + B%):STRING$
40 PRINT USING Z40:STRING$
50 PRINT USING L40:[email protected]
Statement 10 will left justify CHARACTERS" in a 40Ćcharacter field
beginning with column 1.
6Ć38
The next print expression would start in column 41:
column 1
CHARACTERS
column 41
40-CHARACTER FIELD
Print statements 20,30,40, and 50 would appear as follows:
ăăăăăăăăăăăăăăăăă CHARACTERS
CHARACTERS
000000000000000000000000000000CHARACTERS
TRUE.
The L/R/C/Z formats are used mainly for string fields. These formats
can, however, be used to print any data type. If these formats are
used to print a numeric field, the resulting number will be in the
same decimal format as described for the unformatted PRINT:
D BASIC will use the 8 digits of significance available and attempt
to locate the decimal point such that there is no need for an
exponent (123.45678 or .12345678 or 1234567.8).
D If this is not possible, the number will be given one numeric
position to the left of a decimal point and an exponent will be
used (3.7836524E+12).
In either case, the number will be treated just like a string" and will
be right or left justified using the same rules as a string would be
when using the L/R/C/Z formats.
Only numeric expressions can use the decimal (D) format of PRINT
USING. This includes integers or floating point numbers (decimal
numbers). The following are some examples using the D format:
5 BIG_NUMBER =21.7654E+10
7 FIELD_WIDTH = 40
10 PRINT USING D(FIELD_WITH+5) .2:BIG_NUMBER
15 SPEED = 2.887654
20 PRINT USING D25.6:SPEED
25 REFERENCE% = 124
30 PRINT USING D10.1:REFERENCE%
column 1
ăăă column 26 ă
ă ă column 46
123456789012345678901234567890123456789012345
ă 124.0
Statement 30
0000.00
2.887654
Statement 20
21765400
Statement 10
Note that, when the integer REFERENCE% was printed with a
format of D10.1, the numbers after the decimal were added and set
to zero even though REFERENCE% as an integer has no fractional
part. This will occur with all integers when the number of decimal
6Ć39
places to the right of the decimal point is specified as greater than
zero.
The following are all valid PRINT USING statements:
20 PRINT USING L24:HI",R34:THERE"
20 PRINT USING L40:HI" + THERE"
20 PRINT USING D80.0:CURRENT_REFERENCE
20 PRINT USING &
D(LINEWIDTH%-16).(DECPTS%):SPEED
20 PRINT USING L42:INTEGER%,SPEED
In the last example, an unformatted print field follows a formatted
one of L42:INTEGER%, which is legal. Unformatted print
expressions may be mixed with formatted expressions in PRINT
USING. However, an unformatted PRINT statement may not contain
formatted print fields. If an unformatted print expression is used in a
PRINT USING statement, it will follow the same rules for zoning" as
the PRINT statement.
Commas or semicolons may be used to separate fields in a PRINT
USING statement the same way as in the PRINT statement. If
formatted fields are used backĆtoĆback, they are not zoned but get
their format information from the format type they are printing
(L/R/C/Z/D/). If a nonĆformatted field follows a formatted field and
they are separated by a comma, the nonĆformatted field will follow
the same rules as the normal PRINT statement: it will zone the
unformatted value.
6Ć40
6.8.5
IOWRITE Statement (Accessing Foreign I/O)
See JĆ3649, JĆ3750 or J2Ć3045 for the requirements for using foreign
modules in an AutoMax system. Once it is determined that all the
requirements have been met, you can use the IOWRITE statement
to write to the foreign modules. The IOWRITE statement can also be
used to write to AutoMax Modules that have not been configured.
The base address of each slot in an AutoMax chassis is:
20FFFF(Hex)
slot #0 ĆAddress Range 200000 Ć
slot #1 ĆAddress Range 210000 Ć
21FFFF(Hex)
slot #2 ĆAddress Range 220000 Ć
22FFFF(Hex)
23FFFF(Hex)
slot #3 ĆAddress Range 230000 Ć
24FFFF(Hex)
slot #4 ĆAddress Range 240000 Ć
slot #5 ĆAddress Range 250000 Ć
25FFFF(Hex)
26FFFF(Hex)
slot #6 ĆAddress Range 260000 Ć
27FFFF(Hex)
slot #7 ĆAddress Range 270000 Ć
slot #8 ĆAddress Range 280000 Ć
28FFFF(Hex)
29FFFF(Hex)
slot #9 ĆAddress Range 290000 Ć
slot #10 ĆAddress Range 2A0000 Ć
2AFFFF(Hex)
slot #11 ĆAddress Range 2B0000 Ć
2BFFFF(Hex)
slot #12 ĆAddress Range 2C0000 Ć
2CFFFF(Hex)
slot #13 ĆAddress Range 2D0000 Ć
2DFFFF(Hex)
slot #14 ĆAddress Range 2E0000 Ć
2EFFFF(Hex)
slot #15 ĆAddress Range 2F0000 Ć
2FFFFF(Hex)
Each slot in the rack has 64 K of address space.
Attempting to access memory on AutoMax Processors is not
permitted. The following is the format of the IOWRITE statement:
IOWRITE(option, data, address)
where:
option =
the kind of write to take place; literal or
expression:
1 = single byte write (low byte of data is written to the
address)
2 = double byte write (address must be even)(MSB is
written to the address) (LSB is written to the
address + 1) This option is used to write to
foreign I/O modules that only support an 8Ćbit
data path.
3 = word write (address) = A 16Ćbit word is written to
the designated address. This option writes data
to modules that support AutoMax addressing
and data conventions.
4 = long word write (address) = MSB
(address + 1) = next 8 bits
(address + 2) = next 8 bits
(address + 3) = LSB
data =
integer variable name or expression defining
data to output; literal or expression
address =
double integer variable name or expression
defining the destination address; literal or
expression; must be > 220000H
6Ć41
Note that all taskĆtoĆtask communication information is managed by
the system on the Common Memory module (M/N 57C413).
The GET statement is used to input a single character from a device
(not a channel). The GET statement has the following format:
GET #logical_device_number, string_variable
where:
logical_device_number =
the logical number assigned to a device during
an OPEN statement. If no device number
given, the default device is PORTA on the
Processor module on which the task resides.
string_variable =
a variable of data type string only
The GET statement reads a single character from a device and
loads the character into a string variable. The character is NOT
echoed to the device as it is with an INPUT operation.
The optional parameter :EMPTY=n can be used to transfer control
of the program in the event that the channel is empty. The
parameter is added immediately after the device number; n is the
line number to which to transfer control.
The following are valid GET statements:
20ăGET #2,A$
30ăGET A$
40ăGET #4:EMPTY=50, CHAR$
Refer to the OPEN statement description (6.8.1) for more information
on how the GET statement is used with the OPEN statement.
The PUT statement is used to output a single character from a
device (not a channel). The PUT statement has the following format:
PUT #logical_device_number, string_variable
where:
logical_device_number =
the logical number assigned to a device during
an OPEN statement. If no device number is
given, the default device is PORTA on the
Processor module on which the task resides.
string variable =
variable of data type string
The PUT statement outputs a single character from a string variable
to a device. The operation does not generate a <CR> <LF> as a
standard PRINT operation does.
The following are valid PUT statements:
20 PUT #2,A$
30 PUT A$
6Ć42
Refer to the OPEN statement description (6.8.1) for more information
on how the GET statement is used with the OPEN statement.
The READ statement directs the system to read from a list of values
built in a data block by a DATA statement. A READ statement is not
legal without at least one DATA statement.
A READ statement causes the variables listed in it to be given the
value of the next expression in the next DATA statement. BASIC has
a pointer to keep track of the data being read by the READ
statement. Each time the READ statement requests data, BASIC
retrieves the next expression indicated by the data pointer.
The READ statement has the following format:
READ variable_1,variable_2,...,variable_N
where:
variable_1 through variable_N = the value(s) listed in the DATA
statements
The variables can be simple (A%) or subscripted (A%(4)) and can be
any of the five variable types: integer, double integer, real, string,
and boolean. All variables should be separated by commas. String
variables should be enclosed within single or double quotes.
The following is a valid READ statement:
10 READ A%,B%,C$,D%(5)
The DATA statement has the following format:
DATA expression_1, expression_2,... ,expression_n
where:
expression_1 to expression_n =
expression that, after evaluation, is loaded into
the corresponding variable in a READ
statement when the READ is executed
The data type of the expression in the DATA statement must be the
same as the data type of the variable that corresponds to it in the
READ statement.
The program will run faster with READ and DATA statements as
opposed to the INPUT statement simply because the system does
not have to wait the extra time it takes for the system to stop and
request data. The data is already within the program.
The DATA statements may be formatted with any number of
expressions as long as the same number is being requested by the
READ statements:
10 READ A,B,C,D,E,F
20 ...
30 ...
40 ...
800 DATA 17
900 DATA 25,30,43,76,29
6Ć43
The number of variables in the READ statement does not have to
match the number of expressions in a specific DATA statement.
BASIC will simply go to the next sequential DATA statement in the
program to acquire the value. The variable type and expression
must match.
A READ statement is not legal without at least one DATA statement.
However, you can have more than one DATA statement as long as
there is one READ statement in the program:
10 READ A,B,C,D,E,F
20...
30...
40...
50 DATA 17,25,30
60 DATA 43,76,29
A READ statement can be placed anywhere in a multiĆstatement
line. A DATA statement, however, must be the only statement on a
line.
If you build your READ statement with more variables than you
include in the data block, the system will print an error message
when it attempts to access the next DATA expression and finds one
is not there.
The following is an example of a READ and DATA sequence:
10 READ A%,B,C1!,D2%,[email protected],E6$,Z$
20 DATA 2,32.9987,(83+19),-6, TRUE, CAT",'DOG'
30 PRINT A%,B,C1!,D2%,[email protected],E6$,Z$
In the example above, BASIC assigns these values:
A% = 2
B = 32.9987
C1! =102
D2% =-6
[email protected] = TRUE
E6$ = CAT
Z$ = DOG
READ and DATA are useful to initialize the values of variables and
arrays at the beginning of a program. To do this, place READ
statements at the beginning of the program. You can put the DATA
statements anywhere in the program. It is often useful to put them all
at the end of the program just before the END statement. See also
the RESTORE statement.
The RESTORE statement is used when reading from a DATA
statement more than once. When you READ data from a series of
DATA statements, BASIC advances an internal pointer to the next
item in the data list every time a READ is done. Once you have read
all the items in the data list, this internal pointer points to the end of
the data list. If you want to read starting with the first DATA
statement, the RESTORE statement tells BASIC to reset its pointer to
the beginning of the DATA statements. The RESTORE statement has
the format:
RESTORE
or
RESTORE line_number(expression)
6Ć44
The effect of the first format (with no line number) is to move the
DATA statement pointer back to the first DATA statement in the
program. The effect of the second format (with the line number) is to
reset the DATA statement internal pointer to the DATA statement at
the line number specified following the RESTORE. This line number
may be specified either by an integer constant or integer expression.
There must be a DATA statement at the line number that follows the
RESTORE or the system will generate a STOP ALL error. A
RESTORE can be used at any time, not only when all the DATA
statements have been read or at the end of the data.
6.9
Error Handling
During the execution of a BASIC task, error conditions can occur
that are not severe enough to stop the task but are worth noting. All
errors that happen during execution are logged in the task error log,
accessible through the onĆline menu of the Programming Executive
software. If the error is severe, it is displayed on the two 7Ćsegment
LEDs on the Processor module (M/N 57C430, 57C430A, 57C431,
and 57C435) and all tasks are stopped. See JĆ3684, JĆ3750 or
J2Ć3045 for more information.
BASIC provides two statements to help deal with errors that occur
during execution.
1. ON ERROR statement
2. RESUME statement
6.9.1
ON ERROR Statement
The ON ERROR statement is used to define where the task should
transfer control if a nonĆfatal error occurs. The ON ERROR statement
has the following format:
ON ERROR GOTO line_number
where:
line_number =
line_number where
error handling routine begins.
When BASIC executes the ON ERROR statement, it stores the line
number referenced for later reference. When an error occurs, BASIC
transfers control of the program immediately to that line number.
The ON ERROR statement may be executed as many times as
desired. BASIC reĆloads the error handler line number each time.
To tell the user what kind of error occurred and where it took place.
BASIC provides two preĆdefined symbols:
D ERR% Ć The error number of the logged error (decimal
ăerror number)
D ERL% Ć The line number where the error occurred
These symbols are automatically defined when the task is created
and can be accessed the same as any other variable. Refer to
Appendix B for a complete listing of runĆtime error codes.
6Ć45
6.9.2
RESUME Statement
After BASIC has transferred control to an error handling routine,
RESUME tells BASIC that the error handling is complete. The
RESUME statement has the following format:
RESUME
The RESUME statement returns processing to the statement that
was in progress when the error condition diverted it to the error
handling routine.
The following is a program with a valid RESUME statement:
10 ON ERROR GOTO 850
.
.
.
850!ĆĆĆĆĆĆĆĆRun time error handlerĆĆĆĆĆĆĆ
860!
870 IF ERR% = INT_VAR_OVRFLOW% AND &
ERL% = 720 THEN GAIN = 0
880...
890...
895...
900 RESUME
6.9.3
CLR_ERRLOG
The statement CLR_ERRLOG is used to clear the error log for the
application task, regardless of the number of logged errors. See
7.35 for more information about testing the error log. The format of
the statement is:
CLR_ERRLOG.
6.10
INCLUDE Statement
The INCLUDE statement allows the programmer to include a file
containing BASIC statements in the task as it is compiling.
MultiĆstatement lines and multiĆline statements are permitted. The
file must not include line numbers. The compiler will add line
numbers in increments of 1, beginning with the INCLUDE statement
line number. The programmer must allow enough line numbers
between the INCLUDE statement and the statement that follows it to
accommodate the lines automatically generated. There are no limits
on the number of INCLUDE statements in a task. However, no
INCLUDE statements are permitted in a file that will be included in
the task. The format of the INCLUDE statement is:
INCLUDE filename.INC"
where:
filename =
6Ć46
name of the file containing the statements to
be included. The extension .INC is required.
No drive or subdirectory specification is
permitted. The file to be included must be
located in the drive and subdirectory in which
the task is located.
When you save a reconstructible task from the processor, the
system will write the lines included back to a file with the same
filename as specified in the INCLUDE statement. The reconstructed
file will look exactly like the source file. See JĆ3684, JĆ3750 or
J2Ć3045 for more information on reconstructible tasks.
The following is an example of a valid INCLUDE statement:
50 INCLUDE IODEFS.INC"
The file IODEFS.INC contains the following:
IODEFă[email protected]ă[SLOT=3,REGISTER=1,BIT=4]
IODEFă[email protected]ă[SLOT=3,REGISTER=1,BIT=5]
IODEFă[email protected]ă[SLOT=3,REGISTER=1,BIT=6]
When the file is compiled, it will look like this to the compiler:
50ăINCLUDE IODEFS.INC"
51ăIODEFă[email protected]ă[SLOT=3,REGISTER=1,BIT=4]
52ăIODEFă[email protected]ă[SLOT=3,REGISTER=1,BIT=5]
53ăIODEFă[email protected]ă[SLOT=3,REGISTER=1,BIT=6]
6.11
Stopping Execution
(STOP and END Statements)
WARNING
CAREFULLY REVIEW MACHINE OPERATION TO INSURE THAT UNSAFE
MOVEMENT IS NOT INITIATED BY STOPPING ALL APPLICATION SOFTWARE.
FAILURE TO OBSERVE THIS PRECAUTION COULD RESULT IN BODILY INJURY
OR DAMAGE TO EQUIPMENT.
The STOP statement will stop all tasks in the system and should
only be used when a severe error has occurred. It will not be
possible to continue from a stopped" state without reĆstarting all
tasks in the rack. The STOP statement has the following format:
STOP
The following are valid STOP statements:
20 IF [email protected] THEN STOP
20 IF GAIN%>MAXGAIN% THEN PRINT ăăăăă&
ERROR_MESSAGE$\STOP
The END statement is used to end the task execution or to place the
task in a suspended state until the time interval that was
programmed in a START EVERY statement expires. If a task has a
periodic execution defined, it will at some later point be reĆactivated
when that period or interval expires. Refer to section 6.7 for more
information.
The END statement has the format:
END
The END statement must be at the physical end of the task.
6Ć47
fafadfdfdasfdsfdsdsdfdsfdsfdsfsdfdsa
afdfdsfdsfdfdsfdsfsadfda
asfdfaddfdd
;:5(> 4/(4*,+ 04*58658(:,9 4;3,85;9 04:80490*
-;4*:0549 0, -;4*:0549 :/(: *(4 ), ;9,+ =0:/04 ,>68,990549 53,
(8, 9:(4+(8+ (4+ 953, /(<, ),,4 (++,+ :5 *5362,3,4: :/,
;:5(> ,4<08543,4: !/, -5225=04. 09 ( 209: 5- :/, *;88,4: -;4*:0549
(<(02()2, -58 ;9, 04 (4 ;:5(> 9?9:,3
04,
5904,
!(4.,4:
8*:(4.,4:
(:;8(2 25.(80:/3 25. )(9, ,
>654,4:0(2 ,>
7;(8, 855:
)952;:, <(2;,
,: */(8(*:,8 -853 <(2;,
<(2;, 5- 9:804. */(8(*:,8
,4:/ 5- 9:804.
:804. -853 4;3,80* ,>68,99054 04:,.,8
04(8? -583 5- 046;: 9:804. 04:,.,8
,>(+,*03(2 <(2;, 5- 046;: 9:804. 04:,.,8
;)9:804. -853 2,-: 90+, 5- 9:804.
;)9:804. -853 80./: 90+, 5- 9:804.
;)9:804. -853 *,4:,8 5- 9:804.
4:,.,8 <(2;, 5- 04:,.,8 9:804. ,>68,99054
,(2 <(2;, 5- 8,(2 9:804. ,>68,99054
$/52, 6(8: 542? 5- 8,(2
590:054 *;8958 #!
2,(8 :/, 9*8,,4 #!
2,(8 204, #!
,(+ -853 -58,0.4 )5(8+
!,9: 0- )0: 09 9,:
!,9: 0- )0: 09 *2,(8
5+0-? )0: <(2;,
/0-: ( 4;3,80* -0,2+ 2,-:
/0-: ( 4;3,80* -0,2+ 80./:
5:(:, ( 4;3,80* -0,2+ 2,-:
5:(:, ( 4;3,80* -0,2+ 80./:
;:6;: :/, 4;3),8 -853 (
@+,*03(2 4;3),8
'
46;: :/, +,*03(2 4;3),8 -853 (
@ 4;3),8
'#
5<, ( )25*1 5- 04:,.,89 -853:5
@8,.09:,89
!$&'' (:,=(? :8(49-,8 -;4*:054
#!
,:;84 6504:,8 :5 <(80()2,
! !'
!,9: 9:(:, 5- ,8858 25. -58 :(91
#
,(+9 <(80()2, 8,:;849 <(2;,
$!#
$80:,9 <(2;, :5 <(80()2,
#
,:;849 6504:,8 :5 <(80()2,
#!
54<,8:9 +(:( -583(:9
!
! !
%
!
!
&
%
!
!
#
#
%
" !' !
! !'&
!
!
!!
!!
'"!
A
$
#
$ ! ! % ! ! "! ! ! ! $
#
$ ! ! % ! ! "! ! ! ! $
#
$ ! ! % ! ! "! ! ! ! $
$
#
$ ! ! %
! ! "! ! ! ! &
7.5
LN Function
&)$+
/')**"&%
.!)
/')**"&% $,*+ & %,$)" "%+ ) &) )# +0'
! ,%+"&% )+,)%* )# -#, (,# +& +! %+,)# #& & +! "%',+
! )*,#+ "* "% )# &)$+
7.6
EXP (e**x) Function
&)$+
/')**"&%
.!)
/')**"&% $,*+ & %,$)" "%+ ) &) )# +0'
! ,%+"&% )+,)%* )# -#, (,# +& /')**"&% .!) "*
! )*,#+ "* "% )# &)$+
7.7
SQRT Function
&)$+
/')**"&%
.!)
/')**"&% $,*+ & %,$)" "%+ ) &) )# +0'
! ,%+"&% )+,)%* )# -#, (,# +& +! *(,) )&&+ & +!
"%',+ % +! *$ + +0' * +! "%',+
7.8
ABS Function
&)$+
/')**"&%
.!)
/')**"&% $,*+ & %,$)" "%+ ) &) )# +0'
! ,%+"&% )+,)%* )# &) "%+ ) -#, (,# +& +! *&#,+
-#, & +! "%',+ % +! *$ + +0' * +! "%',+
7.9
CHR$ Function
&)$+
/')**"&%
.!)
/')**"&% $,*+ & "%+ ) +0' !/"$# "* #*&
&%*") "%+ )
1
$0- .:4+9154 7-9:748 ) 89714/ +0)7)+9-7 +577-8654,14/ 95 90,-+13)2 # ;)2:- 5. 90- 146:9 -=67-88154
#$"!# "
#$"!# "
#$"!# "
&) '("#$# -&*% !
&) '("#$# -&*% !
&) '("#$# -&*% !
573)9
#89714/
<0-7-
89714/ +)4 *- ) 89714/ ;)71)*2- 57 89714/ -=67-88154
$0- .:4+9154 7-9:748 90- # ;)2:- 5. ) 814/2- 89714/ +0)7)+9-7 905665819- 5. 90- " .:4+9154
#$"! (
!% " ##$"! %") *%$
/////////,"'+$ 573)9
!89714/ -=67-88154
<0-7-
-=67-88154 3:89 *- 5. 89714/ 9>6-
$0- .:4+9154 7-9:748 90- 2-4/90 5. 90- 89714/ -=67-88154
#$"'! !(#$"! &) '("#$#
/////////.-&*% #$" (&
#$"'! !#$" ? &)
/////////'("#$# -&*% 573)9
#$"-=67-88154
<0-7-
-=67-88154 3:89 *- 5. 4:3-71+ 149-/-7 57 7-)2 9>6-
$0- .:4+9154 7-9:748 ) 89714/ 5. +0)7)+9-78 .753 ) 4:3-71+
-=67-88154
#$"! #$"
&) '("#$# -&*% !% #$"! #$"!% &) '("#$# -&*% #$"! #$"
&) '("#$# -&*%
//////
@
6 <1. 4*;< [email protected]*584. <1. /7:5*< 7/ <1. :.*4 6=5+.: :.<=:6.- *; *
;<:260 2; <1. ;*5. 6=5+.: +=< 26 * -2//.:.6< :.8:.;.6<*<276 44 :.*4
6=5+.:; ?244 +. :.<=:6.- +A <1. "#! /=6,<276 26 <12; /7:5*<
#1. ;<:260 ?244 *4?*A; +. ,1*:*,<.:; 4760 ?2<1 * ;206
7: * -.,25*4 8726< -202<; *6 [email protected]< ;206
*6- -202<; 7/ [email protected]< && #1. ;206 ,1*:*,<.: 2; *4?*A;
8:.;.6< */<.: <12; ,76>.:;276 .>.6 2/ <1. 6=5+.: 2; 87;2<2>.
7.13
BINARY$ Function
7:5*<
!'[email protected]:.;;276
?1.:.
[email protected]:.;;276 5=;< +. *6 26<.0.: 7: 26<.0.: [email protected]:.;;276
#1. /=6,<276 :.<=:6; <1. +26*:A /7:5 7/ <1. 268=< *; * ;<:260 7/ ; *6
; 7: [email protected]*584.
# !' $!(
7.14
HEX$ Function
7:5*<
&[email protected]:.;;276
?1.:.
[email protected]:.;;276 5=;< +. *6 26<.0.: 7: 26<.0.: [email protected]:.;;276
#1. /=6,<276 :.<=:6; <1. [email protected]*-.,25*4 >*4=. 7/ <1. 268=< *; * ;<:260
7: [email protected]*584.
&(%&&
7.15
LEFT$ Function
7:5*<
#;<:260;<:(4.60<1
?1.:.
;<:260 ,*6 +. * ;<:260 >*:2*+4. 7: [email protected]:.;;276
;<:(4.60<1 2; <1. 6=5+.: 7/ ,1*:*,<.:; <7 <*3. /:75 <1. 4./< ;2-.
7/ <1. ;<:260 ;<:260 [email protected]:.;;276 26 8*:*5.<.: #1. /=6,<276 :.<=:6; * ;=+;<:260 <1*< 2; .9=*4 <7 );<:(4.60<1
8*:*5.<.: 7/ <1. 4./<57;< ,1*:*,<.:; 7/ <1. ;<:260 7: ;<:260
[email protected]:.;;276 8*:*5.<.: "$("#! #) "#! )
"$("#! #"#! ) B
7.16
RIGHT$ Function
Format:
RIGHT$(string,str_length)
where:
string can be a string variable or expression.
str_length is the number of characters to take from the right side
of the string (expression) in parameter 1.
The function returns a substring that is equal to
`strĆlength'(parameter 2) of the rightĆmost characters of the string or
string expression (parameter 1):
SUB_STRING$ = RIGHT$(`ABCDEFG',4) ##" has the value DEFG)
STR1$ = '12345'
SUB_STRINGS$ = RIGHT$(STR1$ + 'ABC',6)
" 7.17
MID$ Function
Format:
MID$(string, start, end)
where:
string can be a string variable or expression.
start is the starting character position of the substring.
end is the ending character position of the substring.
The function returns a substring from within another string. The
three parameters are, respectively, the string to operate on, the
starting character position, and the ending character position. The
substring is then taken from those two inclusive positions:
SUB_STRING$ = MID$(`ABCDEFG',2,3) _
# #!
STRING$ = BIGLONGSTRING"
SUB_STRING$ = MID$(STRING$,3,7) #
7.18
#"!
VAL% Function
Format:
VAL%(string)
where:
string can be a string variable or expression.
The function returns the integer value of a string in an integer format.
If the string is not in an integer format, the returned value will be zero
and an error is logged:
STR_VAL% = VAL%(`123' + `74') """"""""""
7Ć6
7.19
VAL Function
;>[email protected]
( [email protected]>6:4
C52>2
[email protected]>6:4 0.: /2 . [email protected]>6:4 B.>6./82 ;> 2D<>2??6;:
&52 3A:[email protected];: >[email protected]>:? @52 >2.8 B.8A2 ;3 . [email protected]>6:4 6: . >2.8 3;>[email protected] 3 @52
[email protected]>6:4 6? :;@ 6: . >2.8 3;>[email protected] @52 >[email protected]>:21 B.8A2 C688 /2 F2>; .:1 .:
2>>;> 6? 8;4421
%&$,( ( - & ' )!( 7.20
FIX Function
;>[email protected]
*2D<>2??6;:
C52>2
2D<>2??6;: 0.: /2 . >2.8 B.>6./82 ;> >2.8 2D<>2??6;:
&52 3A:[email protected];: >[email protected]>:? @52 C5;82 <.>@ ;3 . >2.8 ;> 12069.8 :A9/2>
$ ,( )" #$& *$ ,( 7.21
CURPOS$ Function
;>[email protected]
'$#"%>;C0;8A9:
C52>2
>;C .:1 0;8A9: .>2 6:@242> B.>6./82? ;> 2D<>2??6;:? @[email protected]
>2<>2?2:@ . 0A>?;> 8;[email protected];: ;: @52 ?0>22: ;3 . (&
0;9<[email protected]/82
@2>96:.8 @; >;C? 6:08A?6B2 .:1 @; 0;8A9:? 6:08A?6B2
'$#"% >[email protected]>:? .: % [email protected]>6:4 ;> 2?0.<2 ?2=A2:02 &56?
3A:[email protected];: 6? A?21 6: 0;9/6:[email protected];: [email protected] . #$!& [email protected]@292:@ @; <;[email protected];:
@52 0A>?;> [email protected] . ?<206360 8;[email protected];: ;: @52 ?0>22: ?<2063621 /E >;C .:1
0;8A9: 3;> . 12B602 @[email protected] >20;4:6F2? @52 !% [email protected]:1.>1 0A>?;>
<;[email protected];: 2?0.<2 ?2=A2:02 % + >;C 0;8 $") " ! G& #$!&'$#"%$")" ! % "'&
* ' (%&#% $#& ' #" )52: A?6:4 @52 '$#"% 3A:[email protected];: [email protected] @52 #$!& [email protected]@292:@ .
?2960;8;: ?5;A81 .8C.E? /2 8;[email protected] 6: 3>;:@ ;3 @52 3A:[email protected];: 0.88 @;
@288 % :;@ @; <[email protected] @52 [email protected]>6:4 42:2>[email protected] /E @52 3A:[email protected];: 0.88 6: .
F;:21 36281 . 36281 @[email protected] 6? . [email protected]<82 ;3 05.>[email protected]>?
3 @52 ?2960;8;: 6? :;@ A?21 % C688 <.1 @52 3>;:@ ;3 @52 2?0.<2
?2=A2:02 [email protected] ?<.02? C5605 C688 9;[email protected] 86728E :;@ 5.B2 @52 12?6>21
[email protected] @; 9;B2 @52 0A>?;> >[email protected]> @5.: @; <>6:@ ?;[email protected]:4 A>@52>
H
.2+361&8.32 &'398 46.28.2, &2) >32*) +.*0)7 (&2 '* +392) .2
! 8&8*1*287 .2 7*(8.32 361&8
348.32
;-*6*
348.32 .7 &2 .28*,*6 :&6.&'0* 36 .28*,*6 *<46*77.32 8-&8 )*+.2*7
8-* (0*&6 7(6**2 348.32 83 4*6+361
6*89627 &2 786.2, 36 *7(&4* 7*59*2(* -.7 *7(&4*
7*59*2(* ;.00 (0*&6 :&6.397 4&687 3+ & 7(6**2 32 & 8*61.2&0 8-&8
6*(3,2.>*7 8-* 78&2)&6) *6&7*?.2?).740&= *7(&4* 7*59*2(*
#348.32 $ -* 348.32 :&09*7 &6* &7 +3003;7
6&7* +631 8-* &(8.:* (96736 437.8.32 83 8-* *2) 3+ 8-*
7(6**2 .2(097.:*
6&7* +631 8-* 78&68 3+ 8-* 7(6**2 83 8-* &(8.:* (96736
437.8.32 .2(097.:*
6&7* &00 3+ 8-* ).740&=
36 *<&140*
% % "-*2 97.2, 8-* +92(8.32 ;.8- 8-* 78&8*1*28 &
7*1.(3032 7-390) &0;&=7 '* 03(&8*) .2 +6328 3+ 8-* +92(8.32 (&00 83
8*00 238 83 498 8-* 786.2, ,*2*6&8*) '= 8-* +92(8.32 (&00 .2 &
>32*) +.*0) & +.*0) 8-&8 .7 & 1908.40* 3+ (-&6&(8*67
+ 8-* 7*1.(3032 .7 238 97*) ;.00 4&) 8-* +6328 3+ 8-* *7(&4*
7*59*2(* ;.8- 74&(*7 ;-.(- ;.00 1378 0./*0= 238 -&:* 8-* )*7.6*)
*++*(8 83 13:* 8-* (96736 6&8-*6 8-&2 83 46.28 731*8-.2, 968-*6
.2+361&8.32 &'398 46.28.2, &2) >32*) +.*0)7 (&2 '* +392) .2
! 78&8*1*287 .2 7*(8.32 361&8
348.32
;-*6*
348.32 .7 &2 .28*,*6 :&6.&'0* 36 .28*,*6 *<46*77.32 8-&8 )*+.2*7
8-* (0*&6 0.2* 348.32 83 4*6+361
6*89627 &2 786.2, 36 *7(&4* 7*59*2(*
-.7 *7(&4* 7*59*2(* ;.00 (0*&6 :&6.397 4&687 3+ & ).740&= 0.2* 32 &
8*61.2&0 8-&8 6*(3,2.>*7 8-* 78&2)&6) *6&7*?.2?0.2* *7(&4*
7*59*2(* -* 348.327 &6* &7 +3003;7
# 6&7* +631 8-* &(8.:* (96736 437.8.32 83 8-* *2) 3+ 8-* 0.2*
.2(097.:*
#6&7* +631 8-* 78&68 3+ 8-* 0.2* 83 8-* &(8.:* (96736 437.8.32
.2(097.:*
?
ESC [2K Erase all of the line, inclusive.
CLR_TO_ENDLINE% = 0
PRINT;CLRLINE$(CLR_TO_ENDLINE%); When using the CLRLINE$ function with the PRINT statement, a
semicolon should always be located in front of the function call to
tell BASIC not to put the string (generated by the function call) in a
zoned field (a field that is a multiple of 15 characters).
If the semicolon is not used, BASIC will pad the front of the escape
sequence with spaces, which will most likely not have the desired
effect: to move the cursor rather than to print something. Further
information about printing and zoned fields can be found in
PRINT/PRINT USING statements in section 6.8.
The IOREAD% function is used to access I/O from foreign modules
that are byte accessible only. The function returns an integer value.
Format:
IOREAD%(option,address)
where:
option is an integer variable or expression that defines the type
of read operation to perform:
option 1 =
option 2 =
byte read
double byte read (address must be even)
(address) = MSB
(address + 1) = LSB
This option is used to read from foreign I/O
modules that only support an 8Ćbit data path.
option 3 =
word read
(address) = MSB
(address + 1) = LSB
The 16Ćbit word is read from the designated
address. This option reads data from modules
that support AutoMax addressing and data
conventions.
option 4 =
long word read
(address) = MSB
(address + 1) = next 8 bits
(address + 2) = next 8 bits
(address + 3) = LSB
address is a double integer variable or expression that contains the
address from where data is to be read; the address must be
>220000H.
See JĆ3649, JĆ3750 or J2Ć3045 for more information on accessing
foreign I/O.
7Ć9
7.25
[email protected] Function
472'9
!% !;'7/'(1+(/9A3:2(+7
<.+7+
;'7/'(1+ /8 ' 8/3-1+ 47 *4:(1+ /39+-+7 ;'7/'(1+
(/9A3:2(+7 /8 9.+ (/9 3:2(+7 </9./3 9.+ ;'7/'(1+ 94 9+89 94 ,47 8/3-1+ /39+-+7 94 ,47 *4:(1+ /39+-+7
!./8 ,:3)9/43 9+898 9.+ ;'1:+ 4, ' (/9 </9./3 9.+ ;'7/'(1+ '8 85+)/,/+*
(> 9.+ (/9A3:2(+7 , 9.+ (/9 /8 8+9 94 ' ;'1:+ 4, 43+ 9.+ (441+'3
7+8:19 4, 9.+ ,:3)9/43 /8 !" , 9.+ ;'1:+ 4, 9.+ (/9 /8 ?+74 9.+
7+8:19 4, 9.+ ,:3)9/43 /8 !./8 ,:3)9/43 *4+8 349 ).'3-+ 9.+
89'9+ 4, ' (/9 /9 8/251> 9+898 /9
!%# @@@
!% !!%# ! 3 9./8 +='251+ 9.+ & 89'9+2+39 </11 9'0+ 9.+ (7'3). 94 1/3+ (+)':8+ 9.+ )43*/9/43 /8 !" !.+ ;'1:+ 4, (/9 4,
!%# /8 !" 47 7.26
[email protected] Function
472'9
!%;'7/'(1+ (/9%3:2(+7
<.+7+
;'7/'(1+ /8 ' 8/3-1+ 47 *4:(1+ /39+-+7 ;'7/'(1+
(/9%3:2(+7 /8 9.+ (/9 3:2(+7 </9./3 9.+ ;'7/'(1+ 94 9+89 94 ,47 8/3-1+ /39+-+7 94 ,47 *4:(1+ /39+-+7
!./8 ,:3)9/43 9+898 9.+ ;'1:+ 4, ' (/9 </9./3 9.+ ;'7/'(1+ '8 85+)/,/+*
(> 9.+ (/9A3:2(+7 , 9.+ (/9 /8 )1+'7 47 ' ;'1:+ 4, ?+74 9.+
(441+'3 7+8:19 4, 9.+ ,:3)9/43 /8 !" , 9.+ ;'1:+ 4, 9.+ (/9 /8 43+
9.+ 7+8:19 4, 9.+ ,:3)9/43 /8 !./8 ,:3)9/43 *4+8 349
).'3-+ 9.+ 89'9+ 4, ' (/9 /9 8/251> 9+898 /9
!%# !%!%# ! 3 9./8 +='251+ 9.+ & 89'9+2+39 </11 9'0+ 9.+ (7'3). 94 1/3+ (+)':8+ 9.+ )43*/9/43 4, 9.+ (/9 9+89 <'8 !" !.+ (/9 <'8 )1+'7 47
+6:'1 94 ?+74 !.+ ;'1:+ 4, (/9 4, !%# /8 .4<+;+7
9.+ +39/7+ ,:3)9/43 /8 !" /, 9.+ ;'1:+ 4, 9.+ (/9 /8 ?+74 84 9.+
,:3)9/43 /8 !"
7.27
[email protected] Function
472'9
!% $;'7/'(1+ (/9%3:2(+7459/43
<.+7+
;'7/'(1+ /8 ' 8/3-1+ 47 *4:(1+ /39+-+7 ;'7/'(1+
(/9%3:2(+7 /8 9.+ (/9 3:2(+7 </9./3 9.+ ;'7/'(1+ 94 9+89
94 /, 8/3-1+ /39+-+7 94 /, *4:(1+ /39+-+7 ;'7/'(1+
A
015+0/ &'(+/'4 5*' %*#/)' 50 $' .#&' 50 5*' $+5 #/& .#: $' #/
+/5')'3 03 $00-'#/ '913'44+0/
*+4 (6/%5+0/ 5'454 5*' 7#3+#$-' #4 41'%+(+'& $: 5*' $+5"/6.$'3
#4'& 0/ 5*#5 7#-6' 5*' $+5 8+5*+/ 5*' 7#3+#$-' 8+-- $' .0&+(+'&
/%0/&+5+0/#--: %-'#3 5*' $+5 4'5 50 /%0/&+5+0/#--: 4'5 5*' $+5 50 ( 5*' $+5 +4 #-3'#&: ;'30 4'5 +5 50 ( 5*' $+5 +4 %-'#3 5*' $+5 4'5 50 *' (6/%5+0/ +54'-( +4 # $00-'#/ (6/%5+0/ #/& /05 #/ +/5')'3 (6/%5+0/
*'3'(03' 5*' 7#-6' 5*#5 +5 3'563/4 +4 /05 5*' 61&#5'& 7#-6' 0( 5*'
7#3+#$-' .0&+(+'& $65 5*' 45#564 0( 5*' $+5 %*#/)' 01'3#5+0/ *'
3'563/ 45#564 0( 5*' (6/%5+0/ +4 +( 5*' 3'26'45'& $+5 %*#/)'
01'3#5+0/ 8#4 %0.1-'5'& 03 +( 5*' 3'26'45'& $+5 %*#/)'
01'3#5+0/ 8#4 /05 %0.1-'5'&
80 %0/&+5+0/4 8+-- 4501 # 3'26'45 (30. $'+/) %0.1-'5'& *' (+345 +4
5*#5 5*' 7#3+#$-' +4 +/ # (03%'& %0/&+5+0/ #/& 5*' $+54 %#//05 $'
.0&+(+'& *' 4'%0/& +4 5*#5 5*' 3'26'45'& %*#/)' +4 #-3'#&: 5*'
%633'/5 45#5' 0( 5*' $+5
( 5*' 3'26'45 +4 50 %-'#3 # $+5 +( +5 +4 4'5 #/& 5*' %633'/5 45#5' 0( 5*' $+5
+4 #-3'#&: %-'#3'& 5*' (6/%5+0/ 45#564 8+-- $' $'%#64' 5*'
01'3#5+0/ 8#4 /05 %0.1-'5'& +' 5*'3' 8#4 /0 /''& 50 .#,' 5*'
%*#/)' *+4 5'--4 5*' 64'3 5*' 45#5' 0( 5*' $+5 13+03 50 5*' $+5 .0&+(:
01'3#5+0/ /-'44 5*' 7#3+#$-' +4 (03%'& 015+0/4 #/& 8+-- #-8#:4
3'563/ # (6/%5+0/ 45#564 4+/%' 5*': #3' 6/%0/&+5+0/#01'3#5+0/4
00-'#/ 7#-6'4 %#/ $' 64'& #4 5*' 015+0/ /6.$'3 (03 5*' (6/%5+0/
*+4 8+-- 3'46-5 +/ #/ 015+0/ +( 5*' $00-'#/ +4 03 +/ #/ 015+0/
+( 5*' $00-'#/ +4 *+4 %#/ $' 64'& 50 %*#/)' 5*' 45#5' 0( #
$+5 50 .#5%* #/05*'3 $00-'#/
03 '9#.1-'
" !" " <<
<<
<<
"!" !" / 5*+4 '9#.1-' $+5 0( " 8+-- $' )+7'/ 5*' 4#.' 7#-6' #4
5*' $00-'#/ !"
03.#5
7#3+#$-' 4*+(5"%06/5
8*'3'
7#3+#$-' +4 # 4+/)-' 03 &06$-' +/5')'3 7#3+#$-'
4*+(5"%06/5 +4 5*' /6.$'3 0( $+5 104+5+0/4 50 4*+(5 5*' +/5')'3
'913'44+0/ 50 (03 4+/)-' +/5')'3 50 (03 &06$-' +/5')'3
*+4 (6/%5+0/ 3'563/4 #/ +/5')'3 7#-6' '26#- 50 5*' +/5')'3
'913'44+0/ 5*#5 8#4 +/165 4*+(5'& 5*' 41'%+(+% /6.$'3 0( $+/#3:
=
3/%')6 72 7,) /)*7 -7 25 &-7 -* (28&/) -17)+)5 '20)6 2** 7,)
)1( !,) &-1%5< 3/%')6 9%'%7)( &< 7,) 6,-*7 %5) *-//)( :-7, =)526
25 );%03/)
! $$ !"!$ 1 7,-6 );%03/) % ?&-7 9%/8) -6 5)%( *520 %1 -1387 02(8/) !,)
/)%67 6-+1-*-'%17 +5283 2* &-76 &-76 72 %5) 6,-*7)( 72 7,) /)*7 -172
7,) 0267 6-+1-*-'%17 326-7-21 !,) 5)0%-1-1+ /2:)5 &-76 %5) 0%6.)(
2** &< >%1(-1+ :-7, ,); 9%/8) 250%7
!9%5-%&/)6,-*7$'2817
:,)5)
9%5-%&/) -6 % 6-1+/) 25 (28&/) -17)+)5 9%5-%&/)
6,-*7$'2817 -6 7,) 180&)5 2* &-7 326-7-216 72 6,-*7 7,) -17)+)5
);35)66-21 72 *25 6-1+/) -17)+)5 72 *25 (28&/) -17)+)5
!,-6 *81'7-21 5)78516 %1 -17)+)5 9%/8) )48%/ 72 7,) -17)+)5 );35)66-21
7,%7 :%6 -1387 6,-*7)( 7,) 63)'-*-' 180&)5 2* &-1%5< 3/%')6 72 7,)
5-+,7 -7 '20)6 2** 7,) )1( !,) 5)68/7 -6 127 6-+1 );7)1()( &87
75)%7)( %6 % /2+-'%/ 6,-*7
25 );%03/)
$ !"!$ 1 7,-6 );%03/) % ?&-7 9%/8) -6 5)%( *520 %1 -1387 02(8/) !,)
6)'21( +5283 2* &-76 &-76 72 %5) 6,-*7)( 72 7,) 5-+,7 -172 7,)
/)%67 6-+1-*-'%17 326-7-21 !,) 5)0%-1-1+ 833)5 &-76 %5) 0%6.)( 2**
&< >%1(-1+ :-7, ,); 9%/8) 250%7
!!9%5-%&/) 527%7)$'2817
:,)5)
9%5-%&/) -6 % 6-1+/) 25 (28&/) -17)+)5 9%5-%&/) 25 );35)66-21
527%7)$'2817 -6 7,) 180&)5 2* &-7 326-7-216 72 527%7) 7,) -17)+)5
);35)66-21 72 *25 6-1+/) -17)+)5 72 *25 (28&/) -17)+)5
!,-6 *81'7-21 5)78516 %1 -17)+)5 9%/8) )48%/ 72 7,) -17)+)5
);35)66-21 7,%7 :%6 -1387 527%7)( 7,) 63)'-*-' 180&)5 2* &-1%5<
3/%')6 72 7,) /)*7 -7 25 &-7 -* (28&/) -17)+)5 :5%36 %5281( 72
&-7 25 );%03/)
#$
$ !!"!$
1 7,-6 );%03/) % ?&-7 9%/8) -6 5)%( *520 %1 -1387 02(8/) %1( &-76
72 %5) 527%7)( -172 7,) 0267 6-+1-*-'%17 &-7 326-7-216 72 -76 72 %5) 527%7)( -172 &-7 326-7-216 72 ?
7.31
ROTATER% Function
250&7
!!9&5.&'/* 527&7*%(2817
:-*5*
9&5.&'/* .6 & 6.1,/* 25 )28'/* .17*,*5 9&5.&'/* 25 *;35*66.21
527&7*%(2817 .6 7-* 180'*5 2+ '.7 326.7.216 72 527&7* 7-* .17*,*5
*;35*66.21 72 6.1,/* .17*,*5 72 +25 )28'/* .17*,*5
!-.6 +81(7.21 5*78516 &1 .17*,*5 9&/8* *48&/ 72 7-* .17*,*5
*;35*66.21 7-&7 :&6 .1387 527&7*) 7-* 63*(.+.( 180'*5 2+ '.1&5<
3/&(*6 72 7-* 5.,-7 .7 :5&36 &5281) 72 '.7 25 '.7 .+ )28'/*
.17*,*5
25 *;&03/*
$%
% !!"!%
1 7-.6 *;&03/* & ='.7 9&/8* .6 5*&) +520 &1 .1387 02)8/* &1) '.76
72 &5* 527&7*) .172 '.7 326.7.216 72 .76 72 &5*
527&7*) .172 '.7 326.7.216 72 7.32
BCD_OUT% Function
250&7
%"!9&5.&'/*
:-*5*
9&5.&'/* .6 & 6.1,/* 25 )28'/* .17*,*5 9&5.&'/* 25 *;35*66.21
9&5.&'/* 9&/8* )*(.0&/
!-.6 +81(7.21 5*78516 &1 .17*,*5 9&/8* *48&/ 72 7-* .17*,*5
*;35*66.21 7-&7 :&6 .1387 :.7- *&(- )*(.0&/ ).,.7 (219*57*) 72 &
-*;&)*(.0&/ ='.7 '.1&5< *48.9&/*17 23326.7* 2+ 7-* +81(7.21
$!%# "!% %"! $!%# 1 7-* &'29* *;&03/* 7-* )*(.0&/ 9&/8* .6 (219*57*) 72 &
='.7 -*;&)*(.0&/ 9&/8* *48&/ 72 -*;
+ 7-* 9&/8* .1387 72 %"! .6 ,5*&7*5 7-&1 )*(.0&/ 7-*
287387 :.// '* -*; &1) &1 *5525 :.// '* /2,,*) !-* 6&0* .6
758* .+ 7-* .1387 180'*5 .6 1*,&7.9* 7-* 287387 :.// '* -*;
&1) &1 *5525 :.// '* /2,,*)
7.33
BCD_IN% Function
250&7
%9&5.&'/*
:-*5*
9&5.&'/* .6 & 6.1,/* 25 )28'/* .17*,*5 9&5.&'/* 25 *;35*66.21
9&5.&'/* 9&/8* -*;
!-.6 +81(7.21 5*78516 &1 .17*,*5 9&/8* *48&/ 72 7-* .17*,*5
*;35*66.21 7-&7 :&6 .1387 :.7- *&(- ).,.7 (219*57*) +520 &
=
2/A+./-36+5 D,3= ,37+;B =8 =2/ ./-36+5 /:>3?+5/7= 8998<3=/ 80 =2/
*$# 0>7-=387 7 =2/ [email protected] /A+695/ +<<>6/ =2/ ?+5>/ +=
$#*! 3< 2/A
*%"* $#*!
#2/ 2/A ?+5>/ 3< -87?/;=/. =8 + D,3= ./-36+5 ?+5>/ /:>+5 =8
0 =2/ ?+5>/ 379>= =8 * 3< 1;/+=/; =2+7 2/A =2/ 8>=9>=
@355 ,/ ./-36+5 +7. +7 /;;8; @355 ,/ 5811/.
8;6+=
*%<8>;-/ ./<= <3C/
@2/;/
<8>;-/ +7. ./<= 6><= ,/ 37=/1/; .8>,5/ 37=/1/; ,885/+7 8;
;/+5 ?+;3+,5/< 8; 87/D.36/7<387+5 37=/1/; +;;+B< 0 37=/1/;
.8>,5/ 37=/1/; 8; ,885/+7 ?+;3+,5/< =2/B 6><= ,/ ?+;3+,5/<
./037/. 37 =2/ -87031>;+=387 =+<4 =2+= 9837=< =8 =2/ ./<3;/.
<9/-303- <8>;-/ 8; ./<=37+=387 ;/13<=/; 87 =2/ 7/[email protected];4 0 =2/
<8>;-/ 8; ./<=37+=387 3< +7 +;;+B 3= 6><= ,/ D .36/7<387+5 #2/
+;;+B 6+B ,/ -86687 8; 58-+5
<3C/ 3< =2/ 7>6,/; 80 ;/13<=/;< D,3= @8;.< =8 =;+7<0/; 0;86 =2/
<8>;-/ =8 =2/ ./<=37+=387
#2/ *% 0>7-=387 =;+7<0/;< .+=+ =8 +7. 0;86 =2/ 7/[email protected];4
= 3< + ,885/+7 0>7-=387 +7. 3< #!$ 30 =2/ 89/;+=387 3< <>--/<<0>5
" 30 78= #2/ 0>7-=387 [email protected]< =2/ ></; =8 <9/-30B 875B + <=+;=371
?+;3+,5/ 7+6/ 08; =2/ ./<=37+=387 8; <8>;-/ ?+;3+,5/ 53<= +7. + 5/71=2
80 ;/13<=/;< =8 ,/ =;+7<0/;;/. #23< /53637+=/< 2+?371 =8 ./037/ /+-2
?+;3+,5/ /A953-3=5B 37 =2/ ;+-4 -87031>;+=387 +7. =2/7 =;+7<0/;;371 =2/
.+=+ 87/ ?+;3+,5/ += + =36/ @3=2 + 5871 53<= 80 # <=+=/6/7=<
#2/ *% 0>7-=387 -2/-4< =2/ 37.3?3.>+5 ;/13<=/; ?+5>/< +<
=2/B +;/ 68?/. 30 +7B 80 =2/ ?+5>/< +;/ ! =2/ 08;-/. ?+5>/
@355 ,/ ></. #2>< =2/ /A/->=387 =36/ 08; =2/ 0>7-=387 ?+;3/<
-87<3./;+,5B +7. 3< ./9/7./7= 87 =2/ 7>6,/; 80 ?+;3+,5/< 37 =2/
->;;/7= 08;-/ 53<= 6+A36>6 80 +7. @2/=2/; +7B 80 =28</
?+;3+,5/< +;/ 37 =2/ <8>;-/ 8; ./<=37+=387 ;+71/ 80 =2/
*% ?+;3+,5/< 7 =2/ [email protected] /A+695/ ;/13<=/;< +;/
68?/.
# *%#&** #&**
# "#
//9 37 637. =2/ [email protected] @2/7 08;-371 ?+;3+,5/< +7. 8?/;5+B371
?+;3+,5/ ./0373=387< +7 37=/1/; 3< 8?/;5+B/. 8?/; </?/;+5 ,885/+7<
0 ,885/+7 ?+;3+,5/< +;/ 08;-/. @3=237 + 08;-/. 37=/1/; .8>,5/
37=/1/; 8; ;/+5 ?+;3+,5/ =2/ 37=/1/; 08;-/. ?+5>/ @355 9;/?+35
8; /A+695/ 0 +7. +;/ ./037/. +< ,3=< @3=237 '()
'() +7. +7. +;/ +55 08;-/. +7. '() 3< ></. +< =2/
<8>;-/ ?+;3+,5/ 37 + % 0>7-=387 =2/ ;/<>5= @355 ,/
=2+= =2/ '() 08;-/. ?+5>/ @355 =+4/ 9;/-/./7-/ 8?/; =2/ +7. 08;-/. ?+5>/<
D
, 9.+ *+89/3'9/43 /8 ,47)+* '3* 9.+ 84:7)+ /8 ,47)+* 9.+
*+89/3'9/43 ,47)+* ;'1:+ </11 57+;'/1 ".+ # ,:3)9/43
</11 7+9:73 ' ! 89'9:8 /, '3> 4, 9.+ ,4114</3- 4)):78
".+ &# ,:3)9/43 </11 7+9:73 ' ! 89'9:8 /, '3> 43 9.+
,4114</3- 4)):78
".+ 3:2(+7 4, 7+-/89+78 94 97'38,+7 97'38,+7 8/?+ /8
D +88 9.'3 47 +6:'1 94 ?+74
D 7+'9+7 9.'3 ".+ 84:7)+ 47 *+89/3'9/43 ;'7/'(1+ '**7+88 /8 1+88 9.'3 9.+ ;'1/*
89'79/3- 4,,(4'7* '**7+88 ,47 9.'9 7')0 )43,/-:7'9/43
D , 9.+7+ /8 34 42243 +247> 24*:1+ 9.+
89'79/3- '**7+88 2:89 (+ +6:'1 94 47 -7+'9+7 9.'3
.+=
D , 9.+7+ /8 ' 42243 +247> 24*:1+ 9.+
89'79/3- '**7+88 2:89 (+ +6:'1 94 47 -7+'9+7 9.'3
.+=
".+ 3:2(+7 4, 7+-/89+78 94 97'38,+7 /8 -7+'9+7 9.'3 9.+ 3:2(+7 4,
+1+2+398 /3 9.+ 84:7)+ 47 *+89/3'9/43 '77'> , 9.+ 84:7)+ 47
*+89/3'9/43 /8 '3 '77'> '3* 9.+ 3:2(+7 4, +1+2+398 /8 -7+'9+7
9.'3 9.+ 3:2(+7 4, 7+-/89+78 94 24;+ 431> 9.+ 3:2(+7
7+6:+89+* </11 (+ 24;+* '3* 9.+ 7+89 4, 9.+ '77'> </11 349 (+
',,+)9+*
7.35
[email protected] Function
"$%&& /8 ' (441+'3 ,:3)9/43 9.'9 5+7,4728 7+-/89+7
97'38,+78 94 47 ,742 9.+ 39+7,')+ 24*:1+8 /3)1:*/3- 9.+
[email protected]'*1+> 4*(:8 '3* :94'9+
24*:1+8 "./8 ,:3)9/43 )'3349 (+ :8+* 43 9.+
:94'= , 9.+ 45+7'9/43 /8 8:))+88,:1 9.+ ,:3)9/43 7+9:738
' ;'1:+ , 9.+ 45+7'9/43 /8 349 8:))+88,:1 9.+ 45+7'9/43 7+9:738 '3
+7747 )4*+ 9.'9 /8 *+9+72/3+* (> 9.+ .'7*<'7+ </9. <./). 9.+
39+7,')+ 24*:1+ /8 )422:3/)'9/3-
472'9
"$%&&89'9:8 )2*&)4*+ 81';+&*745 81';+&7+- 2'89+7&;'7 3:2&7+-8
<.+7+
89'9:8 /8 '3 /39+-+7 ;'7/'(1+ 7+57+8+39/3- 9.+ 14)'9/43 <.+7+ 9.+
7+8:19/3- )422'3* 89'9:8 /8 8947+* 89'9:8 </11 )439'/3 ' ?+74 /,
9.+ 97'38,+7 45+7'9/43 /8 8:))+88,:1 '3* '3 +7747 )4*+ /, /9 /8
:38:))+88,:1 ".+ +7747 )4*+ /8 *+5+3*+39 43 9.+ 24*:1+ :8+*
!++ 9.+ /3897:)9/43 2'3:'1 ,47 9.+ 85+)/,/) 39+7,')+ 24*:1+ ,47
9.+ +7747 )4*+8
)2*&)4*+ /8 ' ;'7/'(1+ 3'2+ 47 +=57+88/43 4, 9>5+ /39+-+7
7+57+8+39/3- 9.+ )422'3* 8+39 94 9.+ 39+7,')+ 24*:1+ 9.+
)422'3*8 ';'/1'(1+ '7+ 85+)/,/) 94 +'). /39+7,')+ 24*:1+ !++
9.+ /3897:)9/43 2'3:'1 ,47 9.+ 85+)/,/) 39+7,')+ 24*:1+ ,47 9.+
';'/1'(1+ )422'3*8
81';+&*745 /8 ' ;'7/'(1+ 3'2+ 47 +=57+88/43 4, 9>5+ /39+-+7
7+57+8+39/3- 9.+ *+;/)+ '**7+88 +- 34*+ 3:2(+7 4, 9.+
.'7*<'7+ 9.+ 39+7,')+ 24*:1+ /8 )422:3/)'9/3- </9.
@
3,"6&!2&( *3 " 6"2*"#,& ."-& /2 &802&33*/. /' 490& 342*.(
2&02&3&.4*.( 4)& 34"24*.( 2&(*34&2 *. 4)& %&6*$& 4)"4 *3 4/ #& 2&"%
'2/- /2 72*44&. 4/ )& '/2-"4 /' 4)*3 0"2"-&4&2 *3 %&0&.%&.4 /.
4)& -/%5,& 53&% && 4)& *.3425$4*/. -".5", '/2 4)& 30&$*'*$
.4&2'"$& -/%5,& '/2 4)& $/22&$4 '/2-"4
-"34&2!6"2 *3 " 6"2*"#,& ."-& /2 &802&33*/. /' 490& %/5#,&
*.4&(&2 2&02&3&.4*.( 4)& "$45", )&8"%&$*-", "%%2&33 /' 4)& '*234
,/$"4*/. 4)"4 *3 4/ #& 2&"% '2/- /2 72*44&. 4/ *. 4)& .4&2'"$&
-/%5,& && #&,/7 '/2 -/2& *.'/2-"4*/.
.5-!2&(3 *3 6"2*"#,& ."-& /2 &802&33*/. /' 490& *.4&(&2 4)"4
%&'*.&3 4)& .5-#&2 /' #*43 /2 2&(*34&23 #*43 &"$) 4/ #&
42".3'&22&% $-%!$/%& %&4&2-*.&3 7)&4)&2 4)& 6"2*"#,&
2&02&3&.43 #*43 /2 2&(*34&23 /4& 4)"4 *' 9/5 "2& 42".3'&22*.(
%/5#,& *.4&(&2 ;#*4 6"2*"#,&3 4)& .5-:2&(3 0"2"-&4&2 -534
30&$*'9 4)& .5-#&2 /' ;#*4 6"2*"#,&3 4/ -/6& /2 &8"-0,& *'
9/5 7".4 4/ -/6& 47/ %/5#,& *.4&(&2 6"2*"#,&3 34"24*.( "4
"%%2&33 .5-:2&(3 -534 #& &15", 4/ )& -"34&2:6"2 0"2"-&4&2 $". #& 30&$*'*&% 53*.( ".9 /.& /' 4)&
4)2&& -&4)/%3 %&3$2*#&% #&,/7
)& "#3/,54& )&8"%&$*-", "%%2&33 /' 4)& '*234 #*4 *.4&(&2 /2
%/5#,& *.4&(&2 /. 4)& .4&2'"$& -/%5,& 4/ #& 2&"% /2 72*44&. /2
&8"-0,&
6"2*"#,& ."-& 7)*$) 2&02&3&.43 4)& "#3/,54& )&8"%&$*-",
"%%2&33 /' 4)& '*234 #*4 *.4&(&2 /2 %/5#,& *.4&(&2 /. 4)& .4&2'"$&
-/%5,& 4/ #& 2&"% /2 72*44&. 90*$",,9 4)& '5.$4*/. *3
53&% 4/ 9*&,% 4)& "#3/,54& "%%2&33 /2 &8"-0,& *' *. 9/52 4"3+
9/5 %&'*.& 4)& '/,,/7*.(
:
4)&. 9/5 $". 53& "3 4)& -"34&2:6"2 0"2"-&4&2 )*3
"335-&3 4)"4 : )"3 #&&. %&'*.&% "3 " ;#*4 *.4&(&2
6"2*"#,& /. 4)& .4&2'"$& -/%5,&
. &802&33*/. 7)*$) 7)&. 3/,6&% 7*,, 9*&,% ". "#3/,54&
)&8"%&$*-", "%%2&33 /' 4)& '*234 #*4 *.4&(&2 /2 %/5#,& *.4&(&2 4/
#& 2&"% /2 72*44&. /2 &8"-0,& 4)& -"34&2:6"2 0"2"-&4&2 $/5,%
#&
:
7)&2& : )"3 #&&. %&'*.&% "3 " #//,&". /. 4)&
.4&2'"$& -/%5,&
/2 -/2& %&4"*,&% *.'/2-"4*/. 3&& 4)& *.3425$4*/. -".5", '/2 &"$)
30&$*'*$ .4&2'"$& -/%5,&
/2-"4
6"2*"#,&
7)&2&
6"2*"#,& *3 " $/--/. #//,&". 3*.(,& #*4 *.4&(&2 #*43 /2
%/5#,& *.4&(&2 #*43 %&'*.&% *. 4)& $/.'*(52"4*/. "3 4)&
;
&(9:&1 5->8.(&1 &))7*88 4+ 9-* +.789 14(&9.43 43 9-* 39*7+&(*
24):1* +742 47 94 <-.(- )&9& .8 94 '* 7*&) 47 <7.99*3
-.8 +:3(9.43 .8 :8:&11> :8*) .3 (43/:3(9.43 <.9- 9-*
#$%% +:3(9.43 9 7*9:738 9-* &(9:&1 &))7*88 .3
-*=&)*(.2&1 +472&9 4+ 9-* '.9 .39*,*7 47 )4:'1* .39*,*7 <-.(7*57*8*398 9-* +.789 14(&9.43 43 9-* 39*7+&(* 24):1* 94 <-.(- 47 +742
<-.(- )&9& .8 94 '* 97&38+*77*)
7.37
[email protected] Function
-* +:3(9.43 % 9*898 9-* 89&9* 4+ 9-* *7747 14,
2&.39&.3*) +47 9-* &551.(&9.43 9&80 '> 9-* 74,7&22.3, =*(:9.;*
84+9<&7* -.8 *7747 14, (&3 '* &((*88*) 9-74:,- 9-* [email protected]* 2*3:
4+ 9-* 84+9<&7* -* +:3(9.43 % 574;.)*8 & 2*9-4)
4+ (-*(0.3, 9-* *7747 14, <-.1* 9-* &551.(&9.43 9&80 .8 7:33.3, -.8
+:3(9.43 .8 (1*&7*) <.9- % 8** 49* 9-&9 +47
"*78.43 &3) 1&9*7 4+ 9-* 74,7&22.3, =*(:9.;* 84+9<&7* 9-.8
+:3(9.43 (&3 '* *39*7*) &8 ? 47 ?
472&9
%;&7.&'1*
<-*7*
;&7.&'1* .8 &3 .39*,*7 ;&7.&'1* 431> :8*) 94 8947* 9-* 3:2'*7 4+
*77478 14,,*) 94 +47 9-* 9&80
+ 9-*7* &7* 34 *77478 14,,*) 9-* 7*8:19 4+ 9-* '441*&3 +:3(9.43 .8
&3) 9-* 3:2'*7 5&7&2*9*7 .8 .3)*9*72.3&39 + 9-*7* &7*
*77478 9-*3 9-* +:3(9.43 .8 97:* &3) 9-* ;&7.&'1* 85*(.+.*) .8 14&)*)
<.9- 9-* (:77*39 3:2'*7 4+ 14,,*) *77478 94 -.8 ;&7.&'1* 2:89
'* &3 .39*,*7 ;&7.&'1*
7.38
READVAR% Function
-.8 +:3(9.43 7*6:.7*8 9-* :94&= 45*7&9.3, 8>89*2 <.9- 9-*
9-*73*9 459.43
472&9
" ;3 ;&1:* <-*7*
;3
.8 & 897.3, *=57*88.43 +47 9-* 3&2* 4+ 9-* ;&7.&'1* 94
7*&) 9 (&3 '* & '441*&3 .39*,*7 )4:'1* .39*,*7
7*&1 47 &3 &77&> 4+ 9-*8* 9>5*8 31> 8.3,1*
).2*38.43 &77&>8 &7* &114<*)
;&1:*
.8 9-* ;&7.&'1* <-*7* 9-* ;&1:* 7*&) .8 <7.99*3
-.8 +:3(9.43 &((*598 & ;&7.&'1* 3&2* &8 & 897.3, *=57*88.43 &3)
7*9:738 9-* ;&1:* .3 ;&7.&'1* "! -* 897.3, 9-&9 )*+.3*8 9-*
;&7.&'1* 3&2* 2:89 -&;* & 8:++.= &8 +4114<8
4 8:++.=
441*&38
39*,*78
4:'1* .39*,*7
*&18
+ 85*(.+>.3, &3 &77&> *1*2*39 9-* 8:'8(7.59 2:89 '* &+9*7 9-* )&9&
9>5* (-&7&(9*7 .+ 9-*7* .8 43* 31> (42243 ;&7.&'1*8 (&3 '*
&((*88*)
@
#&/8*6 *7851*)
>
8((*66
#&5.&'/* 127 +281)
&7& 7<3* 0.60&7(25 *;&03/*
#% = !%! !!" # #% #" !-.6 +81(7.21 5*48.5*6 7-* 872&; 23*5&7.1, 6<67*0 :.7- 7-*
7-*51*7 237.21
250&7
$!# 91 9&/8* :-*5*
91
.6 & 675.1, *;35*66.21 +25 7-* 1&0* 2+ 7-* 9&5.&'/* 72
:5.7* 72 7 (&1 '* & '22/*&1 .17*,*5 )28'/* .17*,*5
5*&/ 25 &1 &55&< 2+ 7-*6* 7<3*6 1/< 6.1,/*
).0*16.21 &55&<6 &5* &//2:*)
9&/8*
.6 7-* 9&5.&'/* 7-&7 -&6 7-* 9&/8* 72 :5.7*
!-.6 +81(7.21 &((*376 & 9&5.&'/* 1&0* &6 & 675.1, *;35*66.21 &1) &
9&/8* 72 :5.7* .172 7-* 9&5.&'/* !-* 675.1, 7-&7 )*+.1*6 7-* 9&5.&'/*
1&0* 0867 -&9* & 68++.; &6 +2//2:6
2 68++.;
22/*&16
17*,*56
28'/* .17*,*56
*&/6
+ 63*(.+<.1, &1 &55&< */*0*17 7-* 68'6(5.37 0867 '* &+7*5 7-* )&7&
7<3* (-&5&(7*5 .+ 7-*5* .6 21*
+ 7-* )&7& 7<3* 2+ 7-* 9&5.&'/* &6 )*+.1*) .1 7-* 675.1, 91 .6
).++*5*17 7-&1 7-&7 2+ #" &1 *5525 .6 ,*1*5&7*) 1/< (20021
9&5.&'/*6 (&1 '* &((*66*)
#&/8*6 *7851*)
>
8((*66
#&5.&'/* 127 +281)
&7& 7<3* 0.60&7(#&5.&'/* +25(*)
25 *;&03/*
#% = !%! #" !!" $!# #% #" ?
7.40
FINDVAR! Function
#019 .;4+:154 8-7;18-9 :0- ;:5)> 56-8):14/ 9?9:-3 =1:0 :0:0-84-: 56:154
583):
$! <)84)3- =0-8-
<)84)3- 19 ) 9:814/ ->68-99154 .58 :0- 4)3- 5. :0<)81)*2- :5 .14,
#019 .;4+:154 )++-6:9 ) <)81)*2- 4)3- )9 ) 9:814/ ->68-99154 )4,
8-:;849 ) 6514:-8 :5 :0): <)81)*2-
#019 3)? :0-4 *- ;9-, 14 :0" )4, !$ .;4+:1549
5 9;..1>
552-)49
4:-/-89
5;*2- 14:-/-89
":814/9
!-)29
. 96-+1.?14/ )4 )88)? -2-3-4: :0- 9;*9+816: 3;9: *- ).:-8 :0- ,):)
:?6- +0)8)+:-8 1. :0-8- 19 54-
$)2;-9 !-:;84-,
514:-8 :5 $)81)*2 $)81)*2- 45: .5;4,
58 ->)362- :5 .14, ) 6514:-8 :5 %&'
$!( @%&'
#! $! $!( 7.41
CONVERT% Function
#019 .;4+:154 8-7;18-9 :0- ;:5)> 56-8):14/ 9?9:-3 =1:0 :0:0-84-: 56:154
#019 .;4+:154 +)4 *- ;9-, 54 :0- ;:5)> )2:05;/0 :0- ,5-9 45: 9;6658: :0- 5:0-8 :0-84-: .;4+:1549
583):
$!#
A98+(<)81)*2- 98+(9;*9+816: ,-9:(<)81)*2- BBBBBBBA,-9:(9;*9+816: 4;3(5.(=58,9 35,- =0-8-
98+(<)81)*2-
19 :0- <)81)*2- :0): 9-2-+:9 =-8- :5 /-: ,):)
.853
#019 6)8)3-:-8 3)? *- ) 9+)2)8 58 )4
)88)? 5. )4? ,):) :?6-
. 98+(<)81)*2- 19 )4
)88)? 1: 905;2, 542? *- :0- *)9- 4)3- )4, )4?
,):) :?6- +0)8)+:-8
98+(9;*9+816:
19 542? ;9-, 1. :0- 98+(<)81)*2- 19 )4 )88)?
:
,-:-8314-9 =0-8- 14 :0- )88)? :5 *-/14
8-),14/
. 45: )4 )88)? :0- <)2;- 905;2, *- ,-9:(<)81)*2-
19 :0- <)81)*2- :0): 9-2-+:9 =-8- :5 35<- :0,):)
#019 6)8)3-:-8 3)? *- ) 9+)2)8 58 )4
)88)? 5. )4? ,):) :?6-
. ,-9:(<)81)*2- 19 )4
)88)? 1: 905;2, 542? *- :0- *)9- 4)3- )4, )4?
,):) :?6- +0)8)+:-8
C
dest_subscript
is only used if destination_variable is an array.
It determines where in the array to begin
writing. If not an array, the value should be 0.
num_of_words
mode
selects the number of words to move.
determines the mode of operation.
VALUE
ăă0
ăă1
ăă2
ăă4
ăă8
ăă9
ă10
FUNCTION
Move data with no change in
format
Convert from Motorola Floating
Point to IEEE format
Convert from IEEE Floating Point
to Motorola format
Word swap (0102H to 0201H)
Long word swap (01020304H to
04030201H)
Motorola to IEEE followed by long
word swap
Long word swap followed by IEEE
to Motorola
All other values are illegal
This function is used to convert between data formats used by
AutoMax and data formats used by other computers.
Values Returned:
ă1
-26
-32
-33
-34
-35
-36
Success
Array is not single dimension
Beyond end of array
Illegal mode value
Zero number of words
Odd number of words on long word swap
Number of words > dest data type when dest memory is
on CPU
For example, to move 30 real numbers beginning at
SRC_ARRAY(10) to DST_ARRAY(20) converting from Motorola to
IEEE and inverting the byte order:
STATUS% = CONVERT%( SRC_ARRAY, 10, DST_ARRAY, 20,
ąąąąą15, 9 )
7.42
[email protected] Function
Format:
[email protected](#n, control_val%)
where:
#n is the logical number assigned to the port in the OPEN
statement.
control_val% (input constant of variable integer) is nonĆzero to
turn the RTS signal on and 0 to turn the RTS signal off.
This function provides control of the RTS modem control signal. If
hardware handshaking is enabled and RTS is set true using this
function, RTS will remain true after all characters have been
transmitted so that the application task can set it false after a delay.
Refer to the OPEN statement for a description of the purpose of the
RTS signal.
7Ć20
This function returns false only under the following conditions:
D #n is not assigned to an opened port
D #n is not assigned to a serial communication port (PORTA on the
leftmost Processor; PORTA or PORTB on other Processors)
The following example would turn RTS on, wait 55ms, send the text,
wait for all characters to be sent, wait 110ms, then turn RTS off.
10
30
40
50
60
65
66
70
80
90
OPEN "PORTA" AS FILE #1, SETUP=0,9600
CONTROL_VAL% = 1
/turn RTS on
[email protected] = [email protected](#1, CONTROL_VAL%)
DELAY 10 TICKS
/delay 55 ms
PRINT #1, SEND$
/send text out port A
IF (ALL_SENT(#1)) THEN GOTO 70
DELAY 1 TICK : GOTO 65
/wait for all sent
DELAY 20 TICKS
/delay 110 ms
/turn RTS off
CONTROL_VAL% = 0
[email protected] = [email protected](#1, CONTROL_VAL%)
Format:
[email protected](#n)
where:
#n is the logical number assigned to the port in the OPEN
statement.
This function provides a method to detect when all characters in a
message are sent.
This function returns true if all of the characters from the previous
print statement have been transmitted (that is, the transmit queue is
empty).
This function returns false only under the following conditions:
D Some characters have not yet been transferred.
D #n is not assigned to an opened port
D #n is not assigned to a serial communication port (PORTA on the
leftmost Processor; PORTA or PORTB on other Processors)
Refer to the OPEN statement for a description of the purpose of the
RTS signal.
Format:
WRITE_TUNE(tunable, new_value, [email protected])
where:
tunable is the tunable variable. It can be an integer, double
integer, or real.
new_value is the new value for the tunable variable. It can be a
variable, an expression, or a literal value. The compiler will
report an error if 'tunable' and 'new_value' are not the same
data type.
7Ć21
% $ %#& ('& $ $$ % # "& % %
%& '#$ % #%# # "& % % %&
'#$ ( % $ !#%# $ !% $ &% !# '$ % %* % % &##% '& %& '#$ $ &% ( #$!% % %& '#$
( %$ !# ( $ ( &$ * %#
$%%% &% # %# % (#% % %& '#$
+ # % %$ % , %$ $% ( $%
( % %$ )&%$ %$ &% % & % (
&##% '& ( (#%% % ,' % $ #* (
'& ( % (#%% % $ #* % $ % $ $ % '&
% & % %& '# $ (# &
%# % % $ ( &%!) (%
% $%! % % % % ( % %& '& $ $ ( % $% % ( '& % %& '# $ %
$ $ % &##% '&
# !
" ! ! " ! $ ,
8.0 ETHERNET
COMMUNICATION
FUNCTIONS
The following functions are used only with the Ethernet Network
Interface (ENI) module (M/N 57C440). Before any of the following
functions can be used, the AutoMax operating system with the Ethernet
option must be loaded onto the Processor. Note that tasks that use
these functions must be run on the leftmost Processor in the rack.
These functions cannot be used on the AutoMax PC3000.
Function Name
ENI_INIT%
SOCKET%
BIND%
CONNECT%
ACCEPT%
SEND%
SENDL%
RECV%
RECVL%
SETSOCKOPT%
GETSOCKOPT%
SHUTDOWN%
8.1
Description
Initializes ENI
Creates socket
Binds socket
Assigns destination for socket
TCP only; directs a passive open
Sends specified type of variable
Sends double integer array
Writes received variable
Writes received array
Sets socket option
Reads socket option
Closes socket
ENI_INIT% Function
Format:
ENI_INIT%( slot%, addr$, tcp%, udp%, ether% )
where:
slot%
is the logical slot the ENI is to be in. This can be
a variable or a constant. The only legal values
are 2 or 4.
addr$
is the Internet address to assign to the ENI. This
is a string of four decimal numbers separated
by decimal points, each ranging from 0 to 255.
A typical address is 128.0.0.10.
tcp%
defines the number of sockets to use for the
TCP protocol.
udp%
defines the number of sockets to use for the
UDP protocol.
ether%
defines the number of sockets to use for Raw
Ethernet.
The ENI_INIT% function commands the Ethernet Network Interface
to go through its initialization. The ENI supports three types of
protocols: TCP, UDP, and Raw Ethernet. Up to 64 channels (sockets)
can be assigned to each ENI. Part of the initialization selects how
may sockets to allow for each protocol. The green LED on the front
8Ć1
of the ENI will turn off for approximately 10 seconds while the
initialization is performed.
Values Returned:
ă1
-1
-8
-10
-11
-12
-13
Success
ENI failed self test
Bus error
Error allocating interrupts
Bad slot number
Bad Internet address
Total number of sockets >64
For example:
STATUS% = ENI_INIT%( 4, 128.0.0.10", 32, 10, 3 )
8.2
SOCKET% Function
Format:
SOCKET%( slot%, type% )
where:
slot%
is the logical slot the ENI is to be in. This can be
a variable or a constant. The only legal values
are 2 or 4.
type%
is used to select the protocol for this socket.
Legal values for type are:
1 for a TCP socket
2 for a UDP socket
3 for a Raw Ethernet socket
This function will find an available socket of the requested type. If
successful, the value returned is the number of the socket allocated.
All subsequent function calls to communicate with the ENI use this
socket number to select the socket to talk through.
Values Returned:
>0
-2
-3
-9
-11
-14
The socket number allocated
ENI not initialized
Did not create socket
No buffer space
Bad slot number
Bad socket type
For example:
SOCKET_NUM% = SOCKET%( 4, 1 )
8.3
BIND% Function
Format:
BIND%( sn%, port% )
where:
sn%
8Ć2
is the number of the socket you want to bind. This
is the value that was returned from the SOCKET%
function. This can be specified as a simple
variable or as an element of an array.
port%
is the local port number you want to give to the
socket. Begin assigning TCP and UDP port
numbers at 5000.
For raw Ethernet sockets, this value is used to
select the value of the 16Ćbit packet type in the
message header.
This function assigns a local port number or Ethernet packet type to
a socket.
Values Returned:
ă1
-2
-4
-9
-15
Success
ENI not initialized
Did not bind socket
No buffer space
Bad socket number
For example:
STATUS% = BIND%( SN%, 5000 )
Format:
CONNECT%( sn%, addr$, port% )
where:
sn%
is the number of the socket you want to connect to
a destination. This is the value returned from the
SOCKET% function. This can be specified as a
simple variable or as an element of an array.
addr$
is the destination Internet or Ethernet address you
want to connect to. See ENI_INIT for applicable
rules for Internet addresses. Ethernet addresses
are 12Ćdigit Hex number strings.
port%
is the destination port number you want to connect
to.
This function assigns a permanent destination for a socket. It must
be done before any messages can be sent using any of the three
protocols. For Raw Ethernet or UDP sockets, this function is used
only to specify the destination address. For TCP sockets, it directs
the ENI to do an active open. A passive open (ACCEPT%), done by
the destination TCP socket, must occur prior to this function being
executed to establish a connection. After the connection is made,
messages can be exchanged.
If connecting a TCP socket and the other end is not ready to accept
the connection, the socket will be closed. To try to connect again,
the application must create a new socket and bind it again.
For raw Ethernet sockets, the port number defines the packet type
of all messages that will be sent. The receiving end must do a
BIND% with the same value for the port number.
8Ć3
Values Returned:
ă1
-2
-9
-12
-15
-102
Success
ENI not initialized
No buffer space
Bad InterNet address
Bad socket number
Socket not connected
For example:
STATUS% = CONNECT%( SN%, DEST_INET_ADDR$, 5001 )
Format:
ACCEPT%( sn%, nsn% )
where:
sn%
is the number of the TCP socket that should begin
waiting for a connection to be made. This can be
specified as a simple variable or as an element of
an array.
nsn%
is filled in by this function with a new socket
number created when a connection has been
established. This must be a simple variable; array
elements are not allowed.
This function is used to direct the ENI to do a passive open. This is
valid only on TCP sockets. This function suspends execution of the
task and waits until a connection is established. When a connection
arrives, it creates a new socket with the attributes of the given
socket to service the connection. The application program may then
shut down the original socket sn%, or it may loop back to the
ACCEPT% to wait for another connection to come in. In this way a
given service may have more than one client at a time.
Communication will take place through the new socket.
Values Returned:
ă1
-2
-7
-9
-15
-16
Success
ENI not initialized
Did not accept
No buffer space
Bad socket type
Not a TCP socket
For example:
STATUS% = ACCEPT%( SN%, NSN% )
8Ć4
Format:
SEND%( sn%, var, len% )
where:
sn%
is the number of the socket through which the
message is to be sent. This is the value that was
returned from the SOCKET% or ACCEPT%
function. This can be specified as a simple variable
or as an element of an array.
var
is the variable that has the data to send. It can be a
boolean, integer, double integer, real, string, or an
array of these types. It may be local or common. If
an array is specified, no subscript may be given. It
will always start with the zeroth element of the
array.
len%
is the number of bytes to send beginning at var.
This parameter can be a constant, an integer, or a
double integer.
If var is an array, and len% is zero, the length to
send is the size of the array. An error is generated if
len% is greater than the size of the array.
This function causes a message to be sent to the destination as
defined by the socket number.
If a TCP socket is specified, it must be connected. If the connection
was established with an ACCEPT%, the destination is the station
that established the connection.
Values Returned:
>0
-2
-9
-15
-17
-18
-26
-32
-102
Number of bytes transferred
ENI not initialized
No buffer space
Bad socket number
Message too long, UDP > 1472, ETH > 1500
Zero length for nonĆarray
Array is not single dimension
Beyond end of array
Socket not connected
For example:
XMIT_LEN% = SEND%( SN%, SET_POINTS%, MSG_LEN% )
where SET_POINTS% is the name of an array.
8Ć5
Format:
SENDL%( sn%, list! )
where:
sn%
is the number of the socket through which the
message is to be sent. This is the value that was
returned from the SOCKET% or ACCEPT%
function. This can be specified as a simple variable
or as an element of an array.
list!
is a single dimension double integer array whose
size is limited only by memory capacity. The values
in this array define where to get the data to send.
No subscript is given on this parameter.
Beginning at list!(0), the even elements of the array
contain pointers to the data to send and odd
elements of the array contain the number of bytes
to transfer. The number of bytes must be even. The
value for pointers is found with the VARPTR! or
FINDVAR! function. The list is terminated by a
pointer with a value of zero at the even boundary.
This function causes a message to be sent to the destination as
defined by the socket number.
If a TCP socket is specified, it must be connected. If the connection
was established with an ACCEPT%, the destination is the station
that established the connection.
Values Returned:
>0
-2
-9
-15
-17
-18
-19
-25
-26
-27
-30
-102
Number of bytes transferred
ENI not initialized
No buffer space
Bad socket number
Message too long
Zero length
Illegal Pointer
Not a double integer array
Not a single dimension array
Bad array format
Odd number of bytes in list parameter
Socket not connected
For example:
XMIT_LEN% = SENDL%( SN%, NETWORK_LIST! )
8Ć6
Format:
RECV%( sn%, var, len% )
where:
sn%
is the number of the socket through which the
message is to be received. This is the value that
was returned from the SOCKET% or ACCEPT%
function. This can be specified as a simple variable
or as an element of an array.
var
is the variable where the data received is written. It
can be a boolean, integer, double integer, real,
string, or an array of those types. If an array is
specified, no subscript may be given.
len%
is the number of bytes to receive. This parameter
can be a constant, an integer, or a double integer.
If var is a simple variable and len% is greater than
the size of the simple variable, then var must be
defined as I/O to avoid overwriting AutoMax
memory.
If var is an array, and len% is zero, the length to
receive is the size of the array. An error is
generated if len% is greater than the size of the
array.
For TCP only, if len% is -1, the number of bytes
received will be returned to the sender.
This function writes up to len% bytes of data from socket SN% into
the variable VAR.
If a TCP socket is specified, it must be connected.
A socket can be selected as blocking or nonĆblocking. If the socket
is blocking and no data has come in, the task will be suspended
until data arrives. If the socket is nonĆblocking and no data has
come in, the RECV% command will return with the error No
message waiting. The default mode is blocking.
Values Returned:
>0
-2
-9
-15
-17
-18
-26
-29
-31
-32
-101
-102
Length of message received
ENI not initialized
No buffer space
Bad socket number
Message too long
Zero length for nonĆarray
Array is not single dimension
Max size of strings are not equal
Max size of string < recv size of string
Beyond end of array
No message waiting
Socket not connected
For example:
RECV_LEN% = RECV%( SN%, SET_POINTS%, LEN%)
8Ć7
Format:
RECVL%( sn%, list! )
where:
sn%
is the number of the socket through which the
message is to be received. This is the value that
was returned from the SOCKET% or ACCEPT%
function. This can be specified as a simple variable
or as an element of an array.
list!
is a single dimension double integer array whose
size is limited only by memory capacity. The values
in this array define where to put the data to
received. No subscript is given on this parameter.
Beginning at list!(0), the even elements of the array
contain pointers to where to put the data and odd
elements of the array contain the number of bytes
to accept. The number of bytes must be even. The
value for pointers is found with the VARPTR! or
FINDVAR! function. The list is terminated by a
pointer with a value of zero at the even boundary.
This function receives data from socket SN% into memory pointed
to by the list. All pointers must reference variables defined as I/O.
Pointers may not reference variables defined in the Common
Memory Module or AutoMax Processor.
If a TCP socket is specified, it must be connected first.
A socket can be selected as blocking or nonĆblocking. If the socket
is blocking and no data has come in, the task will be suspended
until data arrives. If the socket is nonĆblocking and no data has
come in, the RECVL% command will return with the error No
message waiting. The default mode is blocking.
Values Returned:
>0
-2
-9
-15
-17
-18
-19
-25
-26
-27
-30
-101
-102
Number of bytes transferred
ENI not initialized
No buffer space
Bad socket number
Message too long
Zero length
Illegal pointer
Not a double integer array
Not a single dimension array
Bad array format
Odd number of bytes in list parameter
No message waiting
Socket not connected
For example:
RECV_LEN% = RECVL%( SN%, NETWORK_LIST! )
8Ć8
8.10
SETSOCKOPT% Function
Format:
SETSOCKOPT%( sn%, opnum%, opval% )
where:
sn%
is the number of socket whose option you want to
set.
opnum%
is the number of the option to set.
opval%
is the value to write into the ENI.
This function is used to select different modes of operation.
OPNUM% selects which option to change, and OPVAL% selects the
mode of operation.
Options
OPNUM%
OPVAL%
Description
Keep Alive
0008h
0
Keep alive is disabled
ăă(Default)
Keep alive is enabled
1
This option is only used on TCP sockets. When enabled, the ENI will
periodically send an empty message to maintain the connection. If
this option is not used and a frame is not received within 8 minutes
the ENI will assume it has been broken.
Linger
0080h
0
1
Linger is disabled (Default)
Linger is enabled
This option is only used on TCP sockets to select how the
SHUTDOWN function will operate. When linger is enabled and there
are messages in any transmit or receive queues the ENI will process
those messages before doing the shutdown.
Non Blocking 0200h
0
1
Non Blocking is disabled
ăă(Default)
Non Blocking is enabled
This option is used to select how the RECV% and RECVL% function
will operate. If Non blocking is enabled and no message has arrived
for the RECV% or RECVL%, control is returned to the application
program and an error code Ć101 is returned by the RECV% or
RECVL%.
Values Returned:
ă1
-2
-5
-9
-15
-20
-21
Success
ENI not initialized
Did not set option
No buffer space
Bad socket number
Bad option number
Bad option value
For example, to set the socket to nonblocking:
STATUS% = SETSOCKOPT%( SN%, 0200h, 1 )
8Ć9
8.11
GETSOCKOPT% Function
Format:
GETSOCKOPT%( sn%, opnum%, opval% )
where:
sn%
is the number of socket whose option you want to
read.
opnum%
is the number of the option to read.
opval%
is the name of the option variable where the current
value is written.
This function is used to examine what modes of operation are
selected. OPNUM% selects which option to look at, and OPVAL%
displays the current status.
Options
OPNUM%
OPVAL%
Description
Keep Alive
0008h
0
Keep alive is disabled
ą(Default)
Keep alive is enabled
1
This option is only used on TCP sockets. When enabled, the ENI will
periodically send an empty message to maintain the connection. If
this option is not used and a frame is not received within 8 minutes,
the ENI will assume it has been broken.
Linger
0080h
0
1
Linger is disabled
ą(Default)
Linger is enabled
This option is only used on TCP sockets to select how the SHUTĆ
DOWN function will operate. When linger is enabled and there are
messages in any transmit or receive queues the ENI will process
those messages before doing the shutdown.
Non Blocking 0200h
0
1
Non Blocking is disabled
ăă(Default)
Non Blocking is enabled
This option is used to select how the RECV% and RECVL% function
will operate. If Non Blocking is enabled and no message has arrived
for the RECV% or RECVL%, control is returned to the application
program and an error code Ć101 is returned by the RECV% or
RECVL%.
Connected
0800h
0
1
Socket not connected
Socket connected
This option is only used on TCP sockets. It allows the application
program to test if a connection is established without doing a
SEND% or RECV%.
Values Returned:
ă1
-2
-6
-9
-15
-20
-100
8Ć10
Success
ENI not initialized
did not get option
No buffer space
Bad socket number
Bad option number
No buffer space
For example, to test if the socket is connected:
STATUS% = GETSOCKOPT%( SN%, 0800h, OPTION_VALUE%)
8.12
SHUTDOWN% Function
Format:
SHUTDOWN%( sn% )
where:
sn%
is the number of the socket for which the
connection should be terminated.
This function closes the socket to allow it to be reused at a later
time.
TCP sockets need to be shut down at only one end. Either the active
or passive side may close the connection. The other side will
automatically shut down. UDP and Raw Ethernet sockets need to be
shut down at both ends.
Values Returned:
ă1
-2
-15
-28
Success
ENI not initialized
Bad socket number
Socket closed by destination
For example:
STATUS% = SHUTDOWN%( SOCKET_NUM% )
8Ć11
fafadfdfdasfdsfdsdsdfdsfdsfdsfsdfdsa
afdfdsfdsfdfdsfdsfsadfda
asfdfaddfdd
Appendix A
Converting a DCS 5000 BASIC Task to
AutoMax
You can easily convert any DCS 5000 Version 4 task to AutoMax. Simply
reĆcompile the task using the AutoMax Executive Programming software. Refer
to JĆ3684, the ReSource AutoMax Programming Software instruction manual, for
more information on compiling a BASIC task.
Converting a Version 1.0 BASIC Task to Version 2.0
You can easily convert any AutoMax Version 1.0 BASIC task created with M/N
57C304Ć57C307 Executive software to run in a 2.0 (M/N 57C390Ć57C393)
system. Simply reĆcompile the task using AutoMax Executive Programming
software V 2.0 (M/N 57C390Ć57C393). Refer to JĆ3684 for more information on
compiling a BASIC task.
Converting a Version 2.0 BASIC Task to Version 3.0
You can easily convert any AutoMax Version 2.0 BASIC task created with M/N
57C390Ć57C393 Executive software to run in an AutoMax V3 system. Simply
copy the task into AutoMax V3 using the AutoMax Executive Programming
software V 3.0 (M/N 57C390Ć57C393), and then reĆcompile the task. Refer to
JĆ3750 for more information on copying and compiling a BASIC task.
AĆ1
fafadfdfdasfdsfdsdsdfdsfdsfdsfsdfdsa
afdfdsfdsfdfdsfdsfsadfda
asfdfaddfdd
Appendix B
BASIC Compiler and Run Time Error
Codes
The following error codes are displayed on the screen when tasks are compiled.
Control Block Error Codes (BASIC Compiler)
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
Bad control block statement format
Unrecognized name for control block
Missing END statement in control block task
Not assigned
Variable used in control block not defined
Bad literal value for KI, KP, or KD
Bad WLD * KP/C value (See AutoMax Control Block Language Instruction
Manual; JĆ3676.)
Bad literal value for DEAD_BAND, MAX_CHANGE, or LOOP_TIME
Invalid data type for literal in control block
Incomplete input pairs or input/output pairs in a control block
Bad SCALE, REQUIRED_SAMPLES, or MAX_COLUMNS Value
Bad specification for array in control block
Control block not the only statement for that line number
CML specified literal field out of range
SCAN_LOOP block not allowed with CML block
Integer literal field too large
Invalid parameter keyword in control block
Calculated K value out of range
Literal symbol too long
Required control block field missing
Required control block literal missing
Control block field must be literal
Control block field must be variable
NonĆcontiguous inputs, input pairs, or input/output pairs in control block
Missing SCAN_LOOP block in control block task
Signed boolean literal or numeric variable not allowed
WLD value out of range
Invalid value for Lead Lag W
Invalid value for WM
Invalid value for WLD
Word size out of range
Array specified has too many subscripts
Integer literal > 24 bits; can't be accurately converted to real
Invalid value for Max_Input
More than 1 SCAN_LOOP call in a control block task
Fast floating point overflow
Fast floating point underflow
Fast floating point divided by zero
Meaningless tangent argument
Minimum number of inputs or outputs not programmed
BĆ1
297
298
299
300
301
302
303
304
305
Invalid data type for variable in Control Block
Parameter keyword previously defined in Control Block
Data structure symbol name too long
Data Structure requires more than maximum storage
Number of inputs/outputs greater than data structure definition
Duplicate definition or incorrect data structure type
Invalid Control Block Mode specified
Bad NOTCH bock Q_FACTOR value
Bad NOTCH block WN value
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
Bad IODEF statement format
IODEF address must not be odd
Bad IODEF variable type
IODEF hex address too large
Invalid bit number specification in RIO/NET DEF
Invalid literal in RIO/NET DEF
Missing master slot specification in RIODEF
Bad literal in IODEF
Missing bit field specification
Missing slot specification
Bad RIO/NET DEF statement format
Missing drop specification
Bad MODDEF statement format
Bad GATEWAY register specification
Bad RNETDEF statement format
Bad RNETDEF register specification
Invalid variable data type in GATEWAY definition
Bad ABDEF statement format
Bad file specification in ABDEF statement
Bad BOOLEAN literal specification
Bad GBLDEF statement format
Invalid network specification
Type of NET_NAME does not match type of variable
Network file not found
No network file drive
Invalid network file drive
Error opening OBN file
Error reading from OBN file
Network variable name not found on OBN file
No memory to build network functions
336
337
338
339
340
341
342
BĆ2
Invalid function call format
Incorrect number of parameters in function call
Bad parameter data type in function call or bad array subscript
Parameter symbol not defined
Variable must be simple (not array variable)
Invalid function parameter
Invalid function expression
343
344
345
346
347
Bad function variable
Bad array; must be 1 dimension (integer)
Bad BLOCK_MOVE variable
Variable in function call not defined as COMMON
Ticks per scan too high
356
357
358
359
360
361
362
363
364
365
366
Insufficient memory to compile array
Insufficient memory to compile FOR statement
Insufficient memory to build symbol table
Insufficient symbol table memory
Object code buffer overflow
Opcode position overflow; statement too long
No more user stack
No more program stack
No more type stack; expression too long
No more operator stack; expression too long
No more memory to link object code buffer
376
377
378
379
380
381
382
383
384
385
386
387
FOR control variable cannot be a tunable variable
NEXT control variable does not match FOR control variable
Control variable must be simple variable (not array).
Invalid data type on control variable in FOR statement
Bad FOR statement format
Invalid statement type following THEN in IF statement
Missing expected THEN
Invalid data type for expression in FOR statement
Missing corresponding FOR statement
FOR loops nested too deep
IFĆTHENĆELSE statement >32K
Missing <CR> or old and new IFĆTHEN formats mixed
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
Bad device name
Bad logical file number specification
Bad device name for OPEN statement
Bad baud rate in OPEN SETUP parameter
Invalid device specification
Bad OPEN statement format
Duplicate logical file number
Invalid CLOSE statement format
Invalid device name
Missing expected print field
Specified file has not been defined (no OPEN)
Device must be accessed by OPEN first
Invalid data type for print using format
Bad PRINT USING format
Specified format field width too wide
Cannot have print using with channel
BĆ3
412
413
414
415
416
417
418
419
420
421
422
423
Bad GET statement format
Bad PUT statement format
Bad INPUT statement format
Cannot close a channel
Cannot GET from a channel
Cannot PUT to a channel
Bad SETUP specification in OPEN device
Open device attempted on a channel
Bad format in OPEN FOR READ or OPEN FOR WRITE
Invalid keyword in OPEN configuraton
Bad ACCESS parameter (must be EXCLUSIVE or NON_EXCLUSIVE)
SETUP requires EXCLUSIVE access
START, WAIT, DELAY, EVENT Error Codes
426
427
428
429
430
431
432
433
434
435
436
Invalid time units specification
Missing DELAY expression
Bad START EVERY statement
Bad WAIT statement format
Invalid event name
Bad EVENT statement format
Bad time units in START statement
Delay time units must be an integer
Duplicate event name
Missing start interval
Missing event definition
Channel I/O Error Codes
446
447
448
449
450
451
452
453
454
455
Missing DEPTH parameter on OPEN CHANNEL FOR INPUT
Bad OPEN CHANNEL format
Bad channel template in OPEN statement
Invalid DEPTH specification for OPEN CHANNEL
INPUT/PRINT reference does not match channel template
Not assigned
Channel template too large
Channel packet too large
Channel was opened for input but output attempted
Channel was opened for output but input attempted
Array Error Codes
466
467
468
470
471
BĆ4
Array requires more than maximum storage
Bad array subscript
Number of subscripts does not match definition
Missing array dimension
Too many array subscripts
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
New value must be same type as tunable in WRITE_TUNE
Tunable variable expected
Missing delimiter
Missing equal sign ="
Missing left parenthesis ("
Missing right parenthesis )"
Missing expected comma ," or semicolon ;"
Missing line number
Invalid line number
Line number out of range (must be 1 to 32767)
Invalid data type mixing in expression
Invalid variable type
Variable name same as reserved symbol
Variable name too long
Missing variable name
Variable name too long
Invalid subscripted variable
Invalid variable specified in READ statement
Missing variable definition
Invalid statement terminator; expecting EOS
Task must be a CONFIGURATION task
Missing operand (symbol or literal)
Missing arithmetic/relational operator
Not a valid statement for this task type
Invalid integer expression for ON GOTO
Invalid ON GOTO statement format
Missing expected TO
Expected expression not found
Missing expected line number
Invalid boolean expression
Invalid tunable statement definition
Symbol already defined; duplicate definition
Invalid data type for a tunable variable
Tunable variable ranges are inconsistent
Undefined variable or statement not permitted in this type of task
Invalid tunable variable definition format
Tunable cannot be array, left side of equal, or control block output
Missing expected variable
DATA statement not first statement for this line number
Not assigned
Overflow in ASCII to binary integer conversion
Numeric literal too large
Real literal too large
Null buffer overflow; statement too large
Object buffer overflow; statement too large
Expression evaluator; stack integrity lost;expression too long
Compiler integrity lost
Illegal symbol in REM statement
CALL statement not first statement for this line number
BĆ5
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
BĆ6
Task not of type BASIC, CONTROL, or CONFIGURATION
Invalid task statement format
Invalid task priority
Invalid task name
Invalid slot specification
Missing string variable in GET or PUT statement
Illegal on board I/O address specified
Bad IOWRITE format
Bad IOWRITE option expression
Bad IOWRITE value expression
Bad IOWRITE address expression
REM statement not first statement on the line
Bad ON ERROR statement format
Fatal expression evaluation error; no opcode match
String literal too large
Too many total elements for an array
Array variable was referenced as a simple variable
Illegal state in expression evaluation; integrity lost
Bad expression in SET_MAGNITUDE statement
Bad SET_MAGNITUDE statement format
Bad variable type in SET_MAGNITUDE statement
Invalid TIMEOUT expression in EVENT statement
Symbol > 255 characters long; statement too long
Bad IF statement transfer line number
Invalid characters after the ampersand continuator
Remark statement too long
Line number out of range
Must be first statement on the line
Symbol is not a variable name
Loss of precision in converting real number
ELSE or END_IF encountered while not compiling an IF statement
ELSE not needed (condition already satisfied with ELSE or END_IF)
Missing THEN in IF-THEN ELSE statement
IF-THEN SECTION nested to deep
ELSE not valid in old style IF-THEN format statement
Path prefix not supported or bad format for include file name
Nested include files not supported
Undefined compiler directive
String length specified > 256 characters
String length specified not of type integer
Cant update INCLUDE structure info - object code corrupted
Include file could not be opened
Invalid file extension Ć must be .INC
Missing rate specification
Invalid rate specification
Redefinition of tick rate for this slot
Invalid tickdef statement format
No executable statements encountered! No object code can be
generated
590
591
592
593
594
595
596
Invalid value for WLG
Invalid value for ORDER
Control Blocks encountered before SCAN_LOOP
Invalid value for RES_N
Invalid value for RES_D
Invalid value for ZETA_N
Invalid value for ZETA_D
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
Line used in RESTORE is not a DATA statement
FOR and NEXT variables do not match
Insufficient memory to compress object code
Object code larger than 32K
Stack requirements too large
Data structures too large
Symbol table integrity lost
Insufficient memory for postĆcompile resolution
Line number not resolved
Symbol offset too big; task too large
No TASK statement in configuration task
No symbols in configuration task
Duplicate data pointers with same data type; caused by assigning two
DIFFERENT variables of the SAME type to the SAME register or bit:
IODEF [email protected][slot=3,REGISTER=1,BIT=1]
IODEF [email protected][slot=3,REGISTER=1,BIT=1]
or
NETDEF FIRST%[slot=2,DROP=1,REGISTER=2]
NETDEF SECOND%[slot=2,DROP=1,REGISTER=2]
Symbol table too large; too many symbols
Invalid condition; integer literal in BASIC task symbol table
Unable to allocate enough space for symbol table
Symbol table integrity lost
Too many COMMON integers, double integers, booleans used
Unable to allocate space for the BASIC runtime structure header
Too many LOCAL integers, double integers, booleans used
Too many LOCAL integers, double integers, boolean literals used
Too many COMMON reals, strings, arrays used
Too many LOCAL reals, strings, arrays used
Too many OPEN CHANNEL statements
Too many arrays used
Too many FOR loops used
Too many real literals used
Too many real tunable variables defined
Invalid condition; literal in CONFIGURATION task
Invalid condition; string literal type in the symbol table
Offset to real literal in CONTROL task greater than 16 bits
Invalid condition; LOCAL variable in CONFIGURATION task
Invalid condition; relative symbol number not resolvable
Offset required for relocatable reference greater than 16 bits
BĆ7
690
691
692
693
694
695
696
697
698
699
700
701
702
725
Error opening the object output file
Error writing to object output file
Task with READ statements but no DATA statements
Too many LOCAL integers, double integers, boolean variables used
Unable to allocate enough space for object code
Undefined Control Block data structure found
Error closing source file (disk may be full)
Error closing log file (disk may be full)
Error closing include file
Error attempting to load time/date into object file
Object size >32767 in Control Block task
Symbol & data size >32767 in Control Block task
Object+Symbol+Data size >20480 in UDC control block task
Invalid number of array dimensions
The following error codes are displayed in the error log accessible from the
ONĆLINE menu when the task is running.
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
BĆ8
Arithmetic integer overflow code
Arithmetic real overflow code
String concatenate overflow
Divide by zero
Integer multiply overflow
Integer assign overflow
Single integer conversion overflow in real to single integer
Double integer conversion overflow in real to double integer
Real to double integer conversion yields number > 24 bits
String overflow
Precision lost in real to integer array element conversion
Precision lost in real to double integer array element conversion
Precision lost in real to single integer conversion
Array subscript out of bounds
Requested substring > string
DATA type in READ statement does not match DATA statememt
No more DATA statements
Bad line number for RESTORE statement
Overflow in conversion of real to integer of FOR loop control variable
Overflow in conversion of real to integer of FOR statement TO value
Overflow in conversion of real to integer of FOR statement STEP value
Integer > 24 bits in STEP value integer to real conversion
Bad IOWRITE
Integer control variable overflow in FOR statement
Double integer control variable overflow in FOR statement
Real control variable overflow in FOR statement
Negative delay
Delay value too large (0 to 32767)
Negative start interval
Delay value too large (0 to 32767)
Not assigned
Hardware event # ticks < 0
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
Hardware event ticks overflow
Print buffer overflow; print field too long
Device not open properly
OPEN with bad device address
Device not open for write
No stack space for print
Device not allocated
No buffer for print operation; insufficient memory
Fatal print error
Device already open
Device OPENed differently from attempted operation
Bad allocate
Bad default OPEN
Device already closed
Device opened as a channel
Bad device close; no address
Default device not allocated
Channel not open
Print integer channel overflow
Message overflow
Unsuccessful channel open
Integer > 24 bits in real conversion
Real to integer overflow
No buffer for GET operation
No print buffer
Device closed on GET
GET not open for read; GET attempted on unopened device
Bad GET operation
No buffer for PUT operation
No print buffer
Device closed on PUT statement
PUT not open for write; PUT attempted on unopened device
Unsuccessful PUT operation
Device should be open
Invalid baud rate
Bad SETUP reĆconfiguration
Precision out of range
Width too long printing integer field in PRINT USING D format
Width too long printing integer field in PRINT USING with L/R/C/Z format
Negative decimal places
Number decimal points greater than maximum precision allowed
Width less than zero
Field width overflow
Requested substring width less than zero
Requested width greater than maximum
No space for requested PRINT USING field
String greater than field width
Bad channel depth
Device not open
Attempted negative square root
BĆ9
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
BĆ10
First substring position specification greater than string length
Not assigned
Not assigned
Wrong data type input for boolean
Another error occurred during execution of ON ERROR routine
Could not allocate for write
Wrong data type input for string
Last substring position less than first substring position
First substring position specification < 0
Last substring position specification < 0
Rotate count greater than 31
Overflow on absolute value function
Not assigned
Device open at END
Channel not open on input
Wrong type for integer
Next character after field not legal
Bad next character
No input channel I/O buffer
Not allocated for reĆconfiguration
Bad BCD digit
Channel already open
Wrong token for comma
Not open for read
No comma between fields
Wrong data type input for real
No buffer space can be allocated for I/O
Not assigned
Invalid reĆconfiguration
Missing line number
Bad device on input
Wrong type for double integer
No device address
Number greater than 24 bits
Not open for write
No device address
Attempt to execute a null opcode
Unbalanced GOSUBĆRETURN
NEXT does not match loop variable in FOR statement
NEXT does not match FOR
Bad START statement format
Bad hardware event call
Undefined opcode
Stack overflow
No channel buffer space
STOP executed
Opcode not assigned
No event address defined
GOSUBs not balanced
Bad VAL function conversion
888
889
890
891
892
893
894
895
956
958
959
960
961
962
963
964
BCD output number greater than 9999
Bad bit number in function call
Bad option number in function call
Invalid GATEWAY transfer call
Note: Check returned status variable of
[email protected] function; decode status error numbers as follows
(01 through 07 are MODBUS exception codes):
Decimal
01
Illegal function code
02
Illegal starting register
03
Illegal data
04
PC aborted
05
Not assigned
06
PC busy
07
Not assigned
08
Illegal data in response message
09
Response timeout error
20
Dual port address error
21
Gateway card not found or not accessible
22
No available Gateway channel
23
Illegal register number
24
Illegal number of register
25
Illegal command number
26
Illegal command number/register set
27
Illegal register number/number of registers
28
Illegal device address
BLOCK_MOVE invalid source parameter
BLOCK_MOVE invalid destination parameter
BLOCK_MOVE invalid transfer size parameter
RESUME without executing ON ERROR statement first
UDC tick rates do not match
PMI gains out of range
UDC Processor error
Floating point format conversion error
Spurious interrupt detected from Multibus
CCLK must be enabled to execute task
OS background not completing
Flash update not completing in time; check utilization
Corrective action: For error code 757, check real and double integer value
ranges.
1000
1001
1002
1003
1004
1005
1006
1007
SCR fault
MĆcontactor fault
(not used)
Instantaneous overcurrent fault
Synch loss (AC line voltage)
Conduction timeout
Field loss fault
Tach loss fault
BĆ11
1008
1009
1010
1011
1012
1013
1014
1015
Broken wire in resolver
(not used)
Overspeed trip
Power Technology module fault
PMI power supply fault
PMI bus fault
UDC run fault
Fiber optic link com. fault
Corrective action: These errors reflect the status of the drive fault register
(A=202, B=1202) on the UDC module. See SĆ3006 for more information.
The possible causes of serial I/O errors include:
A hardware problem with device connected to serial ports on the face of the
Processor module.
1064
1065
1066
1067
EIA control (carrier detect) lost
Parity error (when enabled)
Overrun error
Framing error
2060
2061
2062
2063
2064
2065
2066
BĆ12
Bad wN in NOTCH block
Bad Q value in NOTCH block
ResN or resD out of range
ZetaN or zetaD out of range
LIM_BAR is out of range
TRIP_TIME is out of range
THRESHOLD is out of range
Appendix C
Hardware Interrupt Line Allocation
Current Minor Loop (CML) tasks or tasks that use BASIC hardware EVENT
statements require Processors to allocate hardware interrupt lines on the rack
backplane. This is because some portion of task execution depends upon
receiving a userĆdefined hardware interrupt from another module in the rack,
e.g., a Resolver Input module. This appendix will describe the basic method by
which interrupt lines are allocated. See the Control Block Language instruction
manual (JĆ3676) for more information on CML tasks.
Because the number of interrupt lines is limited to four, it is necessary to take
into account the rules by which they are allocated in order to prevent errors
when application tasks are put into run. Each of the four interrupt lines can
service" one of the following:
a)
four BASIC language hardware EVENT statements in BASIC or Control
Block tasks
b)
one CML task (used in racks containing drive cards only)
Any one Processor module can allocate one of the four interrupt lines for up to
four EVENT statements and one line for a CML task. (CML tasks are limited to
two per rack because of drive module configuration restrictions.) A minimum of
one hardware interrupt line is allocated for a Processor Module regardless of
whether one or four hardware EVENT statements are used in the application
tasks loaded on that Processor.
The following examples of interrupt line allocation assume that there are two
Processor modules in the rack. Note that these examples do not take into
account the efficiency of distributing application tasks between Processor
modules in this manner (in terms of system performance).
Example #1
Slot 1
Processor
Module
x x x x
4 hardware EVENT
statements in
BASIC or Control
Block tasks.
Slot 2
Processor
Module
No hardware
EVENT statements
or CML tasks.
=ăInterrupt Line
x
=ăHardware EVENT Statement
CML =ăCML Task
CĆ1
Example #2
Slot 1
Processor
Module
CML
1 CML task
Slot 2
Processor
Module
x x x x
4 hardware EVENT
statements
=ăInterrupt Line
x
=ăHardware EVENT Statement
CML =ăCML Task
Example #3
Slot 1
Processor
Module
x
1 hardware EVENT
statement
Slot 2
Processor
Module
CML
x x x x
1 CML task and
4 hardware EVENT
statements
=ăInterrupt Line
x
=ăHardware EVENT Statement
CML =ăCML Task
Example #4
Slot 1
Processor
Module
CML
CML
2 CML tasks
Slot 2
Processor
Module
x x x x
4 hardware EVENT
statements
=ăInterrupt Line
x
=ăHardware EVENT Statement
CML =ăCML Task
CĆ2
The following BASIC statements are supported in UDC Control Block tasks:
CLR_ERRLOG
COMMON
END
FORĆNEXT
GOSUB
GOTO
IFĆTHENĆELSE
INCLUDE
LET
LOCAL
ON ERROR
REM OR !
RESUME
RETURN
SET_MAGNITUDE
The following BASIC functions are supported in UDC Control Block tasks:
ABS
ATAN
BCD_IN%
BCD_OUT%
COS
EXP
LN
ROTATEL%
ROTATER%
SHIFTL%
SHIFTR%
SIN
SQRT
TAN
[email protected]
WRITE_TUNE
The following expressions are supported in UDC Control Block tasks:
+
Addition, Unary+
Subtraction, Unary*
Multiplication
/
Division
**
Exponentiation
AND
Logical AND"
OR
Logical OR"
XOR
Logical exclusiveĆOR"
NOT
Unary boolean operator performs a boolean complement
=
Equal to
<
Less than
>
Greater than
<=
Less than or equal to
>=
Greater than or equal to
<>
Not equal to
><
Not equal to
DĆ1
fafadfdfdasfdsfdsdsdfdsfdsfdsfsdfdsa
afdfdsfdsfdfdsfdsfsadfda
asfdfaddfdd
The list that follows shows which AutoMax Processor modules can be used with
the AutoMax Programming Executive software.
Version 1.0
M/N 57C304, 57C305
M/N 57C306, 57C307 (updates)
M/N 57C430
M/N 57C430
Version 2.0
M/N 57C390, 57C391
M/N 57C392, 57C393 (updates)
M/N 57C430A
M/N 57C430A
Version 2.1D and later
M/N 57C391
M/N 57C393 (update)
Version 3.0
M/N 57C395
M/N 57C397 (update)
Version 3.1
M/N 57C395
M/N 57C397 (update)
Version 3.3* and later
M/N 57C395
M/N 57C397 (update)
M/N 57C430A
M/N 57C431
M/N 57C435
M/N 57C430A
M/N 57C431
M/N 57C435
M/N 57C430A
M/N 57C430A
M/N 57C430A
M/N 57C431
M/N 57C435
M/N 57C430A
M/N 57C431
M/N 57C435
M/N 57C430A
M/N 57C431
M/N 57C435
M/N 57C430A
M/N 57C431
M/N 57C435
*Note that if you are using the Programming Executive for drive control
applications, the Universal Drive controller (UDC) module (B/M 57552) is
supported only in Version 3.3 and later of the Programming Executive software.
EĆ1
fafadfdfdasfdsfdsdsdfdsfdsfdsfsdfdsa
afdfdsfdsfdfdsfdsfsadfda
asfdfaddfdd
Appendix F
New Features
The following are either new or changed in BASIC for Version 3.0 of the
AutoMax Programming Executive.
1. ENI_INIT%
2. SOCKET%
3. BIND%
4. CONNECT%
5. ACCEPT%
6. SEND%
7. SENDL%
8. RECV%
9. RECVL%
10 SETSOCKOPT%
11. GETSOCKOPT%
12. SHUTDOWN%
13. READVAR%
14. WRITEVAR%
15. FINDVAR!
16. CONVERT%
The following are either new or changed in BASIC for Version 3.3 of the
AutoMax Programming Executive.
Section 2.3 Ć
describes the use of BASIC statements and functions in UDC
Control Block tasks.
Appendix D Ć
lists the BASIC functions and statements supported in UDC
Control Block tasks.
Appendix E Ć
lists the AutoMax Processors that are compatible with
versions of the AutoMax Programming Executive software.
The following are either new or changed in BASIC for Version 3.4 of the
AutoMax Programming Executive.
Section 4.1.1 has been revised to state that E" notation should be used to
indicate an exponent in BASIC.
Section 8.0, describing the Ethernet functions, now states that tasks that use the
Ethernet functions must be run on the leftĆmost Processor in the rack.
The following functions have been added to BASIC:
[email protected]
[email protected]
WRITE_TUNE
Additional BASIC statements and functions that can now be used in UDC tasks:
FORĆNEXT
SET_MAGNITUDE
SIN, COS, TAN, ATAN
EXP
LN
BCD_IN%, BCD_OUT%
WRITE_TUNE
FĆ1
fafadfdfdasfdsfdsdsdfdsfdsfdsfsdfdsa
afdfdsfdsfdfdsfdsfsadfda
asfdfaddfdd
fafadfdfdasfdsfdsdsdfdsfdsfdsfsdfdsa
afdfdsfdsfdfdsfdsfsadfda
asfdfaddfdd
For additional information
1 Allen-Bradley Drive
Mayfield Heights, Ohio 44124 USA
Tel: (800) 241-2886 or (440) 646-3599
http://www.reliance.com/automax
Publication J-3675-6 - April 1998
Copyright © 2002 Rockwell Automation, Inc. All rights reserved. Printed in U.S.A.
Was this manual useful for you? yes no
Thank you for your participation!

* Your assessment is very important for improving the work of artificial intelligence, which forms the content of this project

Download PDF

advertisement