JP2010142940A - Method and apparatus for generating and executing task model of robot - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To provide a method and apparatus for generating and executing a task model of a robot providing a model for notifying information on available actions to an arbitrary robot and the peripheral environment to be recognized by the robot to a robot service designer, and generating the task by separating the design and the embodiment of the action model constituting the robot task to the service considered by the designer, and executing the robot task so that the inside of the action expressed in the service is directly embodied, and the robot task is executed so as to provide the action library when the generated model is used. <P>SOLUTION: In the method and the apparatus for generating and executing the task model of the robot, it is very versatile to separate the generation of an abstract model from an execution process to realize the knowledge through generalization and systematization of the robot action models and the relationship thereof. Only the robot action and the abstract structure of the task are taken into consideration. A person for the task embodiment is concentrated only in generation of the task library. Thus, many advantages are obtained in the safety, the gradual expansion and systematization, of the task to be operated by an arbitrary robot. <P>COPYRIGHT: (C)2010,JPO&INPIT

Description

  The present invention relates to a method and apparatus for generating and executing a robot task model, and more particularly, to provide a model capable of generating a robot task by separating the design and implementation of an action model constituting the robot task. The present invention relates to a method and an apparatus capable of executing a robot task using a selected model.

  As is well known, a service robot is a mechanical device that can automatically perform human actions and work. The application field of this service robot is classified into industrial use, medical use, space use and submarine use. For example, recently, service robots are gradually emerging. Various work is done in various forms at home, office or exhibition hall.

  When generating (for example, defining or writing) a task of such a robot, the generated task model is generated as it is by a program code and executed in the robot. In a normal case, a robot task is created by combining an application program interface (hereinafter referred to as API) that abstracts a robot device.

  The task created in this way is sufficient to understand the robot device and the API that provides it, and only those who can implement the application using this can create the robot task. Most of the existing robot task development tools are also written from the viewpoint of assisting such developers.

  However, when the task model generated as described above is created directly as program code and executed in the robot, the reusability of existing code decreases when new tasks are added or updated. To do. Also, because the robot control structure is intricately intertwined, there are many difficulties in reconfiguring the robot tasks.

  Also, when the robot developer develops all robot tasks, there is a limit to providing the robot service and the desired services here, such as education, entertainment, transportation, military demand, etc. The robot service designer must be included in the development, but since this service designer has insufficient understanding of the robot, the robot he / she intends to provide only by understanding the basic characteristics of the robot. There are limitations in creating service tasks, and it is not easy for robot developers to understand all the various application service domains.

  If the robot service designer is informed about the actions available for any robot and information about the surrounding environment that the robot can recognize, the robot service designer can describe the service he / she thinks in an abstract robot action. A service defined in this way is much more abstract than using an API. Since robots do not operate with such abstract definitions alone, those who are familiar with robots directly embody the actions expressed in the services defined by the robot service designers, or provide action libraries. There must be.

Korean open patent 10-2007-0004268 specification

  Therefore, the present invention has been made in view of the above circumstances, and its purpose is to provide a model that can generate a task by separating the design and implementation of an action model that constitutes a task of a robot. To provide a task model generation and task execution method and apparatus for a robot that performs a task using a model.

  A robot task model generation and execution method according to an aspect of the present invention includes a step of generating a robot action, a step of expressing the action in context, and a step of generating an abstract task execution model based on the context. And executing the generated abstract task execution model by calling an API of the robot to actually operate the robot. A robot task model generation and execution apparatus according to another aspect of the present invention includes a generation unit that generates a robot action and context, an abstract task execution model based on the context, and an actual robot. A context management unit that executes the abstract task execution model to operate, and a robot API that is called by the context management unit to interface the abstract task execution model. .

  According to the present invention, it is possible to develop the robot task more effectively by dividing the development of the robot task into the service designer and the implementer of the robot task.

  In addition, the present invention provides a method and apparatus for generating and executing a task model of a robot, so that a service developer considers only an abstract structure of a robot action and a task, and a task implementer needs a necessary task library. By concentrating only on the generation of tasks, there are many advantages to the safety and gradual expansion and systematization of tasks that work on any robot.

It is a figure which shows the difference and relationship of a viewpoint of the designer of the robot service by one Embodiment of this invention, and the implementer of a robot task. 1 is a block diagram of a robot task model generation and execution apparatus according to an embodiment of the present invention. FIG. It is a figure which shows the abstract action model shown by FIG. Sensor 1, sensor 2,... Located in the robot API shown in FIG. . . , Sensor n and executor 1, executor 2,. . . FIG. It is a figure which shows the abstract task execution model shown by FIG. 6 is a flowchart illustrating a method for generating a tree-type abstract task execution model based on a context for an abstract action model according to an exemplary embodiment of the present invention. 5 is a flowchart illustrating a method for executing an abstract task execution model according to an embodiment of the present invention. 3 is a flowchart sequentially illustrating a method for generating and executing a robot task model according to an embodiment of the present invention.

  Hereinafter, the operation principle of the present invention will be described in detail with reference to the accompanying drawings.

  FIG. 1 is a diagram illustrating a difference between a viewpoint of a robot service designer according to an embodiment of the present invention and a viewpoint of a person embodying a robot task, and a relationship thereof.

  The service designer regards the robot task as a combination of an abstract context 1011 and an abstract behavior 1012.

  The abstract context 1011 includes the context name and description, the abstract action 1012 includes the action name and description, and as an observed context and output indicating the conditions that drive the task as an input to this abstract action. Provide observation of active context. In this state, the service designer considers the abstract action 1012 as a node, and defines an abstract task while associating the abstract action with the input context and the output context.

  Next, the implementer of the task regards the task as a combination of a context manager 1021 and a behavior implementation 1022. From the task implementer's standpoint, the context manager 1021 considers that the abstract context is defined by a logical expression of information extracted from the sensing API actually provided by the robot. The implementation of the abstract action 1022 has an object and a function form defined by using a task library expressed by a driving API or a separate finite state machine (FSM).

  FIG. 2 is a block diagram of a robot task model generation and task execution apparatus according to an embodiment of the present invention, and an abstract action model designed by a service designer using an abstract action model. Indicates the switching of abstract execution tasks defined using. The apparatus shown in FIG. 2 can include a generation unit 10, a context management unit 20, a context database (DataBase, hereinafter referred to as DB) 30, an abstract task execution model 40, and a robot API 50.

  The generation unit 10 includes an action generation unit 11 and a context generation unit 12. As shown in FIG. 3, for example, as in the example of the abstract action model 301, robot actions are generated abstractly through the action generation unit 11, and these relationships can be expressed in the context through the context generation unit 12. The expressed context can be provided to the context management unit 20.

  Here, referring to FIG. 3, the relationship from act 1 (Go to p) to act 7 (Replan path) is shown in each context 1, 2,. . . 7, and the relationship between actions is connected by a context of 1: n, and the abstract action model can be in the form of a graph as a whole.

  As shown in FIG. 2, the context management unit 20, as an example, with respect to the context of the abstract action model input from the generation unit 10, includes context 1 (on), context 2 (off),. . . , It can be provided to the context DB 30 by specifying the context n (off). Here, the context management unit 20 can update the context for the abstract action model stored in the context DB 30 and add an action at any time.

  Further, the context management unit 20 is based on the context of the abstract action model input from the generation unit 10, as shown in FIG. 5, in a tree format designated from the start action (action 5) to the target action (action 4). The abstract task execution model can be generated through the flowchart process of FIG. 6 and provided to the runtime modeling unit 40. Here, once the abstract task execution model is generated, the context management unit 20 can remove unnecessary actions in the abstract task execution model.

  Further, the context management unit 20 applies the generated abstract task execution model to actually operate in the robot so that the context management unit 20 operates, as in the viewpoint 102 of the task implementer shown in FIG. And the action implementation 1022 must be generated, the content of the context is read from the context DB 30 during execution, and the robot API 50 is called to execute the abstract task execution model included in the action implementation. In response, the abstract task execution model modeled in the runtime modeling unit 40 through the interface of the robot API 50 can be executed in the flow chart of FIG.

  The context DB 30 stores contexts (for example, context 1 (on), context 2 (off),..., Context n (off)) specified for the abstract action model input from the context management unit 20. .

  As shown in FIG. 5 input from the context management unit 20, the runtime modeling unit 40 models an abstract task execution model designated from a start action (act 5) to a target action (act 4) in a tree format.

  As shown in FIG. 4, the robot API 50 includes a plurality of sensors 1, sensors 2,. . . , Sensor n and a plurality of executers 1, executers 2,. . . , And an interface n so that an abstract task execution model modeled in the runtime modeling unit 40 can be executed in response to a call instruction of the context management unit 20.

  Therefore, the present invention informs the robot service designer of information on the actions available for any robot and the surrounding environment that the robot can recognize, and separates the design and implementation of the action model that constitutes the robot task for the service considered by itself. If the generated model is used and the generated model is used, the robot task is executed by directly implementing the action expressed in the service or providing the action library. Can be developed more effectively.

  FIG. 6 is a flowchart illustrating a method for generating a tree-type abstract task execution model based on a context for an abstract action model according to an embodiment of the present invention.

  First, the context management unit 20 specifies a task start action (S601), and extracts a context activated by the currently specified action (S603).

  Next, the context management unit 20 determines whether or not each action is the last with the extracted context as an input (S605).

  As a result of the determination (S605), if the action is the last, it is checked whether there is a newly added lower action (S607).

  If there is no newly added subordinate action as a result of the check (S607), the action is designated as a target action (S609), and unnecessary actions are removed up to the designated target action (S611). If there is a newly added subordinate action as a result of the check (S607), the process proceeds to S603 for extracting a context that activates the newly added subordinate action.

  If the action is not the last as a result of the determination (S605), it is determined (S613) whether the action forms a cycle (that is, the action is already included).

  If the cycle is not formed as a result of the determination (S613), the action is designated as a subordinate action of the currently designated action (S615). However, as a result of the determination (S613), if a cycle is formed, the process proceeds to S605 in which it is determined whether each action receiving the extracted context as the input is the last.

  FIG. 7 is a flowchart illustrating a method for executing an abstract task execution model according to an embodiment of the present invention.

  Referring to FIG. 7, a context is extracted from the abstract task execution model (S701).

  Next, the context management unit 20 determines the priorities of the extracted contexts so as to match the tree structure of the abstract task execution model using the extracted contexts (S703).

  After the priority order is determined, the context management unit 20 acquires updated context information from the context DB 30 (S705).

  Next, the acquired context information is analyzed to determine whether there is an on-state context (S707).

  As a result of the determination (S707), if there is no context in the on state, it is checked whether a predetermined time has elapsed (S709).

  As a result of the check (S709), when the predetermined time has not elapsed, the process proceeds to the process of S705 for acquiring the context information. On the other hand, when the predetermined time has elapsed as a result of the check (S709), finish.

  On the other hand, as a result of the determination (S707), if there is a context in the on state, an action is executed (S711) in which the context having the highest priority among the contexts in the on state is input.

  Thereafter, it is determined whether or not the executed action is a purpose (S713).

  As a result of the determination (S713), if the executed action is not the purpose, the process proceeds to the process of S705 for acquiring context information. On the other hand, if the executed action is the purpose as a result of the determination (S713), the process ends.

  FIG. 8 is a flowchart sequentially illustrating a method for generating and executing a robot task model according to an embodiment of the present invention.

  First, as an example, as shown in FIG. 3, the generation unit 10 abstractly generates a robot action for an abstract action model through the action generation unit 11 (S801), and the relationship between the actions is a context generation unit. 12 is expressed as a context (S803), and the expressed context is provided to the context management unit 20.

  Next, in the context management unit 20 that receives the context for the abstract action model from the generation unit 10, as an example of the input context, as shown in FIG. 2, the context 1 (on) and the context 2 (off) ),. . . Then, it is specified in the form of context n (off) and stored in the context DB 30 (S805).

  Thereafter, in the context management unit 20, based on the context for the abstract action model input from the generation unit 10, as shown in FIG. 5, a tree format designated from the start action (act 5) to the target action (act 4) is specified. An abstract task execution model is generated through the process of the flowchart of FIG. 6 (S807) and provided to be modeled into the abstract task execution model 40 (S809).

  Next, the abstract task execution model generated by the context management unit 20 is actually applied to the robot (S811). The context manager 1021 and the action implementation 1022 must be generated as seen from the viewpoint of the implementer of the robot task shown in FIG.

  Thereafter, during execution, the content of the context is read from the context DB 30, and the robot API 50 is called to execute the abstract task execution model included in the action implementation (S813).

  Then, the robot API 50 performs an interface (S815) so that the abstract task execution model modeled in the runtime modeling unit 40 can be executed in accordance with the call command of the context management unit 20 using the corresponding sensor and executor.

  In response to this call, the context management unit 20 executes the abstract task execution model modeled in the runtime modeling unit 40 through the interface of the robot API 50 by the method shown in FIG. 7 (S817).

  As described above, the present invention provides a method and apparatus for generating and executing a robot task model, so that a service developer considers only an abstract structure of robot actions and tasks, and a task implementer is necessary. By concentrating only on the generation of task libraries, there are many benefits to the safety and incremental expansion and organization of tasks that work with any robot.

  On the other hand, specific embodiments have been described in the detailed description of the present invention, but it goes without saying that various modifications can be made without departing from the scope of the present invention. Therefore, the scope of the present invention should not be limited to the described embodiments, but should be determined not only by the claims described below, but also by the equivalents of the claims.

10 generation unit 20 context management unit 30 context DB
40 Abstract task execution model 50 Robot API

Claims (20)

In a robot task model generation and execution method,
Generating a robot action;
Expressing the act in context;
Generating an abstract task execution model based on the context;
A method for generating and executing a robot task model, comprising: calling a robot API to actually operate the robot and executing the generated abstract task execution model. The step of generating the abstract task execution model includes:
Specifying the task start action,
Extracting a context that the act activates;
Determining whether each act receiving the context as input is a final act;
Designating the action as a target action when the action is the last action in the determination result and there is no newly added action;
The robot task according to claim 1, further comprising: designating the action as a sub-action of the action if the action is not the last action in the determination result and the action does not form a cycle. How to generate and execute a model.   3. The robot according to claim 2, wherein, in the determination result, when the action is the last action and there is no newly added action, an unnecessary action is removed up to the designated target action. 4. Task model generation and execution method.   3. The robot task model generation according to claim 2, wherein, in the determination result, when the action is the last action and there is an action to be newly added, the process is performed again from the stage of extracting the context. 4. And execution method.   3. The method of generating and executing a robot task model according to claim 2, wherein the determination is performed again from the step of determining whether the action is the last action when the action forms a cycle.   3. The method of generating and executing a robot task model according to claim 2, wherein the step is performed again from the step of determining whether it is the last action after the step of designating as the subordinate action. The step of executing the abstract task execution model includes:
Extracting a context from the abstract task execution model;
Determining priorities of the contexts and obtaining updated context information;
Analyzing the context information, and starting with an action having the highest priority among the contexts in the on state as an input, and executing until the target action is reached. The method for generating and executing a robot task model according to claim 1.   When the context information is analyzed and there is no context in an on state, if a predetermined time has not elapsed, the process is performed again from the step of acquiring the updated context information. Item 8. A robot task model generation and execution method according to Item 7.   The robot task model generation and execution method according to claim 1, wherein the robot actions are expressed by respective contexts, and the relation between the actions is connected by a 1: n context.   Context 1 (on), context 2 (off),. . . 2. The method for generating and executing a robot task model according to claim 1, wherein the context n (off) is designated and stored in the context DB.   2. The method of generating and executing a robot task model according to claim 1, wherein a context manager and an action implementation are generated to actually operate the robot. In the robot task model generation and execution device,
A generation unit for generating a robot action and context;
A context management unit that generates an abstract task execution model based on the context and executes the abstract task execution model to actually operate the robot;
A robot task model generation and execution device, comprising: a robot API that is called by the context management unit to interface with the abstract task execution model. The generator is
An action generation unit for generating an action of the robot;
The robot task model generation and execution device according to claim 12, further comprising: a context generation unit that generates the action by expressing the action in a context. The generator is
14. The robot task model generation and execution device according to claim 13, wherein the robot actions are expressed in respective contexts, and the relationship between the actions is connected in a 1: n context. The generator is
The apparatus for generating and executing a robot task model according to claim 13, wherein a context manager and an action implementation are generated to actually operate the robot. The context management unit
Specify the starting action of the task, extract the context activated by the starting action, and each action that receives the context as an input is the last action, and when there is no newly added action, the action is The abstract task execution model is generated by designating as a target action and designating the action as a subordinate action if each action is not the last action and the action does not form a cycle. The robot task model generation and execution device according to claim 12. The context management unit
When generating the abstract task execution model, when each action is a last action and there is no newly added action, unnecessary actions are removed until the specified target action is characterized. The robot task model generation and execution device according to claim 16. The context management unit
The context is extracted from the abstract task execution model, the priority of the context is determined, updated context information is obtained, the context information is analyzed, and the priority is highest in the context of an on state. 17. The robot task model generation and execution device according to claim 16, wherein the abstract task execution model is executed until an objective action is reached, starting with an action having a context as an input.   17. The robot task model generation and execution device according to claim 16, further comprising a context DB that repeatedly specifies ON and OFF sequentially and stores the generated context. The robot API is
13. The robot task model generation according to claim 12, wherein the abstract task execution model is interfaced using a corresponding sensor and an executor among a large number of sensors and a large number of executors. And execution device.

Images