JP2005321954A - Robot apparatus, information processing system, information processing method, and computer program - Google Patents

Abstract

PROBLEM TO BE SOLVED: To suitably realize class inheritance between an object described in a compiler language and an object described in a script language.
Inheritance of a class is handled by having a reference of the other object as a member in an object of a mutual language. A member of a class in the first language holds a reference to a class of the second language that is a class that inherits the member, and a member of an object of the second language holds a reference to the first class. When a method is called from a C ++ base class, if the inherited class is a script language class, the method of the script language class can be correctly called.
[Selection] Figure 1

Description

  The present invention relates to a robot apparatus, an information processing system, an information processing method, and a computer program that execute a program described in an object-oriented language, and in particular, class inheritance between languages written in a plurality of object-oriented languages. The present invention relates to a robot apparatus, an information processing system, an information processing method, and a computer program.

  More particularly, the present invention relates to a robot apparatus, an information processing system and an information processing method, and a computer program that realize class inheritance between an object described in a compiler language and an object described in a script language. The present invention relates to a robot apparatus, an information processing system, an information processing method, and a computer program that perform an appropriate function call between an object described in a compiler language native to the robot apparatus and an object in a script language format downloaded to the apparatus.

  A mechanical device that uses an electrical or magnetic action to perform a movement resembling human movement is called a “robot”. It is said that the word “robot” comes from the Slavic word “ROBOTA (slave machine)”. In Japan, robots began to spread from the end of the 1960s, but many of them are industrial robots such as manipulators and transfer robots for the purpose of automating and unmanned production operations in factories. Met.

  Recently, a pet-type robot that mimics the body mechanism and movement of a quadruped animal, such as a dog or a cat, or the body mechanism or movement of a biped upright animal such as a human or monkey. Research and development related to the structure of legged mobile robots such as “humanoid” or “humanoid robots” and stable walking control thereof have progressed, and expectations for practical use are also increasing. These legged mobile robots are unstable compared to crawler robots, making posture control and walking control difficult, but they are superior in that they can realize flexible walking and running operations such as climbing stairs and climbing obstacles. Yes.

  In recent years, robotic devices have been increasingly used for purposes other than industrial applications, such as living together, that is, for “symbiosis” or “entertainment” with humans. In the conventional toy machine, the relationship between the user operation and the response operation is fixed, and the operation of the toy cannot be changed according to the user's preference. Therefore, the user gets tired of repeating the same operation. In contrast, intelligent robotic devices are equipped with behavioral models and learning models due to movement, and the movement is determined autonomously by changing the model based on input information such as voice, images, and touch from outside. Realization of thought and motion control. Furthermore, by preparing an emotion model and instinct model, the robot can express autonomous behavior according to the robot's own emotion and instinct. In addition, by introducing recognition technology such as image recognition processing and voice recognition processing as an interface with humans, more advanced and realistic communication is possible.

  This type of robot has a high information processing capability and can be regarded as a kind of computer system. In other words, the above-described action planning and robot operation control for embodying the action plan are implemented in the form of execution of a program code (for example, an application) on the computer system. In other words, the construction of a robot behavior / motion control system has the aspect of software development / design in a computer system.

  By the way, in recent software design, an “object-oriented” technique that places importance on data to be processed rather than a processing procedure is widely adopted. In general, object orientation makes software development and maintenance more efficient. Software based on object orientation is basically handled in units of modules called “objects” in which data and processing procedures for the data are integrated. Further, a plurality of objects are created as necessary, and one software is completed by combining these objects.

  The object-oriented paradigm is realized by the main basic technologies of “encapsulation”, “class / instance”, “class inheritance (inheritance)”, and “message passing”.

  Encapsulation refers to integrating data and procedures (methods). Class refers to defining multiple objects in common. An instance represents an entity of an object belonging to a class (an object belonging to the same class, ie, an instance, basically has the same method, so there is no need to define each method individually). Inheritance means that another (for example, subordinate) class inherits what was defined in one class (when a new class is defined, only the difference from the defined class needs to be added or changed. ). Message passing refers to sending a message to an object to instruct a predetermined action. Since each object hides its own data, it is usually not possible to access the object by any means other than message passing.

  The main difference between a general computer system and a robot is that the former has a relatively small difference in the types and combinations (ie, hardware configurations) of hardware components constituting the system, while the latter. Can be mentioned that the hardware configuration changes significantly between systems. Even if it is a mobile robot, there are many different types of movable parts that can be attached to the body, such as a robot composed of a head, legs and tail, and a robot composed only of a head and wheels.

  In a computer system in which the installed hardware configuration is relatively uniform among systems, the design of software executed on the system is relatively unaffected by hardware. On the other hand, in the case of the latter robot, the hardware dependency becomes extremely high particularly in the control software for performing the hardware operation.

  For example, when considering the movement control of the robot, the stability determination criteria at the time of movement and walking are completely different between the case where the moving means is a movable leg, the case of a wheel, and the case of two legs and four legs. The operating environment for executing applications varies significantly between systems. In view of such circumstances, it is efficient to perform software development and design separately into a software layer with relatively low hardware dependency and a software layer with high hardware dependency. In other words, hardware-independent software and hardware-dependent software can be developed separately, and a combination of the two can provide a product lineup with a wide variety of characteristics and performance.

  The hardware-independent software is, for example, an application that performs a process with little relation to hardware operations such as an emotion model, a behavior model, and a learning model. The hardware-dependent software is, for example, middleware composed of a collection of software modules that provide the basic functions of the robot. The configuration of each module includes the mechanical and electrical characteristics and specifications of the robot, Influenced by hardware attributes such as shape. Functionally, the middleware performs recognition and control of each part's sensor input and notifies the higher-level application, and performs hardware drive control such as driving each joint actuator according to the command issued by the application. It can be roughly divided into output middleware.

  For example, by introducing middleware adapted to the hardware configuration to the robot, the same application can be executed on the robots having various hardware configurations. Further, in order to allow any combination between an application and middleware, it is necessary to establish a format for exchanging data and commands between these software layers, that is, an interface between programs (for example, Patent Document 1). See

JP 2002-113675 A

  By the way, as a form of introducing software to various computer systems including a robot, new software can be supplied via a removable medium, or software can be downloaded via a network.

  For example, new software such as applications and middleware can be easily introduced into the robot via a removable medium such as a memory card or memory stick at a certain part of the robot body. Alternatively, when the robot is equipped with a wireless or wired LAN interface, the latest version of the program can be downloaded from a predetermined site via, for example, the nearest base station or server.

  Here, as the programming language, there are a compiler language that becomes an execution form after compilation processing, and a high-level programming language called a script language or a simple programming language. Examples of the former include C and C ++. In the latter example, perl, Python, Ruby, etc. can be mentioned.

  Although the script language is highly functional, there is a problem that it is slow because it is executed on the interpreter. For this reason, a portion requiring high speed is described in a compiler type language or used in combination with a library such as C or C ++ in advance. For example, in an information processing apparatus such as a robot, a native code portion is described in a compiler language such as C or C ++.

  However, since the compiler language can only be executed after compilation, the program module downloaded to the device can be executed without compilation, so it is convenient to write it in script language. The inventors contemplate.

  In this case, a subroutine written in the compiler language is called from the program module side written in the script language, or vice versa. A subroutine written in the script language is called from the program module side written in the compiler language. Must be called and must absorb the differences between both languages.

  In particular, one of the basic concepts of message mechanisms in object-oriented programming is polymorphism (polymorphism, diversity). This polymorphism means that by giving the same operation name to another method defined in different classes, they can be used in the same message. With the establishment of polymorphism, different methods with the same name can be defined in the upper and lower classes, and inheritance (inheritance) can be used efficiently. Regarding polymorphism, see, for example, “Programming Language C ++ 3rd Edition” (Addison-Wesley, ASCII, pp 67) by Bjarne Strustrup.

  In the above-described example, in order to achieve polymorphism, it is necessary to have reference information for the other object between objects described in the compiler language and the script language, and to correctly handle class inheritance. For example, when a method is called from a C ++ base class, the correct class is called. If this is a script language class, the method of the script language class is called.

  In C ++, polymorphism is generally implemented using a virtual function. Declare the member function as a virtual function in the base class and override the function in the derived class. At this time, the class to which the object belongs is determined by providing the class with a virtual table.

  In a compiler type language such as C ++, it is possible to determine whether a derived class is overriding a function at the time of compilation. On the other hand, the script type language has high execution efficiency, but it is not possible to determine whether or not the function is overridden unless it is executed by the interpreter. For this reason, it is difficult to inherit the C ++ class to the script language.

  In addition, in order to absorb the difference between the two languages, a program called wrapper code is sometimes used. SWIG or the like is known as a tool for automatically generating this wrapper code (see http://swig.org/ or http://swig-jp.dyndns.org/). However, in this SWIG, the script language class only has a C ++ object, and the script language cannot be called from C ++. That is, the C ++ class cannot be inherited by the script language.

  The present invention takes into account the technical problems as described above, and its main purpose is an excellent robot apparatus capable of suitably realizing class inheritance between other languages described in an object-oriented language. An information processing system, an information processing method, and a computer program are provided.

  A further object of the present invention is to provide an excellent robot apparatus, information processing system, information processing method, and computer capable of suitably realizing class inheritance between an object described in a compiler language and an object described in a script language.・ To provide a program.

  A further object of the present invention is to provide an excellent robot apparatus, information processing system, and information processing system capable of correctly calling an appropriate function between an object in a compiler language format native to the robot apparatus and an object in a script language format downloaded to the apparatus. It is to provide an information processing method and a computer program.

  A further object of the present invention is to provide an excellent robot that can call a function correctly from any object of the compiler language and script language depending on whether or not the function is overridden by an object on the script language side and achieve polymorphism. An apparatus, an information processing system, an information processing method, and a computer program are provided.

The present invention has been made in consideration of the above problems, and a first aspect of the present invention is a robot apparatus including one or more movable parts.
A control device for controlling the operation of the robot device by executing a program code described in a first language;
An inheriting device that inherits the control device by executing program code described in a second language;
When the class described in the first language is inherited by the class of the second language, the control device holds a reference to the class of the second language, and the inheritance device Holds a reference to a language class,
It is a robot apparatus characterized by this.

  However, “system” here refers to a logical collection of a plurality of devices (or functional modules that realize specific functions), and each device or functional module is in a single housing. It does not matter whether or not.

  The first and second languages referred to here are both object-oriented languages. The first language is a compiler language such as C ++, for example, and the second language is Python or another script language, which is executed on the interpreter. That is, in the robot apparatus according to the present invention, the control system is configured by an object-oriented programming environment in which objects described in a compiler language and a script language are mixed.

  Under such a system environment, there is a problem of class inheritance between different languages. Specifically, there is a situation in which a class that inherits a class described in a first language must be a class in the second language. In this case, it is necessary to call the function correctly even if the function is called from any language class.

  In the control system of the robot apparatus according to the present invention, the inheritance of the class is handled by having the object of the other language as a member in the mutual language object. Specifically, the member of the class in the first language holds a reference to the class of the second language that is a class that inherits the member, and the member of the object of the second language Keep a reference to the class. For example, when a method is called from a C ++ base class, the correct class is called. That is, if the inherited class is a script language class, a method of the script language class can be correctly called.

  Specifically, when the base class described in the first language is inherited to the super class described in the second language, the base class is described in the first language described in the first language. In addition to inheriting in the wrapper class, the super class inherits the second wrapper class described in the second language. The first wrapper class stores a pointer to an instance of the second wrapper class, and the second wrapper class stores a pointer to an instance of the first wrapper class.

  However, polymorphism cannot be achieved completely by constructing cross-reference relationships between the classes of both languages. That is, if the function defined in the C ++ class is overridden in the script language class that inherits it, it can be called correctly, but it is not overridden in the script language class. Has a problem that an infinite loop occurs and the function cannot be called correctly.

  One way to solve such an infinite loop is to equip a judgment function to check whether the function of the base class is overridden by a class inherited on the second language side. it can.

  Specifically, the first wrapper class overrides the base class function and checks whether it is overridden in the super class within the overridden function. When overridden in the super class, a function on the second language side is called. On the other hand, when not overridden in the super class, the function of the base class is called. Do not rush into.

  In addition, as another method for solving the infinite loop, it is possible to provide a function for determining which function the second wrapper class calls.

  Specifically, the first wrapper class has a pseudo-override function that overrides the function of the base class and calls the function of the base class. Also, the second wrapper class overrides the base class function. In the second wrapper class, when the overridden function is called, it is checked whether the overridden function is overridden in the super class. When overridden in the super class, the function on the second language side is called, but when not overridden in the super class, the pseudo-override function is called. Since this check mechanism is automatically performed in the second language, it is not necessary for the user to load the check mechanism check mechanism. Since the pseudo-override function calls the base class function, it does not enter an infinite loop.

  Alternatively, the first wrapper class overrides the function of the base class and provides a third wrapper class that inherits the first wrapper class. In this third wrapper class, a pseudo-override function that calls a function of the base class is defined. Also, the second wrapper class overrides the base class function. Then, in the second wrapper class, when calling the overridden function, it is checked whether it is overridden in the super class. If it is overridden in the super class, the function on the second language side is called. If not overridden in the super class, the third wrapper class is called. Since the pseudo override function defined in the third wrapper class calls the base class function, it does not enter an infinite loop.

According to a second aspect of the present invention, a process for executing a program in an object-oriented programming environment in which objects described in the first language and the second language are mixed is executed on a computer system. In a computer program written in a computer readable format,
When a class that inherits a class described in the first language is used as a second language class, a member of the class in the first language holds a reference to the class in the second language that inherits the class. Causing a member of a second language object to retain a reference to a class of the first language;
A computer program characterized by comprising:

  The computer program according to the second aspect of the present invention defines a computer program described in a computer-readable format so as to realize predetermined processing on a computer system. In other words, by installing the computer program according to the second aspect of the present invention in the computer system, a cooperative action is exhibited on the computer system, and the robot apparatus according to the first aspect of the present invention. The same operation effect as the control system can be obtained.

  According to the present invention, it is possible to provide an excellent robot apparatus, information processing system and information processing method, and computer program capable of suitably realizing class inheritance between other languages described in an object-oriented language. it can.

  Further, according to the present invention, it is possible to preferably realize class inheritance between an object described in a compiler language and an object described in a script language. A computer program can be provided.

  Further, according to the present invention, an excellent robot apparatus and information processing system capable of correctly calling an appropriate function between an object in a compiler language format native to the robot apparatus and an object in a script language format downloaded to the apparatus And an information processing method and a computer program can be provided.

  Further, according to the present invention, from any object of the compiler language and the script language, the function can be correctly called according to whether or not the function is overridden by the script language side object, and polymorphism can be achieved. A robot apparatus, an information processing system, an information processing method, and a computer program can be provided.

  Other objects, features, and advantages of the present invention will become apparent from more detailed descriptions based on embodiments of the present invention described later and the accompanying drawings.

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

  FIG. 1 schematically shows a functional configuration of a robot apparatus 1 that is used in the present invention. As shown in the figure, the robot apparatus 1 includes a control unit 20 that performs overall control of the entire operation and other data processing, an input / output unit 40, a drive unit 50, and a power supply unit 60. . Hereinafter, each part will be described.

  The input / output unit 40 is provided in the CCD camera 15 corresponding to the eyes of the robot apparatus 1 as an input unit, the microphone 16 corresponding to the ear, or a part such as the head or the back, and a touch sensor that detects a user's contact. 18 or other various sensors corresponding to the five senses. As an output unit, a speaker 17 corresponding to the mouth, an LED indicator (eye lamp) 19 that forms a facial expression by a combination of blinking and lighting timing, and the like are provided.

  The drive unit 50 is a functional block that realizes the body operation of the robot apparatus 1 in accordance with a predetermined motion pattern commanded by the control unit 20, and is a control target by behavior control. The drive unit 50 is a functional module for realizing the degree of freedom in each joint of the robot apparatus 1 and includes a plurality of drive units provided for each axis such as roll, pitch, and yaw in each joint. Each drive unit adaptively controls the rotational position and rotational speed of the motor 51 based on the output of the motor 51 that performs a rotational operation around a predetermined axis, the encoder 52 that detects the rotational position of the motor 51, and the encoder 52. A combination of drivers 53 is used.

  The power supply unit 60 is a functional module that supplies power to each electric circuit in the robot apparatus 1. The robot apparatus 1 according to the present embodiment is an autonomous drive type using a battery, and the power supply unit 60 includes a charging battery 61 and a charging / discharging control unit 62 that manages the charging / discharging state of the charging battery 61. . The rechargeable battery 61 is configured, for example, in the form of a “battery pack” in which a plurality of lithium ion secondary battery cells are packaged in a cartridge type. Further, the charge / discharge control unit 62 grasps the remaining capacity of the battery 61 by measuring the terminal voltage of the battery 61, the amount of charge / discharge current, the ambient temperature of the battery 61, etc., and determines the charging start timing and end timing. decide.

  The control unit 20 corresponds to a “brain” and is mounted on, for example, the head unit or the torso unit of the robot apparatus 1.

  FIG. 2 illustrates the configuration of the control unit 20 in more detail. As shown in the figure, the control unit 20 has a configuration in which a CPU (Central Processing Unit) 121 as a main controller is connected to a memory and other circuit components and peripheral devices via a bus. The bus 28 is a common signal transmission path including a data bus, an address bus, a control bus, and the like.

  A RAM (Random Access Memory) 22 is a writable memory composed of a volatile memory such as a DRAM (Dynamic RAM), and loads a program code executed by the CPU 21 or temporarily stores work data by the execution program. Used to save.

  A ROM (Read Only Memory) 23 is a read-only memory that permanently stores programs and data. Examples of the program code stored in the ROM 23 include a self-diagnosis test program that is executed when the robot apparatus 1 is powered on, and an operation control program that defines the operation of the robot apparatus 1.

  The nonvolatile memory 24 is configured by a memory element that can be electrically erased and rewritten, such as an EEPROM (Electrically Erasable and Programmable ROM), and is used to hold data to be sequentially updated in a nonvolatile manner. . Examples of data that should be updated sequentially include security information such as a manufacturing number and an encryption key.

  The interface 25 is a device for interconnecting with devices outside the control unit 20 and enabling data exchange. The interface 25 performs data input / output with the camera 15, the microphone 16, and the speaker 17, for example. Further, the interface 25 inputs / outputs data and commands to / from each drive circuit 53-1... In the drive unit 50.

  In addition, the interface 25 includes a serial interface such as RS (Recommended Standard) -232C, a parallel interface such as IEEE (Institut of Electrical and Electronics Engineers) 1284, a USB (Universal Serial Bus) I interface 94, an E A general-purpose interface for connecting peripheral devices of computers such as a small computer system interface (SCSI) interface, a memory card interface, etc., so as to transfer programs and data to / from locally connected external devices It may be.

  As another example of the interface 25, an infrared communication (IrDA) interface may be provided to perform wireless communication with an external device.

  Furthermore, the control unit 20 includes a wireless communication interface 26, and an access point (not shown) disposed within a few meters of the aircraft by a short-range wireless data communication such as Bluetooth or a wireless network such as IEEE802.11b. Wireless data communication can be performed between the two. The access point is further interconnected to a small-scale network such as a LAN or a wide-area network such as the Internet, and can guide the robot apparatus 1 to an information providing space on the network.

  Many host devices such as a content server are connected on the network. The robot apparatus 1 can download software from the content server. Here, the native code portion in the robot apparatus is described in a compiler language such as C or C ++ in order to speed up the processing. On the other hand, the downloaded program module is described in a script language so that it can be executed without compiling.

  FIG. 31 schematically shows a network configuration surrounding the robot apparatus according to the present embodiment.

  The robot apparatus is equipped with a wireless data communication function and is connected to a network via an access point (described above). The robot apparatus has a capability of recognizing an instruction given by a user, or a program that the robot determines to be necessary for its own action.

  The network mentioned here includes a small-scale network such as a LAN and a wide area network such as the Internet.

  On the network, there are a relay server that performs WWW information search on behalf of the robot apparatus, and many other servers. On the network, hosts such as servers are interconnected by, for example, the TCP / IP protocol.

  The relay server stores programs (objects), information contents, data, and the like necessary for the robot apparatus in advance, updates them as needed, and distributes them to a specific robot apparatus or all robots via a network. Conversely, a program (object), information content, data, etc. sent from the robot apparatus can be received and stored in a local storage system.

  There are information providing servers on the network that provide information for a fee or free of charge. For example, the information providing server operates as a typical WWW server on which a website is constructed, accumulates information contents described in an HTML (Hyper Text Transfer Protocol) format, and discloses the information. The relay server can access the HTML content using HTTP.

  The application server stores program modules for function expansion of the robot apparatus, and provides the program modules for a fee or free of charge according to a request from the robot apparatus.

  The program code executed on the robot apparatus is designed and created by object-oriented programming for both the native code and the program module downloaded from the application server. The program module downloaded from the application server inherits a class native to the robot apparatus.

  In the robot apparatus, a native code portion is described in a compiler language such as C or C ++ in order to increase processing speed. On the other hand, the program modules stored on the application server side are described in a script language so that they can be executed without compiling after downloading to the robot apparatus.

  FIG. 3 schematically shows a functional configuration of the behavior control system 100 of the robot apparatus 1 according to the embodiment of the present invention. The robot apparatus 1 can perform behavior control according to the recognition result of the external stimulus and the change in the internal state. Furthermore, by providing a long-term memory function and associatively storing a change in the internal state from an external stimulus, it is possible to perform action control according to the recognition result of the external stimulus and the change in the internal state.

  The illustrated behavior control system 100 can adopt and implement object-oriented programming. In this case, each software is handled in units of modules called “objects” in which data and processing procedures for the data are integrated. In addition, each object can perform data transfer and invoke using message communication and an inter-object communication method using a shared memory.

  The behavior control system 100 includes a visual recognition function unit 101, an auditory recognition function unit 102, and a contact recognition function unit 103 in order to recognize an external environment (Environments).

  The visual recognition function unit (Video) 51 performs image recognition processing such as face recognition and color recognition and feature extraction based on a photographed image input via an image input device such as a CCD camera. The visual recognition function unit 51 includes a plurality of objects such as “MultiColorTracker”, “FaceDetector”, and “FaceIdentify” which will be described later.

  The auditory recognition function unit (Audio) 52 performs voice recognition on voice data input through a voice input device such as a microphone, and performs feature extraction or word set (text) recognition. The auditory recognition function unit 52 includes a plurality of objects such as “AudioRecog” and “AuthorDecoder” described later.

  The contact recognition function unit (Tactile) 53 recognizes an external stimulus such as “struck” or “struck” by recognizing a sensor signal from a contact sensor built in the head of the aircraft, for example.

  An internal status management unit (ISM: Internal Status Manager) 104 manages several types of emotions such as instinct and emotion by modeling them, and includes the above-described visual recognition function unit 101, auditory recognition function unit 102, and contact recognition function. The internal state such as instinct and emotion of the robot apparatus 1 is managed according to an external stimulus (ES: External Stimula) recognized by the unit 103.

  The emotion model and the instinct model have the recognition result and the action history as inputs, respectively, and manage the emotion value and the instinct value. The behavior model can refer to these emotion values and instinct values.

  In the present embodiment, the emotion is composed of a plurality of hierarchies depending on the significance of existence, and operates in each hierarchy. From a plurality of determined operations, which operation is to be performed is determined according to the external environment and internal state at that time (described later). In addition, actions are selected at each level, but by expressing actions preferentially from lower-order actions, higher-order actions such as instinct actions such as reflexes and action selection using memory Behavior can be expressed consistently on one individual.

  The robot apparatus 1 holds information for a relatively long period of time, and a short-term storage unit 105 that performs short-term storage that is lost over time in order to perform behavior control according to the recognition result of external stimuli and changes in internal state. A long-term storage unit 106 is provided. The classification of memory mechanisms, short-term memory and long-term memory, relies on neuropsychology.

  A short-term memory unit (ShortTermMemory) 105 is a functional module that holds targets and events recognized from the external environment by the visual recognition function unit 101, the auditory recognition function unit 102, and the contact recognition function unit 103 for a short period of time. For example, the input image from the camera 15 is stored for a short period of about 15 seconds. On the other hand, a long term memory unit (LongTermMemory) 106 is used to hold information obtained by learning such as the name of an object for a long period of time. For example, the long-term storage unit 106 can associatively store a change in internal state from an external stimulus in a certain behavior module.

  Also, the behavior control of the robot apparatus 1 according to the present embodiment is performed by the “reflection behavior” realized by the reflection behavior unit 109, the “situation dependence behavior” realized by the situation-dependent behavior hierarchy 108, and the contemplation behavior hierarchy 107. It can be roughly divided into "contemplation behavior" to be realized.

  A reflexive behavior unit (Reflexive Situated Behaviors Layer) 109 is a functional module that realizes a reflective body operation in response to an external stimulus recognized by the visual recognition function unit 101, the auditory recognition function unit 102, and the contact recognition function unit 103 described above. It is. The reflex action is basically an action that directly receives the recognition result of the external information input from the sensor, classifies it, and directly determines the output action. For example, a behavior such as chasing a human face or nodding is preferably implemented as a reflex behavior.

  The situation-dependent behavior hierarchy (Situated Behaviors Layer) 108 is based on the storage contents of the short-term storage unit 105 and the long-term storage unit 106 and the internal state managed by the internal state management unit 104. Control responsive behavior.

  The situation-dependent action hierarchy 108 prepares a state machine (or a state transition model) for each action, and classifies recognition results of external information input from the sensor depending on previous actions and situations. Behavior is expressed on the aircraft. The situation-dependent action hierarchy 108 also realizes an action for keeping the internal state within a certain range (also referred to as “homeostasis action”). When the internal state exceeds the specified range, the internal state is The action is activated so that the action for returning to the range is likely to appear (actually, the action is selected in consideration of both the internal state and the external environment). Situation-dependent behavior has a slower response time than reflex behavior.

  A deliberate action hierarchy (Deliberate Layer) 107 performs a relatively long-term action plan of the robot apparatus 1 based on the storage contents of the short-term storage unit 105 and the long-term storage unit 106. A contemplation action is an action that is performed based on a given situation or a command from a human being and making a plan to realize it. For example, searching for a route from the position of the robot and the position of the target corresponds to a contemplation action. Such an inference or plan may require a processing time or a calculation load (that is, a processing time) rather than a reaction time for the robot apparatus 1 to maintain interaction. While responding in real time, the contemplation action makes inferences and plans.

  The contemplation behavior layer 107, the situation-dependent behavior layer 108, and the reflex behavior unit 109 can be described as higher-level application programs that are independent of the hardware configuration of the robot apparatus 1. On the other hand, the hardware dependent layer control unit (ConfigurationDependentActionsAndReactions) 110 performs hardware (external environment) such as joint actuator drive in accordance with commands from these higher-level applications (behavior modules called “schema”). Operate directly.

  Each functional module in the behavior control system 100 of the robot 1 as shown in FIG. 3 is configured as an object. Each object can perform data transfer and invoke by message communication and an inter-object communication method using a shared memory. FIG. 4 schematically shows the object configuration of the behavior control system 100 according to the present embodiment.

  The visual recognition function unit 101 includes three objects, “FaceDetector”, “MultiColtTracker”, and “FaceIdentify”. FaceDetector is an object that detects a face area from an image frame, and outputs the detection result to FaceIdentify. The MultiClotTracker is an object that performs color recognition, and outputs the recognition result to FaceIdentify and ShortTermMemory (an object constituting the short-term memory 105). FaceIdentify also identifies a person by searching the detected face image in a hand-held person dictionary, and outputs the person ID information together with the position and size information of the face image area to ShortTermMemory.

  The auditory recognition function unit 102 includes two objects “AudioRecog” and “SpeechRecog”. AudioRecog is an object that receives audio data from an audio input device such as a microphone and performs feature extraction and audio segment detection, and outputs the feature amount and sound source direction of the audio data in the audio segment to SpeedRecog and ShortTermMemory. The SpeechRecog is an object that performs speech recognition using the speech feature amount, the speech dictionary, and the syntax dictionary received from the AudioRecog, and outputs a set of recognized words to the ShortTermMemory.

  The tactile sensation recognition storage unit 103 is composed of an object called “TactileSensor” that recognizes sensor input from the contact sensor, and outputs the recognition result to the ShortTermMemory and an internal state model (ISM) that manages the internal state.

  ShortTermMemory (STM) is an object constituting the short-term storage unit 105, and holds targets and events recognized from the external environment by each object of the recognition system described above (for example, an input image from the camera 15 is about 15 seconds). This is a functional module that stores only for a short period of time, and periodically notifies the Stimated BehaviorsLayer, which is an STM client, of external stimuli (Notify).

  LongTermMemory (LTM) is an object that constitutes the long-term storage unit 106 and is used to hold information obtained by learning such as the name of an object for a long period of time. For example, LongTermMemory can associatively store a change in internal state from an external stimulus in a certain behavior module.

  The Internal Status Manager (ISM) is an object that constitutes the internal state management unit 104, manages several types of emotions such as instinct and emotion by modeling them, and external stimuli (ES that are recognized by each object of the recognition system described above. : Manages the internal state of the robot apparatus 1 such as instinct and emotion according to (ExternalStimula).

  Situated Behaviorslayer (SBL) is an object that constitutes the context-dependent action hierarchy 108. SBL is an object that becomes a client of ShorTermMemory (STM client), and receives a notification (Notify) of information related to external stimuli (targets and events) periodically from ShorTermMemory, that is, a behavior module to be executed. Is determined (described later).

  The Reflexive Situated BehaviorsLayer is an object that constitutes the reflexive action unit 109, and executes reflexive and direct body motion according to the external stimulus recognized by each object of the recognition system described above. For example, behaviors such as chasing a human face, nodding, and avoiding by detecting obstacles are performed.

  The Situated Behaviors layer selects an action according to a situation such as an external stimulus or a change in an internal state. In contrast, Reflexive Situated BehaviorsLayer acts reflexively in response to external stimuli. Since the action selection by these two objects is performed independently, when the action modules (schema) selected from each other are executed on the aircraft, the hardware resources of the robot 1 may compete and cannot be realized. is there. The ResourceManager object arbitrates hardware conflicts when selecting actions by the Situated Behaviorslayer and the Reflexive Situated BehaviorsLayer. Then, the airframe is driven by notifying each object that realizes the airframe motion based on the arbitration result.

  SoundPerformer, MotionController, and LedController are objects that realize the body operation. The SoundPerformer is an object for performing voice output, performs voice synthesis in accordance with a text command given from the SituatedBehaviorLayer via the ResourceManager, and outputs voice from the speaker on the body of the robot 1. The Motion Controller is an object for performing the operation of each joint actuator on the aircraft, and calculates a corresponding joint angle in response to receiving a command to move a hand, leg, or the like from the Situated BehaviorLayer via the ResourceManager. The LedController is an object for performing the blinking operation of the LED 19, and performs the blinking drive of the LED 19 in response to receiving a command from the Situated BehaviorLayer via the ResourceManager.

  FIG. 5 schematically shows a form of situation-dependent action control by the situation-dependent action hierarchy (SBL) 108 (however, including the reflex action unit 109). The recognition result of the external environment by the recognition systems 101 to 103 is given to the situation-dependent action hierarchy 108 (including the reflex action part 109) as an external stimulus. In addition, a change in internal state according to the recognition result of the external environment by the recognition system is also given to the situation dependent action hierarchy 108. In the situation-dependent action hierarchy 108, the situation can be determined according to an external stimulus or a change in the internal state, and action selection can be realized.

  The state-dependent action hierarchy 108 prepares a state machine for each action module, classifies the recognition results of external information input from the sensor depending on the previous action and situation, and expresses the action on the aircraft To do. The action module describes an action function that describes the body motion and realizes a state transition (state machine) accompanying the action execution, and evaluates the execution of the action described in the action function according to an external stimulus or an internal state, and makes a situation determination. It is described as a schema with a monitor function to perform. FIG. 6 schematically illustrates the situation-dependent action hierarchy 108 configured by a plurality of schemas.

  The situation-dependent action hierarchy 108 (more strictly speaking, the hierarchy that controls the normal situation-dependent action among the situation-dependent action hierarchy 108) is configured as a tree structure in which a plurality of schemas are hierarchically connected. In accordance with changes in the internal state, a more optimal schema is determined in an integrated manner to perform action control. The tree includes a plurality of subtrees (or branches) such as a behavior model obtained by formulating an ethological situation-dependent behavior and a subtree for executing emotion expression.

  FIG. 7 schematically shows a schema tree structure in the situation-dependent action hierarchy 108. As shown in the figure, the situation-dependent action hierarchy 108 is directed from the abstract action category to the specific action category, starting with the root schema that receives the notification (Notify) of the external stimulus from the short-term storage unit 105. A schema is arranged for each hierarchy. For example, in the hierarchy immediately below the root schema, schemas “Search”, “Insert”, and “Play” are arranged. Then, below “Investigate”, a schema describing more specific search behaviors such as “Investigative Location”, “HeadinAirSniffing”, and “InvestigativeSniffing” is arranged. Similarly, a schema describing more specific eating and drinking behavior such as “Eat” and “Drink” is arranged below the schema “Ingestive”, and “Schema” is placed below the “Play”. Schemas describing more specific playing behaviors such as “PlayBowing”, “PlayGreeting”, and “PlayPawing” are arranged.

  Thus, the behavior control program of the robot apparatus 100 is configured by a schema tree structure. The schema below this tree structure can be downloaded from the content server and installed sequentially. For example, a schema describing specific behavior of the schema “play”, the next version of the schema, and the like can be downloaded and incorporated into the behavior control system as needed.

  As shown in FIG. 7, each schema inputs an external stimulus and an internal state. Each schema has at least a Monitor function and an Action function. FIG. 8 schematically shows the internal structure of the schema. As shown in the figure, the schema includes an action function describing the body motion in the form of a state transition model (state machine) in which the state (or state) changes according to the occurrence of a predetermined event, and an external stimulus. The Monitor function that evaluates each state of the Action function according to the internal state and returns it as an activity level value, and the state machine of the Action function is either READY (ready), ACTIVE (active), or SLEEP (standby) The state management unit stores and manages the schema state as the state.

  The Monitor function is a function that calculates an activity level (Activation Level: AL value) of the schema in accordance with an external stimulus and an internal state. When a tree structure as shown in FIG. 7 is configured, the upper (parent) schema can call the Monitor function of the lower (child) schema with the external stimulus and the internal state as arguments, and the child schema has an AL value. Is the return value. The schema can also call the child's schema Monitor function to calculate its AL value. Since the AL value from each sub-tree is returned to the root schema, the optimum schema corresponding to the external stimulus and the change of the internal state, that is, the behavior can be determined in an integrated manner.

  In the example shown in FIG. 8, a behavior state control unit (tentative name) that manages a schema, that is, a behavior module, selects an action to be executed based on a return value from the Monitor function, and calls an action function of the corresponding schema. Alternatively, the transition of the schema state stored in the state management unit is instructed. For example, the schema having the highest activity level as the action induction evaluation value is selected, or a plurality of schemas are selected according to the priority order so that resources do not compete. In addition, when a schema having a higher priority is activated and a resource conflict occurs, the behavior state control unit saves the state of the schema having a lower priority from ACTIVE to SLEEP, and when the conflict state is solved, the behavior state control unit changes to ACTIVE. Control schema state, such as recovery.

  The behavioral state control function can be distributed and arranged hierarchically for each schema in the situation-dependent behavior hierarchy 108. As shown in FIG. If the schema forms a tree structure, the behavioral state control of the upper (parent) schema calls the Monitor function of the lower (child) schema with the external stimulus and the internal state as arguments, and the activity level from the child schema. Receives the level and resource used as a return value. In addition, the child schema further calls the Monitor function of the child schema in order to calculate its activity level and resource used. Then, the activity level control unit and the resources used from each sub-tree are returned to the action state control unit of the root schema, so that the optimum schema corresponding to the external stimulus and the change of the internal state, that is, the action is integrally determined. , Call the Action function to start or interrupt the execution of the child schema.

  In this embodiment, the program code portion native to the robot apparatus 1 is described in a compiler language such as C ++ for the purpose of increasing the speed. On the other hand, for the purpose of making the compiling process after installation unnecessary for the code part added later by downloading from the content server, such as the code part positioned in the lower level in the schema tree structure, It is written in another script language and executed on the interpreter.

  In the present embodiment, both the code portion described in the native compiler language and the downloaded script-format code portion are configured as an object-oriented language. Here, the problem of class inheritance between languages arises in order to achieve polymorphism.

  In order to realize polymorphism, it is necessary to call a function correctly regardless of which class calls the function. For example, even if a function is called from a class on either the compiler language such as C ++ or script language such as Python, if the function with the same name is overridden in the class on the script language side, the function is changed. If it is called but not overridden, it must call a function in the base class on the compiler language side.

  Here, the correct polymorphism operation is shown below. However, a class on the compiler language side is Base, a script language class that inherits the class is ScriptSuper, and a function to be called is func.

  FIG. 10 schematically shows a program development procedure in an object-oriented programming environment in which objects described in a compiler language and a script language such as C ++ are mixed.

  A source program described in a compiler language such as C ++ is compiled and further combined with other libraries to constitute an execution library.

  On the other hand, a source program written in a script language such as Python is executed on an interpreter.

  Further, after the C ++ source program is translated by the translator, a wrapper code for absorbing the language difference when the class is inherited between the two languages is generated.

  As a tool for automatically generating this wrapper code, SWIG (described above) is known. In the example of SWIG or the like, by holding the pointer of the instance on the C ++ side in the class on the script language side, it is possible to call the function and method on the C ++ side from the class on the script language side. However, in this case, since the pointer of the instance on the script language side is not held on the C ++ side, the method on the script language side cannot be called from the class on the C ++ side. This relies on the fact that it is not possible to determine whether the function is overridden unless it is run by the interpreter.

  Therefore, in the present embodiment, the value of the inherited object of the script language is given as a member of the class on the C ++ side, and the value of the instance (this) of the base class of the C ++ side is given to the member of the inherited script language side class. As a result, a wrapper code that can be called between C ++ and the script language is incorporated. This allows the script language class to have an inheritance relationship with the C ++ class.

  FIG. 11 shows a state in which wrapper code that can be called between C ++ and a script language is incorporated.

  In the illustrated example, on the C ++ language side, the user class is inherited by the base class, and further, the super class inherits the base class. On the script language side, the script user class inherits the wrapper class. In addition, the base class and the wrapper class have an inheritance relationship between the two languages.

  Here, the base class on the C ++ language side and the wrap class on the script language side are so-called dummy classes provided for establishing an inheritance relationship between the two languages. As an entity, a script user class is created by inheriting a user class described in C ++.

  The base class has the inherited object value of the script language, and the inherited script language side wrap class member has the C ++ base class instance value (this), and the class inheritance relationship is established.

  The code of the user class and the base class when considering the creation of the script user class (ScriptSuper) by inheriting the user class (UserBase) described in C ++ is simulated in FIG. It shows. FIG. 13 shows a pseudo class declaration on the script language side.

  Referring to FIG. 14, a case will be considered in which the instance of the script language side is mutually held in the instance of the C ++ side.

  In the illustrated example, since the C ++ side has an inheritance relationship with the class on the script language side, Wsuper is prepared as a wrapper class instead of directly inheriting from the original class UserBase to the class on the script language side. , Once inherited to Wsuper.

  Similarly, the script language side does not directly perform class inheritance from the C ++ language side, but prepares ScriptBase as a wrapper class. Then, the ScriptSuper as a class inherited entity is a form in which the wrapper class ScriptBase is inherited. It is assumed that the user inherits ScriptBase.

  When an instance of the wrapper class ScriptBase is constructed on the script language side, the pointer of the instance of the wrapper class ScriptBase on the script language side is stored as py_self in the wrapper class Wsuper on the C ++ side (14-1). In ScriptBase, the pointer of the instance of the wrapper class Wsuper on the C ++ side is stored in this (14-2). Accordingly, classes in each language can be referred to each other, and a script language function can be called from the C ++ side, and a C ++ function can be called from the script language side.

  However, polymorphism cannot be achieved completely by simply providing wrapper classes in both languages and storing the respective pointers to construct the cross-reference relationship. That is, if the function defined in the C ++ class is overridden in the script language class that inherits it, it can be called correctly, but it is not overridden in the script language class. Has the problem that it cannot call functions.

  FIG. 15 illustrates a function call procedure when the function funcok1 defined in the class on the C ++ side is overridden by a class on the script language side that inherits the function funcok1. In the example shown in the figure, when a script Script class on the script language side inherits the class, processing for overriding the function is performed.

  First, when the function funcOK1 () is called from the script language class side (15-1-1), since the funcOK1 () is overridden by the script language class, an appropriate function ScriptSuper. Call funcOK1 () and return (15-1-2).

  On the other hand, when the function funkOK1 () is called from the class side of the compiler language (15-2-1), since funcOK1 () is overridden virtually from the UserBase by WSuper, which is a wrapper class, The function automatically calls the appropriate overriding function WSuper :: funcOK1 () (15-2-2). In polymorphism design, when a function is overridden in an inherited class, the overridden function is called sequentially.

  Then, an instance inherited by the script language is taken out from the pointer py_self of the script language instance, and funcOK1 () is called. In Wsuper, the pointer of the instance of the wrapper class ScriptBase on the script language side is stored as py_self. Therefore, on the script language side, first, the function ScriptBase. funcOK1 () is called appropriately. Then, an appropriate function ScriptSuper. funcOK1 is automatically called (15-2-3).

  As described above, when the function defined in the class on the C ++ side is overridden in the class on the script language side, the function can be appropriately called. However, if it is not overridden on the script language side, the function may not be called correctly only by the cross-reference mechanism shown in FIG.

  FIG. 16 illustrates the function call procedure when the function funcNG defined in the class on the C ++ side is not overridden in the class on the script language side that inherits the function funcNG. As shown in the figure, when the script Script class ScriptSuper inherits ScriptBase, the function is not overridden. This is because the base class does not override the function at class inheritance by default.

  When the function funcNG () is called from the class side of the script language (16-1), since funcNG () is not overridden by the class ScriptSuper inherited in the script language, the function ScriptBase. funcNG () is called (16-2). In the polymorphism design, when there is no corresponding function in the inheritance destination class, the inherited original class function is called.

  Here, UserBase is a wrapper class, and since there is no function overridden in the class, the function on the original class side is then called. In ScriptBase, since the pointer of the instance of the wrapper class Wsuper on the compiler language side is stored in this, the function Base :: funcNG () of the original class UserBase is called on the compiler language side via Wsuper. (16-3).

  Since the function Base :: funcNG () is overridden by WSuper :: funcNG (), WSuper :: funcNG () is automatically called (16-4). Here, the reason why WSuper :: funcNG () is automatically called is to use a virtual function in C ++, and the instance of C ++ stored in ScriptBase is constructed by WSuper. funcNG () is called automatically.

  Then, an instance that inherits the class in the script language is taken out from the pointer py_self of the script language instance, and the function is called. In Wsuper, the pointer of the instance of the wrapper class ScriptBase on the script language side is stored as py_self. Therefore, the script class function ScriptBase :: funcNG () is first called on the script language side (16-5). . However, in this case, since the function is not overridden by ScriptSuper, the function Base :: funcNG () of the original class UserBase is called (16-3), and further, WSuper :: funcNG () overriding this is called. Is automatically called (16-4) and falls into an infinite loop.

  On the other hand, when the function funcNG () is called from the class side of C ++ (16-6), the function Base :: funcNG () is overridden by WSuper :: funcNG (), so WSuper :: funcNG automatically. () Is called (16-4). Here, the reason why WSuper :: funcNG () is automatically called is to use a virtual function in C ++, and the instance of C ++ stored in ScriptBase is constructed by WSuper. funcNG () is called automatically.

  Then, an instance that inherits the class in the script language is taken out from the pointer py_self of the script language instance, and the function is called. In Wsuper, the pointer of the instance of the wrapper class ScriptBase on the script language side is stored as py_self. Therefore, the script class function ScriptBase :: funcNG () is first called on the script language side (16-5). . However, in this case, since the function is not overridden by ScriptSuper, the function Base :: funcNG () of the original class UserBase is called (16-3), and further, WSuper :: funcNG () overriding this is called. Is automatically called (16-4), it falls into an infinite loop (same as above).

  FIG. 17 schematically shows the processing when the function func () is called from the C ++ side for the instance of ScriptSuper when the function func () is not defined in the inheritance class ScriptSuper on the script language side. .

  First, the function func () is called from the class UserBase on the C ++ side. Here, since UserBase :: func () is a virtual function, WSuper :: func () is called.

  When WSuper :: func () is called, the function func () of the WSuper :: func () member variable py_this is obtained.

  Here, since the function Func () is not defined (not overridden) in ScriptSuper, the obtained function is that of ScriptBase, and ScriptBase. Call func ().

  ScriptBase. In func (), the function this. Call func (). Since the class of this is WSuper, WSuper :: func () is called.

  That is, WSuper :: func () is called and falls into an infinite loop.

  One way to solve such an infinite loop is whether the function is overridden in the class inherited on the script language side (excluding the wrapper class) in the wrapper class WSuper prepared on the compiler language side It can be mentioned that a judgment function to check whether or not is equipped.

  That is, a class belonging to an instance on the script language side stored in WSuper is extracted, and whether or not the member function of the class is overridden, the function WSuper :: funcOK () overridden in WSuper is called each time. Check every time.

  Then, when the function is overridden in the script superscript script superscript, the script language side function is called. When the function is not overridden, the script language side function is not called, and the function Base :: funcOK is called from UserBase. To avoid entering an infinite loop.

  FIG. 18 illustrates the function call procedure when the wrapper class WSuper prepared on the compiler language side is equipped with a determination function for checking whether or not the function is overridden in the class inherited on the script language side. doing. In the illustrated example, when the class ScriptSuper on the script language side inherits ScriptBase, the process of overriding the function is not performed.

  When the function funcOK1 () is called from the class side of the script language (18-1-1), since funcOK1 () is not overridden by the class ScriptSuper inherited by the script language, the function ScriptBase. funcOK1 () is called (18-1-2). In the polymorphism design, when there is no corresponding function in the inheritance destination class, the inherited original class function is called.

  UserBase is a wrapper class, and since there is no function overridden in the class, the function on the original class side is then called. In ScriptBase, the pointer of the instance of the wrapper class Wsuper on the compiler language side is stored in this, so the function WSuper :: funcOK1 () of the wrapper class WSuper is called on the compiler language side (18-1- 3).

  Here, in WSuper :: funcOK1 (), a pointer py_self of an instance of the wrapper class ScriptBase on the script language side is taken out, and a class to which py_self belongs is obtained. If the class overrides funkOK1 (), the function funcOK1 () on the script language side is called; otherwise, the function Base :: funcOK1 () overridden by itself is called. In the illustrated example, the script ScriptSuper class to which py_self belongs does not override the function, so the function funkOK1 () is called (18-1-4).

  On the other hand, when the function funcok1 () is called from the C ++ class side (18-2-1), it is overridden by the function WSuper :: funcOK1 () defined in the wrapper class WSSuper, so WSuper :: funcOK1 () Is automatically called (18-2-2).

  Here, in WSuper :: funcOK1 (), a pointer py_self of an instance of the wrapper class ScriptBase on the script language side is taken out, and a class to which py_self belongs is obtained. Then, the script language class ScriptSuper to which py_self belongs does not override the function, so the function funkOK1 () is called (same as above).

  FIG. 19 and FIG. 20 show description examples of the class definition in C ++ and the class definition in Python when the above-described solution is applied.

  Note that when the script language class ScriptSuper inherits ScriptBase, when the function is overridden, the function call operation is the same as that shown in FIG. Description is omitted.

  As another method for solving the infinite loop as shown in FIG. 16, a class belonging to an instance on the script language side stored in a wrapper class WSuper prepared on the compiler language side is taken out, and which function should be called Judging by the class on the script language side can be mentioned.

  In this case, when the C ++ wrapper class WSuper inherits the base class UserBase, in addition to overriding the function of the base class UserBase, a pseudo override function for calling the base class is prepared. On the script language side, the wrapper class ScriptBase that inherits WSuper overrides the function of the base class UserBase. This function determines which function should be called.

  When a function called func () exists in the base class UserBase, a pseudo-override function func_Base () in which a code that calls the func () of UserBase is written is written in the wrapper class WSSuper. In the wrapper class ScriptBase on the script language side, func () is overridden, and when calling the overridden base function in this func (), a pseudo-override function WSuper :: func_Base () is used instead. Write to call.

  FIG. 21 illustrates a function call procedure when a function for determining which function is to be called by a class on the script language side is provided. In the illustrated example, when the class ScriptSuper on the script language side inherits ScriptBase, the process of overriding the function is not performed.

  When the function funcOK2 () is called from the script language class side (21-1-1), since funcOK2 () is not overridden by the script Scriptclass inherited by the script language, the function ScriptBase. funcOK2 () is automatically called (21-1-2). In the polymorphism design, when there is no corresponding function in the inheritance destination class, the inherited original class function is called.

  Since ScriptBase is a wrapper class and there is no entity that is overridden in the class, the original class-side function is then called. In ScriptBase, the pointer of the instance of the wrapper class Wsuper on the compiler language side is stored in this, so the compiler class calls the wrapper class WSuper. Here, since funcOK2 () is not overridden by the class ScriptSuper inherited in the script language, when calling the function overridden by ScriptBase :: funcOK2 (), the pseudo-override function WSSuper :: funcOK2_Base () is called (21-). 1-3). Then, the pseudo override function WSuper :: funcOK2_Base () calls userBase funcOK2 () (21-1-4).

  On the other hand, when the function funcOK2 () is called from the class side of C ++ (21-2-1), it is overridden by the function WSuper :: funcOK2 () defined in the wrapper class WSuper, so WSuper :: funcOK2 () Is automatically called (21-2-2).

  Then, in WSuper :: funcOK2 (), the function funcOK2 overridden in ScriptBase is called from the pointer py_self of the instance on the script language side (21-2-3).

  Since ScriptBase is a wrapper class and there is no entity that is overridden in the class, the original class-side function is then called. In ScriptBase, the pointer of the instance of the wrapper class Wsuper on the compiler language side is stored in this, so the compiler class calls the wrapper class WSuper. Here, since funcOK2 () is not overridden by the class ScriptSuper inherited in the script language, when calling the function overridden by ScriptBase :: func (), the pseudo-override function WSuper :: funcOK2_Base () is called (21-). 2-3). Then, the pseudo override function WSuper :: funcOK2_Base () calls UserBase func () (same as above).

  FIG. 22 and FIG. 23 show description examples of the class definition in C ++ and the class definition in Python when the above-described solution is applied.

  Note that when the script language class ScriptSuper inherits ScriptBase, when the function is overridden, the function call operation is the same as that shown in FIG. Description is omitted.

  As a modification of the embodiment shown in FIG. 21, a dedicated wrapper class Wrap called from the script language side may be prepared on the C ++ side.

  When the function is not overridden in the script language class, when performing class inheritance on the C ++ side, in addition to generating an instance of the wrapper class WSSuper overriding the base class UserBase function, UserBase func () An instance of a wrapper class Wrap defining a pseudo override function func_Base () in which a code for calling is written is generated. In the pseudo override function func_Base (), it is written that func () of UserBase is called. On the script language side, in the wrapper class ScriptBase that inherits WSuper, the function of the base class UserBase is overridden, but not which function of the C ++ side wrapper class should be called, which wrapper class Determine whether to call.

  FIG. 24 illustrates the execution order of function calls in this case. In the illustrated example, when the script Script class ScriptSuper inherits ScriptBase, the function is overridden.

  First, when the function funcOK3 () is called from the script language class side (24-1-1), since funcOK3 () is overridden by the script language class, an appropriate function ScriptSuper. Call func3 () and return (24-1-2).

  On the other hand, when function funcOK3 () is called from the class side of the compiler language (24-2-1), funcOK3 () is virtually overridden by WSuper, which is a wrapper class, from UserBase. The function automatically calls the appropriate overriding function WSuper :: funcOK3 () (24-2-2). In polymorphism design, when a function is overridden in an inherited class, the overridden function is called sequentially.

  Then, an instance inherited in the script language from the script language instance pointer py_self is extracted, and funcOK3 () is called. In Wsuper, the pointer of the instance of the wrapper class ScriptBase on the script language side is stored as py_self. Therefore, on the script language side, first, the function ScriptBase. funcOK3 () is called appropriately. Then, an appropriate function ScriptSuper. funcOK3 is automatically called (24-2-3).

  FIG. 25 illustrates the execution sequence of function calls when the script language class ScriptSuper inherits ScriptBase and does not perform the process of overriding the function.

  When the function funcOK4 () is called from the class side of the script language (25-1-1), since funcOK4 () is not overridden by the class ScriptSuper inherited in the script language, the function ScriptBase. funcOK4 () is automatically called (25-1-2). In the polymorphism design, when there is no corresponding function in the inheritance destination class, the inherited original class function is called.

  Since ScriptBase is a wrapper class and there is no entity that is overridden in the class, the original class-side function is then called. Here, since funcOK4 () is not overridden by the class ScriptSuper inherited in the script language, the C ++ side wrapper class Wrap is called (25-1-3). This wrapper class Wrap defines a pseudo-override function WSuper :: funcOK4_Base (), and calls FunBase4 () of UserBase (25-1-4).

  On the other hand, when the function funcOK4 () is called from the class side of C ++ (25-2-1), it is overridden by the function WSuper :: funcOK4 () defined in the wrapper class WSuper, so WSuper :: funcOK4 () Is automatically called (25-2-2).

  Then, in WSuper :: funcOK4 (), the function funcOK4 overridden by ScriptBase is called from the pointer py_self of the instance on the script language side (25-2-3).

  Since ScriptBase is a wrapper class and there is no entity that is overridden in the class, the original class-side function is then called. Here, since funcOK4 () is not overridden by the class ScriptSuper inherited in the script language, the C ++ side wrapper class Wrap is called. This wrapper class Wrap defines a pseudo-override function WSuper :: funcOK4_Base (), and calls UserBase funcOK4 () (same as above).

  FIG. 26 and FIG. 27 respectively show description examples of the class definition in C ++ and the class definition in Python when the above-described solution is applied.

  FIG. 28 illustrates the execution order when constructing an instance of a script language-side class ScriptSuper that inherits the base class UserBase on the C ++ side (constructor).

  First, ScriptSuper. __Init __ () is called (28-1).

  Next, ScriptBase. Call __init __ () (28-2).

  Next, WSuper :: WSuper () is called (28-3).

  At this time, since C ++ is automatically initialized from the base class, UserBase :: UserBase () is called (28-4).

  And after UserBase :: UserBase (), WSuper :: WSuper () is called (28-5).

  After the completion of WSuper :: WSuper (), the pointer of the C ++ instance is stored in this of ScriptBase (28-6).

  In order to write a pointer of an instance on the script language side to a member variable of C ++, WSuper. Set_self () is called (28-7).

  After storing the pointer of the script language instance with WSuper :: set_self (), the process returns (28-8).

  And ScriptBase. _Init_ () returns (28-9), and ScriptSuper. Return from _init_ () (28-10).

  Also, FIG. 29 illustrates the execution order when an instance of ScriptSuper disappears (destructor).

  First, ScriptSuper. When __del __ () is called (29-1), ScriptBase. __Del __ () is called (29-2).

  Then, WSuper :: ˜WSuper () is called from the value of the member variable “this” of ScriptBase (29-3).

  Next, WSuper :: ˜WSuper () is called (29-4), and UserBase :: ˜UserBase () is called (29-5).

  By functioning the constructor and the destructor in this way, as a result, as shown in FIG. 30, it seems that the C ++ class is virtually inherited by the script language class.

  The present invention has been described in detail above with reference to specific embodiments. However, it is obvious that those skilled in the art can make modifications and substitutions of the embodiments without departing from the gist of the present invention.

  The gist of the present invention is not necessarily limited to a product called a “robot”. That is, as long as it is a mechanical device that performs an exercise resembling human movement using an electrical or magnetic action, the present invention can be applied to products belonging to other industrial fields such as toys. Can be applied.

  In short, the present invention has been disclosed in the form of exemplification, and the description of the present specification should not be interpreted in a limited manner. In order to determine the gist of the present invention, the claims section described at the beginning should be considered.

FIG. 1 is a diagram schematically illustrating a functional configuration of a robot apparatus 1 that is used in the present invention. FIG. 2 is a diagram showing the configuration of the control unit 20. FIG. 3 is a diagram schematically illustrating a functional configuration of the behavior control system 100 of the robot apparatus 1 according to the embodiment of the present invention. FIG. 4 is a diagram schematically illustrating an object configuration of the behavior control system 100. FIG. 5 is a diagram schematically showing a form of situation-dependent action control by the situation-dependent action hierarchy (SBL) 108 (including the reflex action unit 109). FIG. 6 is a diagram schematically showing how the situation-dependent action hierarchy 108 is composed of a plurality of schemas. FIG. 7 is a diagram schematically showing a schema tree structure in the situation-dependent action hierarchy 108. FIG. 8 is a diagram schematically showing the internal structure of the schema. FIG. 9 is a diagram for explaining the mechanism of behavioral state control when the schema forms a tree structure. FIG. 10 is a diagram schematically showing a program development procedure in an object-oriented programming environment in which objects described in a compiler language and a script language such as C ++ are mixed. FIG. 11 is a diagram showing a state where a wrapper code that can be called between C ++ and a script language is incorporated. FIG. 12 shows the code of the user class and the base class when it is considered that the script user class (Script_Super) is created by inheriting the user class (UserBase) described in C ++. FIG. FIG. 13 is a diagram showing a pseudo class declaration on the script language side. FIG. 14 is a diagram showing a state in which pointers of instances on the script language side are mutually held on instances on the C ++ side. FIG. 15 is a diagram for explaining the execution order of function calls when the function funcok1 defined in the class on the C ++ side is overridden by a class on the script language side that inherits the function funcok1. FIG. 16 is a diagram for explaining the execution order of function calls when the function funcok1 defined in the class on the C ++ side is not overridden by the class on the script language side that inherits the function funcok1. FIG. 17 is a diagram for explaining an operation that falls into an infinite loop due to a function call when the function func () is not defined in the inheritance class ScriptSuper on the script language side. FIG. 18 illustrates the execution sequence of function calls when the wrapper class WSuper prepared on the compiler language side is equipped with a judgment function for checking whether or not a function is overridden in a class inherited on the script language side. It is a figure for doing. FIG. 19 is a diagram showing a description example of class definition in C ++ when the solution shown in FIG. 18 is applied. FIG. 20 is a diagram showing a description example of class definition in Python when the solution shown in FIG. 18 is applied. FIG. 21 is a diagram for explaining the execution order of function calls when a function for determining which function should be called is provided by a class on the script language side. FIG. 22 is a diagram showing a description example of class definition in C ++ when the solution shown in FIG. 21 is applied. FIG. 23 is a diagram showing a description example of class definition in Python when the solution shown in FIG. 21 is applied. FIG. 24 is a diagram for explaining a modification of the execution order of the function calls shown in FIG. FIG. 25 is a diagram for explaining a modification of the execution order of the function calls shown in FIG. FIG. 26 is a diagram showing a description example of class definition in C ++ when the solution shown in FIG. 25 is applied. FIG. 27 is a diagram showing a description example of class definition in Python when the solution shown in FIG. 25 is applied. FIG. 28 is a diagram for explaining the execution order when constructing an instance of the script language-side class ScriptSuper that inherits the base class UserBase on the C ++ side (constructor). FIG. 29 is a diagram for explaining the execution order when an instance of ScriptSuper disappears (destructor). FIG. 30 is a diagram showing a state in which a C ++ class is virtually inherited by a class on the script language side. FIG. 31 is a diagram schematically showing a network configuration surrounding the robot apparatus according to the present invention.

Explanation of symbols

DESCRIPTION OF SYMBOLS 1 ... Robot apparatus 15 ... CCD camera 16 ... Microphone 17 ... Speaker 18 ... Touch sensor 19 ... LED indicator 20 ... Control part unit 21 ... CPU
22 ... RAM
23 ... ROM
24 ... Non-volatile memory 25 ... Interface 26 ... Wireless communication interface 28 ... Bus 40 ... Input / output unit 50 ... Drive unit 51 ... Motor 52 ... Encoder 53 ... Driver

Claims (23)

In a robot apparatus having one or more movable parts,
A control device for controlling the operation of the robot device by executing a program code described in a first language;
An inheriting device that inherits the control device by executing program code described in a second language;
When the class described in the first language is inherited by the class of the second language, the control device holds a reference to the class of the second language, and the inheritance device Holds a reference to a language class,
A robot apparatus characterized by that. The first language is a compiled language that allows program code to be executed through a predetermined compilation process, and the second language is a script language that can execute the program code on an interpreter.
The robot apparatus according to claim 1. When the inheriting device inherits the base class described in the first language to the super class described in the second language,
A first wrapper class written in a first language that inherits the base class;
A second wrapper class written in a second language inherited by the super class;
A pointer from the first wrapper class to an instance of the second wrapper class;
A pointer from the second wrapper class to an instance of the first wrapper class;
The robot apparatus according to claim 1, further comprising: The first wrapper class has a determination function for checking whether the function of the base class is overridden by a class inherited on the second language side,
The robot apparatus according to claim 3. The first wrapper class overrides the function of the base class, and checks whether the function of the base class is overridden in the super class in the overridden function. Calling a second language side function if the base class function is overridden in the class, but calling the base class function if not overridden in the super class;
The robot apparatus according to claim 4, wherein: The second wrapper class is equipped with a function for determining which function to call.
The robot apparatus according to claim 3. The first wrapper class has a pseudo-override function that overrides the base class function and calls the base class function;
The second wrapper class overrides the base class function, and checks whether the base class function is overridden in the super class in the overridden function, and Call a second language function if the class has overridden the base class function, but call the pseudo-override function if not overridden in the super class;
The robot apparatus according to claim 6. The first wrapper class overrides the base class function;
A third wrapper class defining a pseudo-override function that calls a function of the base class inherits the first wrapper class;
The second wrapper class overrides the base class function, and checks whether the base class function is overridden in the super class in the overridden function, and Call a function on the second language side if the function of the base class is overridden in the class, but call the third wrapper class if not overridden in the super class;
The robot apparatus according to claim 6. In an information processing system for executing a program in an object-oriented programming environment in which objects described in a first language and a second language are mixed,
When a class that inherits a class described in the first language is used as a second language class, a member of the class in the first language holds a reference to the class in the second language that inherits the class. And having a member of the second language object hold a reference to the first language class,
An information processing system characterized by this. The first language is a compiled language that allows program code to be executed through a predetermined compilation process, and the second language is a script language that can execute the program code on an interpreter.
The information processing system according to claim 9. When inheriting a base class written in a first language to a super class written in a second language,
The super class inherits the base class from a first wrapper class written in a first language and the second wrapper class written in a second language;
The first wrapper class stores a pointer to an instance of the second wrapper class;
The second wrapper class stores a pointer to an instance of the first wrapper class;
The information processing system according to claim 9. The first wrapper class is equipped with a determination function for checking whether the function of the base class is overridden by a class inherited on the second language side,
The information processing system according to claim 11. The first wrapper class overrides the function of the base class, and checks whether the function of the base class is overridden in the super class in the overridden function. Calling a second language side function if the base class function is overridden in the class, but calling the base class function if not overridden in the super class;
The information processing system according to claim 12. The second wrapper class is equipped with a function for determining which function to call.
The information processing system according to claim 11. The first wrapper class has a pseudo-override function that overrides the base class function and calls the base class function;
The second wrapper class overrides the base class function, and checks whether the base class function is overridden in the super class in the overridden function, and Call a second language function if the class has overridden the base class function, but call the pseudo-override function if not overridden in the super class;
The information processing system according to claim 14. The first wrapper class overrides the base class function;
A third wrapper class defining a pseudo-override function that calls a function of the base class inherits the first wrapper class;
The second wrapper class overrides the base class function, and checks whether the base class function is overridden in the super class in the overridden function, and Call a function on the second language side if the function of the base class is overridden in the class, but call the third wrapper class if not overridden in the super class;
The information processing system according to claim 14. In an information processing method for executing a program in an object-oriented programming environment in which objects described in a first language and a second language are mixed,
When a class that inherits a class described in the first language is used as a second language class, a member of the class in the first language holds a reference to the class in the second language that inherits the class. Causing a member of a second language object to retain a reference to a class of the first language;
An information processing method comprising: The first language is a compiled language that allows program code to be executed through a predetermined compilation process, and the second language is a script language that can execute the program code on an interpreter.
The information processing method according to claim 17. When inheriting a base class written in a first language to a super class written in a second language,
Inheriting the base class with a first wrapper class written in a first language;
The super class inheriting a second wrapper class written in a second language;
The first wrapper class storing a pointer to an instance of the second wrapper class;
The second wrapper class storing a pointer to an instance of the first wrapper class;
The information processing method according to claim 17, further comprising: The first wrapper class comprises overriding the base class function and checking whether the base class function is overridden in the super class within the overridden function. ,
In the checking step, if the function of the base class is overridden in the super class, the function of the second language side is called. If not overridden in the super class, the function of the base class is called. Call a base class function,
The information processing method according to claim 19. The first wrapper class has a pseudo-override function that overrides the base class function and calls the base class function;
The second wrapper class overriding the function of the base class and checking whether the function of the base class is overridden in the super class in the overridden function; ,
In the checking step, if the function of the base class is overridden in the super class, the function of the second language side is called. If not overridden in the super class, the function of the base class is called. Call the pseudo-override function,
The information processing method according to claim 19. The first wrapper class overrides the base class function;
A third wrapper class defining a pseudo-override function that calls a function of the base class inherits the first wrapper class;
The second wrapper class comprises overriding the base class function and checking whether the base class function is overridden in the super class within the overridden function. ,
In the checking step, if the function of the base class is overridden in the super class, the function of the second language side is called. If not overridden in the super class, the function of the base class is called. Call the third wrapper class,
The information processing method according to claim 19. A computer program written in a computer-readable format so that processing for executing the program is executed on a computer system in an object-oriented programming environment in which objects described in the first language and the second language are mixed. In
When a class that inherits a class described in the first language is used as a second language class, a member of the class in the first language holds a reference to the class in the second language that inherits the class. Causing a member of a second language object to retain a reference to a class of the first language;
A computer program comprising:

Images