United States Patent [19]
`Wright et ale
`
`I11111111111111111111111111111111111111111111111111111111111111111111111111
`US005453933A
`[11] Patent Number:
`[45] Date of Patent:
`
`5,453,933
`Sep. 26, 1995
`
`[54] CNC CONTROL SYSTEM
`
`5,272,642 1211993 Suzuki ............................... 364/474.24
`
`[75]
`
`Inventors: Michael R. Wright, Indianapolis;
`David E. Platts, Plainfeild; Daniel B.
`French, Carmel; Gerald Traicoff,
`Indianapolis; Michael A. Dupont,
`Fishers; Gregory A. Head, Plainfield,
`all of Ind.
`
`[73] Assignee: Hurco Companies, Inc., Indianapolis,
`Ind.
`
`OTHER PUBLICATIONS
`
`International Search Report, Jan. 11, 1995.
`Article entitled "Object Oriented Programming for Motion
`Control", D. E. Halpert (1991).
`Article entitled "MMS:MAP Application Services for the
`Manufacturing Industry", Brill and Gramm, Jul. 1991.
`Ultimax Programming, Hurco Manufacturing Co., Inc.,
`instruction manual, Hurco Part No. 704-0001-598, Oct.,
`1992, Revision C.
`
`[21] AppI. No.: 118,445
`
`[22] Filed:
`
`Sep. 8, 1993
`
`Int. Cl.6
`...................................................... G06F 15/46
`[51]
`[52] U.S. Cl. ................ 364/474.23; 3641191; 364/474.24
`[58] Field of Search ......................... 364/474.22, 474.23,
`364/474.24,468, 188-193,474.15,474.16,
`474.17, 474.26
`
`[56]
`
`4,477,754
`4,823,253
`4,885,717
`4,939,635
`5,079,713
`5,095,522
`5,150,303
`5,168,441
`5,177,689
`5,181,162
`5,212,767
`5,235,701
`5,237,654
`5,239,477
`5,247,447
`
`References Cited
`u.s. PATENT DOCUMENTS
`10/1984 Roch et al ......................... 364/474.22
`4/1989 Shima ..................................... 364/167
`12/1989 Beck et al. .............................. 364/900
`7/1990 Seki ........................................ 364/191
`111992 Kawamura .............................. 364/474
`3/1992 Fujita et al. . ... _...................... 395/200
`9/1992 Fukaya .................................... 364/474
`12/1992 Onarheim et at ....................... 364/146
`1/1993 Kinasi ..................................... 364/474
`1/1993 Smith et at ............................. 364/419
`5/1993 Baker et at ............................. 395/600
`8/1993 Ohler et at. ............................. 395/600
`8/1993 Schackelford et at .................. 395/160
`8/1993 Matsumura ............................. 364/474
`9/1993 Korncoff et al ........................ 364/468
`
`Primary Examiner-Roy N. Envall, Jr.
`Assistant Examiner-Thomas E. Brown
`Attorney, Agent, or Firm-Baker & Daniels
`
`[57]
`
`ABSTRACT
`
`A CNC machine tool control system that includes a con(cid:173)
`trollable, movable tool for shaping a workpiece, a mecha(cid:173)
`nism for receiving control instructions describing shaping
`functions to be performed on the workpiece, a processing
`unit and memory. The control systems includes objects
`defined according to an object oriented design. One type of
`object is a model of a shaping process to be performed on a
`workpiece, including informational parameters regarding
`the physical dimensions of the shape resulting from the
`process. The process objects communicates through an
`object oriented messaging system to machine objects, which
`represent physical devices present on the CNC machine on
`which the control system operates. The system also includes
`object oriented motion control and exception handler
`objects, each of which may communication with other
`object via object oriented messages. The control system
`permits easy modifications to the control system by persons
`with limited knowledge about the entire control system, and
`is readily adaptable to advances in new CNC machine tools.
`
`38 Claims, 2 Drawing Sheets
`
`COMMUNICATIONS INTERFACE
`(SERIAL & PARALLEL)
`
`________ 20
`
`17 ______
`
`y
`
`Page 1 of 43
`
`

`

`~
`~
`\,C
`~
`01
`~ .a;.
`01
`
`~
`
`~
`
`~
`
`o ....,
`m.
`rJJ. ::r
`
`Ul
`\C
`\C
`~
`
`~~
`~
`
`~
`rJJ.
`
`~ = ~
`
`~
`~
`~
`•
`rJ1
`d •
`
`60
`
`26/
`
`25/
`
`FIG. 1
`
`21/
`
`PENDANT
`
`JOG
`f
`
`19/
`
`PANEL
`
`CONTROL
`
`I
`
`24/
`
`23/
`
`Y
`
`22/
`
`17 ______
`
`______ 20
`
`(SERIAL & PARALLEL)
`
`COMMUNICATIONS INTERFACE
`
`i __ 18
`
`BOARD
`
`MOTION CONTROL
`
`____ 16
`
`INTERFACE
`CAN BUS
`
`'---10
`
`i
`
`,----
`
`INTERFACE
`
`VIDEO
`
`/15
`
`M~~
`
`STORAGE
`
`/14
`
`I
`
`INTERFACE
`NETWORK
`
`/13
`
`j
`
`MEMORY
`
`/12
`
`I
`
`CPU
`
`/11
`
`Page 2 of 43
`
`

`

`u.s. Patent
`
`(39 Microfiche, 2419 Pages)
`
`Sep. 26, 1995
`
`Sheet 2 of 2
`
`5,453,933
`
`c-
`Operator
`Part Program Interpreter
`--------
`-----~~--~-----~
`
`~
`~
`
`Jog
`Pendant
`
`Inilializer
`
`Motion
`Controller
`
`Logic
`Controller
`
`Fig.2
`
`Process
`
`Machine
`
`Kernel
`
`Platform
`Services
`
`Operating
`System
`
`Device
`Drivers
`
`Page 3 of 43
`
`

`

`5,453,933
`
`1
`CNC CONTROL SYSTEM
`
`MICROFICHE APPENDIX
`
`2
`the above simplified example illustrates.
`The motion control function of the software receives
`commands describing how a particular axis or motor should
`be moved. For example, in the above example for logic
`control, the logic control function sent the motion control
`function a command to raise the spindle. The motion control
`function takes this "general" command, breaks it down into
`smaller, discrete movements (Le. controllably move the
`spindle up 0.001" at a time until it has moved up a total of
`6 inches), and sends and receive electric signals from
`precision motors to ensure the movement is carried out. The
`motion control function is also able to execute more com(cid:173)
`plex, multi-dimensional commands, such as to move the
`axes of a milling machine in a pattern so as to cut an ellipse
`15 of specified dimensions in a workpiece.
`Because the motion control function is the portion of the
`software (except for device drivers) that interacts most
`closely with the hardware components that actually carry out
`shaping processes on a workpiece, the motion control func-
`tion also receives information about hardware faults from
`hardware devices. For example, if a hardware device is
`unable to execute an instruction, the motion control function
`will receive a notice of the error from the hardware (or its
`associated device driver). This information needs to be
`25 communicated back to the other portion of the CNC control
`software responsible for requesting the motion control func(cid:173)
`tion to complete the function the software is currently
`undertaking, so that appropriate action, such as displaying a
`message on the operator CRT, may occur. However, there
`30 are usually many other portions of the CNC control system
`software that will also need to be informed of the hardware
`fault. Moreover, the portions that need to know about the
`fault will vary depending on the exact fault. In past systems,
`the motion control function has been used to keep track of
`35 which portions of the CNC control system software must be
`notified of which hardware faults. This not only places an
`increased burden on the motion control portion of the CNC
`control system software, but also makes this portion more
`difficult to maintain.
`Computer programmers writing CNC software have gen-
`erally designed the entire software system using structured
`techniques that analyze what the entire CNC machine tool
`must do (functional decomposition). This has resulted in
`complex, difficult-to-modify
`software
`systems. For
`45 example, software code relating to the user interface by
`which a user describes a part to be machined, can be found
`in other portions of the CNC control system software, such
`as the motion controller. One example is that when a motion
`controller receives a signal from a machine tool indicating a
`fault condition (for example, when an object in the work
`area prevents the table from moving to a desired location, or
`a blown fuse), the motion controller might directly display
`an error message on the CRT display. Because prior CNC
`control system software generally is not broken down into
`55 portions corresponding to the discrete, physical components
`of a CNC machine tool, a change in one portion of the
`software is difficult to make and frequently requires changes
`to other portions of the software.
`Another example illustrating this problem occurs when a
`user, system integrator or even machine tool manufacturer
`wishes to add a new hardware component to the machine
`tool. For example, it may be desirable to replace an AC
`induction motor with a DC brushless motor from a different
`manufacturer. The new motor will likely use a different
`communications protocol and have different tolerance speci(cid:173)
`fications and operating limits. Therefore, the motion control
`software will need to be modified to be able to communicate
`
`This application includes a microfiche appendix having 5
`39 frames.
`
`FIELD OF THE INVENTION
`
`This invention relates to computer numeric controlled
`(CNC) machine tools, and in particular, to the control 10
`systems used to operate such machine tools.
`
`BACKGROUND OF THE INVENTION
`
`CNC Control Systems
`
`20
`
`. The purpose of a CNC machine is to use a set of input
`specifications describing a physical object to produce a
`machined part according to the specifications. The part is
`typically formed from solid block stock material such as
`metal, and shaped by various machine tools such as drills,
`mills, lathes, electrostatic discharge machines (EDMs),
`gauging systems and the like. CNC machines are complex
`and include hundreds of components. Examples of input
`devices include keyboards, operator consoles, pressure sen(cid:173)
`sitive CRTs, various tools and machine sensors, limit
`switches and network interfaces. Output devices include
`motion controllers that send motion control signals to
`motors driving axes or a tool, CRT displays, console status
`lights and audible alarms. Other components include micro(cid:173)
`processors, memory, disk drives, data buses and wiring
`harnesses. The software executed by the computer processor
`is a critical component of a CNC machine, as it coordinates
`the functions of the all the other components of the system.
`In general, CNC software is custom written for the particular
`brand of components a CNC manufacturer or system inte(cid:173)
`grator chooses to include in the CNC machine. As a result,
`CNC software is extremely complex, and a software pro(cid:173)
`grammer for a particular CNC machine must be intimately
`familiar with the way virtually every hardware component 40
`interfaces with the software, and with the entire software
`system itself.
`For example, two representative functions of most CNC
`software are the logic and motion control functions (collec(cid:173)
`tively referred to herein as the "kernel"). The logic control
`function keeps track of the specific sequence of steps that
`must be taken by various movable hardware components to
`accomplish a task. For example, the steps required to mount
`a differently sized drill bit into the tool holder of a spindle
`from an automatic tool changer in a milling application
`might be: (1) send a command to raise the spindle containing
`the currently mounted drill bit so the tool changer will fit
`underneath it, (2) send a command to the tool changer
`instructing it to move below the spindle, (3) send a com(cid:173)
`mand to the spindle instructing it to release the currently
`mounted drill bit, (4) wait for a signal from the spindle
`indicating that the drill bit has been released, (5) send a
`command to the tool changer instructing it to move to rotate
`clockwise 30 degrees to position the new drill bit below the
`spindle, (6) interrogate the tool changer to confirm that the 60
`tool changer has successfully executed the rotation com(cid:173)
`mand, (7) send a command to the spindle commanding it to
`engage the new drill bit underneath it in the tool changer,
`and (8) send a command to the tool changer instructing it
`move away from the spindle and work area. Given the 65
`hundreds of moving, controllable parts in a CNC machine
`tool, the logic control function is much more complex than
`
`50
`
`Page 4 of 43
`
`

`

`5,453,933
`
`3
`with the new motor using its communications protocol. The
`user interface will also need to be modified so that the user
`may specify the improved tolerance parameters. However,
`with past CNC software, these changes will have a ripple
`effect throughout the entire software system, greatly increas-
`ing the time required to develop a new software system
`capable of using the new motor. Many of the additional
`revisions are caused by the fact that the data the software
`needs to access is dispersed throughout the entire software
`system. For example, to add a new software function, the 10
`software may need to know, what tool is presently in the
`spindle, the speed the spindle is rotating, the coordinates of
`the axes (location of the table), the readings of a thermal
`sensor, information about forces being exerted on the cutting
`spindle, and the stage (or step) of processing the workpiece 15
`is currently in. In past CNC systems, this information would
`likely be diffused throughout various software modules, and
`the way these data elements interact is either too complex to
`discern (execpt to the original software author), or propri(cid:173)
`etary.
`These problems with CNC control systems have led to
`several other problems throughout the industry. There is a
`long lead time for system integrators or CNC machine tool
`manufacturers to be able to incorporate new hardware
`components into existing systems. This problem applies not
`only to new CNC machine designs, but also to efforts to add
`improved or additional components to an existing CNC
`machine tool, or to retrofit an existing machine tool with
`CNC capabilities. Another problem is that of scalability.
`Because CNC control software is usually written for use in
`accordance with an anticipated collection of hardware com(cid:173)
`ponents, the same software can not be easily adapted for use
`in connection with other hardware components. In other
`words, CNC software is generally not "scalable," meaning
`that the software used to operate sophisticated, high-end
`CNC machines can not also be used to operate "bare-bones,"
`low-end CNC machine tools. As a result, CNC manufactur-
`ers "reinvent" software having the same functionality
`merely because it designed to work in a CNC having
`different hardware components.
`Programmers for CNC control systems can also be
`required to "reinvent" software components not just in
`response to new hardware, but also in response to new
`standards for inputting descriptions of parts to be formed by
`the CNC machine. The earliest CNC machines accepted part
`definitions through punched paper tape. Subsequent CNC
`machines (such as that disclosed in U.S. Pat. No. 4,477,754)
`interrogated a machine operator through a series of ques(cid:173)
`tions to obtain instructions about how to create a desired
`part. More recently, several standard data file formats have 50
`emerged for describing parts to be machined, such as the
`HURCO conversational or RS-274D M&G code programs.
`In the past "part program interpreter" modules of CNC
`control system programs, each module used for accepting a
`part definition in a different format, would generally have to 55
`access, as described above, various data elements and soft(cid:173)
`ware routines diffused throughout the CNC control system
`software. Again, each different input format has resulted in
`a unique part program interpreter software program, and
`these programs all include much common, and therefore 60
`needlessly duplicative, functionality.
`Object Oriented Software
`
`35
`
`Most existing programming languages provide "sequen(cid:173)
`tial" instructions for a processor to implement. These lan(cid:173)
`guages have previously been used to implement CNC con(cid:173)
`trol systems. However, computers are often utilized for
`
`5
`
`4
`modeling systems of interactive componcnts in order to
`determine sequences of actions such systems would perform
`under various conditions. For example, a programmer may
`wish to program a computer to mimic the manner in which
`some particular digital logic network responds to a particular
`input stimulus. When the programmer doesn't know bcfore-
`hand what sequence of steps the logic network would carry
`out in response to the stimulus, but only knows how each
`individual component changes its outputs in response to a
`change to its inputs, the programmer often finds it difficult
`to utilize sequentially organized instructions to program a
`computer to model the behavior of the system.
`In contrast to sequentially organized software, "objcct(cid:173)
`oriented" software is organized into "objects", each com(cid:173)
`prising a block of computer instructions describing various
`procedures ("methods") to be performed in responsc to
`"messages" sent to the object. Such operations include, for
`example, the manipUlation of variables and the transmission
`of one or more messages to other objects. Messages are sent
`20 and received between objects having certain functions and
`knowledge to carry out processes. When one of the objects
`receives a message, the object carries out an operation (a
`message procedure) corresponding to the message and, if
`necessary, returns a result of the operation. Each object has
`25 a region where internal states (instance variables) of thc
`object itself are stored and where the other objects arc not
`allowed to access. The objects comprise concept objects that
`represent concepts and instance objects that represent
`instances of the concept objects. The concepts are clearly
`30 separated from the instances. One feature of the object(cid:173)
`oriented system is inheritance. With respeet to a certain
`concept object, there is defined an upper concept object that
`has a concept more abstract than a concept held by the
`certain concept object, and the certain object can inhcrit the
`functions (message procedures) and knowledge (instance
`variables) of the upper concept object to utilize them. For
`example, a concept object "circle" may inherit functions and
`knowledge from its upper concept object "shape."
`A programmer "programs" in an object-oriented program-
`40 ming language by writing individual blocks of code each of
`which creates an object by defining its methods. A collection
`of such objects adapted to communicate with one another by
`means of messages comprises an object-oriented program.
`Object-oriented computer programming facilitates the mod-
`45 eling of interactive systems in that each component of the
`system can be modeled with an object, the behavior of each
`component being simulated by the methods of its corre(cid:173)
`sponding object, and the interactions between components
`being simulated by messages transmitted between objeets.
`An operator may stimulate a collection of interrelated
`objects comprising an object-oriented program by sending a
`message to one of the objects. A method of the object
`receiving the message may cause the object to respond,
`carrying out predetermined functions which may include
`sending messages to one or more other objects. The other
`objects may in tum carry out additional functions in
`response to the messages they receive, including sending
`still more messages. In this manner, sequences of message
`and response may continue indefinitely or may come to an
`end when all messages have been responded to and no new
`messages are being sent. When modeling systems utilizing
`an object-oriented language, a programmer need only think
`in terms of how each component of a modeled system
`responds to a stimulus and not in terms of the sequence of
`65 operations to be performed in response to some stimulus.
`Such sequence of operations naturally flows out of the
`interactions between the objects in response to the stimulus
`
`Page 5 of 43
`
`

`

`5,453,933
`
`6
`BRIEF DESCRIPTION OF THE DRAWINGS
`
`FIG. 1 is a schematic diagram of the hardware compo(cid:173)
`nents of a CNC machine tool system on which the control
`system of the present invention may operate.
`FIG. 2 is a schematic diagram of the types of software
`classes included in a CNC control system, and several
`representative types of object-oriented objects within sev(cid:173)
`eral of these classes.
`
`SUMMARY OF THE INVENTION
`
`5
`and need not bc preordained by the programmer.
`Although object-oriented programming makes simulation
`of systems of interrelated components more intuitive, the
`operation of an object-oriented program is often difficult to
`understand because the sequence of operations carried out 5
`by an object-oriented program is usually not immediately
`apparent from a software listing as in the case for sequen(cid:173)
`tially organized programs. Nor is it easy to determine how
`an object-oriented program works through observation of
`the readily apparent manifestations of its operation. Most of 10
`the operations carried out by a computer in response to a
`program are "invisible" to an observer since only a relatively
`few steps in a program typically produce an observable
`computer output.
`Object-oriented analysis and design methods permit reuse 15
`of system analysis and requirements from other products in
`the same family. Object-oriented software design means that
`software components are created from data and functions
`and are organized into objects. An object is an abstraction of
`something in the real world, reflecting the capabilities of a 20
`system to keep information about it, interact with it, or both.
`It is, therefore, an encapsulation of attribute values and their
`exclusive services. An object's attributes describe the object,
`but not how it works. The object's services are instructions,
`programs, procedures, or actions that describe what the 25
`object will do when something happens.
`As described above, objects are grouped into classes. A
`class includes a description of how to create new objects in
`the class and establishes the basic variables that are common
`to all of its objects. New objects inherit these common
`characteristics from the parent class. This feature allows the
`software engineer to build on existing design and code by
`creating more specific objects from the easily reused code in
`the general class. For example, a software engineer can use
`a general class of characteristics for a "device" to create a
`model of a more specific device such as a spindle. Object(cid:173)
`oriented analysis and design explicitly represent common(cid:173)
`ality in the system's objects and use inheritance to identify
`and capitalize on commonality of attributes and services.
`The system may only access data through the services, if at
`all. Services hide an object's data and send messages to
`perform operations. This isolates dependency on a particular
`data structure thus permitting new features to be added
`without changing the arrangement of the original objects. 45
`This structure protects the data from the damage that com(cid:173)
`monly occurs during changes in monolithic, proprietary
`systems.
`
`The control system of the present invention provides a
`real-time CNC software system that isolates system respon(cid:173)
`sibilities into classes that permit a CNC manufacturer or
`system integrator to manage complexity and change. The
`control system allows different systems to be created from
`the same model and future, as yet unimagined, technological
`advances can be incorporated without redesigning or making
`massive changes.
`The system utilizes an object-oriented software environ(cid:173)
`ment. A first class of object types is provided for processes
`(such as drilling, reaming, milling) to be carried out by
`machine tool components (the Process Class). Some pro(cid:173)
`cesses objects may inherit characteristics of other objects in
`the Process class. For example, a "hole" object may have
`characteristics such as a depth and diameter, which can be
`inherited by other process objects, such as a drill, ream or
`bore process object. A second class of object types of is
`30 provided which represent instances of machine tool compo(cid:173)
`nents, such as a table (axes), a spindle, tool changer or
`operator console. Again, some objects may inherit attributes
`of other objects. For example, an axis group, namely an
`object for simultaneously controlling multiple axes to shape
`35 complex three-dimensional objects, may be inherit attributes
`of a single axis object. Other objects may be composite
`objects of other tool objects. For example a tool changer
`may be a composite object of a collection of different milling
`bits which may be held in the tool changer (in addition to
`40 having its own attributes).
`Most importantly, during execution of the software com(cid:173)
`ponent of the control system, the objects transmit messages
`to each other. For example a drill process object can be
`defined to hold all the information needed to define a drilling
`process, and this information may be sent in a message to an
`Machine Class spindle object (to move the spindle down and
`form the hole) and to an axis group object (to position the
`workpiece in the proper location). However, the portion of
`the software which defines the drilling process does not need
`to access information regarding how the actual machine tool
`component carries out its task, or how the motion control
`module controls the machine components. Therefore, in a
`software implementation, the same process object can be
`used in virtually any CNC machine, without undue regard to
`its manufacturer or specific hardware components. More(cid:173)
`over, the object oriented messages through which various
`objects communicate provide a standard interface for adding
`additional functionality to a CNC machine tool control
`system.
`For example, the primary purpose of a user interface is to
`collect information about a series of machining processes to
`be performed. Once the basic information is collected, the
`user interface can execute the processes by: (1) calling a
`process object with data about a new process to thereby
`65 create the object; (2) repeat step (1) for each process; and (3)
`sequentially sending a message to each defined object telling
`it to execute itself. Thus, the programmer of the uscr
`
`OBJECTS OF THE INVENTION
`
`50
`
`One object of the invention is to provide a CNC machine
`tool control system that utilizes an object oriented program
`in which objects exchange object oriented messages.
`Another object of the invention is to provide a CNC 55
`machine tool control system that is scalable such that it may
`be used for either high end or low end CNC machine tools.
`Another object of the invention is to provide a CNC
`machine tool control that is easily modifiable, in which
`previously written software can be reused, and in which new 60
`objects can be added which inherit or comprise composi(cid:173)
`tions of previously defined objects.
`Another object of the invention is to provide a CNC
`machine tool control system in which new processes may be
`added by a programmer without requiring the programmer
`to know details of how particular hardware components
`carry out specific workpiece shaping processes.
`
`Page 6 of 43
`
`

`

`5,453,933
`
`7
`interface may be completely insulated from motion control
`data required for the machine tools to carry out their tasks.
`Because communication between software objects is
`accomplished through messages, software functions can be
`more easily distributed among different, simultaneously 5
`executing tasks. For example, instead of a motion control
`module needing to keep track of which task needs informa(cid:173)
`tion regarding a particular hardware fault, information
`regarding a fault may merely be sent to an exception handler
`object. This allows the motion control module to devote 10
`more processing time to its primary task of controlling
`motion, and permits all error conditions to be handled in a
`uniform manner. Specifically, the exception handler may
`keep a database of which objects have a need to know about
`which types of faults, and report specific faults only to those 15
`objects. Therefore, in adding a new process or machine
`component object to the system, modification of the motion
`control module can be kept to a minimum as fault conditions
`may be handled by the exception handler.
`There are seven basic Classes of software components:
`Device Drivers, Operating System, Platform Services, the
`Kernel, Machine Class objects, Process Class objects, and
`the Operator Class. The Device Drivers class contains the
`interfaces to particular hardware such as the hard drive,
`floppy drive, serial and parallel ports, motion board, and I/O
`device. This isolates all hardware interfaces into a single
`class that only needs to be changed when new hardware
`components are added to the existing system components
`and need to communicate in a different manner with the
`system.
`The Operating System class is responsible for hardware
`and software resource management. ·It manages memory,
`timers, and the scheduling of all processes and tasks. This
`class makes it possible to port a control system in accor(cid:173)
`dance with the present invention system to other hardware
`platforms. The Platform Services class is responsible for
`facilitating the execution of tasks such as error handling and
`communication between part program interpreters and the
`lower levels of the system. This class simplifies system
`communications and only requires change if advances in
`computer science technology need to be incorporated
`because they improve the efficiency or change the manage(cid:173)
`ment of initialization and message handling. The Kernel
`class handles continuous motion and discrete input/output 45
`implementation components. This class forms the stable
`core of the CNC control system that only needs to be
`is required. This
`changed when performance scaling
`approach is in sharp contrast to prior CNC control systems
`that require system developers to change the Kernel when 50
`making changes to the Operator Class objects, such as the
`Part Program Interpreter.
`The remaining three classes (Machine, Process, and
`Operator) specifically tailor any system to be a machine tool
`CNC. The Operator and Process classes are the "tools" used
`to communicate clearly to the above hardware-oriented
`classes. The Machine class contains the objects that makes
`this communication understandable by the Kernel compo(cid:173)
`nents.
`The Machine class is a collection of objects that embody
`the abstraction of real-world components such as the tool
`changer, spindle, or coolant. This class describes all generic
`categories of machine tool devices by their basic required
`characteristics. Operator programs usually communicate
`through the objects in this class to the Kernel. The Machine
`class turns operator commands such as "change to tool #6"
`into a message or series of messages that can be understood
`
`8
`by the Kernel's components. New machine tool components
`can be added to the Machine class and existing componcnts
`can be easily modified without making changcs to thc
`Kernel.
`The Process class holds the Process techniques (methods)
`that perform specific common practices on the specific typc
`of machine (low-end milling machine, lathc, punch press,
`EDM, gauging system, etc.). The objects in this class usc
`multiple Machine Class objects and can bc accesscd from
`multiple part program interpreter (operator) programs. This
`class usually contains libraries of canned cycles to handle
`such operations as milling frames, tapping, and boring, but
`it also contains any subroutine that several different appli(cid:173)
`cations need to use. The objects provide easy accessibility to
`the complex CNC features.
`The Operator Class (including the Part Program Inter(cid:173)
`preter) is an extension of the CNC operator's skills and job
`functions. It also holds the operator programs such as parI
`programming and system diagnostics. This class makes usc
`20 of services provided by other classes to manage control of
`the machinery. Using programs at this level, the operator can
`set the system parameters (e.g., maximum feedratc) and
`communicate with the machine tool while it is running a part
`program. Most of the changes made to a CNC will bc
`25 modifications to change what the operator can do. Thcsc
`changes usually affect the part programming and parI cutting
`environment and can be made at this level with any accom(cid:173)
`panying techniques changed in the Process class.
`Engineers changing a control system of the present inven-
`tion can easily make changes to the system because they do
`not need to be experts on the entire system to make a
`modification to a single component in a class. One change
`does not hav