CN113448627A

CN113448627A - Method for running application program, robot operation system and robot

Info

Publication number: CN113448627A
Application number: CN202010219696.2A
Authority: CN
Inventors: 宋纯瑞
Original assignee: Beijing Jingdong Zhenshi Information Technology Co Ltd
Current assignee: Beijing Jingdong Zhenshi Information Technology Co Ltd
Priority date: 2020-03-25
Filing date: 2020-03-25
Publication date: 2021-09-28
Anticipated expiration: 2040-03-25
Also published as: CN113448627B

Abstract

The invention discloses a method for running an application program, a robot operating system and a robot, and relates to the technical field of computers. One embodiment of the method comprises: after the robot is started, acquiring pre-stored historical memory data of at least one application program from a server; wherein the application is provided in the robot; determining an application program to be started from the at least one application program, starting the application program to be started and sending historical memory data of the application program to be started to a local file of the application program to be started; and the application program to be started runs according to the historical memory data in the local file. The embodiment enables the application program with the historical memory data to run according to the historical memory data after being started, thereby improving the intelligence degree of the robot.

Description

Method for running application program, robot operation system and robot

Technical Field

The present invention relates to the field of computer technologies, and in particular, to a method for running an application, a robot operating system, and a robot.

Background

A robot is a machine device that performs work automatically, and can accept human commands and run pre-programmed programs. The robot can be divided into an intelligent robot and a general robot according to the intelligence degree, and the intelligent robot generally depends on the artificial intelligence technologies such as ASR (Automatic Speech Recognition), NLU (Natural Language Understanding), and the like to implement application programs with specific functions, such as playing music, telling stories, and the like.

In the process of implementing the invention, the inventor finds that the existing intelligent robot at least has the following problems:

in the existing intelligent robot, if a certain application program is interrupted by another application program in the running process or is directly interrupted by a shutdown instruction sent by a user, the certain application program enters a life cycle from an original state when being started next time, and the previous running state cannot be continued, so that the intelligent degree is insufficient.

Disclosure of Invention

In view of this, embodiments of the present invention provide a method for running an application, a robot operating system, and a robot, which enable the application with historical memory data to run according to the historical memory data after being started, so as to improve the intelligence of the robot.

To achieve the above object, according to one aspect of the present invention, there is provided a method of running an application.

The method for running the application program of the embodiment of the invention is applied to a robot operating system and comprises the following steps: after the robot is started, acquiring pre-stored historical memory data of at least one application program from a server; wherein the application is provided in the robot; determining an application program to be started from the at least one application program, starting the application program to be started and sending historical memory data of the application program to be started to a local file of the application program to be started; and the application program to be started runs according to the historical memory data in the local file.

Optionally, the historical memory data of some or all of the at least one application includes operation related data generated when the application is abnormally exited in a historical period.

Optionally, determining an application to be started from the at least one application includes: and when the shutdown interruption mark exists in the historical memory data of the at least one application program, determining the application program with the shutdown interruption mark as the application program to be started.

Optionally, the history memory data of any application program of the at least one application program includes priority data of the application program; and determining an application to be started from the at least one application, including: and determining the application program with the highest priority in the application programs with the running associated data as the application program to be started.

Optionally, the running of the application to be started according to the historical memory data in the local file includes: and the application program to be started runs according to the running associated data in the local file.

Optionally, the method further comprises: when the application program to be started exits abnormally: generating operation associated data at the current moment, storing the operation associated data in a local file of the application program to be started, removing the original operation associated data in the local file, and adding a mark to be uploaded in the local file; and uploading the operation associated data in the local file with the mark to be uploaded to a server before the robot is shut down.

To achieve the above object, according to another aspect of the present invention, there is provided a method of running an application.

The method for running the application program of the embodiment of the invention is applied to a robot operating system and comprises the following steps: after the robot is started, acquiring pre-stored historical memory data of at least one application program from a server; wherein the application is provided in the robot; receiving an external instruction aiming at the robot, and determining a target application program corresponding to the external instruction; when the target application program is one of the at least one application program, starting the target application program and sending the historical memory data of the target application program to a local file of the target application program; wherein the target application's historical memory data is used when the target application is running and/or abnormally exited.

Optionally, the historical memory data of any application program in the at least one application program includes a memory function opening mark; the historical memory data of part or all of the at least one application program comprises operation related data generated when the application program is abnormally exited in a historical period.

Optionally, when the target application is one of the at least one application and the history memory data of the target application includes operation related data, the target application is started and then operated according to the operation related data stored in the local file of the target application.

Optionally, the method further comprises: when any application program set in the robot exits abnormally in a first mode: if the memory function starting mark exists in the local file of the application program, generating operation associated data at the current moment, storing the operation associated data in the local file of the application program, and adding a mark to be uploaded in the local file; the abnormal exit of the first mode is an abnormal exit caused by interruption of other application programs; and uploading the operation associated data in the local file with the mark to be uploaded to a server before the robot is shut down.

Optionally, the method further comprises: when any application program set in the robot exits abnormally in a second mode: if the memory function starting mark exists in the local file of the application program, generating operation associated data at the current moment, storing the operation associated data in the local file of the application program, and adding a mark to be uploaded and a shutdown interruption mark in the local file; the abnormal exit of the second mode is an abnormal exit caused by interruption of an external shutdown instruction; and uploading the operation related data and/or the shutdown interruption mark in the local file with the mark to be uploaded to a server before the robot is shut down.

To achieve the above object, according to still another aspect of the present invention, there is provided a robot operating system.

The robot operating system of the embodiment of the invention may include: a memory data acquisition unit for: after the robot is started, acquiring pre-stored historical memory data of at least one application program from a server; wherein the application is provided in the robot; an execution unit to: determining an application program to be started from the at least one application program, starting the application program to be started and sending historical memory data of the application program to be started to a local file of the application program to be started; and the application program to be started runs according to the historical memory data in the local file.

The robot operating system of the embodiment of the present invention may include: a history memory data acquisition unit configured to: after the robot is started, acquiring pre-stored historical memory data of at least one application program from a server; wherein the application is provided in the robot; the external response unit is used for receiving an external instruction aiming at the robot and determining a target application program corresponding to the external instruction; an application startup unit configured to: when the target application program is one of the at least one application program, starting the target application program and sending the historical memory data of the target application program to a local file of the target application program; wherein the target application's historical memory data is used when the target application is running and/or abnormally exited.

To achieve the above object, according to still another aspect of the present invention, there is provided a robot. The robot of the embodiment of the invention is provided with the robot operating system.

To achieve the above object, according to still another aspect of the present invention, there is provided an electronic apparatus.

An electronic device of the present invention includes: one or more processors; the storage device is used for storing one or more programs, and when the one or more programs are executed by the one or more processors, the one or more processors realize the method for running the application program provided by the invention.

To achieve the above object, according to still another aspect of the present invention, there is provided a computer-readable storage medium.

A computer-readable storage medium of the present invention has stored thereon a computer program which, when executed by a processor, implements the method of running an application provided by the present invention.

According to the technical scheme of the invention, one embodiment of the invention has the following advantages or beneficial effects: the embodiment of the invention provides a method for operating a robot application program in two scenes. In the first scenario, after the robot is started, the robot operating system obtains the historical memory data of the application programs stored in advance from the server, and determines the application program to be started from the application programs. For example, the application program with the shutdown interruption flag in the application programs may be used as the application program to be started, or the application program with the highest priority in the application programs with the running associated data may be used as the application program to be started. And then starting the application program to be started and sending the historical memory data of the application program to be started, which is acquired from the server, to the local file of the application program to be started, wherein the application program to be started can run according to the historical memory data in the local file after being started. In the scene, the robot operating system can directly enter the application program interrupted by shutdown last time or the application program with the highest priority without waiting for an external instruction after being started, and continues to run according to the historical memory state. In the second scenario, the robot operating system acquires the pre-stored historical memory data of the application program from the server after starting, and when receiving an external instruction for the target application program, if the target application program corresponds to the historical memory data acquired before, the target application program is started and the corresponding historical memory data is sent to a local file of the target application program, and the historical memory data is used when the target application program is operated or abnormally quitted. Specifically, if the historical memory data contains both operation related data and a memory function opening flag, the target application program can upload the current operation state to the server according to the operation related data when running and when abnormally quitting; if the historical memory data only contains the memory function opening mark and does not contain the operation related data, the target application program can upload the current operation state to the server when the target application program abnormally exits. Through the arrangement, the robot application program with the memory function can run according to historical memory data in various scenes, so that the intelligent degree of the robot is improved, and the interaction experience of the robot and a user is improved.

Further effects of the above-mentioned non-conventional alternatives will be described below in connection with the embodiments.

Drawings

The drawings are included to provide a better understanding of the invention and are not to be construed as unduly limiting the invention. Wherein:

FIG. 1 is a schematic diagram of an architecture in which an intelligent robot is located in an embodiment of the present invention;

FIG. 2 is a diagram illustrating the main steps of a method for running an application program according to a first embodiment of the present invention;

FIG. 3 is a diagram illustrating the main steps of a method for running an application according to a second embodiment of the present invention;

FIG. 4 is a schematic view of a life cycle of a robot operating system according to an embodiment of the present invention;

FIG. 5 is a schematic diagram of the components of a robot operating system in a third embodiment of the present invention;

FIG. 6 is a schematic diagram of the components of a robot operating system in a fourth embodiment of the present invention;

FIG. 7 is an exemplary system architecture diagram in which embodiments of the present invention may be employed;

fig. 8 is a schematic structural diagram of an electronic device for implementing the method for running the application program in the embodiment of the present invention.

Detailed Description

Exemplary embodiments of the present invention are described below with reference to the accompanying drawings, in which various details of embodiments of the invention are included to assist understanding, and which are to be considered as merely exemplary. Accordingly, those of ordinary skill in the art will recognize that various changes and modifications of the embodiments described herein can be made without departing from the scope and spirit of the invention. Also, descriptions of well-known functions and constructions are omitted in the following description for clarity and conciseness.

The robot is a machine device which automatically executes work, can receive human commands, and can run a pre-programmed program. The robot can be divided into an intelligent robot and a common robot according To the intelligent degree, the intelligent robot generally depends on the artificial intelligence technologies of ASR, NLU, TTS (Text To Speech), face recognition, image recognition, expression recognition and the like, various application programs are set, and various specific services are provided for users, such as playing music, telling stories, inquiring weather and the like. Generally, applications for robot settings (which may be simply referred to as robot applications) may be divided into long applications (longer running applications), such as a playing music application, a storytelling application, and short applications (shorter running applications), such as a querying weather application. In the embodiment of the present invention, description is mainly given to a long application program provided in an intelligent robot.

Fig. 1 is a schematic diagram of an architecture of an intelligent robot according to an embodiment of the present invention, and as shown in fig. 1, the architecture may be divided into a plurality of levels: the system comprises a terminal, a cloud service platform, an AI (Artificial Intelligence) module and an application module. The terminal is a robot device, and a touch sensor, a microphone matrix, an image acquisition device and the like are arranged in the terminal. It can be understood that the robot may sense an external instruction through the touch sensor, for example, a touch instruction issued by a user (an actual intention corresponding to a touch action may be preset), may sense a voice instruction issued by the user through the microphone matrix, may sense a visual instruction issued by the user through the image acquisition device, and may further set a key facing the user and receive an instruction through a key identifier pressed by the user. The robot device can directly interact with the transit server to obtain the required service, the transit server can obtain the support of various basic AI modules from the cloud service platform, and the basic AI modules can be a wake-up module, an ASR module, an NLU module, a TTS module and the like which are used for waking up the robot device according to wake-up words sent by users. The cloud service platform may include a base platform provided by each service party, and an SDK (Software development Kit) and an API (Application Programming Interface) therein. The application module refers to applications provided by the robot to the user, such as playing music, telling stories, weather query, voice chat, IOT (Internet Of Things application), and the like.

It should be noted that the embodiments of the present invention and the technical features of the embodiments may be combined with each other without conflict.

Fig. 2 is a schematic diagram of the main steps of the method for running an application program according to the first embodiment of the present invention.

As shown in fig. 2, the method for running an application program according to this embodiment may be specifically executed according to the following steps:

step S201: and after the robot is started, acquiring the pre-stored historical memory data of at least one application program from the server.

In the embodiment of the present invention, the server refers to a relay server directly interacting with the robot, and the historical memory data refers to data related to the memory function opening condition of the application program and/or the running state of the application program in a historical period. In practical application, the server can store the historical memory data of the application program with the memory function for the application program. It is understood that the opening memory function refers to a function that continues to operate according to its operating state when it was last exited after the application was started. For example, if an application program playing music turns on a memory function, it is possible to implement the following functions: the music playing application program exits last time and is playing the audio file marked as 1, the playing time is 1 minute, and the application program automatically plays the audio file marked as 1 after the application program is started, and plays the audio file from 1 minute of the audio file. In a specific scene, a user can set whether to start a memory function for any application program at any time, and corresponding setting data can be sent to a server for storage in real time.

For a certain application program of a certain robot device of a certain user, which starts a memory function, the server may store the history memory data in the following manner. The server may store an identification of the user, an identification of the robotic device, and historical memory data for the application. In some embodiments, the application's historical memory data may include: the identification of the application program and the running associated data of the application program. Wherein, when the number of the application programs of any type is only one, the type of the application program can be used as the identification thereof. For example, music is used as the identifier of the music playing application program, store is used as the identifier of the story telling application program, and file is used as the identifier of the movie playing application program.

The operation related data of the application program refers to data corresponding to a certain operation state of the application program, and the application program can determine the corresponding operation state according to the operation related data. For example, for a music playing application, its running associated data may include: an identifier of a certain audio file and the playing time of the audio file; for a storytelling application, its operational association data may include: the identification of a certain story file (also an audio file) and the playing time of the story file. It is understood that the operation related data can be flexibly set according to actual needs, and is not limited to the above specific data. For example, the operation-related data of the music playing application may also be: the network link address of a certain audio file and the playing time of the audio file, or the identification of a certain audio list and the identification of the audio files in the audio list. In some specific scenarios, the server may store only operation-related data generated by the robot device in a last operation process, where an operation process refers to a complete process from startup to operation to shutdown of the robot device. It should be noted that, for the historical memory data of any application program stored by the server, the operation related data may be included or the operation memory data may not be included.

As a preferred solution, the history data of the embodiment of the present invention is generated when the application program exits abnormally. In the field of robotics, normal exit of an application refers to: the application program executes an exit or end action after receiving an exit instruction sent by a user and aiming at the application program, wherein the abnormal exit of the application program refers to the following steps: and in the case that a quitting instruction for the application program sent by the user is not received, the quitting or ending action is executed according to a starting instruction for other application programs or a shutdown instruction for the robot sent by the user. The abnormal exit of the application program can also be exit or end of the application program caused by direct shutdown of the robot equipment due to low power and the like. It can be understood that the user can issue any of the above instructions by voice, touch, operating keys, and the like.

Preferably, the history memory data of the application program may further include a memory function start flag and/or a shutdown interruption start flag. The memory function starting mark is used for marking that the memory function is started by the application program. In practical applications, since the application programs whose server side stores the history memory data have generally started the memory function, the memory function start flag can be added to the history memory data of each application program. The shutdown interruption opening mark is used for marking the application program which is abnormally exited due to a shutdown instruction or direct shutdown (for example, due to low power) of the robot device in the last running process of the robot device, and if the historical memory data of a certain application program does not contain the shutdown interruption mark but contains running related data, the application program is indicated to be abnormally exited due to an opening instruction which is sent by a user and is aimed at other application programs. It is understood that at the same time, the historical memory data of at most one application program in the server contains a shutdown interruption mark. In addition, the historical memory data containing the shutdown interruption opening mark generally simultaneously contains the running related data of the application program. The server may store history memory data of the application programs in a database or the like, and the following table is history memory data of three application programs in one robot device stored in the server.

User ID	Device ID	Application ID	M	T	Running associated data
						wang	01	music	1	1	a_1.1
wang	01	story	1	0	b_2.2
						wang	01	film	1	0

Wherein, M indicates whether to open the memory function, M1 is the mark for opening the memory function, T indicates whether to be interrupted by shutdown, T1 is the mark for interrupting shutdown, and T1 is not the mark for interrupting shutdown. The operation related field may adopt one field or a plurality of fields (in the above table, one field is adopted), and when one field is adopted, data of a plurality of dimensions needs to be connected into a character string (for example, the audio file identification and the playing time are connected into the character string through underlining); when multiple fields are used, each dimension of the running associated data may correspond to a field, for example, for a music application, the audio file identification and the playing time may be regarded as a field. In the first line of the record in the above table, the music application has a memory function on flag M ═ 1 and a shutdown interruption flag T ═ 1, and its running associated data a _1.1 indicates that the audio file identification is a and the playing time is 1.1 minutes. In the second line of records, the storage application has a memory function start flag M of 1 and no shutdown interruption flag, and its running associated data b _2.2 indicates that the story file is identified as b and the playing time is 2.2 minutes. In the third row of records, the file application has a memory function on flag M ═ 1, and does not have a shutdown interrupt flag and running associated data.

As an alternative, the history data may further include priority data of the corresponding application program. In practical applications, different priority data may be set for different applications, and the priority data of each application may be determined according to factors such as the importance of the application and the frequency of use of the user.

The above data storage manner of the server is only an example, and in practical application, any other suitable manner may also be adopted for data storage. For example, data related to each application program in each robot device of each user may be stored, where the robot device including both the memory function activated robot device (the memory function activated robot device means that at least one application program in the robot device activates the memory function) and the application program, and the robot device and the application program not activating the memory function may be provided with a field for identifying whether or not the memory function is activated.

In step S101, after the robot device is started, the robot operating system may transmit a request to acquire history memory data of at least one application program from the server. In practical applications, the life cycle of the robot operating system can be represented by the following callback functions executed in sequence: system initialization system _ init, system start system _ start, system update system _ update (the callback function may be optionally executed), system end system _ end. When system _ init is executed, the robot operating system can start basic system services, such as various authority verification services and basic AI services such as ASR, NLU, TTS and the like, an application program can be run after system _ start is executed, system _ update can update the robot operating system, and system _ end needs to be executed when the system is shut down. In the embodiment of the present invention, the pre-system-start callback function before system _ start may be added, and the pre-system-end callback function before system _ end may be added. After the request is received by the server, the stored historical memory data corresponding to at least one application program of the robot device is sent to the robot device, and after the sending is successful, the server can delete the operation associated data in the historical memory data to release the disk space. It is understood that the historical memory data of part or all of the at least one application program comprises operation related data generated when the application program is abnormally exited in a historical period. It should be noted that, if the at least one application is a plurality of applications, the part of the applications refers to at least one application; if the at least one application is an application, the portion of the applications means that there are no applications (i.e., the number of applications is zero). After receiving the historical memory data, the robot system can cache the historical memory data in a local system file.

Step S202: determining an application program to be started from at least one application program, starting the application program to be started and sending historical memory data of the application program to be started to a local file of the application program to be started.

In this step, the robot operating system may determine an application program to be started from application programs corresponding to the history memory data after executing system _ start. In a specific application, the application program to be started can be determined in the following two ways. In the first mode, if a shutdown interruption flag exists in the history memory data of each application acquired from the server, the application having the shutdown interruption flag is determined as the application to be started. The method can determine that the application program abnormally quits due to shutdown in the previous operation process of the robot equipment and then directly operates according to the corresponding operation associated data, embodies higher intelligent degree in some scenes, and is beneficial to improving interactive experience. In the second mode, the application program with the highest priority in the application programs with the running associated data can be determined as the application program to be started, the mode can enable the robot device to directly enter the application program which is most interested in or most important for a user after the robot device is started, and the robot device is operated in a memory mode according to the running associated data, so that a higher intelligence degree is embodied in some scenes, and the user experience is favorably enhanced.

And entering the life cycle of the application program after the application program to be started is started. In practical applications, the lifecycle of an application program can be represented by the callback function executed in sequence as follows: init is initialized, start is started, update (the callback function may be optionally executed), and destroy is ended. The application execution init can obtain the service required by the operation of the application execution init, the execution start can enter a normal operation state, the execution update can upgrade the application, and the execution destroy can exit or end. In the embodiment of the present invention, the before-start callback before start may be added, and the before-end callback before definition may be added. In step S202, when the application to be started executes before _ start, the robot operating system sends its history memory data from the system file to its local file, and deletes the history memory data from the system file after the sending is successful. The robot operating system sets a local file for each application program in advance to store data related to the memory function. After executing the start, the application program to be started can be operated according to the operation associated data stored in the local file, that is, after analyzing the operation associated data to obtain the dimensional data, the application program can be operated according to the data. For example, the music playing application may obtain the audio file identifier a and the playing time of 1.1 minutes by parsing the running associated data "a _ 1.1", and then may play the audio file a from 1.1 minutes.

Thereafter, when the application to be started normally exits, the data in the local file may be cleared while the before _ destroy is executed. When the application program to be started exits abnormally, the running associated data at the current time may be generated when the before _ destroy is executed, and the generated running associated data is used to update the original data in the local file, that is, the generated running associated data is stored in the local file and the original running associated data in the local file is removed, and in addition, a mark to be uploaded (for example, FIN is 0) may be added to the local file. When the robot operating system is powered off, by executing the before _ system _ end, the operation related data in the local file with the mark to be uploaded can be uploaded to the server, and after the uploading is successful, the server can store the operation related data in the database and return an uploading success mark (for example, FIN is 1) to the robot device. After the robot device receives the uploading success mark, historical memory data stored in the local file of the application program (namely the historical memory data successfully uploaded) can be cleared so as to reduce the local storage space occupation.

Fig. 3 is a schematic diagram of the main steps of a method for running an application program according to a second embodiment of the present invention.

As shown in fig. 3, the method for running an application program of the present embodiment may be executed according to the following steps:

step S301: and after the robot is started, acquiring the pre-stored historical memory data of at least one application program from the server.

The historical memory data of any application program in at least one application program can include a memory function opening mark, and the historical memory data of part or all of the application programs in at least one application program includes operation related data generated when the application program abnormally exits in a historical period. Since the specific execution process of this step is similar to the step S201 form of the first embodiment, it is not described here again.

Step S302: and receiving an external instruction aiming at the robot, and determining a target application program corresponding to the external instruction.

Before this step, the robot operating system sends a request to the server to acquire history memory data of each application program when executing the before _ system _ start, and then executes the system _ start. Thereafter, the robot device may execute the corresponding application program according to an external instruction (e.g., an instruction issued by a user with respect to the target application program). In this step, after receiving the user instruction through the microphone matrix or other devices, the robot operating system may invoke ASR, NLU, or other services to determine the user intention and further determine the target application corresponding to the user instruction. In an actual scenario, before a user issues an instruction, a user may first need to issue a wake-up word in a manner of voice or the like to wake up the robot device.

Step S303: and when the target application program is one of the at least one application program, starting the target application program and sending the historical memory data of the target application program to a local file of the target application program.

In this step, if the target application corresponding to the user instruction is one of the at least one application corresponding to the history memory data, the target application may be started and the corresponding history memory data may be sent from the system file to the local file when the target application executes before _ start. After the successful transmission, the robot operating system may delete the successfully transmitted historical memory data in the system file. The history memory data stored in the local file of the target application program can be used when the target application program is operated and/or abnormally quitted, and specifically, the history memory data may include an application program identifier, a memory function opening mark and operation associated data, and may also include the application program identifier and the memory function opening mark but not include the operation associated data. If the historical memory data is the former, the target application program can use the operation associated data in the historical memory data during operation, and can use the memory function opening mark in the historical memory data (the memory function opening mark is used for determining whether the data needs to be uploaded) during abnormal exit; if the latter, the target application may use the memory function enable flag in the historical memory data when exiting abnormally.

In practical application, if the historical memory data of the target application program comprises an application program identifier, a memory function opening mark and operation associated data, the target application program can operate according to the operation associated data in the local file after executing the start to realize the memory function; if the history memory data of the target application includes the application id and the memory function open flag without including the operation related data, the target application may operate in an original state after the execution start. If the target application program corresponding to the user instruction does not belong to the at least one application program corresponding to the historical memory data, the robot operating system may start the target application program, and the target application program may run in an original state after the init, the before _ start, and the start are sequentially executed.

In this embodiment, when any application in the robot apparatus normally exits, it may exit after performing before _ determine, determine in order. If data is judged to be present in the local file when before _ destroy is executed, the data may be cleared to release the storage space.

When any application program in the robot device exits abnormally in a first mode (namely, the application program is interrupted by other application programs to cause abnormal exit), if a memory function opening mark is judged to exist in a local file of the application program (the memory function opening mark can be introduced from a system file when the application program executes before _ start), generating operation associated data at the current moment, storing the operation associated data in the local file of the application program (if the operation associated data is stored in the local file before, deleting the original operation associated data), and adding a mark to be uploaded in the local file; when any application program of the robot equipment abnormally exits in a second mode (abnormally exits due to an external shutdown instruction or direct shutdown interruption), if the local file of the application program is judged to have a memory function starting mark, the operation associated data at the current moment is generated, the operation associated data is stored in the local file of the application program (if the operation associated data is stored in the local file, the original operation associated data is deleted), and a mark to be uploaded and a shutdown interruption mark are added in the local file. Before the robot device is powered off, the robot operating system may detect the local file of each application program one by one, and upload the operation associated data or the operation associated data and the power-off interruption flag in the local file with the flag to be uploaded to the server. After receiving the upload success returned by the server, the application program can clear the related data in the local file.

In practical application, after any application program of the robot device, which starts the memory function, exits abnormally in the first mode, because the application program stores the operation related data in the local file when exiting abnormally, if the application program is started again according to a user instruction in the same operation process of the robot device, the application program can directly operate according to the operation related data stored in the local file, so that the memory function in the same operation process of the robot device is realized.

Fig. 4 is a schematic view of a life cycle flow of a robot operating system according to an embodiment of the present invention, as shown in fig. 4, after a robot device is powered on, a system _ init, a before _ system _ start, and a system _ start may be sequentially executed, and when the before _ system _ start is executed, a request may be sent to a server to obtain history memory data. After system _ start is executed, it can be determined whether the memory function is turned on (i.e. whether there is an application to be started in the first embodiment): if yes, directly entering the corresponding application program (namely the application program to be started), and otherwise, entering an IDLE state (namely an IDLE state). When the robot device is in an idle state, an external event (e.g., a user instruction) may be listened to by the listening module and an application may be started according to the external event. The monitoring module can have functions of awakening, ASR, NLU and the like. After the application program is started, the service of the monitoring module can be called, and callback functions such as init, before _ start, start and the like can be sequentially executed until the application program enters the running state. Wherein, the robot operating system may send the corresponding history memory data stored in the system file to the local file of the application program when executing before _ start. The application may also implement software updates by executing update. When the application program exits, before _ destroy and destroy can be executed in sequence to realize exiting, and then the robot device enters an idle state. When before _ destroy is executed, the application program with the memory function can save the current running associated data in a local file and add a mark to be uploaded. When the robot equipment is powered off, the robot operating system sequentially executes the before _ system _ end and the system _ end, and when the before _ system _ end is executed, the robot operating system can upload the running related data in the local file with the mark to be uploaded to the server.

In the technical scheme of the embodiment of the invention, two methods for operating the robot application program under two scenes are provided. In the first scenario, after the robot is started, the robot operating system obtains the historical memory data of the application programs stored in advance from the server, and determines the application program to be started from the application programs. For example, the application program with the shutdown interruption flag in the application programs may be used as the application program to be started, or the application program with the highest priority in the application programs with the running associated data may be used as the application program to be started. And then starting the application program to be started and sending the historical memory data of the application program to be started, which is acquired from the server, to the local file of the application program to be started, wherein the application program to be started can run according to the historical memory data in the local file after being started. In the scene, the robot operating system can directly enter the application program interrupted by shutdown last time or the application program with the highest priority without waiting for an external instruction after being started, and continues to run according to the historical memory state. In the second scenario, the robot operating system acquires the pre-stored historical memory data of the application program from the server after starting, and when receiving an external instruction for the target application program, if the target application program corresponds to the historical memory data acquired before, the target application program is started and the corresponding historical memory data is sent to a local file of the target application program, and the historical memory data is used when the target application program is operated or abnormally quitted. Specifically, if the historical memory data contains both operation related data and a memory function opening flag, the target application program can upload the current operation state to the server according to the operation related data when running and when abnormally quitting; if the historical memory data only contains the memory function opening mark and does not contain the operation related data, the target application program can upload the current operation state to the server when the target application program abnormally exits. Through the arrangement, the robot application program with the memory function can run according to historical memory data in various scenes, so that the intelligent degree of the robot is improved, and the interaction experience of the robot and a user is improved.

It should be noted that, for the convenience of description, the foregoing method embodiments are described as a series of acts, but those skilled in the art will appreciate that the present invention is not limited by the order of acts described, and that some steps may in fact be performed in other orders or concurrently. Moreover, those skilled in the art will appreciate that the embodiments described in the specification are presently preferred and that no acts or modules are necessarily required to implement the invention.

Fig. 5 is a schematic diagram of components of a robot operating system according to a third embodiment of the present invention, and as shown in fig. 5, the robot operating system 500 of this embodiment may include: a memory data acquisition unit 501 and an execution unit 502.

The memory data acquiring unit 501 may be configured to: after the robot is started, acquiring pre-stored historical memory data of at least one application program from a server; wherein the application is provided in the robot; the execution unit 502 may be to: determining an application program to be started from the at least one application program, starting the application program to be started and sending historical memory data of the application program to be started to a local file of the application program to be started; and the application program to be started runs according to the historical memory data in the local file.

In an optional implementation manner, the historical memory data of part or all of the at least one application program comprises operation related data generated when the application program abnormally exits in a historical period. In practical applications, the execution unit 502 may further be configured to: and when the shutdown interruption mark exists in the historical memory data of the at least one application program, determining the application program with the shutdown interruption mark as the application program to be started.

In a specific application, the history memory data of any application program in the at least one application program includes priority data of the application program. The execution unit 502 may be further configured to: and determining the application program with the highest priority in the application programs with the running associated data as the application program to be started.

Preferably, the running of the application program to be started according to the historical memory data in the local file comprises: and the application program to be started runs according to the running associated data in the local file.

Furthermore, in an embodiment of the present invention, the robot operating system 500 may further include a data uploading unit for: when the application program to be started exits abnormally: generating operation associated data at the current moment, storing the operation associated data in a local file of the application program to be started, removing the original operation associated data in the local file, and adding a mark to be uploaded in the local file; and uploading the operation associated data in the local file with the mark to be uploaded to a server before the robot is shut down.

Fig. 6 is a schematic diagram of components of a robot operating system according to a fourth embodiment of the present invention, and as shown in fig. 6, the robot operating system 600 according to this embodiment may include: a history memory data acquisition unit 601, an external response unit 602, and an application program starting unit 603.

The history memory data obtaining unit 601 may be configured to: after the robot is started, acquiring pre-stored historical memory data of at least one application program from a server; wherein the application is provided in the robot; the external response unit 602 may be configured to receive an external instruction for the robot, and determine a target application program corresponding to the external instruction; the application start unit 603 may be configured to: when the target application program is one of the at least one application program, starting the target application program and sending the historical memory data of the target application program to a local file of the target application program; wherein the target application's historical memory data is used when the target application is running and/or abnormally exited.

In an optional implementation manner, the history memory data of any application program in the at least one application program includes a memory function opening mark; the historical memory data of part or all of the at least one application program comprises operation related data generated when the application program is abnormally exited in a historical period.

Preferably, when the target application is one of the at least one application and the history memory data of the target application includes the operation related data, the target application is operated according to the operation related data stored in the local file of the target application after being started.

As a preferred solution, the robot operating system 600 further includes a data uploading unit, configured to: when any application program set in the robot exits abnormally in a first mode: if the memory function starting mark exists in the local file of the application program, generating operation associated data at the current moment, storing the operation associated data in the local file of the application program, and adding a mark to be uploaded in the local file; the abnormal exit of the first mode is an abnormal exit caused by interruption of other application programs; and uploading the operation associated data in the local file with the mark to be uploaded to a server before the robot is shut down.

In addition, in the embodiment of the present invention, the data uploading unit may further be configured to: when any application program set in the robot exits abnormally in a second mode: if the memory function starting mark exists in the local file of the application program, generating operation associated data at the current moment, storing the operation associated data in the local file of the application program, and adding a mark to be uploaded and a shutdown interruption mark in the local file; the abnormal exit of the second mode is an abnormal exit caused by interruption of an external shutdown instruction; and uploading the operation related data and/or the shutdown interruption mark in the local file with the mark to be uploaded to a server before the robot is shut down.

In an embodiment of the present invention, there is further provided a robot provided with the robot operating system described in the third embodiment or the fourth embodiment. It is understood that the robot includes a driving system, a mechanical structure system, a feeling system, a robot-environment interaction system, a man-machine interaction system, a control system, etc. in addition to the robot operation system.

Fig. 7 illustrates an exemplary system architecture 700 for a method of running an application to which embodiments of the present invention may be applied.

As shown in fig. 7, the system architecture 700 may include

robotic devices

701, 702, 703, a network 704, a transit server 705, and

remote servers

706, 707, 708. (this architecture is merely an example, and the components included in a particular architecture may be tailored to application specific circumstances). The network 704 serves as a medium to provide a communication link between the

robotic devices

701, 702, 703 and the relay server 705. Network 704 may include various connection types, such as wired, wireless communication links, or fiber optic cables, to name a few. The transit server 705 may communicate with

remote servers

706, 707, 708 over a network, the

remote servers

706, 707, 708 serving ASR, NLU, etc.

The

robotic devices

701, 702, 703 interact with a transit server 705 over a network 704 to receive or send messages, etc., and the transit server 705 may communicate with

remote servers

706, 707, 708 to obtain ASR, NLU, etc. services. The

robotic devices

701, 702, 703 may have various applications installed thereon, such as applications that play music, applications that tell stories, etc. (by way of example only).

The

robotic devices

701, 702, 703 may be various intelligent robotic devices including, but not limited to, industrial robots, service robots, exploration robots, military robots, and the like.

The relay server 705 may be a server that provides various services, such as a server that provides support for various applications in the

robot devices

701, 702, 703. The relay server 705 may process the received data processing request and feed back the data processing result to the

robot apparatuses

701, 702, and 703. It should be noted that the transit server 705 may need to send a request to the

remote servers

706, 707, 708 to complete the above data processing.

It should be noted that the method for running the application program provided by the embodiment of the present invention is generally performed by the

robot devices

701, 702, and 703.

It should be understood that the number of robotic devices, networks, and servers in fig. 7 are merely illustrative. There may be any number of robotic devices, networks, and servers, as desired for implementation.

The invention also provides the electronic equipment. The electronic device of the embodiment of the invention comprises: one or more processors; the storage device is used for storing one or more programs, and when the one or more programs are executed by the one or more processors, the one or more processors realize the method for running the application program provided by the invention.

Referring now to FIG. 8, shown is a block diagram of a computer system 800 suitable for use in implementing an electronic device of an embodiment of the present invention. The electronic device shown in fig. 8 is only an example, and should not bring any limitation to the functions and the scope of use of the embodiments of the present invention.

As shown in fig. 8, the computer system 800 includes a Central Processing Unit (CPU)801 that can perform various appropriate actions and processes in accordance with a program stored in a Read Only Memory (ROM)802 or a program loaded from a storage section 808 into a Random Access Memory (RAM) 803. In the RAM803, various programs and data necessary for the operation of the computer system 800 are also stored. The CPU801, ROM 802, and RAM803 are connected to each other via a bus 804. An input/output (I/O) interface 805 is also connected to bus 804.

The following components are connected to the I/O interface 805: an input portion 806 including a keyboard, a mouse, and the like; an output section 807 including a signal such as a Cathode Ray Tube (CRT), a Liquid Crystal Display (LCD), and the like, and a speaker; a storage portion 808 including a hard disk and the like; and a communication section 809 including a network interface card such as a LAN card, a modem, or the like. The communication section 809 performs communication processing via a network such as the internet. A drive 810 is also connected to the I/O interface 805 as necessary. A removable medium 811 such as a magnetic disk, an optical disk, a magneto-optical disk, a semiconductor memory, or the like is mounted on the drive 810 as necessary, so that a computer program read out therefrom is mounted into the storage section 808 as necessary.

In particular, the processes described in the main step diagrams above may be implemented as computer software programs, according to embodiments of the present disclosure. For example, embodiments of the invention include a computer program product comprising a computer program embodied on a computer readable medium, the computer program comprising program code for performing the method illustrated in the main step diagram. In the above-described embodiment, the computer program can be downloaded and installed from a network via the communication section 809 and/or installed from the removable medium 811. The computer program, when executed by the central processing unit 801, performs the above-described functions defined in the system of the present invention.

It should be noted that the computer readable medium shown in the present invention can be a computer readable signal medium or a computer readable storage medium or any combination of the two. A computer readable storage medium may be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination of the foregoing. More specific examples of the computer readable storage medium may include, but are not limited to: an electrical connection having one or more wires, a portable computer diskette, a hard disk, a Random Access Memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing. In the present invention, a computer readable storage medium may be any tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device. In the present invention, a computer readable signal medium may include a propagated data signal with computer readable program code embodied therein, for example, in baseband or as part of a carrier wave. Such a propagated data signal may take many forms, including, but not limited to, electro-magnetic, optical, or any suitable combination thereof. A computer readable signal medium may also be any computer readable medium that is not a computer readable storage medium and that can communicate, propagate, or transport a program for use by or in connection with an instruction execution system, apparatus, or device. Program code embodied on a computer readable medium may be transmitted using any appropriate medium, including but not limited to: wireless, wire, fiber optic cable, RF, etc., or any suitable combination of the foregoing.

The flowchart and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments of the present invention. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of code, which comprises one or more executable instructions for implementing the specified logical function(s). It should also be noted that, in some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams or flowchart illustration, and combinations of blocks in the block diagrams or flowchart illustration, can be implemented by special purpose hardware-based systems which perform the specified functions or acts, or combinations of special purpose hardware and computer instructions.

The units described in the embodiments of the present invention may be implemented by software or hardware. The described units may also be provided in a processor, and may be described as: a processor includes a memory data acquisition unit and an execution unit. Where the names of these units do not in some cases constitute a limitation on the unit itself, for example, the memory data obtaining unit may also be described as a "unit that provides history memory data to the execution unit".

As another aspect, the present invention also provides a computer-readable medium that may be contained in the apparatus described in the above embodiments; or may be separate and not incorporated into the device. The computer readable medium carries one or more programs which, when executed by the apparatus, cause the apparatus to perform steps comprising: after the robot is started, acquiring pre-stored historical memory data of at least one application program from a server; wherein the application is provided in the robot; determining an application program to be started from the at least one application program, starting the application program to be started and sending historical memory data of the application program to be started to a local file of the application program to be started; and the application program to be started runs according to the historical memory data in the local file. Or after the robot is started, acquiring pre-stored historical memory data of at least one application program from the server; wherein the application is provided in the robot; receiving an external instruction aiming at the robot, and determining a target application program corresponding to the external instruction; when the target application program is one of the at least one application program, starting the target application program and sending the historical memory data of the target application program to a local file of the target application program; wherein the target application's historical memory data is used when the target application is running and/or abnormally exited.

The above-described embodiments should not be construed as limiting the scope of the invention. Those skilled in the art will appreciate that various modifications, combinations, sub-combinations, and substitutions can occur, depending on design requirements and other factors. Any modification, equivalent replacement, and improvement made within the spirit and principle of the present invention should be included in the protection scope of the present invention.

Claims

1. A method for running application program is applied to a robot operating system; characterized in that the method comprises:

after the robot is started, acquiring pre-stored historical memory data of at least one application program from a server; wherein the application is provided in the robot;

determining an application program to be started from the at least one application program, starting the application program to be started and sending historical memory data of the application program to be started to a local file of the application program to be started; and the application program to be started runs according to the historical memory data in the local file.

2. The method of claim 1, wherein the historical memory data of some or all of the at least one application comprises running association data generated when the application exits abnormally during a historical period.

3. The method of claim 1, wherein determining an application to be launched from the at least one application comprises:

and when the shutdown interruption mark exists in the historical memory data of the at least one application program, determining the application program with the shutdown interruption mark as the application program to be started.

4. The method of claim 1,

the historical memory data of any application program in the at least one application program comprises priority data of the application program; and determining an application to be started from the at least one application, including:

and determining the application program with the highest priority in the application programs with the running associated data as the application program to be started.

5. The method according to claim 2, wherein the application to be started runs according to historical memory data in the local file, and the method comprises the following steps:

and the application program to be started runs according to the running associated data in the local file.

6. The method according to claim 2 or 5, characterized in that the method further comprises:

when the application program to be started exits abnormally: generating operation associated data at the current moment, storing the operation associated data in a local file of the application program to be started, removing the original operation associated data in the local file, and adding a mark to be uploaded in the local file;

and uploading the operation associated data in the local file with the mark to be uploaded to a server before the robot is shut down.

7. A method for running application program is applied to a robot operating system; characterized in that the method comprises:

receiving an external instruction aiming at the robot, and determining a target application program corresponding to the external instruction;

when the target application program is one of the at least one application program, starting the target application program and sending the historical memory data of the target application program to a local file of the target application program; wherein the target application's historical memory data is used when the target application is running and/or abnormally exited.

8. The method of claim 7,

historical memory data of any application program in the at least one application program comprises a memory function starting mark;

the historical memory data of part or all of the at least one application program comprises operation related data generated when the application program is abnormally exited in a historical period.

9. The method according to claim 8, wherein when the target application is one of the at least one application and the history data of the target application includes the operation related data, the target application is operated according to the operation related data stored in the local file of the target application after being started.

10. The method according to claim 8 or 9, characterized in that the method further comprises:

when any application program set in the robot exits abnormally in a first mode: if the memory function starting mark exists in the local file of the application program, generating operation associated data at the current moment, storing the operation associated data in the local file of the application program, and adding a mark to be uploaded in the local file; the abnormal exit of the first mode is an abnormal exit caused by interruption of other application programs;

11. The method according to claim 8 or 9, characterized in that the method further comprises:

when any application program set in the robot exits abnormally in a second mode: if the memory function starting mark exists in the local file of the application program, generating operation associated data at the current moment, storing the operation associated data in the local file of the application program, and adding a mark to be uploaded and a shutdown interruption mark in the local file; the abnormal exit of the second mode is an abnormal exit caused by interruption of an external shutdown instruction;

and uploading the operation related data and/or the shutdown interruption mark in the local file with the mark to be uploaded to a server before the robot is shut down.

12. A robotic operating system, comprising:

a memory data acquisition unit for: after the robot is started, acquiring pre-stored historical memory data of at least one application program from a server; wherein the application is provided in the robot;

an execution unit to: determining an application program to be started from the at least one application program, starting the application program to be started and sending historical memory data of the application program to be started to a local file of the application program to be started; and the application program to be started runs according to the historical memory data in the local file.

13. A robotic operating system, comprising:

a history memory data acquisition unit configured to: after the robot is started, acquiring pre-stored historical memory data of at least one application program from a server; wherein the application is provided in the robot;

the external response unit is used for receiving an external instruction aiming at the robot and determining a target application program corresponding to the external instruction;

an application startup unit configured to: when the target application program is one of the at least one application program, starting the target application program and sending the historical memory data of the target application program to a local file of the target application program; wherein the target application's historical memory data is used when the target application is running and/or abnormally exited.

14. A robot, characterized in that the robot is provided with a robot operating system according to claim 12 or 13.

15. An electronic device, comprising:

one or more processors;

a storage device for storing one or more programs,

when executed by the one or more processors, cause the one or more processors to implement the method of any one of claims 1-11.

16. A computer-readable storage medium, on which a computer program is stored, which, when being executed by a processor, carries out the method according to any one of claims 1-11.