throbber
llllll||||||l|||||l|||l||||Illllllllllllll||llIlll|||||||||||l|||l|l|IH|||
`
`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

This document is available on Docket Alarm but you must sign up to view it.


Or .

Accessing this document will incur an additional charge of $.

After purchase, you can access this document again without charge.

Accept $ Charge
throbber

Still Working On It

This document is taking longer than usual to download. This can happen if we need to contact the court directly to obtain the document and their servers are running slowly.

Give it another minute or two to complete, and then try the refresh button.

throbber

A few More Minutes ... Still Working

It can take up to 5 minutes for us to download a document if the court servers are running slowly.

Thank you for your continued patience.

This document could not be displayed.

We could not find this document within its docket. Please go back to the docket page and check the link. If that does not work, go back to the docket and refresh it to pull the newest information.

Your account does not support viewing this document.

You need a Paid Account to view this document. Click here to change your account type.

Your account does not support viewing this document.

Set your membership status to view this document.

With a Docket Alarm membership, you'll get a whole lot more, including:

  • Up-to-date information for this case.
  • Email alerts whenever there is an update.
  • Full text search for other cases.
  • Get email alerts whenever a new case matches your search.

Become a Member

One Moment Please

The filing “” is large (MB) and is being downloaded.

Please refresh this page in a few minutes to see if the filing has been downloaded. The filing will also be emailed to you when the download completes.

Your document is on its way!

If you do not receive the document in five minutes, contact support at support@docketalarm.com.

Sealed Document

We are unable to display this document, it may be under a court ordered seal.

If you have proper credentials to access the file, you may proceed directly to the court's system using your government issued username and password.


Access Government Site

We are redirecting you
to a mobile optimized page.





Document Unreadable or Corrupt

Refresh this Document
Go to the Docket

We are unable to display this document.

Refresh this Document
Go to the Docket