Robot control device and control method thereof

Abstract

Apparatus and method for controlling robot to improve reusability and compatibility of action tree SOLUTION: The at least one processor is configured to acquire a standard behavior tree satisfying a target standard from a behavior tree based on a behavior tree abstraction model applied to interpretation of the behavior tree, store a robot scenario paired with the standard behavior tree and the standard behavior tree in the memory, and verify validity of the standard behavior tree based on nodes included in the standard behavior tree and edges between the nodes included in the standard behavior tree.SELECTED DRAWING: Figure 1

Description

[Technical Field]

[0001] The present invention relates to a robot control device and a control method thereof, and more particularly to a technique for standardizing a behavior tree. [Background technology]

[0002] When a robot tries to perform a task, the contents that must be executed from start to finish are called a robot behavior scenario. A robot behavior scenario is expressed using various methodologies such as Finite State Machines (FSM), Hierarchical Finite State Machines (HFSM), and Behavior Tree (BT).

[0003] As the number of service robot developers continues to grow, each robot developer is developing its own unique methodology for developing robot behavior scenarios. One of the most common methodologies for designing robot behavior scenarios is the behavior tree. A behavior tree is a method of expressing behavior scenarios in a tree structure by dividing detailed behavior units into nodes and connecting the nodes in the order in which they should be performed.

[0004] When implementing a behavior tree, robot developers use libraries appropriate for their own development language, development environment, and development purpose. When robot developers try to define a robot behavior tree using different libraries, there is no standardized way to represent a robot behavior tree, so they mainly use JSON or XML data formats to represent the behavior tree in their own proprietary standards.

[0005] Therefore, when expressing an action tree, data formats such as JSON or XML are used, or the data structure is expressed differently depending on how the components are defined in a specific data format. JSON and XML are standard data formats, but when expressing an action tree, robot developers configure the internal structure of JSON or MXL according to their own proprietary standards. As a result, a standardized interpreter cannot exist, and the same action tree is expressed using various data standards, resulting in reduced reusability, compatibility, and development efficiency.

[0006] To solve these problems, it is necessary to develop an effective method or technique for expressing behavior trees in a specific format. [Prior art documents] [Patent documents]

[0007] [Patent Document 1] International Publication No. 2017 / 148830 Summary of the Invention [Problem to be solved by the invention]

[0008] The present invention has been made in consideration of the above-mentioned problems in the conventional art, and an object of the present invention is to provide a robot control device and method therefor that improves the reusability and compatibility of behavior trees. [Means for solving the problem]

[0009] In order to achieve the above object, one aspect of the present invention provides a robot control device comprising: a memory storing computer-executable instructions; and at least one processor that accesses the memory and executes the instructions. The at least one processor acquires a standard behavior tree that satisfies a target specification from a behavior tree based on a behavior tree abstraction model applied to interpretation of the behavior tree, stores a robot scenario paired with the standard behavior tree and the standard behavior tree in the memory, and verifies the validity of the standard behavior tree based on the nodes included in the standard behavior tree and the edges between the nodes included in the standard behavior tree.

[0010] The at least one processor may obtain, from the behavior tree abstraction model, a first parameter related to the type of node included in the behavior tree and a second parameter related to each attribute of the node included in the first parameter and included in the behavior tree, and apply the first parameter and the second parameter to the behavior tree to obtain the standard behavior tree. The at least one processor may identify a root node included in the behavior tree by acquiring the first parameter and the second parameter, identify child nodes included in the behavior tree by recursively searching the behavior tree based on the root node, acquire the type of the target node by applying the first parameter to at least one target node among the child nodes included in the behavior tree, and acquire the attributes of the target node by applying the second parameter to the target node. The at least one processor may generate a standard node by combining the type of the target node and the attributes of the target node according to the target standard, and may obtain the standard behavior tree by connecting the standard node to the root node. If the at least one processor is unable to obtain the type of the target node or is unable to obtain the attributes of the target node, it may identify a predetermined exception handling conversion model and obtain the type of the target node or the attributes of the target node through the exception handling conversion model. The at least one processor may load the standard behavior tree stored in the memory, display the nodes included in the loaded standard behavior tree and the edges between the nodes included in the loaded standard behavior tree as a plurality of icons on an interface that is the basis for a user's operation of editing the standard behavior tree, and may perform changes to the standard behavior tree when receiving input for each of a first icon related to a node or a second icon related to an edge among the plurality of icons. The at least one processor may obtain the behavior tree from the standard behavior tree based on the behavior tree abstraction model. If the validity of the standard behavior tree is verified, the at least one processor may control the robot by applying the behavior tree to the robot that performs the robot scenario. The at least one processor may identify a first node that is a root node among the nodes included in the standard behavior tree, identify a second node that is a child node among at least one node connected to the first node, verify the validity of the first node based on the type of the first node and the number of the second nodes, and verify the validity of each node included in the standard behavior tree by recursively searching the standard behavior tree based on the first node.

[0011] In order to achieve the above-mentioned object, one aspect of the present invention provides a robot control method, which includes the steps of: acquiring a standard behavior tree that satisfies a target specification from a behavior tree based on a behavior tree abstraction model applied to the interpretation of the behavior tree; storing a robot scenario paired with the standard behavior tree and the standard behavior tree in memory; and verifying the validity of the standard behavior tree based on the nodes included in the standard behavior tree and the edges between the nodes included in the standard behavior tree.

[0012] The step of obtaining the standard behavior tree may include a step of obtaining, from the behavior tree abstraction model, a first parameter related to the type of node included in the behavior tree and a second parameter related to each attribute of the node included in the first parameter and included in the behavior tree, and a step of applying the first parameter and the second parameter to the behavior tree to obtain the standard behavior tree. The step of acquiring the standard behavior tree may include a step of identifying a root node included in the behavior tree by acquiring the first parameter and the second parameter; a step of identifying child nodes included in the behavior tree by recursively searching the behavior tree based on the root node; a step of acquiring the type of the target node by applying the first parameter to at least one target node among the child nodes included in the behavior tree; and a step of acquiring the attribute of the target node by applying the second parameter to the target node. The step of obtaining the standard behavior tree may include the steps of: generating a standard node by combining the type of the target node and the attribute of the target node according to the target standard; and obtaining the standard behavior tree by connecting the standard node to the root node. The step of acquiring the standard behavior tree may include, if the type of the target node cannot be acquired or the attributes of the target node cannot be acquired, identifying a predetermined exception handling conversion model, and acquiring the type of the target node or the attributes of the target node through the exception handling conversion model. The step of storing the standard behavior tree in the memory may include the steps of: loading the standard behavior tree stored in the memory; displaying nodes included in the loaded standard behavior tree and edges between nodes included in the loaded standard behavior tree as a plurality of icons on an interface that serves as a basis for a step of a user editing the standard behavior tree; and, when an input is received for each of a first icon related to a node or a second icon related to an edge among the plurality of icons, modifying the standard behavior tree. The robot control method may further include a step of obtaining the behavior tree from the standard behavior tree based on the behavior tree abstraction model. The step of acquiring the behavior tree may include, if the validity of the standard behavior tree is verified, controlling the robot by applying the behavior tree to the robot that performs the robot scenario. The step of verifying the validity of the standard behavior tree may include a step of identifying a first node that is a root node among the nodes included in the standard behavior tree; a step of identifying a second node that is a child node among at least one node connected to the first node; a step of verifying the validity of the first node based on the type of the first node and the number of the second nodes; and a step of verifying the validity of each node included in the standard behavior tree by recursively searching the standard behavior tree based on the first node. [Effects of the Invention]

[0013] The advantages of the robot control device and method according to the present invention will be described as follows.

[0014] According to the present invention, by converting and / or acquiring an identified behavior tree for controlling a robot into a standard behavior tree, it is possible to provide robot developers or users with improved development efficiency and to improve the reusability and compatibility of behavior trees.

[0015] In addition, various other effects are provided that are grasped directly or indirectly through this specification. [Brief explanation of the drawings]

[0016] [Figure 1] FIG. 1 is a block diagram of a robot control device according to an embodiment of the present invention. [Figure 2] 1 is a flowchart illustrating a robot control method according to an embodiment of the present invention. [Figure 3] FIG. 10 is a diagram showing an example of an operation for generating a standard behavior tree in a robot control device according to an embodiment of the present invention. [Figure 4] 1A and 1B are diagrams illustrating an example of a behavior tree, a behavior tree abstraction model, and a standard behavior tree. [Figure 5] FIG. 2 is a diagram showing an example of a database stored in a memory in the robot control device according to the embodiment of the present invention. [Figure 6] 3 is a diagram showing an example of an interface provided to a user when a program including code or instructions for performing the operations of FIG. 2 is executed. [Figure 7] 1 is a flowchart illustrating a method for acquiring a standard behavior tree in a robot control device according to an embodiment of the present invention. [Figure 8] FIG. 10 is a diagram showing an example of a behavior tree converted according to a target standard. [Figure 9] 1 is a diagram illustrating a computer system relating to a robot control device or a robot control method according to an embodiment of the present invention. DETAILED DESCRIPTION OF THE INVENTION

[0017] Hereinafter, specific examples of embodiments of the present invention will be described in detail with reference to the drawings.

[0018] When assigning reference numerals to components in each drawing, it should be noted that the same numerals are used for the same components whenever possible, even if they appear in different drawings. Furthermore, when describing embodiments of the present invention, if a detailed description of related known structures or functions is deemed to obscure understanding of the present invention, such detailed description will be omitted. In particular, various embodiments of the present specification will be described with reference to the drawings. However, this is not intended to limit the technology described herein to a specific embodiment, but should be understood to include various modifications, equivalents, and / or alternatives of the embodiments of the present invention. In describing the drawings, similar reference numerals are used to refer to similar components.

[0019] When describing components of embodiments of the present invention, terms such as "first," "second," "A," "B," "(a)," and "(b)" are used. These terms are intended only to distinguish the component from other components and do not limit the nature, order, or sequence of the components. Furthermore, unless otherwise defined, all terms used herein, including technical or scientific terms, have the same meaning as commonly understood by a person of ordinary skill in the art to which the present invention pertains. Terms defined in commonly used dictionaries should be interpreted as meanings consistent with the meanings they have in the context of the relevant art, and should not be interpreted as idealized or overly formal unless expressly defined herein. For example, terms such as "first," "second," "primary," or "secondary" used herein may modify various components regardless of order and / or importance, and are used only to distinguish one component from another, not to limit the corresponding component. For example, a first user device and a second user device refer to different user devices regardless of order or importance. For example, a first component may be named a second component, and similarly, a second component may be named instead of a first component, without departing from the scope of the invention as described herein.

[0020] In this specification, the terms "have," "can have," "include," or "can include" indicate the presence of a relevant feature (e.g., a value, function, operation, or component such as a part) and do not exclude the presence of additional features.

[0021] When referring to a component (e.g., a first component) being "operatively or communicatively coupled with" or "connected to" another component (e.g., a second component), it should be understood that the component is directly coupled to the other component or is coupled through another component (e.g., a third component). On the other hand, when referring to a component (e.g., a first component) being "directly coupled with" or "directly connected to" another component (e.g., a second component), it should be understood that there is no other component (e.g., a third component) between the component and the other component.

[0022] As used herein, the expression "configured to" may be used in place of, for example, "suitable for," "having the capacity to," "designed to," "adapted to," "made to," or "capable of," depending on the context.

[0023] The term "configured to" does not necessarily refer to hardware that is "specifically designed to." Instead, in some contexts, the phrase "device configured to" means that the device is "capable of" performing, in conjunction with other devices or components. For example, the phrase "a processor configured to perform A, B, and C" refers to either a dedicated processor (e.g., an embedded processor) for performing the operations, or a general-purpose processor (e.g., a CPU or application processor) that can perform the operations by executing one or more software programs stored in a memory device. The terms used herein are used merely to describe particular embodiments and are not intended to limit the scope of other embodiments. The singular includes the plural unless the context clearly dictates otherwise. Terms used herein, including technical or scientific terms, have the same meaning as commonly understood by one of ordinary skill in the art described herein. Among the terms used in this specification, terms defined in a general dictionary shall be interpreted to have the same or similar meaning as the meaning they have in the context of the related art, and shall not be interpreted to have an ideal or excessively formal meaning unless expressly defined in this specification. In some cases, even terms defined in this specification shall not be interpreted to exclude the embodiments of this specification.

[0024] As used herein, expressions such as "A or B," "at least one of A and / or B," or "one or more of A and / or B" include all possible combinations of the items listed together. For example, "A or B," "at least one of A and B," or "at least one of A or B" refer to all cases where (1) at least one A is included, (2) at least one B is included, or (3) at least one A and at least one B are included. Furthermore, when describing components of embodiments of the present invention, phrases such as "A or B," "at least one of A and B," "at least one of A or B," "A, B, or C," "at least one of A, B, or C," and "at least one of A, B, C, or any combination thereof" each include any one of the items listed together in the phrase, or all possible combinations thereof. In particular, a phrase such as "at least one of A, B, C, or any combination thereof" includes A or B or C or combinations thereof such as AB or ABC.

[0025] Hereinafter, an embodiment of the present invention will be described in detail with reference to FIGS.

[0026] FIG. 1 is a block diagram of a robot control device according to an embodiment of the present invention.

[0027] The robot controller 100 according to this embodiment includes a processor 110 and a memory 120 that includes an instruction word 122 .

[0028] The robot controller 100 refers to a device that controls a robot. For example, the robot controller 100 identifies a behavior tree to be applied to a robot in order to control the robot. The robot controller 100 converts and / or obtains the identified behavior tree into a standard behavior tree that satisfies a target standard. Illustratively, the robot controller 100 converts and / or obtains the behavior tree into a standard behavior tree that satisfies a target standard (e.g., XML standard) based on the structure of the behavior tree, which has layers.

[0029] The robot controller 100 converts and / or acquires a behavior tree into a standard behavior tree and stores the standard behavior tree in a database or memory 120. The robot controller 100 provides the standard behavior tree stored in the database or memory 120 via a GUI (Graphical User Interface)-based interface so that a user can edit the standard behavior tree. When a user edits the standard behavior tree, the robot controller 100 verifies the validity of the edited standard behavior tree. For example, the robot controller 100 verifies the validity of the edited standard behavior tree based on the nodes and edges between the nodes included in the edited standard behavior tree. However, the method by which the robot controller 100 verifies the validity of the standard behavior tree is not limited thereto. For example, the robot controller 100 converts and / or acquires a standard behavior tree from a behavior tree and then verifies the validity of the converted and / or acquired standard behavior tree. In this case, the validity verification of the converted and / or acquired standard behavior tree is the same as the method for verifying the validity of the edited standard behavior tree described above.

[0030] The robot controller 100 achieves the following effects by converting and / or acquiring an identified behavior tree into a standard behavior tree for controlling a robot. For example, the robot controller 100 improves development efficiency for a robot developer or user. Exemplarily, a robot developer or user can freely exchange and modify a robot scenario or behavior tree developed depending on a specific platform between platforms, thereby reducing the time required for developing a robot scenario or behavior tree. The robot controller 100 improves the reusability and compatibility of behavior trees. Exemplarily, the robot controller 100 increases the reusability of a robot scenario or behavior tree regardless of the development environment of various robot developers through a standard behavior tree that meets target standards. The robot controller 100 improves code quality. Exemplarily, the robot controller 100 provides standardized code (e.g., source code) by acquiring a standard behavior tree, and providing standardized code improves the quality of code management. The robot controller 100 provides a GUI that allows a user to edit the standard behavior tree, allowing not only behavior tree developers but also users to participate in the development of a behavior tree that can control a robot.

[0031] The processor 110 executes software to control at least one other component (e.g., a hardware or software component) coupled to the processor 110. The processor 110 also performs various other data processing or calculation operations. For example, the processor 110 stores a behavior tree or a standard behavior tree in the memory 120.

[0032] For reference, the processor 110 performs all operations performed by the robot controller 100. Therefore, for convenience of explanation, the operations performed by the robot controller 100 will be mainly described as operations performed by the processor 110 in this specification. Also, for convenience of explanation, the processor 110 will be mainly described as one processor in this specification, but is not limited thereto. For example, the robot controller 100 includes at least one processor. Each of the at least one processor performs all operations related to the operation of converting and / or acquiring a behavior tree into a standard behavior tree for controlling the robot.

[0033] The memory 120 temporarily and / or permanently stores various data and / or information required to perform operations of converting and / or acquiring a behavior tree into a standard behavior tree for controlling a robot. For example, the memory 120 stores a behavior tree, a standard behavior tree, etc.

[0034] The robot controller 100 further includes a communication unit. For example, the communication unit supports communication between the robot controller 100 and an external server. Exemplarily, the communication unit includes one or more components that enable communication between the robot controller 100 and the external server. Specifically, the communication unit includes a short-range wireless communication unit, a microphone, etc. In this case, short-range communication technologies include, but are not limited to, wireless LAN (Wi-Fi), Bluetooth (registered trademark), ZigBee (registered trademark), Wi-Fi Direct (WFD), ultra-wideband (UWB), infrared data association (IrDA), Bluetooth (registered trademark) Low Energy (BLE), and near field communication (NFC).

[0035] FIG. 2 is a flowchart illustrating a robot control method according to an embodiment of the present invention.

[0036] In step 210, a processor according to this embodiment (eg, processor 110 in FIG. 1) obtains a standard behavior tree that satisfies the target standard from the behavior tree based on a behavior tree abstraction model that is applied to interpret the behavior tree.

[0037] A behavior tree is a structured tree that shows how an autonomous agent changes a task. For example, a behavior tree includes internal nodes (i.e., control flow nodes) related to control flow and leaf nodes (i.e., execution nodes) related to execution. A behavior tree also includes multiple nodes. The multiple nodes include only one node with no parents and child nodes with one parent node that is a control flow node.

[0038] Illustratively, the control flow nodes include a sequence node, a fallback node, a parallel node, and a decorator node, and the execution nodes include an action node and a condition node.

[0039] A sequence node transmits ticks from the left side of its child nodes. If a child node transmits a failure or running, the sequence node transmits a failure or running to its parent node. That is, it transmits ticks in order from the left side of its child nodes. If a success occurs, it proceeds to the next child node. If a failure or running is returned, it does not transmit ticks to other child nodes and transmits the corresponding value to its parent node.

[0040] The fallback node transmits ticks from the left side of the child node. When the child node transmits success or running, the fallback node transmits success or running to the parent node. That is, it transmits ticks in order from the left side of the child node, but if a failure occurs, it proceeds to the next child node. If it returns success or running, it does not transmit ticks to other child nodes and transmits the corresponding value to its parent node.

[0041] A parallel node transmits a tick to all child nodes. A decorator node is a control flow node associated with one child node. For example, a decorator node adds specific rules for how the child node responds. For example, a decorator node creates a control flow node with a condition that returns failure if the child node fails N times, or a condition that the child node returns success within T seconds.

[0042] An action node executes a command. For example, an action node is a node that performs a specific action, such as opening an automatic door when moving to a destination or docking. An action node transmits "success" when a command is successful, "failure" when a command fails, and "running" when a command is being executed.

[0043] A condition node checks the current state and transmits success or failure. A condition node is used as a way to check the state of a specific variable or robot.

[0044] The behavior tree abstraction model is applied to interpreting a behavior tree. For example, the behavior tree abstraction model is a model for abstracting behavior trees developed in various formats by different robot developers into a standardized robot behavior scenario (e.g., a standard behavior tree). Specifically, the behavior tree abstraction model includes metadata for interpreting the nodes that make up the behavior tree.

[0045] The metadata includes at least one of a parameter related to the node type, a parameter related to an element for each node type, a parameter related to a name, or any combination thereof. For example, the metadata includes a first parameter related to the node type and a second parameter related to an attribute of the node. The second parameter includes a value for the node type and a name of the node. Specifically, the processor identifies the type of each node included in the behavior tree based on the first parameter included in the metadata. Then, the processor identifies the value and name of the node whose type has been identified based on the node and the second parameter. The processor generates a new node according to the target standard based on the node type, value, and name. The processor acquires a standard behavior tree by connecting the newly created nodes according to the target standard based on the connection relationships of the behavior tree.

[0046] The target standard includes at least one of the JSON (JavaScript Object Notation) standard, the XML (Extensible Markup Language) standard, or any combination thereof. For example, the target standard includes a standard predetermined by a robot developer or a user. For convenience of explanation, this specification will be described assuming that the target standard is the XML standard. In particular, detailed examples of the behavior tree, the behavior tree abstraction model, and the standard behavior tree will be described later with reference to FIG. 4 below.

[0047] The processor obtains a behavior tree from a standard behavior tree based on the behavior tree abstraction model. For example, the processor obtains a standard behavior tree from a behavior tree and simultaneously obtains a behavior tree from a standard behavior tree based on the behavior tree abstraction model. That is, the operation of obtaining a standard behavior tree from a behavior tree can be described as a transformation operation. In contrast, the operation of obtaining a behavior tree from a standard behavior tree can be described as an inverse transformation operation. The processor obtains a behavior tree from the standard behavior tree based on the first parameter and the second parameter.

[0048] When the user completes modification of the standard behavior tree via the GUI, the processor obtains an inverse transformation behavior tree from the modified standard behavior tree. For example, the processor obtains the standard behavior tree from the behavior tree (i.e., the first behavior tree) based on the behavior tree abstraction model. The processor obtains a modified standard behavior tree from the standard behavior tree in response to the user's modification. Here, the modified standard behavior tree indicates the standard behavior tree modified by the user. The processor obtains an inverse transformation behavior tree (i.e., the second behavior tree) from the modified standard behavior tree based on the behavior tree abstraction model. The processor performs control of the robot by applying the inverse transformation behavior tree to the robot.

[0049] In step 230, the processor stores the robot scenario paired with the standard behavior tree and the standard behavior tree in a memory (e.g., memory 120 in FIG. 1).

[0050] The processor verifies the validity of the standard behavior tree based on the nodes included in the standard behavior tree and the edges between the nodes included in the standard behavior tree in step 250. If the validity of the standard behavior tree is verified, the processor controls the robot by applying the behavior tree (i.e., the inverse transformation behavior tree) to the robot that executes the robot scenario.

[0051] FIG. 3 is a diagram showing an example of the operation of generating a standard behavior tree in a robot control device according to an embodiment of the present invention.

[0052] A processor according to this embodiment (e.g., processor 110 of FIG. 1) performs a first operation 310 related to behavior tree abstraction. For example, the first operation 310 indicates an operation in which behavior trees expressed in various data formats and data structures used by robot developers (e.g., developers A to D of FIG. 3) are input through an abstraction hierarchy. By performing the first operation 310, the processor identifies the behavior tree and the behavior tree abstraction model.

[0053] The processor performs a second operation 320 related to behavior tree interpretation. For example, the second operation 320 represents an operation of interpreting the contents of a behavior tree received as input via an abstraction hierarchy. Specifically, the processor acquires first and second parameters from the behavior tree abstraction model. The processor interprets the contents of the behavior tree based on the first and second parameters. That is, the operation of interpreting the contents of the behavior tree is the same as the operation of identifying the types and attributes of each node included in the behavior tree.

[0054] The processor acquires, from the behavior tree abstraction model, a first parameter related to the type of node included in the behavior tree and a second parameter related to each attribute of the node included in the first parameter and included in the behavior tree. The processor applies the first parameter and the second parameter to the behavior tree to acquire a standard behavior tree. The processor identifies a root node included in the behavior tree by acquiring the first parameter and the second parameter. The processor identifies child nodes included in the behavior tree by recursively searching the behavior tree based on the root node. The processor acquires the type of the target node by applying the first parameter to at least one target node among the child nodes included in the behavior tree, and acquires the attribute of the target node by applying the second parameter to the target node.

[0055] The processor performs a third operation 330 related to behavior tree transformation. For example, the third operation 330 may refer to rewriting and / or transforming each node included in the behavior tree interpreted based on the first and second parameters according to the target standard. A detailed description of the third operation 330 is provided below with reference to FIG. 7.

[0056] The processor generates a standard node by combining the type of the target node and the attributes of the target node according to the target standard (e.g., XML standard). That is, the standard node indicates a node whose type and attributes are created according to the target standard. The processor obtains a standard behavior tree by connecting the standard node to the root node. Specifically, the processor applies the operation of converting the target node to a standard node to all nodes included in the behavior tree.

[0057] If the processor is unable to acquire the type of the target node or the attributes of the target node, the processor identifies a predetermined exception handling conversion model. The processor acquires the type of the target node or the attributes of the target node through the exception handling conversion model. The exception handling conversion model includes metadata based on the exception handling conversion rules defined by the user.

[0058] The processor performs a fourth operation 340 related to identifying a standard behavior tree. For example, the fourth operation 340 may represent identifying a standard behavior tree obtained based on the first parameter and the second parameter. Here, the processor stores the robot scenario paired with the standard behavior tree and the standard behavior tree in a memory and / or a database. A detailed description of the format in which the standard behavior tree is stored in the database will be provided below with reference to FIG. 5.

[0059] The processor performs a fifth operation 350 related to editing the standard behavior tree. For example, the fifth operation 350 includes loading a standard behavior tree stored in a database, displaying the loaded standard behavior tree on an interface, and allowing a user to edit the standard behavior tree via the interface.

[0060] When a robot developer having a different development environment uses a behavior tree of a robot behavior scenario, the processor shares, edits, and generates the behavior tree through an abstraction process via the first operation 310 to the fifth operation 350. Exemplarily, the processor converts a behavior tree developed by robot developer A into a standard behavior tree and stores the standard behavior tree in a database. When robot developer B is a developer that develops robots in a development environment different from that of robot developer A, it develops a new robot by referring to the standard behavior tree acquired and / or converted from the behavior tree developed by robot developer A in the database. Also, when robot user C who purchased a robot uses a product of robot developer A, and robot user C wishes to change the robot behavior scenario to suit the environment, a behavior tree that is further customized according to the user environment is generated via an interface provided by the processor.

[0061] FIG. 4 is a diagram showing an example of a behavior tree, a behavior tree abstraction model, and a standard behavior tree.

[0062] A processor (eg, processor 110) according to this embodiment obtains a standard behavior tree 430 that satisfies a target standard (eg, XML standard) from the behavior tree 410 based on the behavior tree abstraction model 420.

[0063] The processor acquires the first and second parameters from the behavior tree abstraction model 420. For example, the behavior tree abstraction model 420 includes an 'elem_ID', a 'type_attr', a 'type_value', and a 'name_attr' for each node. The first parameter includes the 'type_attr'. The second parameters include the 'elem_ID', the 'type_value', and the 'name_attr'.

[0064] Illustratively, the processor identifies parameters for action nodes from the metadata included in the behavior tree abstraction model 420. That is, the processor interprets the action nodes included in the behavior tree 410 based on the parameters for the action nodes. After interpreting the action nodes, the processor recreates them according to the target standard to generate standard nodes included in the standard behavior tree 430.

[0065] The processor identifies the attribute "type" which is the "type_attr" value of the element "node" inputted by "elem_ID", and identifies the action node included in the behavior tree 430 by the same element with the "type_value" value "action". In this manner, the processor processes the data of each type of node included in the behavior tree 410 and performs interpretation of the behavior tree 410.

[0066] The processor obtains a standard behavior tree 430 that meets the target standard based on the behavior tree abstraction model 420 and the behavior tree 410.

[0067] FIG. 5 is a diagram showing an example of a database stored in the memory in the robot control device according to one embodiment of the present invention.

[0068] A processor according to this embodiment (e.g., processor 110 in Fig. 1) stores a standard behavior tree and a robot scenario in a database 500 shown in Fig. 5. The processor provides an environment in which robot behavior scenarios can be shared by loading the stored standard behavior tree in response to a user request.

[0069] The database 500 stores behavior trees according to the robot's behavior scenario type, providing an efficient data structure for users to select a behavior tree suitable for their desired scenario. The database 500 also provides a list of unit function nodes that make up the behavior tree, allowing robot developers to select a more suitable behavior tree.

[0070] FIG. 6 is a diagram showing an example of an interface provided to a user when a program including code or instructions for performing the operations of FIG. 2 is executed.

[0071] A processor according to this embodiment (e.g., processor 110 of FIG. 1) provides a user with a program including code or instructions for performing the operations of FIG. 2. When the user executes the program, the user recognizes the interface shown in FIG. 6. That is, when the user executes the program, the processor provides the user with the interface shown in FIG. 6.

[0072] 6, a first interface 610 provides an editing screen for a standard behavior tree, and a second interface 620 provides a list screen for standard behavior trees for each robot scenario stored in a database.

[0073] The processor loads a standard behavior tree stored in a memory (e.g., memory 120 in FIG. 1 ) or a database to provide an editing screen for the standard behavior tree on the first interface 610. The processor displays nodes included in the loaded standard behavior tree and edges between nodes included in the loaded standard behavior tree as multiple icons on an interface (e.g., first interface 610) that serves as the basis for the user's operation of editing the standard behavior tree.

[0074] The processor performs modification of the standard behavior tree by receiving input (i.e., editing by the user) for each of the first icons related to the nodes or the second icons related to the edges of the plurality of icons. That is, the user modifies the standard behavior tree by modifying the plurality of icons displayed on the first interface 610.

[0075] The processor verifies the validity of the standard behavior tree when the standard behavior tree is edited and / or modified by a user. For example, the processor identifies a first node that is a root node among the nodes included in the standard behavior tree. The processor identifies a second node that is a child node among at least one node connected to the first node. The processor verifies the validity of the first node based on the type of the first node and the number of second nodes. Specifically, the processor verifies the validity of the first node based on the fact that if the first node is an action node, it cannot have a child node, or if the first node is a decorator node, it should have only one child node.

[0076] The processor verifies the validity of each node included in the standard behavior tree by recursively searching the standard behavior tree based on the first node. That is, when the validity of the first node is verified, the processor verifies the validity of the second node, which is a child node of the first node, and when the validity of the second node is verified, the processor verifies the validity of the child node of the second node, thereby verifying the validity of each node included in the standard behavior tree.

[0077] The second interface 620 provides a standard behavior tree for each robot scenario stored in the database. The user edits the standard behavior tree by selecting an item from the list displayed on the second interface 620.

[0078] The standard behavior tree that has been edited and / or generated on the first interface 610 and the second interface 620 is reverse-converted to be used as a behavior scenario by the robot developer (i.e., applying the standard behavior tree to the robot for controlling the robot). To perform the reverse conversion, metadata included in the initially input behavior tree abstraction model is referenced.

[0079] FIG. 7 is a flowchart illustrating a method for acquiring a standard behavior tree in a robot controller according to an embodiment of the present invention.

[0080] In this embodiment, a processor (e.g., processor 110 of FIG. 1) identifies inputs to a Behavior Tree in step 711. The processor identifies inputs to a Behavior Tree abstraction model in step 713. The processor performs an operation related to the Behavior Tree abstraction (e.g., first operation 310 of FIG. 3) in step 715. The processor performs an operation related to Behavior Tree interpretation (e.g., second operation 320 of FIG. 3) in step 717.

[0081] In step 719, the processor performs an operation related to behavior tree conversion (e.g., the third operation 330 in FIG. 3). For example, if multiple behavior trees are input instead of one, the processor classifies the behavior trees based on the root node of the behavior tree. If a behavior tree is identified, the processor converts the nodes included in the behavior tree according to the target standard. The processor recursively visits child nodes based on the root node and performs conversion by node type according to the unit function for each node. To process nodes that could not be interpreted, the processor applies exception handling conversion rules (e.g., exception handling conversion model) defined by the robot developer or user.

[0082] In step 721, the processor recursively searches the entire behavior tree and completes the conversion, and then generates a behavior tree in a standard behavior tree structure.

[0083] In step 723, the processor provides an environment in which the user can edit the standard behavior tree through the interface described in Fig. 6. That is, the processor visualizes the standard behavior tree, which is a standardized behavior tree, on the interface.

[0084] The processor performs an inverse transformation of the standard behavior tree in step 725. That is, if the standard behavior tree has been edited by the user, the processor obtains an inverse transformed behavior tree from the edited standard behavior tree.

[0085] The processor acquires the inverse transformation behavior tree and outputs the acquired inverse transformation behavior tree in steps 727 and 729. That is, the processor controls the robot by applying the inverse transformation behavior tree to the robot. For reference, the standard of the inverse transformation behavior tree is different from the target standard of the standard behavior tree, but may be the same standard as the standard of the behavior tree.

[0086] FIG. 8 is a diagram showing an example of a behavior tree converted in accordance with a target standard.

[0087] 8, which shows a behavior tree 810, a first standard behavior tree 830 modified to the JSON standard, and a second standard behavior tree 850 modified to the XML standard. When the target standard is the JSON standard, a processor according to this embodiment (e.g., processor 110 in FIG. 1) obtains the first standard behavior tree 830 from the behavior tree 810. Conversely, when the target standard is the XML standard, the processor obtains the second standard behavior tree 850 from the behavior tree 810.

[0088] FIG. 9 is a diagram showing a computer system relating to a robot control device or a robot control method according to an embodiment of the present invention.

[0089] Referring to FIG. 9, a computer system 1000 relating to a robot control device or a robot control method includes at least one processor 1100, a memory 1300, a user interface input device 1400, a user interface output device 1500, a storage 1600, and a network interface 1700, all connected via a bus 1200.

[0090] The processor 1100 is a central processing unit (CPU) or a semiconductor device that executes processing based on instructions stored in the memory 1300 and / or the storage 1600. The memory 1300 and the storage 1600 include various types of volatile or non-volatile storage media. For example, the memory 1300 includes a read only memory (ROM) 1310 and a random access memory (RAM) 1320.

[0091] Thus, the steps of a method or algorithm described in connection with the embodiments disclosed herein may be embodied directly in hardware executed by processor 1100, in a software module, or in a combination of the two. The software module may reside in a storage medium (i.e., memory 1300 and / or storage 1600) such as RAM memory, flash memory, ROM memory, EPROM memory, EEPROM memory, registers, a hard disk, a removable disk, or a CD-ROM.

[0092] An exemplary storage medium is coupled to processor 1100 such that processor 1100 reads information from, and writes information to, the storage medium. Alternatively, the storage medium may be integral to processor 1100. The processor and the storage medium may reside in an application specific integrated circuit (ASIC). The ASIC may reside in a user terminal. Alternatively, the processor and the storage medium may reside as discrete components in a user terminal.

[0093] The above description is merely an illustrative example of the technical concept of the present invention, and various modifications and variations are possible within the scope of the essential characteristics of the present invention, if one has ordinary knowledge in the technical field to which the present invention pertains.

[0094] The above-described embodiments may be implemented using hardware components, software components, and / or a combination of hardware and software components. For example, the devices, methods, and components described herein may be implemented using a general-purpose computer or a special-purpose computer, such as a processor, controller, arithmetic logic unit (ALU), digital signal processor, microcomputer, field programmable gate array (FPGA), programmable logic unit (PLU), microprocessor, or other device capable of executing and responding to instructions. The processing device executes an operating system (OS) and software applications executed on the operating system. The processing device also accesses, stores, manipulates, processes, and generates data in response to the execution of the software. For ease of understanding, a single processing device may be described. However, those skilled in the art will recognize that a processing device may include multiple processing elements and / or multiple types of processing elements. For example, a processing device may include multiple processors or one processor and one controller. Other processing configurations are also possible, such as parallel processors.

[0095] Software includes computer programs, code, instructions, or a combination of one or more of these, which configure a processing device to operate as desired or, independently or collectively, instruct the processing device. The software and / or data may be permanently or temporarily embodied in some type of machine, component, physical device, virtual device, computer storage medium or device, or transmitted signal wave to be interpreted by the processing device or to provide instructions or data to the processing device. The software may be distributed across computer systems connected by a network and stored and executed in a distributed manner. The software and data may be stored on a computer-readable recording medium.

[0096] The method according to the present invention may be embodied in the form of program instructions executed by various computer means and recorded on a computer-readable recording medium. The computer-readable recording medium may include, alone or in combination, program instructions, data files, data structures, etc. The program instructions recorded on the recording medium may be specially designed and constructed for the present invention, or may be well known and available to those skilled in the art of computer software. Examples of computer-readable recording media include magnetic media such as hard disks, floppy disks, and magnetic tape, optical media such as CD-ROMs and DVDs, magneto-optical media such as floptical disks, and hardware devices specially configured to store and execute program instructions, such as ROM, RAM, and flash memory. Examples of program instructions include not only machine language code, such as that produced by a compiler, but also high-level language code executed by a computer using an interpreter, etc.

[0097] The hardware devices described above may be configured to operate as one or more software modules to perform the operations of the present invention, and vice versa.

[0098] Although the present embodiment has been described above with limited drawings, those skilled in the art may apply various technical modifications and variations thereto. For example, suitable results may be achieved even if the described techniques are performed in a different order than described, and / or the components of the described systems, structures, devices, circuits, etc. are combined or combined in a different manner than described, or are replaced or substituted by other components or equivalents.

[0099] Accordingly, other implementations, other embodiments, and equivalents of the claims are within the scope of the claims.

[0100] Therefore, the embodiments disclosed in this specification are for illustrative purposes only and are not intended to limit the technical idea of ​​the present invention. The scope of protection of the present invention should be interpreted by the claims, and all technical ideas within the scope equivalent thereto should be interpreted as being included in the scope of the present invention. [Explanation of symbols]

[0101] 100 Robot control device 110, 1100 processors 120, 1300 memory 122 Imperative 410 Behavior Tree 420 Behavioral Tree Abstraction Model 430 Standard Action Tree 500 databases 610, 620 First and second interfaces 810 Behavior Tree 830, 850 1st and 2nd Standard Action Trees 1000 Computer Systems 1200 Bus 1310 ROM 1320 RAM 1400 User Interface Input Device 1500 User interface output device 1600 Storage 1700 network interface

Claims

1. A memory that stores computer-executable instructions; at least one processor that accesses the memory and executes the instructions; The at least one processor obtaining a standard behavior tree that satisfies the target specification from the behavior tree based on a behavior tree abstraction model that is applied to interpret the behavior tree; storing a robot scenario paired with the standard behavior tree and the standard behavior tree in the memory; A robot control device that verifies the validity of the standard behavior tree based on nodes included in the standard behavior tree and edges between nodes included in the standard behavior tree.

2. The at least one processor obtaining, from the behavior tree abstraction model, first parameters relating to the types of nodes included in the behavior tree, and second parameters relating to the attributes of each of the nodes included in the behavior tree and included in the first parameters; 2. The robot control device according to claim 1, wherein the standard behavior tree is obtained by applying the first parameter and the second parameter to the behavior tree.

3. The at least one processor Identifying a root node included in the behavior tree by obtaining the first parameter and the second parameter; identifying child nodes contained in the behavior tree by recursively searching the behavior tree based on the root node; acquiring a type of the target node by applying the first parameter to at least one target node among child nodes included in the behavior tree; 3. The robot control device according to claim 2, wherein the attribute of the target node is acquired by applying the second parameter to the target node.

4. The at least one processor generating a standard node by combining the type of the target node and the attribute of the target node according to the target standard; 4. The robot control device according to claim 3, wherein the standard behavior tree is obtained by connecting the standard nodes to the root node.

5. The at least one processor If the type of the target node cannot be obtained or the attribute of the target node cannot be obtained, a predetermined exception handling conversion model is identified; 4. The robot control device according to claim 3, wherein the type of the target node or the attribute of the target node is acquired through the exception handling conversion model.

6. The at least one processor Loading the standard behavior tree stored in the memory; Displaying the nodes included in the loaded standard behavior tree and the edges between the nodes included in the loaded standard behavior tree as a plurality of icons on an interface that is the basis for a user's operation of editing the standard behavior tree; 2. The robot control device according to claim 1, wherein the standard behavior tree is modified by receiving an input for each of a first icon relating to a node or a second icon relating to an edge of the plurality of icons.

7. The robot controller according to claim 1 , wherein the at least one processor obtains the behavior tree from the standard behavior tree based on the behavior tree abstraction model.

8. 8. The robot control device according to claim 7, wherein the at least one processor controls the robot by applying the standard behavior tree to the robot that executes the robot scenario when the validity of the standard behavior tree is verified.

9. The at least one processor Identifying a first node that is a root node among the nodes included in the standard behavior tree; identifying a second node that is a child node of at least one node connected to the first node; Verifying the validity of the first node based on the type of the first node and the number of the second nodes; 2. The robot control device according to claim 1, wherein the validity of each node included in the standard behavior tree is verified by recursively searching the standard behavior tree using the first node as a reference.

10. obtaining a standard behavior tree that satisfies a target specification from the behavior tree based on a behavior tree abstraction model applied to interpret the behavior tree; storing the robot scenario paired with the standard behavior tree and the standard behavior tree in a memory; and verifying the validity of the standard behavior tree based on the nodes included in the standard behavior tree and the edges between the nodes included in the standard behavior tree.

11. The step of obtaining the standard behavior tree includes: obtaining, from the behavior tree abstraction model, first parameters relating to the types of nodes included in the behavior tree, and second parameters relating to the attributes of each node included in the behavior tree and included in the first parameters; and applying the first parameter and the second parameter to the behavior tree to obtain the standard behavior tree.

12. The step of obtaining the standard behavior tree includes: identifying a root node included in the behavior tree by obtaining the first parameter and the second parameter; identifying child nodes in the behavior tree by recursively searching the behavior tree relative to the root node; acquiring a type of the target node by applying the first parameter to at least one target node among child nodes included in the behavior tree; and acquiring an attribute of the target node by applying the second parameter to the target node.

13. The step of obtaining the standard behavior tree includes: generating a standard node by combining the type of the target node and the attribute of the target node according to the target standard; 13. The robot control method according to claim 12, further comprising the step of: obtaining the standard behavior tree by connecting the standard nodes to the root node.

14. The step of obtaining the standard behavior tree includes: identifying a predetermined exception handling conversion model when the type of the target node cannot be obtained or the attribute of the target node cannot be obtained; 13. The robot control method according to claim 12, further comprising: acquiring a type of the target node or an attribute of the target node through the exception handling conversion model.

15. The step of storing the standard behavior tree in the memory includes: loading the standard behavior tree stored in the memory; Displaying the nodes included in the loaded standard behavior tree and the edges between the nodes included in the loaded standard behavior tree as a plurality of icons on an interface that serves as a basis for a user to edit the standard behavior tree; and performing a change to the standard behavior tree by receiving an input for each of a first icon relating to a node or a second icon relating to an edge of the plurality of icons.

16. The robot control method according to claim 10, further comprising the step of obtaining the behavior tree from the standard behavior tree based on the behavior tree abstraction model.

17. 17. The robot control method of claim 16, wherein the obtaining of the behavior tree includes controlling the robot by applying the behavior tree to the robot that executes the robot scenario if the validity of the standard behavior tree is verified.

18. The step of verifying the validity of the standard behavior tree includes: identifying a first node that is a root node among the nodes included in the standard behavior tree; identifying a second node that is a child node of at least one node connected to the first node; verifying the validity of the first node based on the type of the first node and the number of the second nodes; 11. The robot control method according to claim 10, further comprising: a step of verifying the validity of each node included in the standard behavior tree by recursively searching the standard behavior tree using the first node as a reference.

Images