WO2022051974A1

WO2022051974A1 - Code inspection method and apparatus applied to embedded platform, device and computer-readable storage medium

Info

Publication number: WO2022051974A1
Application number: PCT/CN2020/114437
Authority: WO
Inventors: 武泽泽; 林喜挺; 植俊铭; 李诗豪; 苏冠华
Original assignee: 深圳市大疆创新科技有限公司
Priority date: 2020-09-10
Filing date: 2020-09-10
Publication date: 2022-03-17

Abstract

A code inspection method and apparatus applied to an embedded platform, a device and a computer-readable storage medium. The method comprises: acquiring code related data of a code to be inspected as code related data to be inspected, the code related data to be inspected comprising a running result to be inspected which is obtained by running, according to an embedded hardware device of the code to be inspected, the code to be inspected, and which comprises output data of a sensor in the embedded hardware device; according to the code related data to be inspected and standard code related data of a preset standard code, determining a score of the code to be inspected under a preset scoring dimension; and according to the score under the preset scoring dimension, determining the overall score of the code to be inspected to obtain a code inspection result. In this way, scoring is performed according to a real running result in an actual application scene, thereby improving the accuracy of the inspection result to a certain extent and improving inspection effect.

Description

Code detection method, device, device and computer-readable storage medium applied to embedded platform

technical field

The invention belongs to the field of embedded platforms, and in particular relates to a code detection method, device, equipment and computer-readable storage medium applied to embedded platforms.

Background technique

At present, the controlled device is often controlled to perform a series of functional operations through programming codes. For example, control unmanned vehicles for environmental detection through programming codes, control drones for aerial photography through programming codes, and so on. In order to improve the control effect, it is often necessary to perform quality inspection on the control code.

In the prior art, the control code is often sent to the scoring system, and the scoring system performs detection directly according to the control code itself. The accuracy of the detection results in this detection method is poor, and the detection effect is poor.

SUMMARY OF THE INVENTION

The present invention provides a code detection method, device, device and computer-readable storage medium applied to an embedded platform, so as to solve the problems of poor code detection result accuracy and poor detection effect.

In order to solve the above-mentioned technical problems, the present invention is achieved in this way:

In a first aspect, an embodiment of the present invention provides a code detection method applied to an embedded platform, the method comprising:

The code-related data of the code to be detected is obtained as the code-related data to be detected; the data related to the code to be detected includes the running result to be detected, and the running result to be detected is based on the embedded hardware device of the code to be detected. Obtained by running the code to be detected, and the running result to be detected includes output data of sensors in the embedded hardware device;

According to the relevant data of the code to be detected and the relevant data of the standard code of the preset standard code, determine the scoring value of the code to be detected under the preset scoring dimension;

According to the scoring score under the preset scoring dimension, the overall score of the code to be detected is determined, and the code detection result is obtained.

In a second aspect, an embodiment of the present invention provides a code detection apparatus applied to an embedded platform, the apparatus comprising a memory and a processor;

the memory for storing program codes;

The processor calls the program code, and when the program code is executed, is configured to perform the following operations:

In a third aspect, an embodiment of the present invention provides a detection device, where the detection device is configured to perform the steps in the code detection method applied to an embedded platform described in the first aspect.

In a fourth aspect, an embodiment of the present invention provides an embedded hardware device, where the embedded hardware device is configured to run the code to be detected, and send the running result obtained from the running to the detection device described in the third aspect.

In a fourth aspect, an embodiment of the present invention provides a computer-readable storage medium, where a computer program is stored on the computer-readable storage medium, and when the computer program is executed by a processor, the following operations are implemented:

In this embodiment of the present invention, the code-related data of the code to be detected may be acquired as the code-related data to be detected. The data related to the code to be detected includes the running result to be detected, the running result to be detected is obtained by running the code to be detected according to the embedded hardware device of the code to be detected, and the running result to be detected includes the output data of the sensor in the embedded hardware device, and then , according to the relevant data of the code to be detected and the relevant data of the standard code of the preset standard code, determine the scoring value of the code to be detected under the preset scoring dimension, and finally, according to the scoring value under the preset scoring dimension, determine the code to be detected. The overall score of , get the code detection result. In this way, the real running results are obtained by running the code to be detected by the real embedded hardware device in the actual application scenario, and the scores are scored according to the real running results in the actual application scenario, thereby improving the accuracy of the detection results to a certain extent and improving the detection performance. Effect.

Description of drawings

1 is a flowchart of steps of a code detection method applied to an embedded platform provided by an embodiment of the present invention;

2 is a schematic diagram of a scoring process provided by an embodiment of the present invention;

3 is a block diagram of a code detection device applied to an embedded platform provided by an embodiment of the present invention;

FIG. 4 is a block diagram of a computing processing device according to an embodiment of the present invention;

FIG. 5 is a block diagram of a portable or fixed storage unit according to an embodiment of the present invention.

detailed description

The technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings in the embodiments of the present invention. Obviously, the described embodiments are part of the embodiments of the present invention, but not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those of ordinary skill in the art without creative efforts shall fall within the protection scope of the present invention.

1 is a flowchart of steps of a code detection method applied to an embedded platform provided by an embodiment of the present invention. As shown in FIG. 1 , the method can be applied to a detection device, and the method includes:

Step 101: Obtain the code-related data of the code to be detected as the code-related data to be detected; the code-related data to be detected includes the running result to be detected, and the running result to be detected is an embedded hardware device according to the code to be detected Obtained by running the code to be detected, the running result to be detected includes output data of sensors in the embedded hardware device.

In this embodiment of the present invention, the code to be detected may be generated by a code generation device. For example, the code generation device may receive a user's programming input operation, and generate a corresponding code according to the user's programming input operation. The programming language used when generating the code to be detected may be preset according to the actual situation, for example, it may be written based on the Scratch programming language, or may be based on the python programming language, the C++ programming language, and so on. Further, the code to be detected may be a code for controlling the embedded hardware device and for running on the embedded hardware device. The embedded hardware device is the controlled device corresponding to the code to be detected.

Further, the code-related data may be data related to the code to be detected. For example, the code-related data may include a code running result. Correspondingly, in the embodiment of the present invention, when the code to be detected is detected, the code to be detected can be executed according to the embedded hardware device first, and the operation result to be detected can be obtained according to the output data of the sensor in the embedded hardware device, so as to facilitate the subsequent execution according to the actual operation. As a result, the code is instrumented.

In one implementation, an evaluation server equipped with an online code scoring (Online Judge, OJ) system is often set up. When testing the code, the code is directly sent to the evaluation server. After the evaluation server compiles and runs the code, the OJ system Combined with running time, algorithm complexity, space complexity, memory usage, etc. for a comprehensive score. But this method can often only detect the code running and on the computer. For the code to be detected for controlling the embedded hardware device, since the target machine on which the code to be detected runs is different from the target machine (ie, the computer) on which the code runs in the prior art, the difference in hardware structure between the server and the embedded hardware device is relatively different. Large, the evaluation server cannot simulate the real running environment of the code. If the existing OJ system is directly used to detect the embedded hardware devices only from the aspects of memory usage and space complexity, it may lead to inaccurate detection results. That is, the code running on the embedded hardware device cannot be accurately scored by the OJ system in the evaluation server.

In the detection scene of the code used to control the embedded hardware device, in order to ensure the accuracy of the code detection, the embodiment of the present invention uses the code scoring method combining software and hardware to use the real embedded hardware device in the actual application scene to detect the code to be detected After running, the real output data of the sensor in the embedded hardware device is used as the running result to be detected, and the score is subsequently scored according to the real running result in the actual application scenario, which can improve the accuracy of the detection result and the detection effect to a certain extent.

Step 102 , according to the relevant data of the code to be detected and the relevant data of the standard code of the preset standard code, determine the scoring value of the code to be detected under the preset scoring dimension.

In this embodiment of the present invention, the preset standard code may be a preset code that implements the same control function as the code to be detected. For example, assuming that the code to be detected is used to realize the function of controlling the unmanned vehicle to take pictures along the edge of the area to be detected, then the preset standard code can also be used to realize the function of controlling the unmanned vehicle to take pictures along the edge of the area to be detected. Function. The standard code-related data may be code-related data of preset standard codes, and the standard code-related data may be of the same type as the to-be-detected code-related data, so as to facilitate comparison and scoring according to the two. For example, the standard code related data may include a standard operation result, and the standard operation result may be an operation result obtained by the embedded hardware device running the preset standard code. It should be noted that the embedded hardware device running the preset standard code and the embedded hardware device running the code to be detected may be the same device, or may be different devices of the same type. For example, one of the embedded hardware devices can be a model A unmanned vehicle, the other embedded hardware device can be another model A unmanned vehicle, or two embedded hardware devices can be the same model A unmanned vehicle. people and vehicles, which is not limited in this embodiment of the present invention.

Further, the preset scoring dimension may be set according to actual needs, and different dimensions may correspond to different evaluation criteria. By determining the scoring value to be detected under the preset scoring dimension from the preset scoring dimension, the detection can be refined to a certain extent. precision.

Step 103: Determine the overall score of the code to be detected according to the score value under the preset score dimension, and obtain a code detection result.

In the embodiment of the present invention, the scoring scores under each preset scoring dimension can be integrated, the code to be detected can be judged as a whole, the overall score of the code to be detected can be obtained, and the overall score can be used as the code detection result. In this way, using the final overall score as the code detection result, the code detection result can be quantitatively represented, thereby facilitating the user to know the detection result. Further, the code detection result can also be output, so as to facilitate the user to obtain the detection result in time.

To sum up, the code detection method applied to an embedded platform provided by the embodiments of the present invention can acquire code-related data of the code to be detected as the code-related data to be detected. The data related to the code to be detected includes the running result to be detected, the running result to be detected is obtained by running the code to be detected according to the embedded hardware device of the code to be detected, and the running result to be detected includes the output data of the sensor in the embedded hardware device, and then , according to the relevant data of the code to be detected and the relevant data of the standard code of the preset standard code, determine the scoring value of the code to be detected under the preset scoring dimension, and finally, according to the scoring value under the preset scoring dimension, determine the code to be detected. The overall score of , get the code detection result. In this way, the real running results are obtained by running the code to be detected by the real embedded hardware device in the actual application scenario, and the scores are scored according to the real running results in the actual application scenario, thereby improving the accuracy of the detection results to a certain extent and improving the detection performance. Effect.

Optionally, the embedded hardware device in the embodiment of the present invention may be connected to the code generation device and the detection device, respectively. The code generation device can be used to send the code to be detected to the embedded hardware device for running, and the embedded hardware device can send the obtained running result to be detected to the detection device after the running of the code to be detected is completed, that is, the running result to be detected It is sent to the detection device by the embedded hardware device after the execution of the code to be detected is completed. Further, the code generation device can be connected to the detection device, and the code generation device can be used to send other information in the data related to the code to be detected except the running result to be detected to the detection device.

Specifically, the connection between the embedded hardware device, the code generation device and the detection device may be through a wireless local area network (Wireless-Fidelity, WIFI) connection, a Bluetooth connection, or a data line connection, and so on. The code generation device may be a programming terminal, for example, a web terminal, an application (Application, APP) terminal, a client in a computer, and the like. Embedded hardware devices can be embedded processors (Advanced RISC Machines, ARM) terminals, or other hardware platforms built by embedded systems, such as drones, unmanned vehicles, robots, and so on. The detection device can be a computer, a tablet computer, a server, and the like. In the embodiment of the present invention, by setting the embedded hardware device, the code generation device and the detection device to connect and cooperate with each other, the code to be detected is sent to the embedded hardware device to run through the code generation device, and the running result is sent through the embedded hardware device Testing the testing equipment can ensure the accuracy of the testing results to a certain extent.

Optionally, in this embodiment of the present invention, the data related to the code to be detected may further include related information of modules used in the code to be detected. The module may be a code block, specifically a method function called in the code, or may be other function modules preset in the programming language. For example, the programming modules built into the Scratch programming language, a programming module can be used to implement a function. Correspondingly, according to the relevant data of the code to be detected and the relevant data of the standard code of the preset standard code, determining the scoring value of the code to be detected under the preset scoring dimension may include the following steps:

Step 1021: Determine a first scoring value of the code to be tested under the first scoring dimension according to the running result to be detected and the standard running result in the data related to the standard code.

In this step, the first scoring dimension can represent the dimension of the running result item, and the running result item dimension can be used to detect the sensor output data when the code is running on the embedded hardware device. Because the sensor output data has a strong correlation with the running accuracy of embedded hardware devices. Therefore, the first scoring value of the code to be detected under the first scoring dimension can be determined, and the quality of the code to be detected under the dimension of the running result item can be more accurately represented by the first scoring score.

Step 1022: Determine the second scoring value of the code to be detected under the second scoring dimension according to the related information of the used module and the standard module information in the standard code related data.

In this step, the second scoring dimension can represent the program code item dimension, and the program code item dimension can be used to judge the code itself. The standard module information can represent the relevant information of the modules used in the preset standard code. Because the modules used in the code often have a greater impact on the control functions implemented by the code. Therefore, in the embodiment of the present invention, the second scoring score is determined according to the used module, so that the second scoring score can more accurately characterize the quality of the code to be detected in the dimension of the program code item.

In the embodiment of the present invention, on the basis of scoring from the first scoring dimension according to the operation result, the second scoring dimension is further combined with the used module to judge, so as to improve the accuracy of the subsequently determined overall score to a certain extent. At the same time, since the content of the code itself is often large, compared with the method of directly comparing the code itself, the method of judging the situation of the code itself in combination with the module in the embodiment of the present invention can improve the accuracy. At the same time, it avoids the introduction of excessive computation, thereby ensuring the detection efficiency.

Optionally, in this embodiment of the present invention, the standard module information may include relevant information of standard modules used in the preset standard code, and according to the relevant information of the used modules and the standard module information in the standard code-related data, it is determined to be detected. The steps of coding the second scoring value under the second scoring dimension may include:

Sub-step (1): matching according to the relevant information of the used module and the relevant information of the standard module, to determine the first number of the first module matching the standard module in the used module, And/or, determining a second number of second modules whose used parameters in the first module match those of the standard module.

In this step, the relevant information may be information that can refer to the module, for example, the name, number, function of the module, the type it belongs to, and the parameters used, and so on. The relevant information of the module can be entered through the configuration information. Further, that the used module matches the standard module may mean that the used module and the standard module are the same module, or the used module and the standard module are of the same type. Since modules of the same type often have the same function, taking the modules belonging to the same type as the judging benchmark, to a certain extent, it can avoid the problem that the second score is low in the subsequent determination, and ensure that the second score can be accurately represented. The actual situation.

During the specific implementation, the relevant information of the module used in the code to be detected can be compared with the relevant information of each standard module. If the relevant information of the two are the same, it can be considered that the used module is the first module that matches the standard module. a module. Further, for each first module, the parameters used in the first module can be compared with the use parameters of the standard module that matches the first module, and if the parameters are the same, it can be considered that the first module is completely parameterized. matching second module.

Sub-step (2): determine the second scoring value according to the first ratio and/or the second ratio; the first ratio is the ratio of the first quantity to the total quantity of the standard modules, the The second ratio is the ratio of the second amount to the first amount.

In this step, the ratio of the first quantity to the total quantity of standard modules may be calculated first to obtain the first ratio, and the ratio of the second quantity to the first quantity may be calculated to obtain the second ratio. Based on these two ratios, a second scoring score is determined. Wherein, the second scoring score may be positively correlated with the first ratio and the second ratio.

In this embodiment of the present invention, if the first quantity and the second quantity are larger, it means that the code to be tested uses more standard modules and the used parameters match more standard modules. Correspondingly, it can be considered that the code to be tested has more standard modules. Close to the default standard code. Therefore, in the embodiment of the present invention, the second scoring value is determined in combination with the ratio calculated according to the first quantity and the second quantity, which can ensure the accuracy of the second scoring value to a certain extent.

Optionally, the standard module information in this embodiment of the present invention may further include information about disabled modules that are prohibited from being used in the preset standard code. Accordingly, the second score is determined according to the first ratio and/or the second ratio. , which can include:

Sub-step (2A): generating a first numerical value according to the first ratio and the second ratio; the first numerical value is positively correlated with the first ratio and the second ratio.

In the embodiment of the present invention, the first ratio and the second ratio may be input into the preset formula, and the output of the preset formula may be used as the first value. Wherein, the independent variable of the preset formula is positively correlated with the dependent variable. Exemplarily, the standard modules in this embodiment of the present invention may include key modules, recommended modules, and necessary modules. Among them, the key module may be a module that must be used, and if it has been used, the score occupied by the pre-set key module will be obtained, and if it is not used, the score may be deducted accordingly. Recommended modules can be optional modules. If you use it, you can add points. If you don't use it, you can not deduct points. The prerequisite modules can be other modules in the standard modules except the recommended modules and the critical modules. Further, the first value may include a code block score and a code parameter score. The code block score may include the key module score Section _key , the recommendation module score Section _recom and other module scores Section _other , and the code parameter score may include the score Sectio _{matched corresponding to the second module whose parameters are completely matched} .

N _key represents the number of key modules in the standard modules, N _{key_usr} represents the number of modules used in the code to be detected that match the key modules, and N _std represents the total number of standard modules. N recom represents the number of recommended modules in the standard modules, N _{recom_usr} represents the number of _modules used in the code to be detected that match the standard modules, and N _matched represents the number of modules to be detected that match the standard modules.

Correspondingly, other modules can be expressed as: (N _matched -N _{recom_usr} -N _{key_usr} ), and the first ratio can be expressed as: N _{key_usr} /N _std +N _{recom_usr} /N _std +(N _matched -N _{recom_usr} -N _{key_usr} )/ N _std =N _matched /N _std.

Further, the code block score determined according to the first ratio can be expressed as:

Section _key +Section _recom +Section _other .

Wherein, Section _key =N _{key_usr} /N _key *N _key /N _std *100=N _{key_usr} /N _std *100.

Section _recom = N _{recom_usr} /N _recom *N _recom /N _std *100=N _{recom_usr} /N _std *100.

Section _other =(N _matched -N _{recom_usr} -N _{key_usr} )/N _std *100.

That is, the code block score can be expressed as: Section _key +Section _recom +Section _other =N _matched /N _std *100.

Further, N _{usr_match_num} represents the second number of modules whose parameters are completely matched, and N _{std_num} represents the number of matched modules (ie, the first number), then the second ratio can be represented as: N _{usr_match_num} /N _{std_num} .

Further, the code parameter score can be expressed as:

Section _matched = N _{usr_match_num} /N _{std_num} *(100-Section _key -Section _other ).

Finally, the sum of the code parameter score and the code block score may be used as the first value.

Sub-step (2B): Match according to the related information of the used module and the related information of the prohibited module to determine a third number of third modules in the used modules that match the prohibited module.

In this step, the disabled module may be a module that is not allowed to be used. Further, the relevant information of the module used in the code to be detected can be compared with the relevant information of each forbidden module, if the relevant information of the two is the same, then it can be considered that the used module is the third one that matches the forbidden module. module.

Sub-step (2C): reducing the first numerical value according to a third ratio between the third number and the total number of disabled modules; the reduction of the first numerical value and the third ratio positive correlation.

N _forbid represents the number of disabled modules, and N _{forbid_usr} is the number of disabled modules used in the code to be detected. The disabled module score Section _forbid may be calculated according to the third ratio N _{forbid_usr} /N _forbid . Decrease the first value according to Section _forbid .

An example Section _forbid can be specified as:

Section _forbid =-N _{forbid_usr} /N _forbid *(Section _key +Section _recom +Section _other +Section _matched ).

Finally, the reduced first value can be expressed as:

Code _score =Section _key +Section _recom +Section _other +Section _matched +Section _forbid

It should be noted that, based on the calculation formula, it can be known that if the prohibited modules are all used by the code to be detected, all the obtained points can be deducted according to the Section _forbid , that is, the first value can be deducted.

Sub-step (2D): determining the reduced first numerical value as the second scoring score.

It should be noted that, in this embodiment of the present invention, Section _key , Section _recom , Section _other , and Section _matched may also be weighted and summed according to preset weights, and then Section _forbid is used to deduct points to obtain a final second scoring score.

In the embodiment of the present invention, by further determining the number of disabled modules used in the code to be detected, and performing a corresponding deduction operation according to the number of disabled modules used in the code to be detected, to a certain extent, the finally determined No. Two-score scores are more accurate.

Optionally, the standard running result in the embodiment of the present invention may be the running result of the preset standard code running on the embedded hardware device, and the to-be-detected running result is determined according to the running result to be detected and the standard running result in the data related to the standard code. The first scoring value of the code under the first scoring dimension, which can include:

Sub-step (3): For any one of the sensors, according to the degree of matching between the change information of the output data in the operation result to be detected and the change information of the output data in the standard operation result, determine the score corresponding to the sensor. value; the score value corresponding to the sensor is positively correlated with the matching degree.

The sensors in the embodiments of the present invention may include motion-type sensors and non-motion-type sensors. The motion-type sensor may include motion sensors whose output data are continuous numerical values, for example, a position sensor, an angle sensor, an acceleration sensor, a vision sensor, and the like. The non-motion type sensor may be a sensor other than the motion type sensor, for example, a photosensitive sensor for outputting light-emitting/non-emitting state data, and the like.

Further, the change information of the output data can be used to characterize the change process of the output data. If the matching degree of the change information is higher, that is, the control process of the embedded hardware device by the code to be detected and the control process of the embedded hardware device by the preset standard code. The control process is closer, and the code to be detected is more accurate in the control dimension of the sensor. Therefore, according to the matching degree, in the case of a higher matching degree, a higher score value corresponding to a sensor can be set.

Sub-step (4): Determine the first scoring value according to the scoring value corresponding to each of the sensors.

Exemplarily, the sum or weighted sum of the corresponding scores of each sensor may be determined as the first score.

In the embodiment of the present invention, the degree of closeness between the to-be-detected operation result and the standard operation result can be more accurately reflected due to the matching degree of the change information of the output data in the to-be-detected operation result and the standard operation result. Therefore, in this embodiment of the present invention, the scoring value corresponding to each sensor is first determined according to the matching degree, and the first scoring value is determined according to the scoring value corresponding to the sensor, which can ensure the accuracy of the determined first scoring value to a certain extent. Of course, in this embodiment of the present invention, the score may also be determined from other dimensions, for example, the running time, and the like.

Optionally, for a motion-type sensor, the above sub-step (3) can be implemented by the following sub-steps:

Sub-step (3A): sequentially acquiring extreme points in the output curve of the sensor in chronological order, and generating an extreme point change sequence according to the acquired extreme points; the output curve of the sensor is based on the output of the sensor Data OK.

In this step, the relative angle parameter value output at each moment can be determined first according to the angle parameter value output by the sensor and the initial angle parameter value; the output curve is generated according to the relative angle parameter value output at each moment; the output is sequentially obtained according to the time sequence Extreme points in the curve.

Wherein, the initial angle parameter value can be the parameter angle value output by the sensor when the sensor is just started, and the relative parameter angle value can be the parameter angle value output by the sensor, that is, the difference between the total motion value and the initial parameter angle value. When generating the output curve according to the relative parameter angle value output at each moment, the relative parameter angle value can be used as the input of the preset fitting algorithm, and the curve fitted by the fitting algorithm can be used as the output curve. Finally, the extreme points in the output curve can be detected sequentially in time sequence to form a change sequence of extreme points. In this way, by first determining the relative parameter angle value and obtaining the extreme point change sequence from the output curve determined by the relative parameter angle value, the extreme value point change sequence can be made more representative to a certain extent. For example, when the sensor is an angle sensor, the parameter value may be the angle output by the angle sensor, when the sensor is a position sensor, the parameter value may be the position output by the position sensor, and when the sensor is an acceleration sensor, The parameter value can be the acceleration output by the acceleration sensor.

Further, the extreme point in the output curve can be determined according to a preset peak detection algorithm. Specifically, the second-order derivative of the output curve can be determined by a peak detection algorithm, and the overall concave-convexity of the output curve function can be determined according to the second-order derivative, so as to obtain the inflection point of the output curve, that is, the extreme point.

For example, the first-order derivative of the output curve can be calculated first, where the first-order derivative can be expressed as Δsensor _n =sensor _n -sensor _n-1 . The first derivative is then high-pass filtered to remove data bias due to sensor drift and fluctuation issues. Among them, high-pass filtering can be expressed as:

Δsensor _thread =2°, Δsensor _n <Δsensor _thread , Δsensor _n =0.

Next, the first derivative of the difference can be signed according to the following preset formula:

After further deformation, the difference vector representation can be obtained:

if Δsensor _n =0&&Δsensor _n+1 ≥0, Δsensor _n =1

if Δsensor _n =0&&Δsensor _n+1 <0, Δsensor _n =1

Then, the difference vector can be re-derivative to obtain the second derivative. The second derivative can be expressed as ΔΔsensor _n =Δsensor _n -Δsensor _n-1 .

Finally, ΔΔsensor _n can be traversed. Exemplarily, in the traversal result, a point with ΔΔsensor _n =2 may represent a trough, and a point with ΔΔsensor _n =-2 may represent a peak.

Further, the critical point, that is, the migration process of the extreme point, can be searched from the traversal result according to the following preset formula in time sequence.

Among them, _N represents the number of data obtained by sampling the output curve, and an represents the found critical point.

Further, an a _n with a value of 0 in the searched result can be eliminated to obtain a migration chain, that is, a change sequence of extreme points. Exemplarily, the extreme point change sequence can be expressed as: maximum value --> minimum value --> minimum value --> maximum value, for example: 2-->-2-->-2-- >2.

Sub-step (3B): According to the extreme point change sequence and the standard extreme point change sequence of the sensor in the standard operation result, determine the extreme point change sequence and the standard extreme point change sequence in the extreme point change sequence matching extreme points.

In this step, the standard extreme point change sequence may be determined in advance according to the output data of the sensor in the standard operation result, and the specific determination method may refer to the implementation manner in the above steps, which is not repeated in this embodiment of the present invention. Further, the matched extremum points may be points with the same numerical value and the same relative temporal relationship as those in the standard extremum point change sequence. Exemplarily, the change sequence of extreme value points may be compared with the standard change sequence of extreme value points in time sequence, and then the extreme value points with the same numerical value and the same relative time sequence are determined as matching extreme value points. Assuming that the standard extreme point change sequence is: abcde, and the extreme point change sequence is: aced, then it can be determined that the matching extreme point is acd. Among them, the relative timing relationship between acd is the same as the relative timing relationship of "acd" in the standard extreme point change sequence abcde.

It should be noted that, since the embedded hardware device may include multiple sensors, the embodiment of the present invention may first sort the output data of each sensor according to the execution order of each sensor. Then perform the above operations for each sensor separately, so as to avoid the confusion of the data of multiple sensors, thereby ensuring the accuracy of the final score.

Sub-step (3C): Calculate the third ratio between the first length and the second length; the first length is the length of the change sequence composed of the matched extreme points, and the second length is the The length of the standard extreme point change sequence, and the matching degree is positively correlated with the third ratio.

In this step, the first length can represent the size of the same longest continuous chain, and L represents the first length, and the L _mark represents the second length, and the L/L _mark can be used as the third ratio P ₁ . Among them, the larger the third ratio, the greater the matching degree. Alternatively, ε=|(LL _scale )/L _scale |*100% can also be calculated first, and correspondingly, 1-ε is taken as P ₁ .

Sub-step (3D): According to the third ratio, determine the score corresponding to the sensor.

For example, the first ratio P _anchor may be preset, and then the product of P _anchor and the third ratio is determined as the score corresponding to the sensor, that is, S _anchor =P ₁ *P _anchor . The specific value of P _anchor may be preset according to actual requirements, for example, P _anchor may be 0.5.

It should be noted that, in order to ensure the accuracy of the calculation results, the following operations may also be performed before sub-step (3A) in this embodiment of the present invention: value points to filter. The preset filtering algorithm may be an erosion and dilation algorithm in the morphological filtering method. Specifically, according to the erosion and expansion algorithm, the open filter and the closed filter can be used to open and close the output data of the sensor to filter the local peaks and troughs in the sensor signal, thereby filtering the abnormal extreme points.

Specifically, it is assumed that the sensor output data is X(n), (n=1,2,...,N), the predefined structural element is g(m), where (m=1,2,...,M; and N>=M). The specific values of the structural elements may be predetermined according to experiments. Exemplarily, the structural element in this embodiment of the present invention may be: g(k)=[1, 1, 1, 1, 1].

Further, the erosion and dilation operations of x(n) with respect to g(m) can be defined as:

(xΘg)(n)=min[x(n+m)-g(m)]m∈0,1,...,M-1

Correspondingly, the opening and closing operations consisting of erosion and dilation operations can be expressed as:

In the embodiment of the present invention, by first filtering the abnormal extreme value points appearing in the output data, the accuracy of the output data can be ensured, thereby improving the accuracy of the subsequent scores determined according to the output data.

In the embodiment of the present invention, by acquiring the extreme point, the score corresponding to the sensor is determined according to the change sequence of the extreme point. While avoiding the introduction of a large amount of calculation, the scoring value can be determined according to the change information of the output data, thereby ensuring the calculation efficiency to a certain extent. At the same time, the score is determined by the size of the migration chain composed of the matched extreme points in the extreme point change sequence, which can ensure the accuracy of the score to a certain extent.

Optionally, for a non-motion type sensor, the above sub-step (3) can be implemented by the following sub-steps:

Sub-step (3E): Calculate the error value between the output value change sequence of the output data in the running result to be detected and the output value change sequence of the output data in the standard running result; the matching degree and the error value negative correlation.

In this step, the output value change sequence of the output data may be a sequence composed of output values, and the sequence may represent the transition chain formed by the anchor point value, and specifically may represent the state change process of the sensor. For example, sampling is performed in seconds, and the output value of the photosensitive sensor can be composed of a sequence of light-emitting-no light-emitting-no light-emitting-light-emitting, that is, the light-sensitive sensor emits light every one second. Further, when calculating the error value, a preset error algorithm can be used to input the two output value change sequences, for example, as the input of the standard error formula, and then the output is used as the error value.

Sub-step (3F): According to the error value, determine the score value corresponding to the sensor.

Specifically, the output values in the output value change sequence may be divided into multiple groups of output values, and an error value is calculated according to each group of output values, thereby obtaining multiple error values. The average ε2 of these multiple error values is then calculated. Then, P ₂ =1-ε2 is calculated, and finally, the product of the second proportion P _sensor and P ₂ is preset to determine the score corresponding to the sensor, that is, S _sensor =P ₂ *P _sensor . The specific value of P _sensor may be preset according to actual requirements, for example, P _sensor may be 0.5.

Further, when determining the first scoring score according to the corresponding scoring value of each sensor, the sum of all S _anchors and all _Ssensors may be determined as the first scoring score, or the sum of all S _anchors and all S _sensors may be calculated. The weighted sum of the time is obtained to obtain the first scoring score.

Since the error value can more accurately represent the matching degree, in the embodiment of the present invention, by first calculating the error value, and determining the score value corresponding to the sensor according to the error value, the accuracy of the score value can be ensured to a certain extent.

Optionally, in this embodiment of the present invention, the error reporting information may be determined according to data that does not match the standard code-related data in the running result to be detected, and the error reporting information may be output. For example, the anchor value of the sensor can be detected, the unmatched anchor value can be determined, the corresponding preset prompt information can be retrieved, and finally an error report indicating the unmatched anchor value can be output according to the preset prompt information. information. For example, "The output value of the sensor: XXX has a problem" can be output. In this way, the user can obtain the problem in time by outputting the error message, thereby facilitating the user to make adjustments. It should be noted that the error message can also be determined according to other static code data other than the running result. For example, the identifier of the disabled module used in the code to be detected can be obtained, and then the error message indicating the disabled module used in the code to be detected is output. For example, "The following disabled modules exist: YYY, please adjust" can be output.

Optionally, the data related to the code to be detected in the embodiment of the present invention may further include programming parameters of the code to be detected, where the programming parameter may include the programming duration and/or the number of times of debugging of the code to be detected. Correspondingly, according to the relevant data of the code to be detected and the relevant data of the standard code of the preset standard code, the step of determining the scoring value of the code to be detected under the preset scoring dimension may also include the following steps:

Step 1023: Determine a third scoring value of the code to be detected under a third scoring dimension according to the programming parameter; wherein, the smaller the programming parameter is, the larger the third scoring value is.

In this step, the third scoring dimension can represent the dimension of writing and debugging items, and the dimension of writing and debugging items can be used to judge from the situation of writing and debugging during code generation. If the writing time is shorter and the number of debugging times is less, the quality of the code can be considered to be higher to a certain extent. Therefore, in this step, when the programming parameter is smaller, a larger third scoring value can be set.

In the embodiment of the present invention, the judgment is further combined with programming parameters from the third scoring dimension, thereby improving the accuracy of the overall score determined subsequently to a certain extent.

Optionally, the code to be tested is a plurality of codes to be tested submitted by multiple users. According to programming parameters, the third scoring value of the code to be tested under the third scoring dimension is determined, which may include:

Sub-step (4): for any of the programming parameters, according to the size of the programming parameters, the plurality of codes to be detected are divided into different code levels; wherein, the higher the code level, the corresponding code level. The smaller the programming parameters of the code to be detected.

In this step, the codes to be detected may be sorted according to the size of the programming parameters, and then the code levels may be divided according to the sorting result. It should be noted that, when the programming parameters of the codes to be detected have the same size, the sequence of the codes to be detected may be determined according to the name or identification (Identity, ID) of the user corresponding to the codes to be detected. For example, the code to be detected with a larger ID is placed at a higher position.

As an example, taking the programming parameters as the programming time and sorting the programming parameters from large to small as an example, the top 10% of the codes to be detected in the sorting result can be divided into code level A, and the top 11%-40% of the sorting results can be classified into code level A. The code to be detected is divided into code level B, the first 41% to 80% of the code to be detected in the sorting result is divided into code level C, and the first 81% to 100% of the code to be detected in the sorting result, that is, the last 10 % of the codes to be detected are assigned to code level D. Further, taking the programming parameter as the number of debugging times, and sorting the debugging times from large to small as an example, the top 10% of the code to be detected in the sorting result can be divided into code level A, and the top 11%-20% of the sorting result can be divided into code level A. The code to be detected is divided into code grade B, the first 21% to 70% of the code to be detected in the sorting result is divided into code grade C, the first 71% to 100% of the code to be detected in the sorting result, that is, the last 30 % of the codes to be detected are assigned to code level D. Among them, the grades of code grade A, code grade B, code grade C, and code grade D are successively reduced, and the corresponding ratio of each code grade can be defined in the preset programming parameter grade mapping table, and the corresponding ratio of each code grade can be based on actual Requirement settings.

Sub-step (5): for any code to be detected, according to the code level corresponding to the code to be detected, determine the score corresponding to the programming parameter; the score corresponding to the programming parameter is positive with the code level. related.

For example, the value corresponding to the code level corresponding to the code to be detected may be determined as the score corresponding to the programming parameter.

Sub-step (6): Determine the third scoring score according to the score corresponding to the programming parameter.

Exemplarily, a weighted sum between the scores corresponding to each programming parameter may be calculated to obtain a third score. The weight ratio corresponding to each programming parameter can be set according to actual requirements. For example, the weight ratio corresponding to the writing time and the number of debugging times can be 0.5 respectively, that is, the writing time and the number of debugging times each account for 50% of the score of the debugging item.

In the implementation of the present invention, by dividing the code to be detected into different code levels according to the size of the programming parameter, and determining the score corresponding to the programming parameter according to the code level, it can be ensured that the score corresponding to the determined programming parameter fits the actual situation, thereby ensuring that The accuracy of the subsequent determination of the third scoring score.

Optionally, the data related to the code to be detected may further include the code length of the code to be detected; according to the size of the programming parameter, before dividing a plurality of codes to be detected into different code levels, it is also possible to: determine the length of the code to be detected. Whether the code length meets the preset length requirement; if the code length does not meet the preset length requirement and the number of the used key modules is the preset number, then the first preset value is determined as the third Scoring score; if the code length meets the preset length requirement and/or the number of key modules used is not the preset number, then execute the described programming parameters according to the size of the Describe the steps of dividing a plurality of codes to be detected into different code levels.

Specifically, for the definition of the key modules and the manner of determining the number of the key modules, reference may be made to the relevant descriptions in the preceding steps, which will not be repeated here. Further, the preset length requirement and the preset number may be set according to actual requirements.

Exemplarily, L reference represents the preset length threshold, L represents the code length of the code to be detected, the preset length requirement may be (L _reference - L)/L _reference greater than 50%, and the preset number may be 0. Further, if the code length does not meet the preset length requirement and the used key module is 0, the to-be-detected code can be divided into codes of the first category. Among them, the first category can be used to characterize code submitted by malicious users. Correspondingly, the subsequent operation of classifying the code to be detected into different code levels may not be performed, that is, the second scoring value of the malicious code is directly set to 0 points. Further, if the code length meets the preset length requirement and/or the used key module is not 0, it can be considered that the code to be detected is not malicious code, therefore, the operation of classifying the code to be detected into different code levels can be performed.

In the embodiment of the present invention, according to the code length and the number of key modules used in the code, it is determined whether to perform the step of dividing multiple codes to be detected into different code levels according to the size of the programming parameters, which can avoid unnecessary execution of malicious code. operation, which can save processing resources.

Optionally, the above-mentioned sub-step (5) can be realized by the following sub-steps:

Sub-step (5A): According to the number of key modules used in the code to be detected, the number of disabled modules and the degree of matching between the running result to be detected and the standard running result, determine the belonging of the code to be detected. category.

In this step, the number of used key modules can be the same as the number of key modules in the standard modules, and the number of disabled modules can be 0, that is, the disabled modules are not used and the matching degree between the running result to be detected and the standard running result satisfies the predetermined It is assumed that the required codes to be detected are classified into codes of the second category. The second category can be used to represent the basic function completion category, and the matching degree meeting the preset requirement can be that the output result of the sensor trajectory comparison method for the operation result to be detected and the standard operation result satisfies the first preset condition, for example, the output result In order to have a high degree of matching, the anchor point feature value comparison method satisfies the second preset condition for the output result of the running result to be detected and the standard running result, for example, the output result is a matching degree of 100 points. Further, if the code to be detected does not belong to the first category nor the second category, the code to be detected can be divided into a third category, and the third category can be used to represent the basic function incomplete category.

Sub-step (5B): Search for the score corresponding to the code level corresponding to the code to be detected from the corresponding relationship between the preset level and the score corresponding to the category, and obtain the score corresponding to the programming parameter. Wherein, in the corresponding relationship between preset levels and scores corresponding to different categories, the scores corresponding to the same level are different.

In this step, the corresponding relationship between the preset level and the score may be set according to the actual situation, and the corresponding relationship between the preset level and the score may be a mapping table between the code level and the score. For example, in the corresponding relationship between the preset level and the score corresponding to the second category, the score corresponding to code level A may be 100, the score corresponding to code level B may be 90, and the score corresponding to code level C may be 80. , the score corresponding to code level D may be 70. Further, in the corresponding relationship between the preset level and the score corresponding to the third category, the score corresponding to code level A may be 75, the score corresponding to code level B may be 65, and the score corresponding to code level C may be 55. , the score corresponding to code level D may be 45.

Specifically, the corresponding relationship between the preset level and the score corresponding to the category may be obtained first, and then the score corresponding to the code level corresponding to the code to be detected is searched from the preset level and the score.

In the embodiment of the present invention, according to the number of key modules used in the code to be detected, the number of disabled modules, and the degree of matching between the running result to be detected and the standard running result, the categories of the code to be detected are further subdivided into different categories Setting the corresponding relationship between different levels and scores, and searching for the score corresponding to the code to be detected according to the category of the code to be detected, can make the found score closer to the actual situation, thereby improving the score to a certain extent. accuracy.

Optionally, the data related to the code to be tested may also include basic configuration information of the code to be tested. Accordingly, according to the related data of the code to be tested and the standard code related data of the preset standard code, it is determined that the code to be tested is under the preset scoring dimension. The step of scoring the score value can also include the following steps:

Step 1024: Determine the number of preset basic configuration conditions that are satisfied by the code to be detected according to the basic configuration information and the preset basic configuration conditions defined in the standard code related data.

In this step, the preset basic configuration conditions may be set according to actual conditions. Exemplarily, the preset basic configuration conditions may include at least one of the following: successfully establishing a connection with the embedded hardware device in the process of generating the code to be tested, successfully submitting the code to be tested to the testing device, and successfully downloading the code to be tested to the embedded hardware device. It has run and verified the code to be tested. In this way, by setting the configuration condition that needs to be satisfied for normal code detection as the preset basic configuration condition, the accuracy of the subsequent fourth scoring value determined based on the preset basic configuration condition can be ensured to a certain extent.

Further, the basic configuration information can be used to represent the basic configuration when the code to be detected is generated. For example, the basic configuration information may include information representing whether the code to be tested is successfully connected to the embedded hardware device, information representing whether the code to be tested has been successfully submitted to the testing device, and whether the code to be tested has been successfully downloaded to the embedded hardware Information about whether the hardware device and embedded hardware device have performed the operation and verification operation of the code to be tested. In this step, for each preset basic configuration condition, it can be determined whether the code to be detected satisfies the preset basic configuration condition according to the basic configuration information. Finally, the total number of preset basic configuration conditions satisfied by the code to be detected is counted.

Step 1025: Determine a fourth scoring value of the code to be detected under the fourth scoring dimension according to the number; wherein, the fourth scoring value is positively correlated with the number.

In this step, the fourth scoring dimension can represent the basic item dimension, and the basic item dimension can be used to judge from the basic configuration at the time of code generation. If the number of satisfied preset basic configuration conditions is greater, it can be considered that the configuration of the code to be detected is better, and accordingly, a higher fourth score can be set. In the embodiment of the present invention, by further combining with the basic configuration, the judgment is made from the fourth scoring dimension, thereby improving the accuracy of the overall score determined subsequently to a certain extent.

Optionally, if the number matches the total number of preset basic configuration conditions, the second preset value is set as the fourth scoring value; if the number matches the total number of preset basic configuration conditions If the total number does not match, the third preset value is set as the fourth score value; the second preset value is greater than the third preset value. The second preset value and the third preset value may be set according to actual requirements. For example, the second preset value may be 100, and the third preset value may be 0. That is, if any of the preset basic configuration conditions are not satisfied, the fourth score is set to 0, and when all the preset basic configuration conditions are satisfied, the fourth score is set to 100. Further, if there is a preset basic configuration condition that is not satisfied, it can be considered that the submitted code to be tested belongs to a malicious test. If there is no preset basic configuration condition that is not satisfied, it can be considered that the submitted code to be tested belongs to a normal test. The present invention The embodiment selects the second preset value or the third preset value as the fourth scoring value according to the number, to a certain extent, it can avoid that the final overall score of the code to be detected in the malicious test is too large, and the final code to be detected in the normal test is not detected. The overall score is too small, so as to ensure the balance of the overall score determined later.

Optionally, determining the overall score of the code to be detected according to the scoring score under the preset scoring dimension may specifically include: calculating the scoring score under each preset scoring dimension according to the dimension weight corresponding to each preset scoring dimension. The weighted sum of , and then the overall score is obtained.

The dimension weight corresponding to each preset scoring dimension may be defined through a weight ratio table, and the specific value of the dimension weight may be set according to actual requirements. For example, the dimension weight corresponding to the first scoring dimension may be 40%, the dimension weight corresponding to the second scoring dimension may be 30%, the dimension weight corresponding to the third scoring dimension may be 20%, and the dimension weight corresponding to the fourth scoring dimension Can be 10%.

In the following, an embedded hardware device is used as a robot platform, and a specific example in which the code detection method applied to the embedded platform in the embodiment of the present invention is applied to a Scratch programming scenario will be described. By way of example, FIG. 2 is a schematic diagram of a scoring process provided by an embodiment of the present invention. As shown in FIG. 2 , a standard user can send a preset standard code to a robot platform for running through a Scratch programming terminal in advance. The operation of the robot platform can capture the operation results and obtain the standard operation results of the preset standard code. Then, the static code data of the preset standard code and the standard operation result may be submitted to the scoring system as standard code related data. Wherein, the static code data of the preset standard code may include standard module information, related information of prohibited modules that are prohibited from being used, preset basic configuration conditions, and preset detection configuration information. The configuration information may include preset values, preset mapping tables, preset weights, and the like involved in the preceding steps.

Further, the user to be tested can send the code to be tested to the robot platform to run through the Scratch programming terminal. The operation of the robot platform can capture the operation results and obtain the operation results to be detected. Then, the static code data of the code to be tested and the running result of the code to be tested may be submitted to the scoring system as data related to the code to be tested. Among them, in the programming assessment scenario, the Scratch programming terminal can be the assessment machine, and the robot platform can be the external hardware in the scene. The specific hardware type can be set according to the actual needs to ensure that the requirements of different assessment scenarios are met. Further, the static code data of the code to be tested may include related information of modules used in the code to be tested, programming parameters of the code to be tested, code length of the code to be tested, basic configuration information of the code to be tested, and so on. The scoring system may be a system mounted on the detection device for performing each step in the embodiment of the present invention, the scoring system may be an online system, and the detection device may be an online server, that is, the data participating in the detection may be online data. Finally, the scoring system can generate code detection results based on the data related to the code to be tested and the data related to the standard code.

In the embodiment of the present invention, the same detection standard is used for different codes to be detected, which can ensure the accuracy of code detection. At the same time, by combining the operation results of embedded hardware devices in real application scenarios for detection, the detection results can be more suitable for real application scenarios, and the accuracy of code detection can be further improved.

FIG. 3 is a block diagram of a code detection apparatus applied to an embedded platform provided by an embodiment of the present invention. The apparatus may include: a memory 301 and a processor 302 .

The memory 301 is used to store program codes.

The processor 302 calls the program code, and when the program code is executed, is configured to perform the following operations:

Specifically, for the specific implementation process of each operation performed by the processor 302, reference may be made to the relevant descriptions in the foregoing method embodiments, which will not be repeated here.

To sum up, the code detection apparatus applied to the embedded platform provided by the embodiment of the present invention can acquire the code related data of the code to be detected as the code related data to be detected. The data related to the code to be detected includes the running result to be detected, the running result to be detected is obtained by running the code to be detected according to the embedded hardware device of the code to be detected, and the running result to be detected includes the output data of the sensor in the embedded hardware device, and then , according to the relevant data of the code to be detected and the relevant data of the standard code of the preset standard code, determine the scoring value of the code to be detected under the preset scoring dimension, and finally, according to the scoring value under the preset scoring dimension, determine the code to be detected. The overall score of , get the code detection result. In this way, the real running results are obtained by running the code to be detected by the real embedded hardware device in the actual application scenario, and the scores are scored according to the real running results in the actual application scenario, thereby improving the accuracy of the detection results to a certain extent and improving the detection performance. Effect.

Further, an embodiment of the present invention further provides a detection device, and the detection device is configured to perform the steps in the above embodiments of the code detection method applied to an embedded platform.

An embodiment of the present invention further provides an embedded hardware device, the embedded hardware device is used for running the code to be detected, and sending the running result obtained from the running to the above-mentioned detection device. Optionally, the embedded hardware device is one or more of drones, unmanned vehicles, and robots.

Further, an embodiment of the present invention further provides a computer-readable storage medium, where a computer program is stored on the computer-readable storage medium, and when the computer program is executed by a processor, the above-mentioned code detection method applied to an embedded platform is implemented and can achieve the same technical effect, in order to avoid repetition, it will not be repeated here.

The device embodiments described above are only illustrative, wherein the units described as separate components may or may not be physically separated, and the components displayed as units may or may not be physical units, that is, they may be located in One place, or it can be distributed over multiple network elements. Some or all of the modules may be selected according to actual needs to achieve the purpose of the solution in this embodiment. Those of ordinary skill in the art can understand and implement it without creative effort.

Various component embodiments of the present invention may be implemented in hardware, or in software modules running on one or more processors, or in a combination thereof. Those skilled in the art should understand that a microprocessor or a digital signal processor may be used in practice to implement some or all of the functions of some or all of the components in the computing processing device according to the embodiments of the present invention. The present invention can also be implemented as apparatus or apparatus programs (eg, computer programs and computer program products) for performing part or all of the methods described herein. Such a program implementing the present invention may be stored on a computer-readable medium, or may be in the form of one or more signals. Such signals may be downloaded from Internet sites, or provided on carrier signals, or in any other form.

For example, FIG. 4 is a block diagram of a computing processing device provided by an embodiment of the present invention. As shown in FIG. 4 , FIG. 4 shows a computing processing device that can implement the method according to the present invention. The computing processing device traditionally includes a processor 710 and a computer program product or computer readable medium in the form of a memory 720 . The memory 720 may be electronic memory such as flash memory, EEPROM (electrically erasable programmable read only memory), EPROM, hard disk, or ROM. The memory 720 has storage space 730 for program code for performing any of the method steps in the above-described methods. For example, the storage space 730 for program codes may include various program codes for implementing various steps in the above methods, respectively. These program codes can be read from or written to one or more computer program products. These computer program products include program code carriers such as hard disks, compact disks (CDs), memory cards or floppy disks. Such computer program products are typically portable or fixed storage units as described with reference to FIG. 5 . The storage unit may have storage segments, storage spaces, etc. arranged similarly to the memory 720 in the computing processing device of FIG. 4 . The program code may, for example, be compressed in a suitable form. Typically, the storage unit includes computer readable code, ie code readable by a processor such as 710 for example, which when executed by a computing processing device, causes the computing processing device to perform each of the methods described above. step.

The various embodiments in this specification are described in a progressive manner, and each embodiment focuses on the differences from other embodiments, and the same and similar parts between the various embodiments may be referred to each other.

Reference herein to "one embodiment," "an embodiment," or "one or more embodiments" means that a particular feature, structure, or characteristic described in connection with an embodiment is included in at least one embodiment of the present invention. Also, please note that instances of the phrase "in one embodiment" herein are not necessarily all referring to the same embodiment.

In the description provided herein, numerous specific details are set forth. It will be understood, however, that embodiments of the invention may be practiced without these specific details. In some instances, well-known methods, structures and techniques have not been shown in detail in order not to obscure an understanding of this description.

In the claims, any reference signs placed between parentheses shall not be construed as limiting the claim. The word "comprising" does not exclude the presence of elements or steps not listed in a claim. The word "a" or "an" preceding an element does not exclude the presence of a plurality of such elements. The invention can be implemented by means of hardware comprising several different elements and by means of a suitably programmed computer. In a unit claim enumerating several means, several of these means may be embodied by one and the same item of hardware. The use of the words first, second, and third, etc. do not denote any order. These words can be interpreted as names.

Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention, but not to limit them; although the present invention has been described in detail with reference to the foregoing embodiments, those of ordinary skill in the art should understand that it can still be The technical solutions described in the foregoing embodiments are modified, or some technical features thereof are equivalently replaced; and these modifications or replacements do not make the essence of the corresponding technical solutions deviate from the spirit and scope of the technical solutions of the embodiments of the present invention.

Claims

A code detection method applied to an embedded platform, characterized in that, applied to a detection device, the method comprising:

The code-related data of the code to be detected is obtained as the code-related data to be detected; the data related to the code to be detected includes the running result to be detected, and the running result to be detected is based on the embedded hardware device of the code to be detected. Obtained by running the code to be detected, and the running result to be detected includes output data of sensors in the embedded hardware device;

According to the relevant data of the code to be detected and the relevant data of the standard code of the preset standard code, determine the scoring value of the code to be detected under the preset scoring dimension;

According to the scoring score under the preset scoring dimension, the overall score of the code to be detected is determined, and the code detection result is obtained.
The method according to claim 1, wherein the data related to the code to be detected further includes related information of modules used in the code to be detected; Standard code-related data, determine the scoring value of the code to be detected under the preset scoring dimension, including:

According to the running result to be detected and the standard running result in the relevant data of the standard code, determine the first scoring value of the code to be detected under the first scoring dimension;

According to the related information of the used module and the standard module information in the standard code related data, the second scoring value of the code to be detected under the second scoring dimension is determined.
The method according to claim 2, wherein the standard module information comprises relevant information of a standard module used in the preset standard code, and the information according to the relevant information of the used module and the standard code The standard module information in the relevant data determines the second scoring value of the code to be detected under the second scoring dimension, including:

Matching the relevant information of the used modules with the relevant information of the standard modules to determine the first number of the first modules in the used modules that match the standard modules, and/or to determine the the second number of second modules whose parameters used in the first module match those of the standard module;

The second score is determined according to the first ratio and/or the second ratio; the first ratio is the ratio of the first quantity to the total quantity of the standard modules, and the second ratio is the The ratio of the second quantity to the first quantity.
The method according to claim 3, characterized in that, the standard module information further includes information about disabled modules that are prohibited from being used in the preset standard code; The second scoring score, including:

generating a first numerical value according to the first ratio and the second ratio; the first numerical value is positively correlated with the first ratio and the second ratio;

Matching according to the relevant information of the used module and the relevant information of the forbidden module to determine a third number of third modules in the used modules that match the forbidden module;

reducing the first numerical value according to a third ratio between the third quantity and the total quantity of the disabled modules; the reduction of the first numerical value is positively correlated with the third ratio;

The reduced first numerical value is determined as the second scoring score.
The method according to claim 2, wherein the standard running result is the running result of the preset standard code running on the embedded hardware device, and the running result according to the to-be-detected running result and the standard The standard operation result in the code-related data determines the first scoring value of the code to be detected under the first scoring dimension, including:

For any one of the sensors, according to the degree of matching between the change information of the output data in the operation result to be detected and the change information of the output data in the standard operation result, determine the score corresponding to the sensor; the sensor corresponds to The score of the score is positively correlated with the matching degree;

The first scoring value is determined according to the scoring value corresponding to each of the sensors.
The method according to claim 5, wherein, for a motion type sensor, the determination is based on the degree of matching between the change information of the output data in the operation result to be detected and the change information of the output data in the standard operation result. The scores corresponding to the sensors include:

Acquire extremum points in the output curve of the sensor in time sequence, and generate an extremum point variation sequence according to the acquired extremum points; the output curve of the sensor is determined according to the output data of the sensor;

According to the extreme point change sequence and the standard extreme point change sequence of the sensor in the standard operation result, determine the extreme point in the extreme point change sequence that matches the standard extreme point change sequence ;

Calculate a third ratio between the first length and the second length; the first length is the length of the change sequence composed of the matched extreme points, and the second length is the standard extreme point change sequence The length of the matching degree is positively correlated with the third ratio;

According to the third ratio, the score corresponding to the sensor is determined.
The method according to claim 5, wherein, for a non-motion type sensor, according to the degree of matching between the change information of the output data in the operation result to be detected and the change information of the output data in the standard operation result, Determining the score corresponding to the sensor includes:

calculating the error value between the output value variation sequence of the output data in the running result to be detected and the output value variation sequence of the output data in the standard running result; the matching degree is negatively correlated with the error value;

According to the error value, the score value corresponding to the sensor is determined.
The method according to claim 6, wherein the step of sequentially acquiring extreme points in the output curve of the sensor in time sequence comprises:

According to the parameter value output by the sensor and the initial parameter value, determine the relative parameter value output at each moment;

generating the output curve according to the relative parameter values output at each moment;

Acquiring the extreme points in the output curve sequentially in time sequence;

The sensor is an angle sensor, a position sensor or an acceleration sensor, and the parameter value is the angle output by the angle sensor, the position output by the position sensor, or the acceleration output by the acceleration sensor.
The method according to claim 6, wherein the method further comprises:

According to a preset filtering algorithm, the abnormal extreme value points appearing in the output data of the sensor are filtered.
The method according to claim 2, wherein the data related to the code to be detected further includes programming parameters of the code to be detected, and the programming parameter includes the programming duration and/or the number of times of debugging of the code to be detected; The method also includes:

According to the programming parameter, determine the third scoring value of the code to be detected under the third scoring dimension;

Wherein, the smaller the programming parameter is, the larger the third score is.
The method according to claim 10, wherein the code to be detected is a plurality of codes to be detected; the third scoring value of the code to be detected under a third scoring dimension is determined according to the programming parameter ,include:

For any of the programming parameters, according to the size of the programming parameter, the plurality of codes to be detected are divided into different code levels; wherein, the higher the code level is, the higher the code level corresponds to the programming of the code to be detected. The smaller the parameter;

For any of the codes to be detected, the score corresponding to the programming parameter is determined according to the code level corresponding to the code to be detected; the score corresponding to the programming parameter is positively correlated with the code level;

The third scoring score is determined according to the score corresponding to the programming parameter.
The method according to claim 11, wherein the determining the score corresponding to the programming parameter according to the code level corresponding to the code to be detected, comprises:

According to the number of key modules used in the code to be detected, the number of disabled modules and the degree of matching between the running result to be detected and the standard running result, determine the category of the code to be detected;

Searching for the score corresponding to the code level corresponding to the code to be detected from the corresponding relationship between the preset level and the score corresponding to the category, and obtaining the score corresponding to the programming parameter;

Wherein, in the corresponding relationship between preset levels and scores corresponding to different categories, the scores corresponding to the same level are different.
The method according to claim 12, wherein the data related to the codes to be detected further comprises a code length of the codes to be detected; and the plurality of codes to be detected are divided into Before different code levels, the method further includes:

Determine whether the code length of the code to be detected meets the preset length requirement;

If the code length does not meet the preset length requirement and the quantity of the used key modules is a preset quantity, then the first preset value is determined as the third scoring value;

If the code length satisfies the preset length requirement and/or the number of the used key modules is not the preset number, executing the step according to the size of the programming parameter to Steps in which the detection code is divided into different code levels.
The method according to any one of claims 2 to 13, wherein the data related to the code to be detected further includes basic configuration information of the code to be detected, and the method further includes:

According to the basic configuration information and the preset basic configuration conditions defined in the standard code related data, determine the number of preset basic configuration conditions that the code to be detected satisfies;

A fourth scoring value of the code to be detected under a fourth scoring dimension is determined according to the number; wherein, the fourth scoring value is positively correlated with the number.
The method according to claim 14, wherein the determining the fourth scoring value of the code to be detected under the fourth scoring dimension according to the quantity comprises:

If the number matches the total number of the preset basic configuration conditions, setting the second preset value as the fourth scoring value;

If the number does not match the total number of the preset basic configuration conditions, a third preset value is set as the fourth score value, and the second preset value is greater than the third preset value value.
The method according to claim 14, wherein the preset basic configuration conditions include at least one of the following: a connection is successfully established with the embedded hardware device in the process of generating the code to be detected, the The code is successfully submitted to the testing device and the code to be tested is successfully downloaded to the embedded hardware device and execution and verification operations are performed on the code to be tested.
The method according to claim 2, wherein the method further comprises:

According to the data that does not match the standard code-related data in the running result to be detected, determine the error message;

Output the error message.
The method according to claim 1, wherein the embedded hardware device is respectively connected to a code generation device and the detection device; the code generation device is configured to send the code to be detected to the embedded hardware The device is running, and the running result to be detected is sent to the detection device after the embedded hardware device finishes running the code to be detected;

The code generation device is connected to the detection device, and the code generation device is configured to send other information in the data related to the code to be detected except the running result to be detected to the detection device.
A code detection device applied to an embedded platform, characterized in that the device includes a memory and a processor;

the memory for storing program codes;

The processor calls the program code, and when the program code is executed, is configured to perform the following operations:

The code-related data of the code to be detected is obtained as the code-related data to be detected; the data related to the code to be detected includes the running result to be detected, and the running result to be detected is based on the embedded hardware device of the code to be detected. Obtained by running the code to be detected, and the running result to be detected includes output data of sensors in the embedded hardware device;

According to the relevant data of the code to be detected and the relevant data of the standard code of the preset standard code, determine the scoring value of the code to be detected under the preset scoring dimension;

According to the scoring score under the preset scoring dimension, the overall score of the code to be detected is determined, and the code detection result is obtained.
A detection device, characterized in that, the detection device is used to execute the steps in the code detection method applied to an embedded platform according to any one of claims 1 to 18.
An embedded hardware device, characterized in that the embedded hardware device is used for running the code to be detected, and sending the running result obtained from the running to the detection device described in claim 20 .
The method according to claim 21, wherein the embedded hardware device is one or more of an unmanned aerial vehicle, an unmanned vehicle, and a robot.
A computer-readable storage medium, characterized in that a computer program is stored on the computer-readable storage medium, and when the computer program is executed by a processor, the following operations are implemented:

The code-related data of the code to be detected is obtained as the code-related data to be detected; the data related to the code to be detected includes the running result to be detected, and the running result to be detected is based on the embedded hardware device of the code to be detected. Obtained by running the code to be detected, and the running result to be detected includes output data of sensors in the embedded hardware device;

According to the relevant data of the code to be detected and the relevant data of the standard code of the preset standard code, determine the scoring value of the code to be detected under the preset scoring dimension;

According to the scoring score under the preset scoring dimension, the overall score of the code to be detected is determined, and the code detection result is obtained.