CN111858194A - Method and device for generating and processing robot error, robot and background server - Google Patents
Method and device for generating and processing robot error, robot and background server Download PDFInfo
- Publication number
- CN111858194A CN111858194A CN202010405463.1A CN202010405463A CN111858194A CN 111858194 A CN111858194 A CN 111858194A CN 202010405463 A CN202010405463 A CN 202010405463A CN 111858194 A CN111858194 A CN 111858194A
- Authority
- CN
- China
- Prior art keywords
- event
- robot
- script
- voice input
- bottom layer
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/22—Detection or location of defective computer hardware by testing during standby operation or during idle time, e.g. start-up testing
Abstract
The invention provides a method and a device for generating and processing robot errors, a robot and a background server. A robot error generation method is applied to a robot end, and comprises the following steps: recording a bottom layer event stream script and a voice input event script when the operation of the robot fails; unifying the triggering time and the format of the bottom layer event stream script and the voice input event script to form event information comprising a plurality of event character strings; and sending the event information to a background server, wherein the background server is used for injecting the event information in a command form to play back the fault event. By acquiring the time information of the robot operated by the user for background playback, the method can conveniently, quickly and accurately solve the fault of the robot product delivered to the user without filling a report or performing complicated one-to-one fuzzy voice communication by the user, thereby avoiding disturbance to the user.
Description
Technical Field
The invention relates to the technical field of robots, in particular to a method and a device for generating and processing robot errors, a robot and a background server.
Background
The voice interaction robot is favored by more and more users in the market by virtue of rich and convenient interaction capacity, but the rich interaction capacity brings huge challenges to developers, tests and maintenance, particularly after a robot product is delivered to the users, when equipment fails, testers cannot reproduce fault scenes, and meanwhile, the conditions such as interaction flows of the users and operation environments of the robot scenes are not transparent, and the fault can only be traced back by means of logs, and if part of key information is lacked, the repair fault period is prolonged or the frequency of returning the users is increased.
Recording and playback are of great help to many software engineering tasks, especially for batch testing, the repeated workload of testers is reduced to a considerable extent, so that many automated testing tools and platforms are born on an Android platform, but most of the platforms or tools are GUI-based application program pressure testing, recording and playback, and most of the platforms or tools cannot capture advanced complex actions or sensor events of users, such as zooming, acceleration sensors and the like.
Simulating a user touch screen event by using an Android adb shell command: in the Android platform, we can simulate a touch screen operation on an application by using an adb command, such as clicking ($ adb shell input tap 100100) to indicate that we will simulate a one-click behavior on (100, 200) coordinates of a screen.
Disadvantages of the first prior art
The scheme supports fewer events, only supports text/keyevent/tap/swap/press/roll events, has low efficiency and can only be used as a simple one-time debugging test.
Prior art 2
Monkey: monkey is a pressure test tool carried by Android SDK, and sends pseudo-random user event streams such as key input, touch screen input, gesture input and the like to a system in a test process, so as to realize pressure test on an application program under development and log output.
The second prior art has the defects
The tool can only do some pressure tests by a program, and has great limitation because test events and data are random and cannot be defined by user and the controllability is poor. The main characteristic is that all events are randomly generated without the subjectivity of anyone.
Prior art III
Monkey Runner + monkey Recorder: MonkeyRunner is also a testing tool provided by Android SDK. Strictly speaking, the Monkey Runner is actually an Api development kit, is stronger than Monkey, can write test scripts to define data and events, and the Monkey recorder is a GUI recording tool.
Disadvantages of the third prior art
The script is written in Python, which requires additional learning cost for the tester. And the API provided by the plug-in is limited, the plug-in is required to expand the function of the plug-in, and similarly, the plug-in does not meet the recording requirement of people and needs to be separated from the running of a PC.
Prior art four
UiAutomator: the UiAutomator is also an automatic testing framework provided by Android, basically supports all Android event operations, and does not need testers to know the code implementation details in comparison with Instrumentation (the UiAutomatorviewer can be used for acquiring control attributes on an App page without viewing source codes).
Disadvantages of the prior art
Only supporting SDK 16(Android 4.1) and above, and not supporting Hybird App and WebApp. There is a lack of support for the recording function.
Disclosure of Invention
In view of the above problems, the present invention provides a method and an apparatus for generating and processing a robot error, a robot and a backend server, where the existing tool for processing a robot error can only perform some pressure tests, and because test events and data are random, cannot be customized, and has poor controllability, there are great limitations.
The technical scheme of the embodiment of the invention is realized as follows:
The embodiment of the invention provides a robot error generation method, which is applied to a robot end and comprises the following steps:
recording a bottom layer event stream script and a voice input event script when the operation of the robot fails;
unifying the triggering time and the format of the bottom layer event stream script and the voice input event script to form event information comprising a plurality of event character strings;
and sending the event information to a background server, wherein the background server is used for injecting the event information in a command form to play back the fault event.
Further, in the generating method, the recording a bottom layer event stream script and a voice input event script when the operation of the robot fails includes:
the method comprises the steps of obtaining touch operation of a user on the robot, generating corresponding bottom layer events through the touch operation through a device file, and sequencing a plurality of bottom layer events according to time to form a bottom layer event stream script.
Further, in the generating method, each event string includes:
the method comprises the following steps of indicating event triggering time, distinguishing an event into an identification character of a bottom layer event stream or a voice input event, indicating an event type, indicating an event name and indicating a specific numerical value of the event; if the event is a voice input event, the character indicating the specific numerical value of the event is an encrypted character.
Further, in the generating method, the recording a bottom layer event stream script and a voice input event script when the operation of the robot fails includes:
receiving an instruction of starting recording by a user, and recording the bottom layer event stream script and the voice input event script;
and receiving an instruction of stopping recording by the user and stopping recording.
The embodiment of the invention also provides a robot error processing method which is applied to a background server and comprises the following steps:
acquiring event information sent by a robot;
the event information comprises a bottom layer event stream script and a voice input event script when the operation of the robot fails, and a plurality of event character strings formed by uniformly triggering time and formats of the bottom layer event stream script and the voice input event script;
and injecting the event information in a command form to perform fault event playback.
Further, in the processing method, the injecting the event information in the form of a command and performing fault event playback includes:
when the event information is injected and the voice input information is analyzed, the injection operation is suspended, and the robot capability is called for playback; continuing injecting when the robot capability playback is successful;
And when the event information is injected and analyzed to the touch operation information, continuing injecting the event information for analysis.
An embodiment of the present invention further provides a robot error generation apparatus, including:
the recording module is used for recording a bottom layer event stream script and a voice input event script when the operation of the robot fails;
the event information generation module is used for unifying the triggering time and the format of the bottom layer event stream script and the voice input event script to form event information comprising a plurality of event character strings;
and the sending module is used for sending the event information to a background server, and the background server is used for injecting the event information in a command form to play back the fault event.
An embodiment of the present invention further provides a robot error processing apparatus, including:
the acquisition module is used for acquiring event information sent by the robot;
the event information comprises a bottom layer event stream script and a voice input event script when the operation of the robot fails, and a plurality of event character strings formed by uniformly triggering time and formats of the bottom layer event stream script and the voice input event script;
And the playback module is used for injecting the event information in a command form and playing back the fault event. .
An embodiment of the present invention also provides a robot including:
one or more processors;
a memory communicatively coupled to the one or more processors;
one or more application programs, wherein the one or more application programs are stored in the memory and configured to be executed by the one or more processors, the one or more programs configured to perform the generation method described above.
The embodiment of the present invention further provides a background server, including:
one or more processors;
a memory communicatively coupled to the one or more processors;
one or more application programs, wherein the one or more application programs are stored in the memory and configured to be executed by the one or more processors, the one or more programs configured to the processing method described above.
An embodiment of the present invention further provides a system, including: the robot and the background server.
In the method and the device for generating and processing the robot error, the robot and the background server, the time information of the robot when being operated by the user is acquired for background playback, the method can conveniently, quickly and accurately solve the fault of the robot product delivered to the user, and the user does not need to fill a report or perform complicated one-to-one fuzzy voice communication, so that the disturbance to the user is avoided.
Drawings
In order to more clearly illustrate the technical solutions in the embodiments of the present invention, the drawings needed to be used in the description of the embodiments will be briefly introduced below, and it is obvious that the drawings in the following description are only some embodiments of the present invention, and it is obvious for those skilled in the art to obtain other drawings based on these drawings without creative efforts.
FIG. 1 is a flow chart illustrating a method for generating a robot error according to an embodiment of the present invention;
fig. 2 is a schematic flow chart illustrating the start and stop of recording in the method for generating a robot error according to the embodiment of the present invention;
FIG. 3 is a flow chart illustrating a method for handling robot errors in an embodiment of the invention;
FIG. 4 is a schematic diagram showing a configuration of a robot error generation apparatus according to an embodiment of the present invention;
FIG. 5 is a schematic diagram showing a configuration of a robot error processing apparatus according to an embodiment of the present invention;
FIG. 6 shows a flow of robot error generation, processing in an embodiment of the invention;
FIG. 7 is a diagram illustrating log information generated by a touch in an embodiment of the present invention;
FIG. 8 is a schematic diagram of an event script in an embodiment of the invention.
Detailed Description
In order to make the technical solutions of the present invention better understood, the technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the drawings in the embodiments of the present invention.
In some of the flows described in the present specification and claims and in the above figures, a number of operations are included that occur in a particular order, but it should be clearly understood that these operations may be performed out of order or in parallel as they occur herein, with the order of the operations being numbered such as 110, 120, etc. merely to distinguish between the various operations, and the order of the operations by themselves is not intended to represent any order of performance. Additionally, the flows may include more or fewer operations, and the operations may be performed sequentially or in parallel. It should be noted that, the descriptions of "first", "second", etc. in this document are used for distinguishing different messages, devices, modules, etc., and do not represent a sequential order, nor limit the types of "first" and "second" to be different.
The technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the drawings in the embodiments of the present invention, and it is obvious that the described embodiments are only a part of the embodiments of the present invention, and not all of the embodiments. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present invention.
Referring to fig. 1, an embodiment of the present invention provides a method for generating a robot error, which is applied to a robot side, and the method includes the following steps:
step S110, recording a bottom layer event stream script and a voice input event script when the operation of the robot fails;
step S120, unifying the triggering time and the format of the bottom layer event stream script and the voice input event script to form event information comprising a plurality of event character strings;
step S130, the event information is sent to a background server, and the background server is used for injecting the event information in a command form and playing back the fault event.
The generation method is applied to a robot end, and time information of the robot when being operated by a user is acquired for background playback. In particular, by directly capturing and reproducing the underlying event stream (including underlying GUI touchscreen events such as clicks, inputs, and advanced gesture events such as zoom, swipe) and voice input events when a user fails in using the robot. And the format of the bottom layer event stream script is the same as that of the voice input event script, and the trigger time units of the bottom layer event stream script and the voice input event script are the same, so that the fault scene is directly injected and executed when being replayed, and scene replay is provided for developers and testers to solve the fault. The method can conveniently, quickly and accurately solve the fault of the robot product delivered to the user, and does not need the user to fill in a report or perform complicated one-to-one fuzzy voice communication and disturb the user.
Referring to fig. 2, as an embodiment of starting recording and ending recording in the generating method of the present invention, further, in the generating method, in step S110, the step of recording the bottom layer event stream script and the voice input event script when the operation of the robot fails includes:
step S111, receiving a command of starting recording by a user, and recording the bottom layer event stream script and the voice input event script;
and step S112, receiving the instruction of stopping recording of the user and stopping recording.
When the user operates the robot, the robot generates errors, and the user can start to record the bottom layer event stream script and the voice input event script in a voice command or dialog box clicking mode. Thereby reproducing the complete process of the robot with errors.
If the recording is finished, the user can close the recording in the form of voice command or dialog box clicking. And finally, forming a complete bottom layer event stream script for recording the robot errors and the voice input event script. The method for starting and stopping recording of the embodiment can provide a way for a user to feed back whether the robot has an error or not, meanwhile, the feedback mechanism is simple to operate and convenient for the user to use, the user does not need to fill in a report or perform complicated one-to-one fuzzy voice communication, and disturbance to the user is avoided.
Further, in the generating method, in the step S110, the recording a bottom layer event stream script and a voice input event script when the operation of the robot fails includes:
the method comprises the steps of obtaining touch operation of a user on the robot, generating corresponding bottom layer events through the touch operation through a device file, and sequencing a plurality of bottom layer events according to time to form a bottom layer event stream script.
The method comprises the steps of recording touch events of a robot operated by a user through an equipment file by utilizing the characteristics of an Android system, and arranging the events to form a bottom layer event stream script.
Specifically, the Android system is an operating system based on Linux open source code, which adds a Dalvik virtual machine belonging to the Android system to the Linux system, each scene in the Android-based robot belongs to a Dalvik virtual machine instance, when the Android device interacts with the robot, the Android device generates a corresponding (normal or advanced) event (such as click, long press and the like) through a/dev/input/event device file and sends the event to a system kernel, a corresponding event file list can be checked through a getevent, wherein the event file with the name of touch _ dev is concerned, the file is assumed to be/dev/input/event 1, when the Android device clicks a screen, the event information corresponding to the getevent-t-l can be checked through the getevent, and an information log can be generated when an operation is triggered once, for example, one click on the screen will generate the log information shown in fig. 7.
And the information of each row corresponds to four corresponding data ([ timing ] device: typecode), which respectively represent: the method comprises the steps of the Android system, the time from the last system restart, the corresponding touch _ dev equipment, the input event type, the input event name and the value. The default value in the figure is hexadecimal, and we can convert into corresponding decimal when in use, and in addition, the first row is the tracking ID of the event, which is used for distinguishing a plurality of simultaneous operations, for example, when a plurality of fingers touch the device, each finger is bound with an independent tracking ID when the finger is still on the screen, and the tracking ID can be reused when the finger leaves the screen; the fourth, fifth and sixth lines are the X, Y coordinate locations of our click, the third and seventh lines represent the pressure level or signal strength of the touch event, and SYN _ REPORT represents the amount of signal sent when the touch event up occurs. The time information of the first column can be used as interval information in the middle of each operation when the user plays back, and the playback can be accurate to microsecond time precision.
Further, in the generating method, each event string includes:
the method comprises the following steps of indicating event triggering time, distinguishing an event into an identification character of a bottom layer event stream or a voice input event, indicating an event type, indicating an event name and indicating a specific numerical value of the event; if the event is a voice input event, the character indicating the specific numerical value of the event is an encrypted character.
In addition to the touch screen (normal or advanced) event information that we need, we need to capture the voice input event, which we can get through the robot system open interface, and for the data format unification to facilitate the later playback, we will unify the data format to be the touch screen event format consistency, and at the same time will unify the event trigger time to be the microsecond level. After the recording is finished, the information of the event is added to the touch screen event information and is sequenced, so that all event information files from the beginning to the end of recording of the user are obtained. Finally, the entire event file is unified into a script format as shown in fig. 8.
The first column shows the time of each group of event trigger, the second column distinguishes touch or voice events, voice events are shown by letters V instead of numbers because the number of event files owned by different machines is different, such as event 0-event 15, the third column shows the type of input event, the fourth column shows the name of the input event, the fifth column shows specific numerical values, and if voice events, the encrypted character string is used for replacing the input event, for example, the longer information in the figure shows that' how is the weather today? ". After the obtained event information script is obtained, the information can be uploaded to a server for later playback work.
Referring to fig. 3, an embodiment of the present invention further provides a method for processing a robot error, which is applied to a backend server, where the method includes the following steps:
step S210, obtaining the event information sent by the robot;
the event information comprises a bottom layer event stream script and a voice input event script when the operation of the robot fails, and a plurality of event character strings formed by uniformly triggering time and formats of the bottom layer event stream script and the voice input event script;
and step S220, injecting the event information in a command form, and playing back the fault event.
The robot event information records the underlying event stream script and the voice input event script when the robot fails. And injecting the event information in a command form so as to directly inject and execute when a fault scene is reproduced during playback, so that developers and testers can solve the fault conveniently.
Further, in the processing method, in step S220, the injecting the event information in the form of a command and performing fault event playback includes:
step S221, when the event information is injected and the voice input information is analyzed, the injection operation is suspended, and the robot capability is called for playback; continuing injecting when the robot capability playback is successful;
Step S222, when the event information is injected and the touch operation information is analyzed, continuing to inject the event information for analysis.
Specifically, in the Android SDK, another corresponding tool is provided: a sensor, which allows a developer to inject event information into the Android system in the form of commands, each sensor command requires four parameters: for the event type, the name and the value, the click event can be sent only after hexadecimal shown in the upper diagram is converted into decimal. For example, event commands may be injected such that: the sentent/dev/input/event 1353395, by looking over the source code, it can be known that the actual injection event is the writing operation to the corresponding event file, but for frequent quick clicks and sliding, the writing efficiency of the event plays a crucial role, for example, if the time interval during playback is not strictly controlled, some unexpected errors may be generated, for example, if the delay time in the event of sliding together is large, the starting time may be changed into a series of long press events, so we need an efficient and accurate injection event, we can implement the injection event in the manner of JNI, when we resolve the voice information during the injection process, we temporarily suspend the injection operation, start to call the relevant capability of the robot for playback, when the playback of the capability of the robot is successful, resolve the next series of events and continue the injection of the touch event or call the capability of the robot, and if the capacity is encountered again in the later resolving process, the operation is repeatedly executed.
Referring to fig. 6, the implementation process of the method for generating and processing the robot error is described in connection with the robot side and the backend server side.
When the user operates the robot and encounters unpredictable faults, the user may click a fault recording or say "start fault recording" in the setup menu, for example, the robot suspends a prompt indicating that recording is in progress (or replies "recording is in progress …") in the top-level interface, and then the user re-operates the previous fault flow. After the robot end obtains the bottom layer event stream script and the voice input event script, the robot end can click to stop or speak 'fault recording is finished' by voice when the operation is finished.
The robot will arrange the event data into time information file and upload it to the background server, when uploading successfully, the test or development personnel will receive the fault notice, then it will automatically play back and observe the phenomenon on the test machine, then it will process the fault according to the observed phenomenon.
Referring to fig. 4, an embodiment of the present invention further provides a robot error generation apparatus, including:
the recording module 11 is used for recording a bottom layer event stream script and a voice input event script when the operation of the robot fails;
An event information generating module 12, configured to unify the trigger time and format of the underlying event stream script and the voice input event script to form event information including a plurality of event character strings;
and the sending module 13 is configured to send the event information to a background server, where the background server is configured to inject the event information in a command form to perform fault event playback.
Here, it should be noted that: the descriptions of the embodiments of the apparatus are similar to the descriptions of the methods, and have the same advantages as the embodiments of the methods, and therefore are not repeated herein. For technical details that are not disclosed in the embodiments of the apparatus of the present invention, those skilled in the art should refer to the description of the embodiments of the method of the present invention to understand, and for brevity, will not be described again here.
Referring to fig. 5, an embodiment of the present invention further provides a robot error processing apparatus, including:
the acquisition module 21 is used for acquiring event information sent by the robot;
the event information comprises a bottom layer event stream script and a voice input event script when the operation of the robot fails, and a plurality of event character strings formed by uniformly triggering time and formats of the bottom layer event stream script and the voice input event script;
And the playback module 22 is used for injecting the event information in a command form to perform fault event playback. . Here, it should be noted that: the descriptions of the embodiments of the apparatus are similar to the descriptions of the methods, and have the same advantages as the embodiments of the methods, and therefore are not repeated herein. For technical details that are not disclosed in the embodiments of the apparatus of the present invention, those skilled in the art should refer to the description of the embodiments of the method of the present invention to understand, and for brevity, will not be described again here.
An embodiment of the present invention also provides a robot including:
one or more processors;
a memory communicatively coupled to the one or more processors;
one or more application programs, wherein the one or more application programs are stored in the memory and configured to be executed by the one or more processors, the one or more programs configured to perform the generation method described above.
Here, it should be noted that: the description of the robot embodiment is similar to the description of the method, and has the same beneficial effects as the method embodiment, and therefore, the description is omitted. For technical details that are not disclosed in the embodiments of the apparatus of the present invention, those skilled in the art should refer to the description of the embodiments of the method of the present invention to understand, and for brevity, will not be described again here.
The embodiment of the present invention further provides a background server, including:
one or more processors;
a memory communicatively coupled to the one or more processors;
one or more application programs, wherein the one or more application programs are stored in the memory and configured to be executed by the one or more processors, the one or more programs configured to the processing method described above.
Here, it should be noted that: the description of the background server embodiment is similar to the description of the method, and has the same beneficial effects as the method embodiment, and therefore, the description is omitted. For technical details that are not disclosed in the embodiments of the apparatus of the present invention, those skilled in the art should refer to the description of the embodiments of the method of the present invention to understand, and for brevity, will not be described again here.
An embodiment of the present invention further provides a system, including: the robot and the background server.
Here, it should be noted that: the descriptions of the embodiments of the apparatus are similar to the descriptions of the methods, and have the same advantages as the embodiments of the methods, and therefore are not repeated herein. For technical details that are not disclosed in the embodiments of the apparatus of the present invention, those skilled in the art should refer to the description of the embodiments of the method of the present invention to understand, and for brevity, will not be described again here.
An embodiment of the present invention further provides a system, including: the robot and the background server.
Here, it should be noted that: the description of the above system embodiment is similar to the description of the above method, and has the same beneficial effects as the method embodiment, and therefore, the description thereof is omitted. For technical details not disclosed in the embodiment of the storage medium of the present invention, those skilled in the art should refer to the description of the embodiment of the method of the present invention to understand, and for brevity, will not be described again here.
In the several embodiments provided in the present application, it should be understood that the disclosed system, apparatus and method may be implemented in other manners. For example, the above-described apparatus embodiments are merely illustrative, and for example, the division of the units is only one logical division, and other divisions may be realized in practice, for example, a plurality of units or components may be combined or integrated into another system, or some features may be omitted, or not executed. In addition, the shown or discussed mutual coupling or direct coupling or communication connection may be an indirect coupling or communication connection through some interfaces, devices or units, and may be in an electrical, mechanical or other form.
The units described as separate parts may or may not be physically separate, and parts displayed as units may or may not be physical units, may be located in one place, or may be distributed on a plurality of network units. Some or all of the units can be selected according to actual needs to achieve the purpose of the solution of the embodiment.
In addition, functional units in the embodiments of the present invention may be integrated into one processing unit, or each unit may exist alone physically, or two or more units are integrated into one unit. The integrated unit can be realized in a form of hardware, and can also be realized in a form of a software functional unit.
Those skilled in the art will appreciate that all or part of the steps in the methods of the above embodiments may be implemented by associated hardware instructed by a program, which may be stored in a computer-readable storage medium, and the storage medium may include: a Read Only Memory (ROM), a Random Access Memory (RAM), a magnetic or optical disk, or the like.
It will be understood by those skilled in the art that all or part of the steps in the method for implementing the above embodiments may be implemented by hardware that is instructed to implement by a program, and the program may be stored in a computer-readable storage medium, and the above-mentioned storage medium may be a read-only memory, a magnetic disk or an optical disk, etc.
As described above, the method, apparatus, device, and storage medium for preprocessing face detection provided by the present invention are described in detail, and a person skilled in the art may change the specific implementation manner and the application scope according to the idea of the embodiment of the present invention.
Claims (10)
1. A robot error generation method is applied to a robot end, and is characterized by comprising the following steps:
recording a bottom layer event stream script and a voice input event script when the operation of the robot fails;
unifying the triggering time and the format of the bottom layer event stream script and the voice input event script to form event information comprising a plurality of event character strings;
and sending the event information to a background server, wherein the background server is used for injecting the event information in a command form to play back the fault event.
2. The method for generating the event script, according to claim 1, wherein the step of recording the underlying event stream script and the voice input event script when the operation of the robot fails comprises the steps of:
the method comprises the steps of obtaining touch operation of a user on the robot, generating corresponding bottom layer events through the touch operation through a device file, and sequencing a plurality of bottom layer events according to time to form a bottom layer event stream script.
3. The generation method according to claim 1, wherein each event string includes:
the method comprises the following steps of indicating event triggering time, distinguishing an event into an identification character of a bottom layer event stream or a voice input event, indicating an event type, indicating an event name and indicating a specific numerical value of the event; if the event is a voice input event, the character indicating the specific numerical value of the event is an encrypted character.
4. The method for generating the event script, according to claim 1, wherein the step of recording the underlying event stream script and the voice input event script when the operation of the robot fails comprises the steps of:
receiving an instruction of starting recording by a user, and recording the bottom layer event stream script and the voice input event script;
and receiving an instruction of stopping recording by the user and stopping recording.
5. A robot error processing method is applied to a background server and is characterized by comprising the following steps:
acquiring event information sent by a robot;
the event information comprises a bottom layer event stream script and a voice input event script when the operation of the robot fails, and a plurality of event character strings formed by uniformly triggering time and formats of the bottom layer event stream script and the voice input event script;
And injecting the event information in a command form to perform fault event playback.
6. The processing method according to claim 5, wherein said injecting the event information in command form, and performing the fault event replay step comprises:
when the event information is injected and the voice input information is analyzed, the injection operation is suspended, and the robot capability is called for playback; continuing injecting when the robot capability playback is successful;
and when the event information is injected and analyzed to the touch operation information, continuing injecting the event information for analysis.
7. A robot error generation apparatus, characterized in that the generation apparatus comprises:
the recording module is used for recording a bottom layer event stream script and a voice input event script when the operation of the robot fails;
the event information generation module is used for unifying the triggering time and the format of the bottom layer event stream script and the voice input event script to form event information comprising a plurality of event character strings;
and the sending module is used for sending the event information to a background server, and the background server is used for injecting the event information in a command form to play back the fault event.
8. A processing apparatus of a robot error, the processing apparatus comprising:
the acquisition module is used for acquiring event information sent by the robot;
the event information comprises a bottom layer event stream script and a voice input event script when the operation of the robot fails, and a plurality of event character strings formed by uniformly triggering time and formats of the bottom layer event stream script and the voice input event script;
and the playback module is used for injecting the event information in a command form and playing back the fault event.
9. A robot, comprising:
one or more processors;
a memory communicatively coupled to the one or more processors;
one or more application programs, wherein the one or more application programs are stored in the memory and configured to be executed by the one or more processors, the one or more programs configured to perform the generation method of any of claims 1 to 4.
10. A backend server, comprising:
one or more processors;
a memory communicatively coupled to the one or more processors;
one or more application programs, wherein the one or more application programs are stored in the memory and configured to be executed by the one or more processors, the one or more programs configured to perform the processing method of any of claims 5 to 6.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010405463.1A CN111858194A (en) | 2020-05-14 | 2020-05-14 | Method and device for generating and processing robot error, robot and background server |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010405463.1A CN111858194A (en) | 2020-05-14 | 2020-05-14 | Method and device for generating and processing robot error, robot and background server |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN111858194A true CN111858194A (en) | 2020-10-30 |
Family
ID=72985151
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202010405463.1A Pending CN111858194A (en) | 2020-05-14 | 2020-05-14 | Method and device for generating and processing robot error, robot and background server |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN111858194A (en) |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN114012723A (en) * | 2021-11-01 | 2022-02-08 | 中国建设银行股份有限公司 | Robot process automation fault processing method, device, equipment and storage medium |
-
2020
- 2020-05-14 CN CN202010405463.1A patent/CN111858194A/en active Pending
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN114012723A (en) * | 2021-11-01 | 2022-02-08 | 中国建设银行股份有限公司 | Robot process automation fault processing method, device, equipment and storage medium |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US4696003A (en) | System for testing interactive software | |
| US5086393A (en) | System for testing human factors and performance of a system program | |
| US4772206A (en) | Multi-mode teaching simulator | |
| US10853232B2 (en) | Adaptive system for mobile device testing | |
| US9465718B2 (en) | Filter generation for load testing managed environments | |
| US5220658A (en) | System for testing a performance of user interactive-commands using an emulator-overlay for determining the progress of the user timing response | |
| CN102521118B (en) | Automatic testing method of Android program | |
| US20200019490A1 (en) | Automated application testing system | |
| CN102999419B (en) | A kind of Android test incident record back method and device | |
| CN103049371A (en) | Testing method and testing device of Android application programs | |
| CN107357724A (en) | Automatic software test method and device in Android system | |
| CN110362483A (en) | Performance data acquisition method, device, equipment and storage medium | |
| Moran et al. | On-device bug reporting for android applications | |
| TW201616356A (en) | System and method for debug firmware/software to generate trace data, recording medium and computer program product | |
| CN112433948A (en) | Simulation test system and method based on network data analysis | |
| CN102479152A (en) | Method and device for obtaining tool automatic test results on basis of Android platform | |
| CN115658529A (en) | Automatic testing method for user page and related equipment | |
| US11813538B2 (en) | Videogame telemetry data and game asset tracker for session recordings | |
| CN111858194A (en) | Method and device for generating and processing robot error, robot and background server | |
| CN102073590A (en) | Event simulation-based user interface test method and device | |
| CN105094952B (en) | A kind of method and apparatus of analog subscriber operation | |
| CA1267229A (en) | Reconfigurable automatic tasking system | |
| CN110633199A (en) | Testing apparatus, method, and medium for block chain supporting intelligent contract | |
| CN111708704A (en) | Cloud real machine testing method and device, terminal and storage medium | |
| WO2020172765A1 (en) | Representation of user interface interactive regions |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination |