Method and system for simulating robot program of industrial robot

Abstract

A system and method for simulating a robot program for an industrial robot. Receive input on a robot program for a robot. Represent the robot program for the robot with a neutral representation modeled using a neutral language. Compare specific code portions of the robot program in the neutral representation with corresponding specific code portions of a native representation modeled using a native language of at least one robot. Simulate the robot program in one of the neutral representation and the native representation. Synchronize corresponding code portions of the neutral representation and the native representation of the robot program via mapping.

Description

Technical Field

[0001] The present disclosure generally relates to computer-aided design, visualization, and manufacturing ("CAD") systems, computer-aided robotics ("CAR") systems, product lifecycle management ("PLM") systems, product data management ("PDM") systems, and similar systems (collectively, "product data management" systems or PDM systems) that manage data for products and other items. More specifically, the present disclosure relates to production environment simulation. Background Art

[0002] In robotics manufacturing, it is routine to verify complex shop floor learning in a three-dimensional ("3D") view using several types of robots from one or more robot vendors. In the market, there are several industrial robot vendors. Examples of robot vendors include, but are not limited to, KUKA, ABB, and FANUC. Different industrial robots have their own specific native robot languages.

[0003] Industrial customers often use virtual systems to simulate different industrial robots and their corresponding robot programs. Such virtual simulation systems are usually based on a universal natural language and are usually used to simulate the motion, logic such as signal calculation and operation of multiple industrial robots in a virtual simulation environment. Such universal natural languages ​​are usually high-level and visual programming languages, referred to as neutral languages ​​in this article. For example, with some of such neutral visual languages, users can visualize position objects as 3D frames instead of simple digital visualizations.

[0004] The supplier of applications for robot simulation is Siemens Product Lifecycle Management Software. Examples of such applications include, but are not limited to, Process Simulation, NX Robotics, Robot Experts, and other Siemens CAR tools.

[0005] Some of such applications for robotics simulation may conveniently allow one or more of the following actions to be performed:

[0006] - Upload different robot programs - which may even be in different native languages ​​- into a single virtual system using the same neutral language for the different robot programs. Such a single virtual simulation system may for example contain visual objects, high-level OLP ("offline programming") command objects and other virtual objects. Examples of other virtual objects may include but are not limited to operating program objects, wherein such objects are not necessarily 3D objects, but virtual objects that are for example only containers for lists of 3D objects such as positions.

[0007] -Perform relevant virtual verification and modification;

[0008] - Downloading back all robot programs coded in different native languages ​​into different program files. The robot program includes information about the logic and robot movements for performing the robot task, for example information about position, orientation, commands, signal exchanges.

[0009] In some simulation scenarios, for example, if a problem is encountered during simulation, robotics engineers often prefer to visualize the robot program code in its native language representation rather than working exclusively with the high-level representation provided by the neutral general-purpose language. In practice, usually only very experienced users with high-level knowledge of the neutral language capabilities are able to fully utilize its verification mechanisms.

[0010] On the market, there are several robot simulation applications that are able to verify robot controller code in its own specific native language. Unfortunately, such applications only work with the robot native language of a single robot vendor. For example, the Robot Studio application works specifically for the ABB robot native language, the KukaSim application works specifically for the KUKA robot native language, and the RoboGuide application works specifically for the FANUC robot native language.

[0011] Therefore, improved techniques are desired. Summary of the invention

[0012] Various disclosed embodiments include methods and corresponding systems and computer-readable media for simulating a robot program for an industrial robot. The method includes receiving input on a robot program for a robot. Representing the robot program for the robot in a neutral representation modeled using a neutral language. The method includes mapping specific code portions of the robot program in the neutral representation with corresponding specific code portions of a native representation modeled using a native language of the robot. The method includes simulating the robot program in one of the neutral representation and the native representation. Synchronizing the corresponding code portions of the neutral representation and the native representation of the robot program via the mapping.

[0013] The features and technical advantages of the present disclosure have been outlined quite broadly above so that those skilled in the art may better understand the detailed description that follows. Additional features and advantages of the present disclosure that form the subject matter of the claims will be described hereinafter. Those skilled in the art will appreciate that the disclosed concepts and specific embodiments may be readily used as a basis for modifying or designing other structures for the same purpose of implementing the present disclosure. Those skilled in the art will also recognize that such equivalent constructions do not depart from the spirit and scope of the present disclosure in its broadest form.

[0014] Before proceeding to the following "Detailed Description", it may be helpful to set forth definitions of certain words or phrases used throughout this patent document: the terms "include" and "comprising" and their derivatives are intended to include without limitation; the term "or" is inclusive, meaning and / or; the phrases "associated with..." and "associated with" and their derivatives may mean including, included therein, interconnected therewith, containing, contained therein, connected or connected therewith, coupled or coupled therewith, communicable therewith, cooperating therewith, interlaced, juxtaposed, proximate, bound to or bound therewith, having, possessing, etc.; the term "controller" means any device, system, or part thereof that controls at least one operation, whether such device is implemented in hardware, firmware, software, or some combination of at least two thereof. It should be noted that the functionality associated with any particular controller may be centralized or distributed, whether local or remote. Definitions of certain words and phrases are provided throughout this patent document, and one of ordinary skill in the art will understand that such definitions apply to prior and future uses of such defined words and phrases in many, if not most, cases. While some terms may include a wide variety of embodiments, the appended claims may expressly limit these terms to specific embodiments. BRIEF DESCRIPTION OF THE DRAWINGS

[0015] For a more complete understanding of the present disclosure and advantages thereof, reference is now made to the following description taken in conjunction with the accompanying drawings, wherein like reference numerals represent like objects, and wherein:

[0016] Figure 1 shows a block diagram of a data processing system in which embodiments may be implemented;

[0017] Figure 2A , Figure 2B , Figure 2C shows an example of native language code of a robot program with inserted tags according to the disclosed embodiments;

[0018] Figure 3 A robot program viewer including a neutral representation and a native representation according to the disclosed embodiments is schematically shown.

[0019] Figure 4 A flow chart of a method for simulating a robot program of an industrial robot according to a disclosed embodiment is shown. DETAILED DESCRIPTION

[0020] The following discussion Figures 1 to 4The various embodiments for describing the principles of the present disclosure in the patent document are only by way of example, and should not be interpreted as limiting the scope of the present disclosure in any way. It will be appreciated by those skilled in the art that the principles of the present disclosure can be implemented in any appropriately arranged device. Many innovative teachings of the present application will be described with reference to exemplary non-limiting embodiments.

[0021] Embodiments enhance the simulation capabilities of robotics simulation applications.

[0022] Embodiments support robotics engineers to perform their robotics simulation tasks in a user-friendly and easy manner, especially when dealing with manufacturing scenarios with robots from multiple vendors.

[0023] Embodiments enable synchronization of robot simulations in two representations in a parallel manner.

[0024] Embodiments enable decomposition of native robot programs in code portions, enabling the user to know which motion or logic the robot is executing at a given time, e.g., robot goal, specific OLP command, etc.

[0025] Embodiments enable a user to validate the same logic in parallel with two different representations (neutral and native).

[0026] Embodiments enable increased productivity and efficiency of robotics simulation applications by enabling robotics engineers to simultaneously operate in a language they are familiar with.

[0027] In addition to providing a high-level view with a neutral language representation, embodiments enable improved control by factoring the view of the executed code.

[0028] Embodiments enable a skilled robotics programmer to view executed programs in the native language of a particular robotics controller.

[0029] Embodiments also allow for the universality of a method so that a program can be visualized in a common language for all controllers and at the same time can be detailed for each controller or have a detailed and unique representation for each controller without having to maintain common code for the simulation environment. Advantageously, a user who is proficient in the native language can sit with a user who is proficient in the neutral language to solve a problem within a virtual simulation system.

[0030] Embodiments enable improved capabilities during the validation process of a robot program.

[0031] Embodiments enable offline robot code synchronization of different robots within a virtual simulation system.

[0032] Embodiments enable improved OLP programming of robots.

[0033] Figure 1 A block diagram of a data processing system 100 is shown in which embodiments may be implemented, for example, as a PDM system that is specifically configured by software or otherwise configured to perform processes as described herein, and specifically as each of a plurality of interconnect and communication systems as described herein. The data processing system 100 shown may include a processor 102 connected to a secondary cache / bridge 104, which in turn is connected to a local system bus 106. The local system bus 106 may be, for example, a peripheral component interconnect (PCI) architecture bus. Also connected to the local system bus in the example shown are a main memory 108 and a graphics adapter 110. The graphics adapter 110 may be connected to a display 111.

[0034] Other peripheral devices such as a local area network (LAN) / wide area network / wireless (e.g., WiFi) adapter 112 may also be connected to the local system bus 106. An expansion bus interface 114 connects the local system bus 106 to an input / output (I / O) bus 116. The I / O bus 116 is connected to a keyboard / mouse adapter 118, a disk controller 120, and an I / O adapter 122. The disk controller 120 may be connected to a storage device 126, which may be any suitable machine-usable or machine-readable storage medium, including but not limited to non-volatile hard-coded type media, such as read-only memory (ROM) or electrically erasable programmable read-only memory (EEPROM), magnetic tape storage devices, and user-recordable type media such as floppy disks, hard drives, and compact disk read-only memories (CD-ROMs) or digital versatile disks (DVDs) and other known optical, electrical, or magnetic storage devices.

[0035] Also connected to I / O bus 116 in the example shown is an audio adapter 124 to which speakers (not shown) may be connected for playing sounds. Keyboard / mouse adapter 118 provides a connection for a pointing device (not shown) such as a mouse, trackball, trackpointer, touch screen, etc.

[0036] Those of ordinary skill in the art will understand that Figure 1 The hardware shown in the embodiment may vary for a particular implementation. For example, other peripheral devices such as optical disk drives may be used in addition to or instead of the hardware shown. The examples shown are provided for explanation purposes only and are not meant to imply architectural limitations regarding the present disclosure.

[0037] The data processing system according to the embodiment of the present disclosure may include an operating system that adopts a graphical user interface. The operating system allows to present multiple display windows in the graphical user interface at the same time, wherein each display window provides an interface to different applications or to different instances of the same application. The user can manipulate the cursor in the graphical user interface through a pointing device. The position of the cursor can be changed and / or an event such as clicking a mouse button can be generated to start the desired response.

[0038] If appropriately modified, one of a variety of commercial operating systems may be used, such as Microsoft Windows 10, a product of Microsoft Corporation located in Redmond, Washington. TM As described, the operating system is modified or created according to the present disclosure.

[0039] LAN / WAN / wireless adapter 112 can be connected to network 130 (network 130 is not part of data processing system 100), which, as known to those skilled in the art, can be any public or private data processing system network or combination of networks, including the Internet. Data processing system 100 can communicate with server system 140 via network 130, which is also not part of data processing system 100, but can be implemented as, for example, a separate data processing system 100.

[0040] Figure 2A , Figure 2B , Figure 2C An example of native language code of a robot program with inserted tags according to the disclosed embodiments is shown.

[0041] Figure 3 A robot program viewer including a neutral representation and a native representation according to the disclosed embodiments is schematically shown.

[0042] In an embodiment, a robot program of a robot is received as input. By the term "robot program", it is herein referred to as a virtual robot program / operation, whereby a virtual program may contain several operations for the same robot. In other embodiments, the received input may include a virtual representation of the robot, a virtual representation of the environment (e.g., 3D learning, a cell with its contents).

[0043] FIG. 2A to FIG. 2C An exemplary robot program represented in a native representation modeled using a native language specific to the KUKA robot is shown. Figure 3 Another example of a native representation in robot native language code is shown in the upper left portion 301 of the robot program viewer 300 .

[0044] In an embodiment, a robot program for a robot in a native representation may be conveniently received, for example, via upload. The robot program may then be represented in a neutral representation by converting the native representation to a neutral representation. This may be conveniently done, for example, in a virtual simulation environment having such capabilities.

[0045] In other embodiments, the robot program is received in a neutral representation. Examples include receiving the robot program from a repository or obtaining the robot program via modeling within a virtual simulation environment.

[0046] In other embodiments, the above mentioned mixing may advantageously be possible. For example some changes with a neutral representation are modeled, for example by adding new positions and OLPs within the virtual simulation system, to a robot program in a native language received via uploading.

[0047] In an embodiment, the virtual simulation system is provided with the capability to simulate the received robot program with a neutral representation modeled using a neutral language.

[0048] In an embodiment, a robot program expressed in a neutral language may preferably contain 3D objects, high-level OLP commands and / or other virtual objects (e.g., parts, signals, tools, etc.), 3D positions with parameters for motion instructions, OLP command objects for non-motion instructions attached to a parent operation or position. Other virtual objects may be, for example, a paint trigger, where, for example, a paint gun changes its brush once the robot reaches the trigger position.

[0049] In an embodiment, the robot program is simulated in a neutral representation. Advantageously, relevant virtual verification and modification can be performed in a natural representation.

[0050] exist Figure 3 In FIG. 3 , a neutral representation is shown in a graphical portion 302 and a path edit viewer 303 includes a textual description in a higher level language.

[0051] Map specific code portions of the robot program in the neutral representation to corresponding specific code portions of the native representation modeled using the robot's native language.

[0052] In an embodiment, the mapping may be done at the beginning.

[0053] In embodiments, mapping may be done upon notification, such as upon user request, change, error, and other types of notifications.

[0054] In an embodiment, changes to a natural language program or its paired program in a native language are automatically identified, such as by detecting changes to a downloaded file, and a mapping is generated or updated accordingly.

[0055] The mapping can be conveniently performed during downloading of the robot program. The mapping can be done by inserting tags in the robot program's native language code and / or by using a cached mapping table.

[0056] For example, the system controller downloads the robot program in a special silent mode. During this special download, specific tags are inserted in the robot program native syntax code to synchronize the program lines in the native syntax with the neutrally represented system objects. In an embodiment, as an alternative to or in addition to the tags in the native code, the mapping can be advantageously cached in a table.

[0057] In an embodiment, for each robot of the virtual simulation system, the following steps are performed:

[0058] -The system's controller downloads the robot program in a special silent mode

[0059] - During this special download, the controller inserts specific tags in the robot program in native syntax to synchronize the program lines in native syntax with system objects (e.g., operations, positions, OLP commands, etc.).

[0060] In an embodiment, the mapping may be advantageously cached. The cached version of the mapping may advantageously improve the speed of simulation performance. Table 1 is an exemplary embodiment of a cache table, which relates to FIG. 2A to FIG. 2C Example of a tag inserted in native code.

[0061] Table 1

[0062] Keywords Line Number TX_OP_001 7 TX_CMD_001 8 TX_CMD_002 10 TX_LOC_001 12-14 …… ……

[0063] In the exemplary embodiment of Table 1, the keywords in Table 1 are object names mapped to corresponding robot program lines written in native code. In other embodiments, the keywords can be object IDs. In the example of Table 1, the prefix TX is an abbreviation for digital manufacturing (Tecnomatix). The label TX_OP_001 refers to the start of a new operation until the next operation label TX_OP_i. The label TX_CMD_001 refers to the start of a new command until any label TX_CMD_i, TX_OP_i, TX_LOC_i is encountered. The label TX_LOC_001 refers to the start of a new location until the next operation label or location label, TX_OP_i or TX_LOC_i is encountered.

[0064] In FIG. 2 , the tag 201 inserted into the native code is highlighted with grey coloring.

[0065] During simulation, based on the above mapping and also based on possible notifications from the controller, the virtual simulation system can show the program code in the native language and highlight the current simulation line based on the current simulation object.

[0066] exist Figure 3 In the exemplary embodiment of , in the neutral representation of the bottom pane of the robot program viewer screen, during simulation, the location "via5a" is highlighted 304, and the corresponding line 305 in the native language code is also conveniently highlighted based on the mapping. Figure 3 , the highlighted native code lines 305 are lines 39 to 45, and the highlighted neutral code portion 304 is the position object "via5a". Advantageously, a dual representation is also provided in parallel during simulation, for example by showing the 3D position the robot is moving to and the corresponding line in the robot program native code.

[0067] In case the simulation is stopped, the system can advantageously show all robot variables and signal names relative to their values ​​to give a better understanding.

[0068] Figure 4 A flowchart 400 of a method for simulating a robot program of an industrial robot is shown. Figure 1 The method is performed using the system 100, but the "system" in the following process may be any device configured to perform the process.

[0069] At act 405, input on a robot program of the robot is received.

[0070] At act 410, a robot program of the robot is represented in a neutral representation modeled using a neutral language. In an embodiment, a virtual simulation system is provided for simulating the robot in a neutral representation.

[0071] At act 415, specific code portions of the robot program in the neutral representation are mapped to corresponding specific code portions of the native representation modeled using the robot's native language.

[0072] At action 420, the robot program is simulated in one of the neutral representation and the native representation. In an embodiment, the virtual simulation system is also provided with the capability to simulate the robot in the native representation. In an embodiment, relevant virtual verification and modification are performed.

[0073] At action 425, the neutral representation of the robot program and the corresponding code portions of the native representation are synchronized via the mapping of action 415. In an embodiment, the virtual simulation system is provided with the ability to synchronize the corresponding code portions of the neutral representation and the native representation during simulation. In an embodiment, the simulation is performed in one representation and then advantageously synchronized with the other representation.

[0074] In an embodiment, during simulation, synchronized code portions in native representation 305 and in neutral representation 304 are highlighted. In an embodiment, simulation can be performed in the native language by a virtual robot controller and synchronized in the system in the neutral language. Advantageously, an embodiment enables highlighting of desired or current equivalent code portions 304, 305 in both languages.

[0075] As used herein, the term "code portion" means a portion of the code and / or a virtual object, such as a location and OLP command. In fact, the natural representation, virtual objects are actually the real part of the "code", considering that neutral languages ​​often use high-level languages ​​and visual objects.

[0076] Implementations may include multiple robots and multiple native representations.

[0077] In an embodiment, an additional step includes downloading back different program files with different native languages. In an embodiment, upon a successful verification phase, the robot program can be downloaded for use by the real robot.

[0078] In other embodiments, having synchronized code sections in native and natural representations can be used for debugging purposes. For example, in an embodiment, an expert user may wish to read a robot program in the robot's native language to examine the logic in a phase other than simulation time. In other embodiments, another user may wish to compare a robot program to another program. Advantageously, a user can make minor modifications to the neutral language code and view the results in the native language code.

[0079] In an embodiment, during simulation, based on the above mentioned mapping and notification of system objects simulated from the controller, the system may show the program code in the native language and highlight the current simulation line based on the current simulation object.

[0080] In the case of simulation stop, the system can show all robot variables and signal names relative to their values ​​to improve usability. In addition, there can also be "editing capabilities" so that the user can modify their values ​​and continue the simulation (for example by changing the value of a signal).

[0081] Embodiments are useful in the following use case scenarios: user starts generic simulation and simulation stops due to an error; user sees a problem; user can open a viewer of native code, silent download is performed and table mapping is created so that the user can see the current native code. Thus, in embodiments, downloading and mapping can be performed in the next phase upon request.

[0082] Other embodiments may include: downloading a robot program (in a native language) to a robot controller; connecting to the virtual robot controller via a dedicated API to execute the downloaded robot program line by line; synchronizing the two systems to work on the same simulation clock; and, enabling the user to view the lines being simulated in the virtual robot controller and the actual 3D motion in the system.

[0083] Other implementations may include: the system controller performs a "mini-download" for each position, for each OLP command at a simulated time; and the system visualizes the current "mini-download" line for the user.

[0084] Although exemplary embodiments of the present disclosure have been described in detail, those skilled in the art will understand that various changes, substitutions, variations and alterations may be made herein without departing from the spirit and scope of the disclosure in its broadest form.

[0085] None of the description in this application should be read as implying that any particular element, step, or function is an essential element that must be included in the claims scope: the scope of patented subject matter is limited only by the allowed claims.

Claims

1. A method for simulating a robot program of an industrial robot by a data processing system, comprising the following steps: a) receiving (405) input on a robot program of the robot; b) representing (410) the robot program of the robot in a representation modeled using a high-level visual programming language, the high-level visual programming language being referred to hereinafter as a neutral language and the representation being referred to hereinafter as a neutral representation; c) mapping specific code portions of the robot program in the neutral representation with corresponding specific code portions of a native representation modeled using a native language of the robot (415); d) simulating (420) the robot program in one of the neutral representation and the native representation; as well as e) synchronizing (425) corresponding code portions of the neutral representation and the native representation of the robot program via the mapping of step c), where, during simulation, synchronized code sections in native and neutral representation are highlighted, and The mapping in step c) is accomplished by inserting tags in the native code and / or in the cache table.

2. The method according to claim 1, wherein: At step a) the robot program is received via uploading.

3. The method according to claim 1 or 2, wherein: Said mapping of step c) is performed during downloading.

4. The method according to claim 1 or 2, further comprising: Verifying and / or modifying the robot program.

5. The method according to claim 1 or 2, further comprising: Download the robot program in your native language.

6. A data processing system comprising: processor; as well as The data processing system is configured to: a) receiving input on a robot program of the robot; b) representing said robot program of said robot in a representation modeled using a high-level visual programming language, said high-level visual programming language being referred to hereinafter as a neutral language and said representation being referred to hereinafter as a neutral representation; c) mapping specific code portions of the robot program in the neutral representation with corresponding specific code portions of the native representation modeled using the robot's native language; d) simulating the robot program in one of the neutral representation and the native representation; as well as e) synchronizing corresponding code portions of said neutral representation and said native representation of said robot program via said mapping of step c), where, during simulation, synchronized code sections in native representation and in neutral representation are highlighted, and The mapping in step c) is accomplished by inserting tags in the native code and / or in the cache table.

7. The data processing system according to claim 6, wherein: At step a) the robot program is received via uploading.

8. The data processing system according to claim 6 or 7, wherein: Said mapping of step c) is performed during downloading.

9. The data processing system according to claim 6 or 7, further comprising: Verifying and / or modifying the robot program.

10. The data processing system according to claim 6 or 7, further comprising: Download the robot program in your native language.

11. A non-transitory computer readable medium encoded with executable instructions that, when executed, cause one or more data processing systems to: a) receiving input on a robot program of the robot; b) representing said robot program of said robot in a representation modeled using a high-level visual programming language, said high-level visual programming language being referred to hereinafter as a neutral language and said representation being referred to hereinafter as a neutral representation; c) mapping specific code portions of the robot program in the neutral representation with corresponding specific code portions of the native representation modeled using the robot's native language; d) simulating the robot program in one of the neutral representation and the native representation; and e) synchronizing corresponding code portions of said neutral representation and said native representation of said robot program via said mapping of step c), in, During simulation, sections of synchronized code in native and neutral representations are highlighted, and The mapping in step c) is accomplished by inserting tags in the native code and / or in the cache table.

12. The non-transitory computer readable medium of claim 11, wherein: At step a) the robot program is received via uploading.

13. The non-transitory computer readable medium according to claim 11 or 12, wherein: Said mapping of step c) is performed during downloading.

14. The non-transitory computer readable medium of claim 11 or 12, further comprising: Verifying and / or modifying the robot program.

15. The non-transitory computer readable medium of claim 11 or 12, further comprising: Download the robot program in your native language.

Images