Case 6:12-cv-00799-JRG Document 153-3 Filed 04/24/14 Page 1 of 30 PageID #: 4518
`Case 6:12—cv—00799—JRG Document 153-3 Filed 04/24/14 Page 1 of 30 Page|D #: 4518
`
`EXHIBIT F
`
`EXHIBIT F
`
`

`
`Case 6:12-cv-00799-JRG Document 153-3 Filed 04/24/14 Page 2 of 30 PageID #: 4519
`
`(12) United States Patent
`Brown et al.
`
`US006513058B2
`US 6,513,058 B2
`Jan. 28, 2003
`
`(10) Patent N0.:
`(45) Date of Patent:
`
`(54) DISTRIBUTION OF MOTION CONTROL
`COMMANDS OVER A NETWORK
`
`6/1989 Rose
`4,840,602 A
`(List continued on next page )
`
`
`
`Inventors: David W- Brown; Jay S- Clark, of Bmgen, WA (US)
`
`(73) Assignee: Roy-G-Biv Corporation, Bingen, WA
`(Us)
`
`( * ) Notice:
`
`Subject to any disclaimer, the term of this
`~
`~
`patent is extended or adJusted under 35
`U S C 154(k)) b 0 da S
`'
`'
`'
`y
`y '
`
`(21) Appl. NO.Z 09/795,777
`
`(22) Filed:
`
`Feb. 27, 2001
`
`(65)
`
`Prior Publication Data
`Us 2001/0032268 A1 Oct 18 2001
`'
`’
`Related US. Application Data
`
`(63) Continuation of application No. 09/205,627, ?led on Dec. 3,
`1998, now Pat. No. 6,209,037, and a continuation-in-part of
`application No. 09/191,981, ?led on Nov. 13, 1998, which is
`a continuation of application No. 08/656,421, ?led on May
`30, 1996, now Pat. No. 5,867,385, which is a continuation-
`in-part of application No. 08/454,736, ?led on May 30,
`1995, now Pat. No. 5,691,897.
`(60) lljgg‘éi'sional application No. 60/067,466, ?led on Dec. 4,
`
`7
`(51) Int. Cl. .............................................. .. G06F 15/16
`(52) US. Cl. ......................... .. 709/201; 709/230; 700/1;
`700/19; 700/56
`(58) Field Of Search ............................... .. 709/201, 230;
`700/1, 19, 56
`
`(56)
`
`_
`References Clted
`U_S_ PATENT DOCUMENTS
`_
`6/1979 Rubmeam
`471597417 A
`4’218’381 A 11/1982 Molusls et a1‘
`j’?é’égg 2
`2:212“
`4:767:334 A
`8/1988 Thorne et al.
`4,809,335 A
`2/1989 Rumsy
`
`EP
`EP
`EP
`EP
`EP
`GB
`JP
`W0
`W0
`W0
`
`8/1991
`0442676 A2
`8/1992
`0 281 427 B1
`0508912 A1 10/1992
`0 583 908 A2
`2/1994
`0245826 A1
`9/1998
`2 224 896 A 12/1991
`59 228473
`6/1983
`WO 92/11731
`2/1992
`WO 93/08654
`4/1993
`WO 95/07504
`3/1995
`
`OTHER PUBLICATIONS
`
`WOSA Backgrounder: Delivering Enterprise Services to the
`Windows—based Desktop, Jul. 1993, Microsoft Develop
`ment Library; pp. 1—19.
`WOSA INSIDE WINDOWS 95; pp. 348—35 1.
`Software Products for Industrial Aurtomation, ICONICS; 6
`pages_
`
`(List Continued on next page)
`
`-
`
`(57)
`
`-
`~
`-
`OEVZZyLZZZfZLSIEVEm ichael R Schacht
`a
`a
`{'1
`~
`ABSTRACT
`
`A system for allowing an application program to commu
`nicate With any one of a group of Supported hardware
`devices Comprising a Software System Operating on at least
`one workstation and a network communications protocol.
`The Software system includes a control command generating
`module for generating control commands based on compo
`nent functions of an application program, component code
`associated with the component functions, and the driver
`code associated with software drivers associated with the
`hardware devices. The network communication protocol
`allows the control commands to be communicated from the
`control command generating module to at least one of the
`supported hardware devices over the network.
`
`5 Claims, 68 Drawing Sheets
`
`3.9.} ........... s.
`
`(SH-APPLICATION
`|
`
`32
`
`lXMCixxxAPI
`
`!Unknown
`
`DRWER
`ADMlN.
`
`REGISTRY
`
`s4
`
`nknown
`
`

`
`Case 6:12-cv-00799-JRG Document 153-3 Filed 04/24/14 Page 3 of 30 PageID #: 4520
`
`US 6,513,058 B2
`Page 2
`
`US. PATENT DOCUMENTS
`
`7/1989 Baer
`4,846,693 A
`8/1989 Fernandez
`4,855,725 A
`8/1989 Rose
`4,857,030 A
`4,887,966 A 12/1989 Gellerman
`4,897,835 A
`1/1990 Gaskill
`4,937,737 A
`6/1990 Schwane et al.
`5,095,445 A
`3/1992 Sekiguchi
`5,120,065 A
`6/1992 Driscoll et al.
`5,126,932 A
`6/1992 Wolfson et al.
`5,168,441 A 12/1992 Onarheim et al.
`5,175,817 A 12/1992 Adams et al.
`5,245,703 A
`9/1993 Hubert
`5,247,650 A
`9/1993 Judd et al.
`5,377,258 A 12/1994 Bro
`5,390,330 A
`2/1995 Talati
`5,392,207 A
`2/1995 Wilson et al.
`5,402,518 A
`3/1995 Lowery
`5,412,757 A
`5/1995 Endo
`5,450,079 A
`9/1995 Dunaway
`5,453,933 A
`9/1995 Wright et al.
`5,465,215 A 11/1995 Strickland et al.
`5,491,813 A
`2/1996 Bondy et al.
`5,493,281 A
`2/1996 Owens
`5,596,994 A
`1/1997 Bro
`5,600,373 A
`2/1997 Chui et al.
`5,604,843 A
`2/1997 Shaw et al.
`5,607,336 A
`3/1997 Lebensfeld et al.
`5,608,894 A
`3/1997 Kawakami et al.
`5,617,528 A
`4/1997 Stechmann et al.
`5,636,994 A
`6/1997 Tong
`5,652,866 A
`7/1997 Aldred et al.
`5,655,945 A
`8/1997 Jani
`5,666,161 A
`9/1997 Kohiyama et al.
`5,670,992 A
`9/1997 Yasuhara et al.
`5,691,897 A * 11/1997 Brown et al. .......... .. 318/568.1
`5,707,289 A
`1/1998 Watanabe et al.
`5,733,131 A
`3/1998 Park
`5,737,523 A
`4/1998 Callaghan et al.
`5,746,602 A
`5/1998 Kikinis
`5,752,880 A
`5/1998 Gabai et al.
`5,764,155 A
`6/1998 KertesZ et al.
`5,790,178 A
`8/1998 Shibata et al.
`5,800,268 A
`9/1998 Molnick
`5,801,946 A
`9/1998 Nissen et al.
`5,818,537 A 10/1998 Enokida et al.
`5,821,987 A 10/1998 Larson
`5,822,207 A 10/1998 HaZama et al.
`5,828,575 A 10/1998 Sakai
`5,846,132 A 12/1998 Junkin
`5,852,441 A 12/1998 Nakajima et al.
`5,855,483 A
`1/1999 Collins et al.
`5,867,385 A * 2/1999 Brown et al. ................ .. 700/1
`5,873,765 A
`2/1999 Ri?<in et al.
`5,890,963 A
`4/1999 Yen
`5,907,704 A
`5/1999 Gudmundson et al.
`5,907,831 A
`5/1999 Lotvin et al.
`5,914,876 A
`6/1999 Hirai
`5,920,476 A
`7/1999 Hennessey et al.
`5,924,013 A
`7/1999 Guido et al.
`5,960,085 A
`9/1999 De La Huerga
`5,977,951 A 11/1999 Danieli et al.
`6,078,968 A
`6/2000 Lo et al.
`6,101,425 A * 8/2000 Govindaraj et al. ...... .. 700/104
`6,139,177 A 10/2000 Venkatraman et al.
`6,144,895 A 11/2000 Govindarai et al.
`6,216,173 B1
`4/2001 Jones et al.
`OTHER PUBLICATIONS
`WEB 3.0 Products Brochure, Trihedral Engineering Ltd.
`(1994); 6 pages.
`
`The Complete, Computer—Based Automation Tool (IGSS)
`Seven Technologies A/S; 6 pages.
`Oregon Micro Systems Product Guide: pp. 1—20.
`AIMAX—WIN Product Brochure, TA Engineering Co., Inc.;
`8 pages.
`XANALOG Model NL—SIM Product Brochure, XANA
`LOG, 4 pages.
`EXperTune PID Tuning Software, Gerry Engineering Soft
`ware; 6 pages.
`PMAC Product Catalog, p. 43.
`Paragon TNT Product Brochure, Intec Controls corp.; 6
`pages.
`AerotechMotion Control Product Guide; pp. 233—234.
`OpenBatch Product Brief, PID, Inc.; 6 pages.
`PC/DSP—Series Motion Controller C Programming Guide;
`pp. 1—54.
`FIX Product Brochure, Intellution (1994); 6 pages.
`Precision Motion Controls Product Guide; p. 17.
`Compumotor Digiplan (1993—94) Catalog pp. 10—11.
`Sue Chen, Jonathon Lin; “Computer Numerical Control:
`Essentials in Programming and Networking”, Part 5, Chap
`ter 27, pp. 824—848.
`Pritschow et al., “Open System Controllers: Challenge for
`the Future of the Machine Toool Industry”; pub. Jan. 15,
`1993; pp. 449—452.
`William E. Ford; “What Is an Open Architecture Robot
`Controller” pub. Aug. 16, 1994; pp. 27—32.
`Marcos et al., “A New Solution for Integrating Control
`Devices Involved in Computer—Integrated Manufacturing”;
`pub. Sep. 02,1996.
`Chu and Wang; “Development of a Practical SFC System for
`CNC Machine Shop”; pub. 1994; pp. 362—367.
`Microsoft; “The Microsoft Object Technology Strategy
`”pub. Mar. 1994; pp. 1—33.
`Microsoft; “Open Systems: Technology, Leadership, and
`Collaboration”; pub. Mar. 1994; pp. 1—15.
`Microsoft; Microsoft OLE Today and Tomorrow: Technol
`ogy Overview; pub. Dec. 1993; pp. 1—9.
`Microsoft; “Object linking and Embedding 2.0 Back
`grounder”; pub. Sep. 1993, pp. 1—15.
`Robert Anderson; “SMART: A Modular Architecture for
`Robotics and Teleoperation”; pub. 1993; pp. 416—421.
`Proctor et al., “Validation of Standard Interfaces from a
`Machine Control”; pub. 1996; pp. 659—664.
`Altintas et al., “Design and Analysis of a Modular CNC
`System”; pub. Mar. 4—1990; pp. 305—316.
`Wright et al.; “Open Architecture Controllers”; pub. Jun.
`1997; pp. 60—64.
`LutZ et al.; “OSACA—The Vendor—Neutral Control Archi
`tecture”; pub. Dec. 1997; pp. 247—256.
`Morales et al.; “A Generalised Software Control System for
`Industrial Robots”; pub. 1998; pp. 411—416.
`Feng et al.; “Distributed Control of a Multiple—Tethered
`Mogile Robot System for Highway Maintenance and Con
`struction”; pub Nov. 1997; pp. 383—392.
`FedrowitZ; “IRL—Based Expansion of the Commonly Used
`High—Levle Language C for Robot Programming:” pub.
`Oct. 1995; 5 pages.
`SZabo et al.; “Validation Results of Speci?cations for
`Motion Control Interoperability”; pub. 1997; pp. 166—167.
`Chang et al.; “Development and Implementation of an
`Applciation Programming Interface for PC/DSP—based
`Motion Control System”; pub. 1998; pp. 94—105.
`
`

`
`Case 6:12-cv-00799-JRG Document 153-3 Filed 04/24/14 Page 4 of 30 PageID #: 4521
`
`US 6,513,058 B2
`Page 3
`
`Michaloski et 1a.; “A Framework for Component—base CNC
`Machines” pub. Nov. 1998; pp. 132—143.
`BouZouia et al.; “A Three—layer Workcell Control Architec
`ture Design”; pub. May 1998; pp. 1185—1191.
`Muir et al.; “Mechatronic Objects for Real—time Control
`Software Development”; pub. Nov. 1998; pp. 251—265.
`McGraW et al.; “A Friendly Command, Control, and Infor
`mation System for Astronomy”; pub. 1996; pp. 356—367.
`J ackman; “Robotic Control Using Sequential Function
`Charts”; pub. 1996; pp. 120—128.
`Leu et al.; “A Telemanufacturing Workcell over the Inter
`net”, pub. Nov. 1998; pp. 230—237.
`“Requirements of Open Modular Architecture Controllers
`for Applications in the Automotive Industry ”; pub. Dec. 13,
`1994; pp. 1—13.
`Sperling; “Designing Applications for an OSACA Control”;
`pub. Nov. 16, 1997; 5 pages.
`
`LutZ et al.; “OSACA: The Vendor—neutral Control Archi
`tecture”; pub. 1997; 10 pages.
`Sperling et al.; “Enabling Open Control Systems: An Intro
`duction to the OSACA System Platform”; pub. May 1996;
`pp. 1—8.
`Open, Modular Architecture Controls at GM PoWertrain;
`pub. May 14, 1996; pp. 1—33.
`“Technologies Enabling Agile Manufacturing (TEAM)
`Intelligent Closed Loop Processing”; pub. Jan. 11, 1996; 30
`pages.
`“Nemi LoW—cost Controller Project” pub. Dec. 1996; total
`pages 392.
`Protoctor et al., “Open Architecture Controllers”; pub. Jun.
`1997, pp. 60—64.
`
`* cited by examiner
`
`

`
`Case 6:12-cv-00799-JRG Document 153-3 Filed 04/24/14 Page 5 of 30 PageID #: 4522
`
`US 6,513,058 B2
`
`1
`DISTRIBUTION OF MOTION CONTROL
`COMMANDS OVER A NETWORK
`
`RELATED APPLICATIONS
`
`This application is a continuation of U.S. patent applica(cid:173)
`tion Ser. No. 09/205,627 filed Dec. 3, 1998 now U.S. Pat.
`No. 6,209,037, which claims priority of U.S. Provisional
`Application Serial No. 60/067,466 filed Dec. 4, 1997, and is
`a continuation-in-part of U.S. application Ser. No. 09/191,
`981 filed Nov. 13, 1998, which is a continuation of U.S.
`application Ser. No. 08/656,421 filed May 30, 1996, now
`U.S. Pat. No. 5,867,385, which is a continuation-in-part of
`U.S. application Ser. No. 08/454,736 filed May 30, 1995,
`now U.S. Pat. No. 5,691,897.
`
`TECHNICAL FIELD
`
`The present invention relates to motion control systems
`and, more particularly, to interface software that facilitates
`the creation of hardware independent motion control soft(cid:173)
`ware.
`
`BACKGROUND OF THE INVENTION
`
`10
`
`35
`
`2
`Companies that manufacture motion control devices are,
`traditionally, hardware oriented companies that manufacture
`software dedicated to the hardware that they manufacture.
`These software products may be referred to as low level
`5 programs. Low level programs usually work directly with
`the motion control command language specific to a given
`motion control device. While such low level programs offer
`the programmer substantially complete control over the
`hardware, these programs are highly hardware dependent.
`In contrast to low-level programs, high-level software
`programs, referred to sometimes as factory automation
`applications, allow a factory system designer to develop
`application programs that combine large numbers of input/
`output (110) devices, including motion control devices, into
`15 a complex system used to automate a factory floor environ(cid:173)
`ment. These factory automation applications allow any
`number of 1/0 devices to be used in a given system, as long
`as these devices are supported by the high-level program.
`Custom applications, developed by other software
`20 developers, cannot be developed to take advantage of the
`simple motion control functionality offered by the factory
`automation program.
`Additionally, these programs do not allow the program(cid:173)
`mer a great degree of control over the each motion control
`25 device in the system. Each program developed with a factory
`automation application must run within the context of that
`application.
`Each brand or model of motion control device contains
`communication software that defines a communication pro(cid:173)
`tocol that is responsible for transmitting control codes and
`receiving response codes used to control the hardware to
`perform motion operations and to retrieve codes describing
`the results of the operation. This internal communication
`software is machine specific, and an application program
`written to communicate using the communication protocol
`associated with one brand or model of motion control device
`will likely not be able to communicate with the communi(cid:173)
`cation protocol associated another brand or model of motion
`control device.
`Accordingly, it would be desirable for a programmer to be
`able to write an application program that is independent of
`the hardware communication protocol so that the application
`program may be used with different hardware devices with(cid:173)
`out modification by the programmer.
`
`The purpose of a motion control device is to move an
`object in a desired manner. The basic components of a
`motion control device are a controller and a mechanical
`system. The mechanical system translates signals generated
`by the controller into movement of an object.
`While the mechanical system commonly comprises a
`drive and an electrical motor, a number of other systems, 30
`such as hydraulic or vibrational systems, can be used to
`cause movement of an object based on a control signal.
`Additionally, it is possible for a motion control device to
`comprise a plurality of drives and motors to allow multi-axis
`control of the movement of the object.
`The present invention is of particular importance in the
`context of a mechanical system including at least one drive
`and electrical motor having a rotating shaft connected in
`some way to the object to be moved, and that application
`will be described in detail herein. But the principles of the
`present invention are generally applicable to any mechanical
`system that generates movement based on a control signal.
`The scope of the present invention should thus be deter(cid:173)
`mined based on the claims appended hereto and not the
`following detailed description.
`In a mechanical system comprising a controller, a drive,
`and an electrical motor, the motor is physically connected to
`the object to be moved such that rotation of the motor shaft
`is translated into movement of the object. The drive is an 50
`electronic power amplifier adapted to provide power to a
`motor to rotate the motor shaft in a controlled manner. Based
`on control commands, the controller controls the drive in a
`predictable manner such that the object is moved in the
`desired manner.
`These basic components are normally placed into a larger
`system to accomplish a specific task. For example, one
`controller may operate in conjunction with several drives
`and motors in a multi-axis system for moving a tool along
`a predetermined path relative to a workpiece.
`Additionally, the basic components described above are
`often used in conjunction with a host computer or program(cid:173)
`mable logic controller (PLC). The host computer or PLC
`allows the use of a high-level programming language to
`generate control commands that are passed to the controller.
`Software running on the host computer is thus designed to
`simplify the task of programming the controller.
`
`40
`
`45
`
`PRIOR ART
`
`In the following discussions, a number of documents are
`cited that are publicly available as of the filing date of the
`present invention. With many of these documents, the Appli(cid:173)
`cant is not aware of exact publishing dates. The citation of
`these documents should thus not be considered an admission
`that they are prior art; the Applicant will take the steps
`necessary to establish whether these documents are prior art
`55 if necessary.
`As mentioned above, a number of software programs
`currently exist for programming individual motion control
`devices or for aiding in the development of systems con(cid:173)
`taining a number of motion control devices.
`The following is a list of documents disclosing presently
`commercially available high-level software programs: (a)
`Software Products For Industrial Automation, iconics 1993;
`(b) The complete, computer-based automation tool (IGSS),
`Seven Technologies NS; (c) OpenBatch Product Brief, PID,
`65 Inc.; (d) FIX Product Brochure, Intellution (1994); (e)
`Paragon TNT Product Brochure, Intec Controls Corp.; (f)
`WEB 3.0 Product Brochure, Trihedral Engineering Ltd.
`
`60
`
`

`
`Case 6:12-cv-00799-JRG Document 153-3 Filed 04/24/14 Page 6 of 30 PageID #: 4523
`
`US 6,513,058 B2
`
`4
`present invention employ a special protocol to facilitate
`communication with the underlying motion control hard(cid:173)
`ware in a manner that is independent of the specific com(cid:173)
`munication protocols defined by supported motion control
`5 hardware devices. In particular, the present invention uses a
`communication map that maps a generic grid of mapping
`information cells to the actual information cells imple(cid:173)
`mented by the particular hardware. Since each actual infor(cid:173)
`mation cell may be located in different areas in memory and
`10 may transfer different values on each hardware platform, the
`mapping information cells translate common functions
`across a plurality of supported hardware implementations.
`
`BRIEF DESCRIPTION OF THE DRAWINGS
`
`3
`(1994); and (g) AIMAX-WIN Product Brochure, TA Engi(cid:173)
`neering Co., Inc. The following documents disclose simu(cid:173)
`lation software: (a) ExperTune PID Tuning Software, Gerry
`Engineering Software; and (b) XANALOG Model NL-SIM
`Product Brochure, XANALOG.
`The following list identifies documents related to low(cid:173)
`level programs: (a) Compumotor Digiplan 1993-14 94
`catalog, pages 10-11; (b) Aerotech Motion Control Product
`Guide, pages 233-34; (c) PMAC Product Catalog, page 43;
`( d) PC/DSP-Series Motion Controller C Programming
`Guide, pages 1-3; (e) Oregon Micro Systems Product
`Guide, page 17; (f) Precision Microcontrol Product Guide.
`The Applicants are also aware of a software model
`referred to as WOSA that has been defined by Microsoft for
`use in the Windows programming environment. The WOSA 15
`model is discussed in the book Inside Windows 95, on pages
`348-351. WOSA is also discussed in the paper entitled
`WOSA Backgrounder: Delivering Enterprise Services to the
`Windows-based Desktop. The WOSA model isolates appli(cid:173)
`cation programmers from the complexities of programming 20
`to different service providers by providing an API layer that
`is independent of an underlying hardware or service and an
`SPI layer that is hardware independent but service depen(cid:173)
`dent. The WOSA model has no relation to motion control
`devices.
`The Applicants are also aware of the common program(cid:173)
`ming practice in which drivers are provided for hardware
`such as printers or the like; an application program such as
`a word processor allows a user to select a driver associated 30
`with a given printer to allow the application program to print
`on that given printer.
`While this approach does isolates the application pro(cid:173)
`grammer from the complexities of programming to each
`hardware configuration in existence, this approach does not 35
`provide the application programmer with the ability to
`control the hardware in base incremental steps. In the printer
`example, an application programmer will not be able to
`control each stepper motor in the printer using the provided
`printer driver; instead, the printer driver will control a 40
`number of stepper motors in the printer in a predetermined
`sequence as necessary to implement a group of high level
`commands.
`The software driver model currently used for printers and
`the like is thus not applicable to the development of a 45
`sequence of control commands for motion control devices.
`
`FIG. 1 (comprising of FIGS. lA, lB, lC, lD, 1E and lF)
`is a system interaction map of a motion control system
`constructed in accordance with, and embodying, the prin(cid:173)
`ciples of the present invention;
`FIG. 2 is a module interaction map of a motion control
`component of the system shown in FIG. 1;
`FIG. 3 is an object interaction map of the component
`shown in FIG. 2;
`FIGS. 4, 5, 6, 7 and 8 are scenario maps of the component
`25 shown in FIG. 2;
`FIG. 9 is an interface map of the component shown in
`FIG. 2;
`FIG. 10 is a data map showing one exemplary method of
`accessing the data necessary to emulate extended driver
`functions using core driver functions;
`FIG. 11 is a module interaction map of the driver portion
`of the system shown in FIG. 1;
`FIG. 12 is an object interaction map of the driver portion
`shown in FIG. 11;
`FIGS. 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 and 20 are
`scenario maps related to the driver shown in FIG. 11;
`FIG. 21 is an interface map for the driver shown in FIG.
`11;
`FIG. 22 is a module interaction map of the streams used
`by the system shown in FIG. 1;
`FIG. 23 is an object interaction map of the streams shown
`in FIG. 22;
`FIGS. 24, 25, 26, 27, 28, 29, 30, 31 and 32 are scenario
`maps of the streams shown in FIG. 22;
`FIG. 33 is an interface map of the objects comprising the
`stream shown in FIG. 22;
`FIG. 34 is a module interaction map of the driver stub
`50 portion of the system shown in FIG. 1;
`FIG. 35 is an object interaction map of the driver stub
`shown in FIG. 34;
`FIGS. 36, 37 and 38 are scenario maps of the driver stub
`shown in FIG. 34;
`FIG. 39 is an interface map of the driver stub portion
`shown in FIG. 34;
`FIG. 40 is a module interaction map of the driver admin(cid:173)
`istrator portion of the system shown in FIG. 1;
`FIG. 41 is an object interaction map of the driver admin(cid:173)
`istrator shown in FIG. 40;
`FIGS. 42, 43, 44, 45, 46, 47, 48 and 49 are scenario maps
`relating to the driver administrator shown in FIG. 40;
`FIG. 50 is an interface map of the objects that comprise
`65 the driver administrator shown in FIG. 40;
`FIG. 51 is a module interaction map of the driver admin(cid:173)
`istrator CPL applet portion of the system shown in FIG. 1;
`
`OBJECTS OF THE INVENTION
`
`From the foregoing, it should be clear that one primary
`object of the invention is to provide improved methods and
`devices for moving objects.
`Another more specific object of the present invention is to
`obtain methods and apparatus for designing and deploying
`motion control devices in which these methods and appa(cid:173)
`ratus exhibit a favorable mix of the following characteris- 55
`tics:
`(a) allow motion control drivers to communicate with
`hardware in a hardware independent manner; and
`(b) allow motion control streams, used by motion control 60
`drivers, to communicate with hardware in a hardware
`independent manner.
`
`SUMMARY OF THE INVENTION
`
`The present invention is, in one form, a method of and
`apparatus for communicating with a motion control device
`for moving an object. The method and apparatus of the
`
`

`
`Case 6:12-cv-00799-JRG Document 153-3 Filed 04/24/14 Page 7 of 30 PageID #: 4524
`
`US 6,513,058 B2
`
`5
`FIG. 52 is an object interaction map of the driver admin(cid:173)
`istrator CPL applet shown in FIG. 51;
`FIGS. 53, 54, 55, 56 and 57 are scenario maps related to
`the driver administrator CPL applet shown in FIG. 51;
`FIG. 58 depicts a Module Interaction-Map showing all 5
`binary modules that interact with the driver and how they
`interact with one another;
`FIG. 59 depicts an Object Interaction-Map which corre(cid:173)
`sponds to the module interaction map of FIG. 58 expanded
`to display the internal C++ objects making up the language 10
`driver 44, and how these objects interact with one another;
`FIGS. 60, 61, 62, 63, 64 and 65 depict a number of
`Scenario Maps that display the interactions taking place
`between the C++ objects involved during certain processes;
`FIG. 66 depicts an interface map that describes the 15
`interfaces exposed by the language driver component 44, all
`data structures used, and the definitions of each C++ class
`used;
`FIG. 67 depicts a table illustrating how a typical database
`employed by the language driver 44 may be constructed;
`FIG. 68 shows the flow of data through the communica(cid:173)
`tion map for a certain requested hardware service Input
`Buffer Ready;
`FIG. 69 Shows the logic table describing the various 25
`outcomes from data read from the hardware, versus data
`expected from the hardware;
`FIG. 70 shows the communication map for the Parker
`Hannifin, Compumotor Division AT6400-AUX1 motion
`control hardware; and
`FIG. 71 shows the communication map for the Galil
`Motion Control, Inc. DMCl 700 motion control hardware.
`
`20
`
`6
`More particularly, based on data input by the user 24 and
`the contents of the application program 26, the software
`system 22 generates control commands that are transmitted
`by one or more streams such as those indicated at 28a, 28b,
`28c, and 28d. The streams 28 transmit control commands
`incorporating the hardware specific command language nec(cid:173)
`essary to control a given motion control device to perform
`in a desired manner. As will be discussed in more detail
`below, the streams 28 implement the communication pro(cid:173)
`tocol that allows the control commands to reach the appro(cid:173)
`priate motion control device 28 via an appropriate channel
`(i.e., PC bus, serial port).
`Using the system 22, the application program 26 is
`developed such that it contains no code that is specific to any
`one of the exemplary hardware controllers 16. In the normal
`case, the application program 26, and thus the user 24 that
`created the program 26, is completely isolated from the
`motion control devices 20. The user 24 thus need know
`nothing about the hardware specific command language or
`communication protocol associated with each of these
`devices 20; it may even be possible that the command
`language of one or more of the hardware controllers 16 was
`not defined at the time the application program 26 was
`created.
`The software system 22 comprises a combination of
`elements that allow the application program 26 to be com(cid:173)
`pletely isolated from the hardware controllers 16. In the
`following discussion, the framework of the software system
`22 will be described in terms of a method of moving an
`30 object and/or a method of generating control commands.
`After this general discussion, each component of the system
`22 will be described in detail in a specific operating envi-
`ronment.
`
`DETAILED DESCRIPTION OF THE
`INVENTION
`Referring now to the drawing, depicted therein at 10 in
`FIG. 1 is a motion control system constructed in accordance
`with, and embodying, the principles of the present invention.
`This system 10 comprises a personal computer portion 12
`having a hardware bus 14, a plurality of motion control 40
`hardware controllers 16a, 16b, and 16c, and mechanical
`systems 18a, 18b, and 18c that interact with one or more
`objects (not shown) to be moved.
`The personal computer portion 12 of the system 10 can be
`any system capable of being programmed as described 45
`herein, but, in the preferred embodiment, is a system capable
`of running the Microsoft Windows environment. Such a
`system will normally comprise a serial port in addition to the
`hardware bus 14 shown in FIG. 1.
`The hardware bus 14 provides the physical connections 50
`necessary for the computer 12 to communicate with the
`hardware controllers 16. The hardware controllers 16 con(cid:173)
`trol the mechanical system 18 to move in a predictable
`manner. The mechanical system 18 comprises a motor or the
`like the output shaft of which is coupled to the object to be
`moved. The combination of the hardware controllers 16a,
`16b, and 16c and the mechanical systems 18a, 18b, and 18c
`forms motion control devices 20a, 20b, and 20c, respec(cid:173)
`tively.
`The hardware bus 14, hardware controllers 16, and 60
`mechanical systems 18 are all well-known in the art and are
`discussed herein only to the extent necessary to provide a
`complete understanding of the present invention.
`The personal computer portion 12 contains a software
`system 22 that allows an application user 24 to create 65
`software applications 26 that control the motion control
`devices 20.
`
`35
`
`I. Method of Generating Control Commands for
`Controlling a Motion Control Device to Move an
`Object
`Initially, it should be noted that, in most situations, the
`method described in this section will normally but not
`necessarily involve the labors of at least two and perhaps
`three separate software programmers: a software system
`designer; a hardware designer familiar with the intricacies of
`the motion control device; and a motion control system
`designer. The application user 24 discussed above will
`normally be the motion control system designer, and the
`roles of the software system designer and hardware designer
`will become apparent from the following discussion.
`The software system designer develops the software sys(cid:173)
`tem 22. The software system designer initially defines a set
`of motion control operations that are used to perform motion
`control. The motion control operations are not specifically
`related to any particular motion control device hardware
`configuration, but are instead abstract operations that all
`motion control device hardware configurations must per-
`55 form in order to function.
`Motion control operations may either be primitive opera(cid:173)
`tions or non-primitive operations. Primitive operations are
`operations that are necessary for motion control and cannot
`be simulated using a combination of other motion control
`operations. Examples of primitive operations include GET
`POSITION and MOVE RELATIVE, which are necessary
`for motion control and cannot be emulated using other
`motion control operations. Non-primitive operations are
`motion control operations that do not meet the definition of
`a primitive operations. Examples of non-primitive opera(cid:173)
`tions include CONTOUR MOVE, which may be emulated
`using a combination of primitive motion control operations.
`
`

`
`Case 6:12-cv-00799-JRG Document 153-3 Filed 04/24/14 Page 8 of 30 PageID #: 4525
`
`US 6,513,058 B2
`
`15
`
`25
`
`7
`Given the set of motion control operations as defined
`above, the software system designer next defines a service
`provider interface (SPI) comprising a number of driver
`functions. Driver functions may be either core driver func(cid:173)
`tions or extended driver functions. Core driver functions are 5
`associated with primitive operations, while extended driver
`functions are associated with non-primitive operations. As
`with motion control operations, driver functions are not
`related to a specific hardware configuration; basically, the
`driver functions define parameters necessary to implement 10
`motion control operations in a generic sense, but do not
`attach specific values or the like to these parameters. The SPI
`for the exemplary software system 22 is attached hereto as
`Appendix A
`The software system designer next defines an application
`programming interface (API) comprising a set of component
`functions. For these component functions, the software
`system designer writes component code that associates at
`least some of the component functions with at least some of
`the driver functions. The relationship between component 20
`functions and driver functions need not be one to one: for
`example, certain component functions are provided for
`administrative purposes and do not have a corresponding
`driver function. However, most component functions will
`have an associated driver function.
`The overall software model implemented by the software
`program 22 thus contains an API comprising component
`functions and an SPI comprising driver functions, with the
`API being related to the SPI by component code associated
`with the component functions.
`In order fo