Simulation Signing Key for Robot Simulation

Abstract

System and method can support generation and use of simulation signature keys for robot simulation. A computer-aided manufacturing (CAM) system can access robot path data for a robot, and the robot path data includes a target position and corresponding motion parameters for the robot. The CAM system can divide the robot path data into simulation events according to event division criteria, so that each simulation event includes one or more target positions and corresponding motion parameters and also generates corresponding simulation signature keys for each divided simulation event. The simulation signature key can provide a search key to a motion planning data cache. When the entry for the generated simulation signature key for the simulation event is present in the motion planning data cache, the CAM system can retrieve the motion planning data for the simulation event cache. When the entry does not exist, the CAM system can obtain motion planning data by robot simulation.

Description

Background Art

[0001] Computer systems can be used to create, use, and manage data for products and other items. Examples of computer systems include computer-aided manufacturing (CAM) systems, computer-aided engineering (CAE) systems, computer-aided design (CAD) systems, visualization and manufacturing systems, product data management (PDM) systems, product lifecycle management (PLM) systems, etc. These systems may include components that facilitate the design and simulation testing of products. Summary of the invention

[0002] The disclosed embodiments include systems, methods, apparatus, and logic that can support the generation and use of simulation signing keys for robot simulation.

[0003] In one example, the method may be performed, implemented or otherwise implemented by a computer system such as a CAM system. The method may include: accessing robot path data for a robot, the robot path data including a target position and corresponding motion parameters for the robot; and dividing the robot path data into simulation events according to an event partitioning criterion, so that each simulation event includes one or more target positions and corresponding motion parameters. The method may also include, for a given simulation event: using one or more target positions and corresponding motion parameters for a given simulation event to generate a simulation signature key for a given simulation event; obtaining motion planning data for a given simulation event by simulating the robot according to the given simulation event; and associating the simulation signature key for the given simulation event with the obtained motion planning data for the given simulation event.

[0004] In another example, a system may include a motion planning cache and a robotic simulation engine. The robotic simulation engine may be configured to access robot path data for a robot, the robot path data including a target position and corresponding motion parameters for the robot; divide the robot path data into simulation events according to an event division criterion, so that each simulation event includes one or more target positions and corresponding motion parameters. The robotic simulation engine may also be configured to, for each given simulation event of the robot path data: generate a simulation signature key for the given simulation event using the one or more target positions and corresponding motion parameters for the given simulation event.

[0005] In response to determining that the motion planning cache includes an entry for the generated simulation signature key for the given simulation event, the robot simulation engine can be configured to obtain motion planning data for the given simulation event from the entry for the simulation signature key from the motion planning cache. In response to determining that the motion planning cache does not include an entry for the generated simulation signature key for the given simulation event, the robot simulation engine can be configured to: obtain motion planning data for the given simulation event by simulating the robot according to the given simulation event; and insert an entry into the motion planning cache that pairs the simulation signature key for the given simulation event with the obtained motion planning data for the given simulation event.

[0006] In yet another example, a non-transitory machine-readable medium may store processor-executable instructions. When the instructions are executed, the instructions may cause a system to: access robot path data for a robot, the robot path data including a target position and corresponding motion parameters for the robot; divide the robot path data into simulation events according to an event partitioning criterion, so that each simulation event includes a sequence of one or more target positions and corresponding motion parameters; and for each given simulation event of the robot path data, generate a simulation signature key for the given simulation event using the sequence of one or more target positions and corresponding motion parameters for the given simulation event; obtain motion planning data for the given simulation event by simulating the robot according to the given simulation event, and insert an entry into a motion planning cache, the entry pairing the simulation signature key for the given simulation event with the obtained motion planning data for the given simulation event.

[0007] Executing the instruction may also enable the system to: access additional robot path data for the robot; divide the additional robot path data into additional simulation events according to an event division criterion; and for each additional simulation event of the additional robot path data, generate a simulation signature key for the additional simulation event, and when the simulation signature key for the additional simulation event is already stored in the motion planning cache, obtain the motion planning data for the additional simulation event from the motion planning cache. BRIEF DESCRIPTION OF THE DRAWINGS

[0008] In the following detailed description, some examples are described with reference to the accompanying drawings.

[0009] Figure 1 An example of a system that supports generating and using simulation signing keys for robot simulation is shown.

[0010] Figure 2 An example of dividing robot path data into simulation events by a robot simulation engine is shown.

[0011] Figure 3 An example of generating a simulation signing key and inserting an entry into a motion planning cache by a robot simulation engine is shown.

[0012] Figure 4 An example of looking up a motion plan cache by a robot simulation engine is shown.

[0013] Figure 5 An example of logic that a system may implement to support the generation and use of simulation signing keys for robot simulation is shown.

[0014] Figure 6 An example of a system that supports generating and using simulation signing keys for robot simulation is shown. DETAILED DESCRIPTION

[0015] The present disclosure relates to robotic simulation. Modern computing systems can use robotic simulation to design and test complex robotic designs and operations before using physical robots. For example, CAM systems can provide mechanisms for machine tool programming, post-processing, and machine tool simulation to test and program robotic manufacturing tools. Many robotic simulation systems involve iterative (or repeated) spatial simulation to implement, design, and test robotic functions in virtual space before actual physical operation.

[0016] The robot simulation process may involve generating and using robot path data and motion planning data. As used herein (and described in more detail below), robot path data may refer to a sequence of target positions and corresponding motion parameters defined for a robot (e.g., in a manufacturing environment). Various motion parameters are discussed herein, and example motion parameters that may be included in the robot path data include robot configuration data (e.g., posture data), robot position data (e.g., specific robot parts to reach the target position), target area data, robot speed data, robot motion type data, etc. The robot path data may be generated by a user prior to simulation and specify an overall framework of desired robot movement, from which more detailed or complete robot motion data may be generated by simulation. In this regard, the robot path data may include motion data defined for the robot without (or before) using robot simulation.

[0017] The robot path data may be provided to the simulator for generating motion planning data. As used herein, motion planning data (sometimes referred to as full motion planning) may refer to output data generated from a robot simulation, such as output of a robot simulation performed according to a Realistic Robot Simulation (RRS) framework, protocol or interface. Therefore, the motion planning data may include detailed outputs of the simulated robot motion, such as robot timing, comprehensive path position, posture, simulation events, messages or other control outputs generated via the robot simulation. The generation of motion planning data may be time-consuming, computationally expensive and costly.

[0018] The features described herein can improve performance efficiency or robot simulation, and can improve performance efficiency or robot simulation while maintaining the accuracy of simulated robot movement. As described in more detail below, the CAM system can generate and use a simulation signature key that can uniquely identify a sequence of target positions specified in the robot path data. When a match is identified with a simulation signature key applicable to other parts of the robot path data or other robot path data provided to the CAM system, motion planning data obtained for such a sequence of target positions (e.g., obtained through a previous simulation) can be cached and reused. Doing so can reduce the number of robot simulations by reducing the use of a robot simulator, which can improve system efficiency, reduce computing time, or reduce costs.

[0019] A simulation signature key may be generated for a sequence of target positions in the robot path data, and the features described herein may accurately discern between different robot move sequences that include the same target position. Thus, the simulation signature key features described herein may improve robot simulation efficiency while maintaining simulation accuracy, thereby allowing cached motion planning data to be safely reused. These and other robot simulation features, including the simulation signature key features, will be described in more detail below.

[0020] Figure 1 An example of a system that supports generating and using simulation signature keys for robot simulation is shown. The system 100 can take the form of a computing system, including a single or multiple computing devices, such as an application server, a computing node, a desktop or laptop computer, a smart phone or other mobile device, a tablet device, an embedded controller, etc. As described herein, the system 100 can manage robot simulation using a signature simulation key. For motion planning data previously simulated and associated with a signature simulation key, the system 100 can cache and retrieve such motion planning data when a target position sequence in robot path data having the same signature simulation key is identified.

[0021] As an example implementation, Figure 1The system 100 shown in the includes a robot simulation engine 110 that can support robot simulation in various ways. The system 100 can implement the robot simulation engine 110 (and its components) in various ways (e.g., as hardware and programming). The programming for the robot simulation engine 110 can take the form of processor-executable instructions stored on a non-transitory machine-readable storage medium, and the hardware for the robot simulation engine 110 may include a processor for executing those instructions. The processor can take the form of a single processor or a multi-processor system, and in some examples, the system 100 uses the same computing system features or hardware components (e.g., a common processor and a common storage medium) to implement multiple engine components or system elements.

[0022] Figure 1 The example system 100 shown in also includes a motion plan cache 120. As described in more detail below, the motion plan cache 120 can store motion plan data obtained from a robot simulation, and the motion plan cache 120 can be keyed according to a simulation signature key associated with the motion plan data. The system 100 can implement the motion plan cache 120 as any suitable data structure, such as a relational database, a lookup table, or other data structure stored on a non-transitory machine-readable medium.

[0023] In operation, the robot simulation engine 110 may access robot path data for the robot, and the robot path data may include target positions and corresponding motion parameters for the robot (e.g., as specified by user design). The robot simulation engine 110 may divide the robot path data into simulation events according to an event division criterion, and may do so so that each simulation event includes one or more target positions and corresponding motion parameters. For each given simulation event divided from the robot path data, the robot simulation engine 110 may use the one or more target positions and corresponding motion parameters for the given simulation event to generate a simulation signature key for the given simulation event.

[0024] In response to determining that the motion planning cache 120 includes an entry for the generated simulation signature key for the given simulation event, the robot simulation engine 110 may obtain motion planning data for the given simulation event from the entry for the simulation signature key from the motion planning cache 120. In response to determining that the motion planning cache 120 does not include an entry for the generated simulation signature key for the given simulation event, the robot simulation engine 110 may obtain motion planning data for the given simulation event by simulating the robot according to the given simulation event, and insert an entry into the motion planning cache 120 that pairs the simulation signature key for the given simulation event with the obtained motion planning data for the given simulation event.

[0025] These and other robot simulation features (including the simulation signature key features) are described in more detail below.

[0026] Figure 2 An example of dividing robot path data into simulation events by the robot simulation engine 110 is shown. By dividing the robot path data, the robot simulation engine 110 can divide the robot path data into a specific sequence of target positions. Each divided sequence of one or more target positions and corresponding motion parameters can be called a simulation event, and the robot simulation engine 110 can generate a corresponding simulation signature key for each simulation event divided from the robot path data.

[0027] In order to pass Figure 2 , the robot simulation engine 110 accesses the robot path data 210. As described above, the robot path data may include user-specified target positions and corresponding motion parameters that provide an overall framework for the desired robot motion of a robot or a group of robots. Figure 2 The robot path data 210 shown in FIG. 2 specifies each target position by a "target position" field having a value. Figure 2 loc1, "Target.loc2", "Target.loc3", etc. Each target position may specify a (absolute or relative) position for the robot to reach, such as a specific position in a production line, a welding position of an object, a contact position with a neighboring robot, or any other desired position in the robot's environment. In other embodiments, the target position may be referenced in the robot path data by a targetID field or other fields. Each row in the robot path data 210 may specify a target position and its corresponding motion parameters. As shown in Figure 2 As can be seen in the robot path data 210 in FIG. 1 , certain target positions may appear multiple times in the robot path data.

[0028] The robot path data 210 may specify various motion parameters corresponding to a specific target location. The motion parameters may specify any properties of the robot, the target location, the robot movement, or any other attributes associated with the robot or the target location. Figure 2As shown in the example, the robot path data 210 may specify robot configuration data via a “robot configuration” field, robot speed data via a “speed” field, and robot motion type data via a “motion type” field. The robot configuration data may specify any relevant configuration data for the robot, such as a specific robot pose of the robot when reaching a target position, for example, as specified by an array of values ​​for each movement axis of the robot. In some examples, the robot configuration data defines requirements, prompts, suggestions, or other control parameters specific to the robot reaching a target position. The robot speed data may specify a movement speed parameter used to reach a target position, whether absolute or relative to the robot's capabilities (e.g., a maximum or minimum robot movement speed). Since the robot may be able to move along multiple degrees of freedom, the motion type data may specify a specific motion type (e.g., linear motion, circular motion, etc.) that the robot is to move to the target position.

[0029] As Figure 2 As another example motion parameter shown in , the robot path data 210 may specify target area data via an “area” field. The target area data may specify the accuracy with which the robot can reach the target position, whether reaching the target position exactly or reaching within an acceptable area around the target position. In other words, the target area data may specify whether the robot has reached the given target position by reaching the given target position exactly or by reaching an area around the given target position. For example, in Figure 2 In the example, the "fine" value set for the target area data can specify the exact position at which the robot will reach the target position, while the "z30" value set for the target area data can specify that the robot reaches the target position when it is within 30 mm of the target position.

[0030] As another example motion parameter, the robot path data 210 may specify robot position data. The robot position data may specify a specific robot element, robot position, or coordinates of the robot intended to reach a target position. For example, the robot position data may specify position data of a robotic welding tip of the robot intended to reach a specific target position. The robot position data may be specified in terms of tool center point frame (TCPF) coordinates or via any other robot coordinate system.

[0031] Although the above description and Figure 2 Some examples of motion parameters are shown in the robot path data 210 of , but the disclosure herein contemplates any number of additional or alternative motion parameters in the robot path data that the robot simulation engine 110 can recognize and support.

[0032] The robot simulation engine 110 may divide the robot path data 210 into simulation events according to the event division criteria 220, which may be specified based on any number of motion parameters or target positions. To divide the robot path data 210, when one or more conditions specified by the event division criteria 220 are met, the robot simulation engine 110 may sequentially consider the target positions in the robot path data 210 and group the target positions (and their corresponding motion parameters) into simulation events.

[0033] In some embodiments, the event partitioning criteria 220 specifies that each individual target position entry in the robot path data 210 is partitioned into a separate simulation event. In other embodiments, the event partitioning criteria 220 specifies that the robot path data 210 is partitioned into simulation events that include multiple target positions. For example, the event partitioning criteria 220 may group the target positions into simulation events based on a fine-to-fine requirement for the target area data. In such an example, the robot simulation engine 110 may partition the robot path data 210 into simulation events such that each of the partitioned simulation events begins and / or ends with a target position that the target area data specifies the robot is to precisely reach (e.g., a target area value of "fine").

[0034] In addition to or in lieu of the target region data, the event partitioning criteria 220 may be based on any other motion parameters specified in the robot path data 210. As other examples, the event partitioning criteria 220 may specify partitioning the robot path data 210 according to robot posture data (e.g., grouping target positions and corresponding motion parameters into specific simulation events until a specific robot posture or posture mode of the robot is reached) or according to robot speed data (e.g., grouping target positions and corresponding motion parameters into specific simulation events until a threshold robot speed is reached). As yet another example, the event partitioning criteria 220 may specify grouping target positions and corresponding motion parameters according to a combination of multiple motion parameters, such as based on specific thresholds for both robot configuration data and target region data.

[0035] Although some specific examples of event partitioning criteria 220 are described herein, the robot simulation engine 110 may apply any variation of event partitioning criteria 220 as consistently described herein. The event partitioning criteria 220 may be user-configurable, based on a particular partitioning configuration desired by a system administrator or other user.

[0036] In some embodiments, a specific target position in the robot path data 210 may be defined based on a previous target position. For example, the modality-based robot path data may have empty fields (or any other predefined substitute values) for some motion parameters, indicating that the value of the empty motion parameter is inherited from a previous target position. In these embodiments, the robot simulation engine 110 may identify such motion parameters from the previous target position to evaluate the conditions set in the event classification criteria 220 and classify the simulation event accordingly.

[0037] In some embodiments, the event partitioning criteria 220 may specify a partitioning of the robot path data 210 such that the order of the target positions remains unchanged. In such embodiments, the robot simulation engine 110 may group a sequence of consecutive target positions in the robot path data 210 into a single simulation event, and do so without destroying or rearranging the order in which the target positions are specified in the robot path data 210. By ensuring that the order of the target positions in the robot path data 210 remains consistent, the robot simulation engine 110 may preserve the intended process or robot path, thereby allowing the robot simulation engine 110 to recognize the same motion path and robot movement process that may subsequently exist in the robot path data 210. Therefore, the robot simulation engine 110 may partition or form such a simulation event, which includes a sequence of multiple target positions and their corresponding motion parameters from the robot path data 210.

[0038] By including multiple target positions (and corresponding motion parameters) in a single simulation event, the robot simulation engine 110 can account for differences in motion planning data that may occur for a specific target position based on the target position previously reached by the robot or the target position that the robot will reach in the future. Through the event partitioning criteria 220, the robot simulation engine 110 can ensure that the simulation event tracks the specific order of the target positions in the robot path data 210 to properly cache and reuse the simulated motion planning data.

[0039] For illustration, the robot path data 210 may include multiple instances for a specific target position that the robot is about to reach, and each instance of the specific target position may have the same motion parameters (e.g., multiple instances of "Target.loc1", each of which has the same motion parameters). The motion planning data simulated for each of these multiple instances may be different due to the order of the previous target position or subsequent target position reached by the robot. That is, even if the motion planning parameters used for each instance are the same, the simulation of the first instance of "Target.loc1" in the robot path data may produce different motion planning data from the second instance of "Target.loc1". By dividing the simulation events to include a sequence of multiple target positions, the event division criteria 220 can be used by the robot to identify, associate or track path patterns to ensure safe reuse of cached motion planning data. That is, the cached motion planning data for the simulation events can describe the order of target positions in the robot path data, not just individual target positions. Therefore, the robot simulation engine 110 can divide the various instances of "Target.loc1" into different, non-identical simulation events based on the order of target positions before or after each instance of "Target.loc1".

[0040] exist Figure 2 In the embodiment of the present invention, the robot simulation engine 110 divides the robot path data 210 into simulation events according to the event division criteria 220 that specifies the "fine-to-fine" requirement for the target area data. In doing so, the robot simulation engine 110 groups the target locations into simulation events 230, which include Figure 2 In this example, the robot simulation engine 110 groups the target positions and corresponding motion parameters in the robot path data 210 so that each divided simulation event starts and / or ends with a target position whose corresponding target area data value is "fine".

[0041] To further explain Figure 2 According to the example "fine-to-fine" requirement division shown in , the robot simulation engine 110 can start from the first target position and then group the consecutive target positions of the robot path data 210 into simulation events based on whether the target area data of the first target position specifies to reach the target position precisely (the target area data has a "fine" value) or specifies to reach the area around the target position (the target area data has a non-"fine" value).

[0042] When the target area data of the first target position under consideration for a simulation event has a non-"fine" value (e.g., when the only condition of the fine-to-fine requirement is the ending target area data with a "fine" value), the robot simulation engine 110 may group each consecutive target position in the robot path data 210 together into a simulation event until reaching a target position whose target area data has a "fine" value. The robot simulation engine 110 may also group this ending target position whose target area data has a "fine" value into a simulation event.

[0043] When the target area data of the first target position under consideration for a simulation event has a "fine" value, the robot simulation engine 110 may consider the next target position in the robot path data 210. If the target area data of the next target position has a non-"fine" value, the robot simulation engine 110 may group the next target position and each subsequent target position in the robot path data 210 into a simulation event until a target position whose target area data is a "fine" value is reached. As similarly described above, the robot simulation engine 110 may also group the ending target position whose target area data is a "fine" value into the simulation event. Figure 2 Simulation events 231 and 233 in FIG. 1 show examples of simulation events divided in this manner. Conversely, if the target area data for the next target position under consideration for a simulation event has a value of "fine", the robot simulation engine 110 may divide the first target position into its own simulation event without other target positions and treat the next target position as part of another simulation. Figure 2 An example of this can be seen in simulation event 232 in , where the robot simulation engine 110 separates a single target location into its own simulation event.

[0044] In some embodiments, the division of simulation events by the robot simulation engine 110 may include supplementing a given simulation event with additional data related to the given simulation event. The nature and details of the data supplementation may be specified by the event division criteria 220. By doing so, the robot simulation engine 110 may ensure the generation of a unique simulation signature key that may account for motion parameters inherited from a target position before or after one or more target positions that are divided into a given simulation event. For example, the robot simulation engine 110 may supplement a given simulation event to inherit selected motion parameters extracted from one or more target positions before or after a given simulation event, for example, to account for a target position ordering by supplementing a given simulation event with such additional data that specifies a target position (or order of target positions) that immediately precedes or follows a given simulation event.

[0045] To provide a detailed description, the robot simulation engine 110 may supplement the simulation events that are divided into individual target locations (e.g., from Figure 2 The robot simulation engine 110 may use the previous target position data (in this case, the ending target position of the previous simulation event 231) to supplement the simulation event 232 as part of the partitioning process. As another example, the robot simulation engine 110 may use the subsequent target position data (in this case, the initial target position of the subsequent simulation event 233) to supplement the simulation event 232 itself.

[0046] By adding the previous target position data to the given simulation event, the robot simulation engine 110 can ensure that the divided simulation event 232 (as supplemented) is distinguished from another simulation event, which has the same target position and motion parameters as the simulation event 232 but has different previous target position data or subsequent target position data. Since the different previous position data for these simulation events can produce different motion planning data, the robot simulation engine 110 can ensure that different simulation signature keys are generated for these simulation events by adding the previous target position data. In a similar manner, the robot simulation engine 110 can supplement a given simulation event with any number of additional or alternative motion parameters from previous or subsequent simulation events or target positions relative to the given simulation event (e.g., previous robot configuration data, subsequent robot velocity data, etc.).

[0047] The robot simulation engine 110 may selectively supplement the simulation events with additional data according to the event partitioning criteria 220. For example, the event partitioning criteria 220 may specify that the robot simulation engine 110 supplements each simulation event that is partitioned into a single target location with additional data, but does not supplement the partitioned simulation events with multiple target locations. In other examples, the event partitioning criteria 220 may specify that the robot simulation engine 110 supplements the simulation events with target locations exceeding a threshold number, otherwise no supplementation will be performed. Other supplementation conditions may be specified or configured by the user according to the event partitioning criteria 220.

[0048] In any manner described herein, the robot simulation engine 110 may divide the robot path data into simulation events, and the robot simulation engine 110 may generate a simulation signing key from (for) the simulation events.

[0049] Figure 3 2 shows an example of generating a simulation signature key by the robot simulation engine 110 and inserting an entry into the motion planning cache 120. The robot simulation engine 110 may generate a simulation signature key for some or all of the simulation events divided from the robot path data. Figure 3 In the example shown in , the robot simulation engine 110 generates a simulation signing key 310 for the example simulation event 231 .

[0050] The robot simulation engine 110 can generate the simulation signature key 310 in any manner that uniquely represents the sequence of target positions and the specific motion parameters of the simulation event 231. That is, the simulation signature key 310 can be generated so that it is different from any simulation signature key generated for other simulation events with any different (additional or alternative) target positions, different corresponding motion parameters, or both. In some embodiments, the robot simulation engine 110 generates the simulation signature key 310 as a string or concatenation of the values ​​of the simulation event 231 itself (or a selected subset thereof). In other embodiments, the robot simulation engine 110 uses the simulation event 231 as an input (e.g., as a string or concatenation of the values ​​of the simulation event 231 or a selected subset thereof) to apply a key generation function (e.g., a hash value function or other suitable key function).

[0051] In a consistent manner, the robot simulation engine 110 can generate simulation signature keys for the divided simulation events. The simulation signature keys can provide a control mechanism through which the robot simulation engine 110 can obtain motion planning data through simulation or cache lookup. Therefore, the robot simulation engine 110 can use the simulation signature key 310 generated for the simulation event 231 to obtain motion planning data for the simulation event 231 from different sources.

[0052] For example, the robot simulation engine 110 may query the motion plan cache 120 using the simulation signature key 310 as a lookup value. When the motion plan cache 120 includes an entry for the simulation signature key 310, the robot simulation engine 110 may retrieve and use the cached motion plan data for the simulation event 231 from the motion plan cache 120. When the motion plan cache 120 does not include an entry for the simulation signature key 310 (which is for Figure 3), the robot simulation engine 110 may obtain motion planning data for the simulation event 231 through robot simulation.

[0053] like Figure 3 As shown in , the robot simulation engine 110 can provide the simulation event 231 (or part thereof) as input to the simulator 320, which can be any robot simulator that simulates or generates robot motion from the robot path data input. The simulator 320 can take the form of an RRS simulator and thus generate motion planning data via any number of robot simulation techniques or motion planning algorithms. As output, the simulator 320 can generate motion planning data 330 for the simulation event 231.

[0054] When obtaining the motion planning data 330 simulated by the simulator 320 for the simulation event 231, the robot simulation engine 110 may associate the obtained motion planning data 330 with the simulation signature key 310 to support subsequent reuse. For example, the robot simulation engine 110 may form a cache entry 340 for the motion planning cache, which pairs the generated simulation signature key 310 for the simulation event 231 with the obtained motion planning data 330 for the simulation event 231. Then, the robot simulation engine 110 may insert the cache entry 340 into the motion planning cache 120 for subsequent access and reuse. Next, Figure 4 An example of such subsequent access and reuse is shown in .

[0055] Figure 4 An example of searching the motion plan cache 120 by the robot simulation engine 110 is shown. Figure 4 The example search depicted in the example can be found in the insert Figure 3 The cache entry 340 of the simulated signing key 310 described in .

[0056] exist Figure 4 In the example of FIG. 1 , the robot simulation engine 110 accesses additional robot path data 410, which may be Figure 2 The robot simulation engine 110 may divide the additional robot path data 410 into simulation events 430 according to the event division criteria 220. The simulation events 430 may include: Figure 4 The additional simulation event 431 shown in FIG. 4 is related to Figure 2431. Thus, the key generation for the additional simulation event 431 by the robot simulation engine 110 may result in a simulation signing key 310 that matches (e.g., is the same as) the simulation signing key 310 generated for the simulation event 231. This makes sense because the simulation event 231 is the same as the additional simulation event 431, thereby resulting in the generation of the same simulation signing key.

[0057] The robot simulation engine 110 may obtain the motion planning data for the additional simulation event 431 by using the simulation signature key 310. To do this, the robot simulation engine 110 may perform a query in the motion planning cache 120 using the simulation signature key 310 as a lookup value. In this case, the lookup may result in a hit because the cache entry 340 was previously inserted into the motion planning cache 120 by the robot simulation engine 110. Therefore, the robot simulation engine 110 may access the motion planning data 330 for the additional simulation event 431 from the motion planning cache 120, and do so instead of simulating the robot based on the additional simulation event 431 from the additional robot path data 410.

[0058] In some embodiments, the robot simulation engine 110 may modify selected portions of the motion plan data 330 retrieved from the motion plan cache 120. The robot simulation engine 110 may do this to account for any data or elements of the motion plan data 330 that differ between different simulation iterations. For example, because the cached motion plan data 330 may specify counter data or other tracking parameters from a previous simulation iteration, the robot simulation engine 110 may increment counter data or other tracking parameters indicating how many times a particular target position was reached during the simulation. To perform such modifications, the robot simulation engine 110 may separately maintain or track counts or other event-type information during the simulation, and modify or insert any such values ​​that are applicable to the particular simulation iteration for the motion plan data 330.

[0059] To provide an illustrative example, some robot simulations track or generate messages when a target position is reached during simulation, such as an event ID that changes (e.g., increases) each time a particular target position is reached during simulation. In some embodiments, the event ID may also be bound to a current target ID (currentTargetID), which indicates the current target position reached during simulation. In such a case, the motion planning data 330 stored in the motion planning cache 120 may register or include an event ID bound to an initial simulation iteration (e.g., as obtained by the robot simulation of the simulation event 231 using the simulator 320) during which the motion planning data 330 was generated.

[0060] To modify the motion planning data 330 for a subsequent simulation iteration in which the robot simulation engine 110 uses the cached motion planning data 330 instead of robot simulation, the robot simulation engine 110 may increase, adjust, modify, or insert any affected eventID or currentTargetID values ​​to appropriately reflect the current simulation iteration. The robot simulation engine 110 may offset the eventID by a number of simulation iterations previously performed or by a number of times a particular target position was previously reached. In addition, the robot simulation engine 110 may increase the offset eventID as each target position is reached during simulation.

[0061] To support such modifications, the robot simulation engine 110 may track the number of simulation iterations performed for a specific simulation signature key, whether by using the simulator or retrieving the motion planning data from the motion planning cache 120. In some examples, the robot simulation engine 110 may maintain a separate mapping, counter, or other data structure to appropriately track such motion planning data or other simulation data that is affected by or distinguishes between consecutive simulation iterations of matching simulation events. Additionally or alternatively, the robot simulation engine 110 may track global counters, variables, or data that is increased or changed during simulation, whether for matching or distinguishing between simulation events. In this way, the robot simulation engine 110 may modify selected portions of the obtained motion planning data.

[0062] In some examples, the robot simulation engine 110 may determine that the motion plan cache 120 does not include an entry for the generated simulation signature key for the additional simulation event, for example, in response to a lookup miss in the motion plan cache 120. In such an example, the robot simulation engine 110 may simulate the robot according to the additional simulation event to obtain motion planning data for the additional simulation event, and insert an entry into the motion plan cache 120 that pairs the simulation signature key for the additional simulation event with the motion planning data for the additional simulation event obtained through the simulation.

[0063] Therefore, the robot simulation engine 110 can generate and use a simulation signing key to efficiently and securely use cached motion planning data.

[0064] Different operating modes may support various lookup and simulation sequences by the robot simulation engine 110. In some examples, the robot simulation engine 110 operates in a "dynamic lookup" mode in which the robot simulation engine 110 performs a lookup in the motion plan cache 120 and subsequent cache entry retrieval or robot simulation based on the lookup results.

[0065] In other examples, the robot simulation engine 110 may support "active simulation" and "inactive simulation" modes. In the "active simulation" mode (also referred to as "recording mode"), the robot simulation engine 110 may divide the robot path data into simulation events and provide each divided simulation event to the simulator 320 for robot simulation. The generated simulation signature key and the motion planning data obtained from the robot simulation are stored in the motion planning cache 120. In this "active simulation" mode, the simulator 320 may always be used to generate motion planning data and fill the motion planning cache 120.

[0066] In the inactive simulation mode, the robot simulation engine 110 may use the simulator 320 to obtain motion planning data, for example, by generating a simulation signature key and retrieving the motion planning data using the motion planning cache 120. When a lookup miss occurs in the motion planning cache 120 during the "inactive simulation mode", the robot simulation engine 110 may return an error message to the user, or in some embodiments, activate or access the simulator 320 for simulation.

[0067] Such "activate simulation" and "inactivate simulation" modes can be supported to control the use of simulator 320. Since robot simulation may be costly and computationally expensive, setting different operation modes can allow robot simulation engine 110 to specifically control the activation use (or disable use) of the simulator, and even support robot movement planning and simulation without using the simulator in "inactivate simulation" mode. Different workstations or clients in a CAM environment can share the use of robot simulators, and such operation modes can promote the effective allocation of simulation resources. For example, a CAM system or robot simulation engine 110 can support the export or import of motion planning cache 120 to support "offline" robot simulation using previously obtained motion planning data. Therefore, even when simulator 320 is unavailable, inactive, disconnected or otherwise inaccessible (e.g., there is no available site license for current use), such robot simulation is possible.

[0068] Figure 5 An example of logic 500 is shown, which a system may implement to support the generation and use of a simulation signing key for a robot simulation. For example, the system 100 may implement the logic 500 as hardware, executable instructions stored on a machine-readable medium, or a combination of both. The system 100 may implement the logic 500 via a robot simulation engine 110, through which the system 100 may execute or implement the logic 500 as a method for generating and using a simulation signing key for a robot simulation. The following description of the logic 500 is provided using the robot simulation engine 110 as an example of an implementation. However, various other implementation options of the system are possible.

[0069] In implementing the logic 500, the robot simulation engine 110 may access robot path data for a robot (502) and divide the robot path data into simulation events according to the event division criteria (504). For each given simulation event divided from the robot path data, the robot simulation engine 110 may generate a simulation key (506). In some embodiments, the robot simulation engine 110 may generate a simulation signature key for a given simulation event by hashing a selected subset of one or more target positions and corresponding motion parameters for the given simulation event. Hashing the selected subset may include hashing a concatenation of robot configuration data, robot position data, one or more target positions, target area data, robot velocity data, and robot motion type data for the given simulation event.

[0070] The robot simulation engine 110 may determine whether there is an entry in the motion planning cache 120 for the generated simulation signature key for the given simulation event (508). If there is no entry, the robot simulation engine 110 may obtain motion planning data for the given simulation event by simulating the robot according to the given simulation event (510). This may include using an RRS simulator that uses the given simulation event as an input for simulating and generating motion planning data. In such a case, the robot simulation engine 110 may insert an entry into the motion planning cache 120, pairing the generated simulation signature key for the given simulation event with the obtained motion planning data (512).

[0071] If an entry for the generated simulation signing key exists in the motion plan cache 120, the robot simulation engine 110 may obtain the motion plan data for the given simulation event from the motion plan cache rather than through simulation (514). In some implementations, the robot simulation engine 110 may also modify selected portions of the motion plan data to account for multiple simulation iterations, such as via any of the modification or insertion techniques described herein (516).

[0072] Although through Figure 5 An example implementation is shown, but the logic 500 may also include any number of additional or alternative steps. Additionally or alternatively, the logic 500 may implement any other robot simulation features described herein, such as any robot simulation features with respect to the robot simulation engine 110 .

[0073] Figure 6 An example of a system 600 is shown that supports the generation and use of simulation signing keys for robot simulation. The system 600 may include a processor 610, which may take the form of a single processor or multiple processors. The processor 610 may include a central processing unit (CPU), a microprocessor, or any hardware device suitable for executing instructions stored on a machine-readable medium. The system 600 may include a machine-readable medium 620. The machine-readable medium 620 may take the form of any non-transitory electronic, magnetic, optical, or other physical storage device that stores executable instructions, such as Figure 6 As such, for example, the machine-readable medium 620 may be a random access memory (RAM) such as a dynamic RAM (DRAM), a flash memory, a spin transfer torque memory, an electrically erasable programmable read-only memory (EEPROM), a storage drive, an optical disk, or the like.

[0074] The system 600 may execute instructions stored on the machine-readable medium 620 via the processor 610. Execution of the instructions may cause the system 600 (or any other CAD system) to perform any of the robot simulation features described herein, including any features according to the robot simulation engine 110.

[0075] For example, execution of the robot simulation instruction 622 by the processor 610 enables the system 600 to: access robot path data for the robot; divide the robot path data into simulation events according to an event division criterion, so that each simulation event includes a sequence of one or more target positions and corresponding motion parameters; and for each given simulation event of the robot path data, generate a simulation signature key for the given simulation event using the sequence of one or more target positions and corresponding motion parameters for the given simulation event, obtain motion planning data for the given simulation event by simulating the robot according to the given simulation event and inserting an entry into the motion planning cache, and pair the simulation signature key for the given simulation event with the obtained motion planning data for the given simulation event.

[0076] The execution of the robot simulation instructions 622 by the processor 610 can also enable the system 600 to: access additional robot path data for the robot; divide the additional robot path data into additional simulation events according to the event division criteria; and for each additional simulation event of the additional robot path data: generate a simulation signature key for the additional simulation event; and when the simulation signature key for the additional simulation event is already stored in the motion planning cache, obtain the motion planning data for the additional planning event from the motion planning cache.

[0077] The above-described systems, methods, apparatuses, and logic, including the robot simulation engine 110, may be implemented in many different ways in many different combinations of hardware, logic, circuitry, and executable instructions stored on a machine-readable medium. For example, the robot simulation engine 110 may include circuitry in a controller, microprocessor, or application-specific integrated circuit (ASIC), or may be implemented using a combination of discrete logic or components or other types of analog or digital circuitry combined on a single integrated circuit or distributed among multiple integrated circuits. A product, such as a computer program product, may include a storage medium and machine-readable instructions stored on the medium that, when executed in an endpoint, computer system, or other device, cause the device to perform operations according to any of the above descriptions, including according to any of the features of the robot simulation engine 110.

[0078] The processing capabilities of the systems, devices, and engines (including the robot simulation engine 110) described herein may be distributed among multiple system components, such as among multiple processors and memories, and the systems, devices, and engines (including the robot simulation engine 110) may optionally include multiple distributed processing systems or cloud / network elements. Parameters, databases, and other data structures may be stored and managed separately, may be merged into a single memory or database, may be logically and physically organized in many different ways, and may be implemented in many ways, including data structures (such as linked lists), hash tables, or implicit storage mechanisms. Programs may be separate programs, parts of a single program (e.g., subroutines) distributed among multiple memories and processors, or implemented in many different ways, such as in a library (e.g., a shared library).

[0079] Although various examples have been described above, many more implementations are possible.

Claims

1. A method for supporting generation and use of a simulation signing key for robot simulation, comprising: accessing (502) robot path data (210) for a robot, the robot path data (210) comprising a target position and corresponding motion parameters for the robot; Dividing (504) the robot path data (210) into simulation events (230) according to an event division criterion (220), such that each simulation event (231, 232, 233) includes one or more target positions and corresponding motion parameters; and For a given simulation event (231), generating (506) a simulation signing key (310) for the given simulated event (231) using the one or more target positions and corresponding motion parameters for the given simulated event (231); Simulating the robot according to the given simulation event (231) to output motion planning data (330) for the given simulation event; By performing the simulation on the robot according to the given simulation event (231), the motion planning data (330) for the given simulation event (231) output by the simulation is obtained (510); and Associating the simulation signature key (310) for the given simulation event (231) with the obtained motion planning data (330) for the given simulation event (231), comprising: inserting (512) an entry (340) into a motion planning cache (120), the entry (340) pairing the simulation signature key (310) for the given simulation event (231) with the obtained motion planning data (330) for the given simulation event (231), and After simulating the robot according to the given simulation event (231) and inserting the entry (340) into the motion planning cache (120): accessing additional robot path data (410) for the robot, the additional robot path (410) being different from the robot path of the robot; Dividing the additional robot path data (410) into simulation events (430) including additional simulation events (431) according to the event division standard (220); generating a simulation signature key (310) for said additional simulation event (431) for said additional robot path data (410); determining that the simulation signature key (310) generated for the additional simulation event (431) matches the simulation signature key (310) generated for the given simulation event (231) of the robot path data (210); and Accessing motion planning data (330) for the additional simulation event (431) obtained from the motion planning cache (120) instead of simulating the robot based on the additional simulation event (431) for the additional robot path data (410) for the robot different from the robot path of the robot.

2. The method according to claim 1, characterized in that The simulation events divided for the additional robot path data include another additional simulation event different from the additional simulation event, and further include: after simulating the robot according to the given simulation event (231) and inserting the entry (340) into the motion planning cache (120): generating a simulation signature key for the further additional simulation event for the additional robot path data; determining that the motion plan cache does not include an entry for the simulation signing key generated for the another additional simulation event; and simulating the robot according to the other additional simulation event to obtain motion planning data for the additional simulation event; and An entry is inserted into the motion plan cache (120), the entry pairing the simulation signature key for the further additional simulation event with the motion plan data for the further additional simulation event obtained through simulation.

3. The method according to claim 1, further comprising: Prior to inserting the entry (340) into the motion plan cache (120): Selected portions of the obtained motion planning data (330) for the given simulated event (231) are modified to account for multiple simulation iterations of the given simulated event (231).

4. The method according to claim 1, characterized in that: Generating the simulation signature key (310) for the given simulation event (231) comprises: A selected subset of the one or more target positions and corresponding motion parameters for the given simulation event (231) is hashed.

5. The method according to claim 4, characterized in that Hashing the selected subset includes hashing a concatenation of the robot configuration data, the one or more target positions, target area data, robot velocity data, and robot motion type data for the given simulation event (231).

6. The method according to claim 1, characterized in that The dividing of the robot path data (210) into simulation events (230) according to the event division criteria (220) is based on target area data in the robot path data (210), the target area data specifying whether the robot reaches a given target position by precisely reaching the given target position or by reaching an area around the given target position; as well as The robot path data (210) is divided into simulation events (230), so that each of the simulation events ends with a target position that the robot is to reach accurately as specified by the target area data.

7. A system (100) for supporting generation and use of a simulation signing key for robot simulation, comprising: Motion Planning Cache (120); as well as A robot simulation engine (110) is configured to: accessing robot path data (210) for a robot, the robot path data (210) comprising a target position and corresponding motion parameters for the robot; Dividing the robot path data (210) into simulation events (230) according to an event division standard (220), so that each simulation event (231, 232, 233) includes one or more target positions and corresponding motion parameters; as well as For each given simulation event (231) of the robot path data (210), generating a simulation signature key (310) for the given simulated event (231) using one or more target positions and corresponding motion parameters for the given simulated event (231); In response to determining that the motion plan cache (120) already includes an entry (340) for the simulation signing key (310) generated for the given simulation event (231): obtaining motion plan data (330) for the given simulation event (231) from the entry (340) for the simulation signature key (310) already stored in the motion plan cache (120); and In response to determining that the motion plan cache (120) does not include an entry for the simulation signing key (310) generated for the given simulation event (231): Simulating the robot according to the given simulation event (231) to output motion planning data (330) for the given simulation event; Obtaining motion planning data (330) for the given simulation event output by simulating the robot according to the given simulation event (231); and Inserting an entry (340) into the motion planning cache (120), the entry (340) pairing the simulation signature key (310) for the given simulation event (231) with the motion planning data (330) for the given simulation event (231) obtained by simulating the robot according to the given simulation event (231); accessing additional robot path data for the robot (410); Dividing the additional robot path data (410) into simulation events (430) according to the event division standard (220); generating a simulation signature key (310) for each of said simulation events (431) of said additional robot path data (410); as well as When the simulation signature key (310) is already stored in the motion planning cache (120), the motion planning data (330) for the simulation event (431) of the additional robot path data (410) is obtained from the motion planning cache (120), rather than simulating the simulation event of the additional robot path data when the simulation signature key (310) is already stored in the motion planning cache (120).

8. The system (100) according to claim 7, characterized in that The robot simulation engine (110) is configured to, for each specific simulation event of the additional robot path data, when the simulation signature key of each specific simulation event is not stored in the motion planning cache: Simulating the robot according to the specific simulation event to obtain motion planning data as an output of simulating the robot according to the specific simulation event (231); as well as An entry is inserted into the motion plan cache (120): the entry pairing the simulation signature key for the specific simulation event with the obtained motion plan data for the specific simulation event.

9. The system (100) according to claim 7, characterized in that The event classification criteria (220) are based on target area data in the robot path data (210), the target area data specifying whether the robot reaches the given target position by reaching the given target position precisely or by reaching an area around the given target position.

10. The system (100) according to claim 9, characterized in that The robot simulation engine (110) is configured to divide the robot path data (210) into the simulation events (230), so that each of the simulation events (231, 232, 233) ends with a target position that the robot is to reach accurately as specified by the target area data.

11. The system (100) according to claim 9, characterized in that The robot simulation engine (110) is configured to divide the simulation events into a sequence such that at least one of the simulation events (230) includes a plurality of target positions and corresponding motion parameters.

12. A non-transitory machine-readable medium (620) comprising processor-executable instructions (622) which, when executed, cause a system to perform the method according to any one of claims 1 to 6.

Images