`
`US005453933A
`
`United States Patent
`
`1191
`
`[11] Patent Number:
`
`5 453 933
`9
`9
`
`Wright et al.
`
`[45] Date of Patent:
`
`Sep. 26, 1995
`
`[54] CNC CONTROL SYSTEM
`
`5,272,642
`
`12/1993 Suzuki
`
`............................. .. 364/474.24
`
`[75]
`
`Inventors: Michael R. Wright, Indianapolis;
`David E- Plattsy P1ainfei1d;l?aniel 3-
`F1‘enchs Carmel; Gerald Tmlcofil
`Indianapolis; Michael A. Dupont,
`Fishers; Gregory A-Head,P1ainfie1d,
`311 °f Ind-
`
`[73] A
`
`_
`' H
`Sslgnee‘
`
`“re”
`Ind"
`
`C
`
`_
`_
`°
`I
`I d
`1
`°mPa““"s’ "C" 1‘ lamp” 15’
`
`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.
`Inc.,
`Ultimax Programming, Hurco Manufacturing C0,,
`-
`-
`instruction manual, Hurco Part No. 704—OO01—598, Oct.,
`1992, Revision C.
`
`[2]] Appl_ N04 118,445
`
`[22]
`
`Filed:
`
`Sep. 8, 1993
`
`
`........................................ G06F 15/46
`Int. Cl.5
`[51]
`[52] U.S. Cl. .............. .. 364/474.23; 364/191; 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
`
`Primary Examiner—Roy N. Envall, Jr.
`Assistant Examiner——Thomas E. Brown
`
`—
`
`Attorney, Agent, or Firm—Baker & Daniels
`
`[57]
`
`ABSTRACT
`
`_
`_
`“‘a°h“,‘j “t’°11°1‘,’”“‘;} Slstem ‘ha§(“.‘°1“d°S 3 °‘1’1“‘
`3
`." 3 fet ’“°V.a. " °° t°§? atlfilnfia W‘; 915:)?’ 3 ’}‘1‘°°.a‘
`nism_ or receiving con ro ins
`c ions escn ing s aping
`functions to be performed on the workpiece, a processing
`
`y e o
`esign.
`_]eC orien e
`object is a model of a shaping process to be performed on a
`:;’1°’k11’_l’e°.‘°”a1md°.1“d“‘g. mf°r;”f1ti°“:l pa’a‘“"1t[‘;“‘5 rlfgardiéig
`6 P V51“
`““e“S’°“S 9
`" S ape 165“
`“g mm c
`process. ‘The process.ob1ects communicates through ‘an
`object oriented. messaging system to machine Ob_]6CiLS, 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
`-
`-
`-
`perrmts 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
`
`U.S. PATENT DOCUMENTS
`4,477,754 10/1984 Roch etal.
`........................ 364/474.22
`4,823,253
`4/1989 Shima .... .. .
`. . . . .. 364/167
`4,885,717 12/1989 Beck eta1_ _
`_. 364/900
`4,939,535
`7/1990 sekj
`__________
`364/191
`5,079,713
`1/1992 K-awamura
`354/474
`5,095,522
`3/1992 Fujita et al.
`.. 395/200
`5,150,303
`9/1992 Fllkaya --------------
`364/474
`5:153-441
`12/1992 Onafheim 9ta1-
`-- 364/145
`5,177,589
`1/1993 Ki“_a5i
`------------"
`364/474
`5,181,162
`1/1993 Smith et al.
`.. 364/419
`5,212,767
`5/1993 Baker et al.
`.... ..
`.. 395/600
`5,235,701
`8/1993 Ohler et al.
`............. ..
`.. 395/600
`5,237,654
`8/1993 Schackelford et a1_
`._ 395/160
`5,239,477
`8/1993 Matsumura ......... ..
`364/474
`5,247,447
`9/1993 Komcofl et al.
`..................... .. 364/468
`
`
`
`[561
`
`/11
`
`/12
`
`/14
`
`
`
`[15
`mcstsct
`
`\——1o
`
`16
`CAN BUS
`INTERFACE \’
`
`MOTION CONTROL
`BOARD
`
`18
`
`COMMUNICATIONS INTERFACE
`(SERIAL at PARALLEL)
`
`\-/2°
`
`17\Z
`
`/
`
`23/
`
`24/
`
`CONTROL
`PAN EL
`
`J06
`PENDANT
`
`19/
`
`21 /
`
`Page 1 of 43
`
`Page 1 of 43
`
`RA v. AMS
`Ex. 1014
`
`
`
`U.S. Patent
`
`Sep. 26, 1995
`
`Sheet 1 of 2
`
`5,453,933
`
`..:\E\N.\E\
`
`mu<"Em:z_m.o<mo_.mmo<uEEz_.
`
`
`
`89>mm<s_vEo>>Ez>mosm_s_nao
`
`
`
`
`
`
`m_u<uEm+z_wzo_»<o_z:s_s_oo._OE.zOo295.2mamz<o
`.._m:..<m<n_w._<_Em.nE<omS)mu<nEm:.z_
`
`
`
`wow
`
`+z<ozmm
`
`Aompzoo
`
`4mz<m
`
`w.0E\
`
`_u
`
`\\\mw
`
`°°°
`
`
`
`.\\\¢N\\\mN\\\NN
`
`Page 2 of 43
`
`RA V. AMS
`
`Ex. 1014
`
`Page 2 of 43
`
`RA v. AMS
`Ex. 1014
`
`
`
`
`
`U.S. Patent
`
`Sep. 26, 1995
`
`Sheet 2 of 2
`
`5,453,933
`
`(39 Microfiche, 2419 Pages)
`
`Machine
`
`Process
`
`K ern el
`
`Motion
`Controller
`
`
`
`..........................................................................
`Directory
`
`Services
`
`...................................................................................................................................................................................................
`
`Services
`
`System
`
`........................................................................................................................................................................................................................
`
`(1.9 ® Drxvers
`
`Page 3 of 43
`
`RA V. AMS
`
`Ex. 1014
`
`Page 3 of 43
`
`RA v. AMS
`Ex. 1014
`
`
`
`This application includes a microfiche appendix having
`39 frames’
`
`5
`
`FIELD OF THE INVENTION
`This invention relates to computer numeric controlled
`.
`.
`.
`(CNC) machine tools, and in particular,
`to the control
`Systems used to operate Such machine tools.
`
`lo
`
`BACKGROUND OF THE INVENTION
`
`1
`CNC CONTROL SYSTEM
`
`MICROFICHE APPENDIX
`
`5,453,933
`
`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 (i.e. controllably move the
`Splpdle up 0001 at a mm mm it has mmied llp 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 1S also able to execute more com-
`lex, multi-dimensional commands, such as to move the
`Exes 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
`CNC Control Systems
`software (except for device drivers) that
`interacts most
`The purpose of a CNC machine is to use a set of input
`closely Wlth the hardware components that actually carry out
`‘specifications describing a physical object
`to produce a
`shaplng Processes on a Worl<Plecea the motlon control tune‘
`machined part according to the specifications. The part is
`tion also receives information about hardware faults from
`typically formed from solid block stock material such as 20
`hardware devices. For example, if a hardware device is
`metal, and shaped by Various machine tools such as drills’
`unable to execute an instruction, the motion control function
`mills,
`lathes, electrostatic discharge machines (Epll/ls),
`receive a notice Of the error from the haIdWaIe (Or its
`gauging systems and the like‘
`machines are complex
`associated device driver). This information needs to be
`and include hundreds of components_ Examples of input
`devices include keyboards, operator consoles, pressure sen- 25 communicated back to the other Portlon of the CNC control
`sitive CRTs, Various
`tools and machine sensors,
`limit
`software responsible for requesting the motion control func-
`switches and network interfaces. Output devices include
`tlon to complete the tunctlon the software ls currently
`motion controllers that send motion control signals to
`untlertalclnga so that aPProPrlate actlon: such as Cllsplaylng a
`motors driving axes or a tool, CRT displays, console status
`message on the oPerator CRT: may occur- l'loWeVers there
`lights and audible alarms. Other components include rriicro- 3o
`are usually many other Portlons of the CNC control system
`processors, memory, disk drives, data buses and wiring
`software that will also need to be informed of the hardware
`harnesses. The software executed by the computer processor
`rault- Moreoyera the Portlons that need to know about the
`is a critical component of a CNC machine, as it coordinates
`fault Wlll Vary oependlng on the exact fault ln Past systems,
`the functions of the all the other components of the system
`the_motion_ control function has been used to keep track of
`In general, CNC software is custom written for the particular 35 Wluch Portlons or the CNC control system software must he
`brand of components a CNC manufacturer or system inte-
`notllletl of Whlch hardware faults Thls not only Places an
`grator chooses to include in the CNC machine. As a result,
`lncreased burden on the motlon control Portlon of the CNC
`CNC software is extremely complex, and a software pro_
`control system software, but also makes fliis portion more
`grammer for a particular CNC machine must be intimately
`dllllcult to mamtaln-
`familiar with the way virtually every hardware component 40
`Computer programmers writing CNC software have gen-
`interfaces with the software, and with the entire software
`erally designed the entire software system using structured
`system itself.
`techniques that analyze what the entire CNC machine tool
`For example, two representative functions of most CNC
`must do (functional decomDosltlon)- Thls has resulted in
`software are the logic and motion control functions (collec-
`complex:
`dlfhcult’to‘motllfy
`software
`systems
`For
`tively referred to herein as the “kernel”). The logic control 45
`example: software code relatlhg to the user lntertace by
`function keeps track of the specific sequence of steps that
`Whlch a user descrlhes a Part to he machlneda can he found
`must be taken by Various movable hardware components to
`in other portions of the CNC control system software, such
`accomplish a taslr_ For example, the steps required to mount
`as the motion controller. One example is that when a motion
`a dilferently sized drill bit into the tool holder of a spindle
`controller recelyes a slgnal from a machine tool lndlcatlng a
`from an automatic tool changer in a milling application so
`fault condition (for example, when an object in the work
`might be; (ll send a command to raise the spindle containing
`area prevents the table from moving to a desired location, or
`the currently mounted drill bit so the tool changer will fit
`a blown fuse): the motion controller mlght dlrectly tllsplay
`underneath it,
`(2) send a command to the tool changer
`an error message on the CRT ‘llsPlay- Because Prlor CNC
`instructing it to move below the spindle, (3) send a com.
`control system software generally is not broken down into
`mand to the spindle instructing it to release the currently 55 Portlons correspontllng to the dlscretea Physlcal componcnts
`mounted drill bit, (4) wait for a signal from the spindle
`of a CNC machlne tools a change ln one Portlon of the
`indicating that the drill bit has been released, (5) send a
`softwareisdifiicultto make and frequently requires changes
`command to the tool changer instructing it to move to rotate
`to other Portlons of the software-
`clockwise 30 degrees to position the new drill bit below the
`Another exariiple illustrating this problem occurs when a
`spindle, (6) interrogate the tool changer to confirm that the 60 user, system integrator or even machine tool manufacturer
`tool changer has successfully executed the rotation com-
`wishes to add a new hardware component to the machine
`mand, (7) send a command to the spindle commanding it to
`tool. For example, it may be desirable to replace an AC
`engage the new drill bit underneath it in the tool changer,
`induction motor with a DC brushless motor from a different
`and (8) send a command to the tool changer instructing it
`manufacturer. The new motor will likely use a dilferent
`move away from the spindle and work area. Given the 65
`communications protocol and have different tolerance speci-
`hundreds of moving, controllable parts in a CNC machine
`fications and operating limits. Therefore, the motion control
`tool, the logic control function is much more complex than
`software will need to be modified to be able to communicate
`
`Page 4 of 43
`
`RA V, AMS
`
`Ex. 1014
`
`Page 4 of 43
`
`RA v. AMS
`Ex. 1014
`
`
`
`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
`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
`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 (except to the original software author), or propri-
`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-
`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-
`tions to obtain instructions about how to create a desired
`part. More recently, several standard data file formats have
`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
`access, as described above, various data elements and soft-
`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
`needlessly duplicative, functionality.
`
`Object Oriented Software
`
`Most existing programming languages provide “sequen-
`tial” instructions for a processor to implement. These lan-
`guages have previously been used to implement CNC con-
`trol systems. However, computcrs are often utilized for
`
`l0
`
`15
`
`20
`
`25
`
`30
`
`35
`
`40
`
`45
`
`50
`
`55
`
`60
`
`65
`
`4
`
`modeling systems of interactive components 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 before-
`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, “object-
`oriented” software is organized into “objects”, each com-
`prising a block of computer instructions describing various
`procedures (“methods”) to be performed in response 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
`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
`a region where internal states (instance variables) of the
`object itself are stored and where the other objects are 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
`separated from the instances. One feature of the object-
`oriented system is inheritance. With respect 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 inherit 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-
`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-
`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-
`sponding object, and the interactions between components
`being simulated by messages transmitted between objects.
`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 turn 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
`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
`
`RA V. AMS
`
`Ex. 1014
`
`Page 5 of 43
`
`RA v. AMS
`Ex. 1014
`
`
`
`5
`
`5,453,933
`
`6
`BRIEF DESCRIPTION OF THE DRAWINGS
`
`5
`
`FIG. 1 is a schematic diagram of the hardware compo-
`nents of a CNC machine tool system on which the control
`system of the present invention may operate.
`_
`,
`_
`1HG'
`151 Zsghématlccglégram ofl the types ofdsoftwari
`C asses Inc, 11 e m af
`,
`°°r.1tr° dsystem’ an.
`_seVera
`representative types 0 object-oriente objects within sev-
`cm of these classes‘
`
`and need not be preordained by the programmer.
`Although object-oriented prograiruning 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
`by an object-oriented program is usually not immediately
`apparent from a software listing as in the case for sequen-
`daily 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
`SUMMARY OF THE INVENTION
`the operations carried out by a computer in response to a
`The control system of the present invention provides a
`prOgram are “tnVrstb1e”tO an ObserVer since Onty aretattyety
`real-time CNC software system that isolates system respon-
`few steps in a prcgram typtcahy prcduce an Obseryable
`sibilities into classes that permit a CNC manufacturer or
`cOrnputer Output-
`system integrator to manage complexity and change. The
`Object-oriented analysis and design methods permit reuse 15
`control system allows difierent systems to be created from
`of system analysis and requirements from other products in
`the same model and future, as yet unimagined, technological
`the same family. Object-oriented software design means that
`advances can be incorporated without redesigning or making
`software components are created from data and functions
`massive changes.
`and are organized into objects. An object is an abstraction of
`The system uuiizes ah cbjecucriemed software euVircu_
`something in the real world, reflecting the capabilities of a 20
`mem_ A first class of object types is provided for processes
`system to keep information about it, interact with it, or both.
`(such as drilling, reaming, miiiirig) to he carried out by
`It is, therefore, an encapsulation of attribute values and their
`machine rec] ccmpcriems (the process C1ass)_ some pro-
`exclusive services.An object’s attributes describe the object,
`cesses objects may inherit characteristics of other objects in
`but nOt hOW it WOrks- The Object’s serVtces are tnstructrOnsv 25
`the Process class. For example, a “hole” object may have
`prOgrarnsa preceduress Or acttcns that describe What the
`characteristics such as a depth and diameter, which can be
`Object Wtu d0 When semethtng happens
`inherited by other process objects, such as a drill, ream or
`As described above, objects are grouped into classes. A
`bore process object. A second class of object types of is
`class includes a description of how to create new objects in
`the class and establishes the basic variables that are common 30 provided which represent instances of machine tool compo-
`to all of its objects. New objects inherit these common
`nents, such as a table (axes), a spindle,
`tool changer or
`characteristics from the parent class. This feature allows the
`operator console. Again, some objects may inherit attributes
`software engineer to build on existing design and code by
`of other objects. For example, an axis group, namely an
`creating more specific objects from the easily reused code in
`object for simultaneously controlling multiple axes to shape
`the general class. For example, a software engineer can use 35
`complex three-dimensional objects, may be inherit attributes
`a general class of characteristics for a “device” to create a
`of a single axis object. Other objects may be composite
`model of a more specific device such as a spindle. Object-
`objects of other tool objects. For example a tool changer
`oriented analysis and design explicitly represent common-
`may be a composite object of a collection of different milling
`ality in the system’s objects and use inheritance to identify
`bits which may be held in the tool changer (in addition to
`and capitalize on commonality of attributes and services. 40 having its own attributes).
`The system may Only access data thrbugh the serVrcese if at
`Most importantly, during execution of the software com-
`au- SerVtces hide an Objectts data and send messages tO
`ponent of the control system, the objects transmit messages
`pertOrm Operattcns-Thisrsctates dependency On apalttcutar
`to each other. For example a drill process object can be
`data structure thus permitting new features to be added
`defined to hold all the information needed to defineadiilling
`Wttheut changing the arrangement Of the Original Objects 45 process, and this information may be sent in a message to an
`This structure prOtects the data trOrn the damage that cOm'
`Machine Class spindle object (to move the spindle down and
`monly occurs during changes in monolithic, proprietary
`form the hole) and to an axis group object (to position the
`systems.
`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-
`over, the object criemed 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 imerface 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: (l) calling a
`process object with data about a new process to thereby
`create the object; (2) repeat step (1) for each process; and (3)
`sequentially sending amessage to each defined object telling
`it
`to execute itself. Thus,
`the programmer of the user
`
`50
`
`OBJECTS OF THE INVENTION
`h,
`one 0b,eCt of the invention is to r
`_d
`CNC
`3
`_
`,
`P 9“ ea,
`s mac me
`tool Cttmrol ystem that uuhZe.s an Object onemed program
`_ 1“ whlch Objects exchange object onemed messages‘
`Anether Object Of the tnVentiOn is tO prOVrde a CNC 55
`machine tool control system that is scalable such that it may
`be used TOr either high end Or tOW end CNC machine tOO1s-
`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 so
`Objects can be added Which inherit Or cOmpnse cOmpOsr'
`ttOns Or preViOusty dehned Objects
`Another object of the invention is to provide a CNC
`machine tool control system in which new processes maybe
`added by a programmer without requiring the programmer 65
`to know details of how particular hardware components
`carry out specific workpiece shaping processes.
`
`Page 6 of 43
`
`RA V, AMS
`
`Ex. 1014
`
`Page 6 of 43
`
`RA v. AMS
`Ex. 1014
`
`
`
`7
`
`8
`
`5,453,933
`
`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 diiferent, simultaneously
`executing tasks. For example, instead of a motion control
`module needing to keep track of which task needs informa-
`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
`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
`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-
`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 efliciency or change the manage-
`ment of initialization and message handling. The Kernel
`class handles continuous motion and discrete input/output
`implementation components. This class forms the stable
`core of the CNC control system that only needs to be
`changed when performance scaling is
`required. This
`approach is in sharp contrast to prior CNC control systems
`that require system developers to change the Kernel when
`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-
`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
`
`10
`
`15
`
`20
`
`25
`
`30
`
`35
`
`40
`
`45
`
`50
`
`55
`
`60
`
`65
`
`by the Kemel’s components. New machine tool components
`can be added to the Machine class and existing components
`can be easily modified without making changes to the
`Kernel.
`
`The Process class holds the Process techniques (methods)
`that perform specific common practices on the specific type
`of machine (low-end milling machine, lathe, punch press,
`EDM, gauging system, ete.). The objects in this class use
`multiple Machine Class objects and can be accessed 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-
`cations need to use. The objects provide easy accessibility to
`the complex CNC features.
`—
`The Operator Class (including the Part Program Inter-
`preter) is an extension of the CNC operator’s skills and job
`functions. It also holds the operator programs such as part
`programming and system diagnostics. This class makes use
`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 feedrate) and
`communicate with the machine tool while it is running a part
`program. Most of the changes made to a CNC will be
`modifications to change what the operator can do. These
`changes usually affect the part programming and part cutting
`environment and can be made at this level with any accom-
`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 have a ripple effect of change throughout
`the
`system. Portions of the system that are most likely to change
`such as the user interface and device drivers are separated
`from the Kernel. These components are more accessible to
`change‘ through PLC programs, customizations
`to the
`Machine class and addition to or modification of operator
`programs.
`
`Users of the control system of the present invention will
`have a more stable design that can be tested for complete-
`ness. The system makes possible the efiicient reuse of
`system analysis, requirements, design, and components. The
`system fo