CN112363950A

CN112363950A - Application program debugging method and device

Info

Publication number: CN112363950A
Application number: CN202011378948.2A
Authority: CN
Inventors: 胡彪
Original assignee: Hangzhou Haikang Auto Software Co ltd
Current assignee: Hangzhou Haikang Auto Software Co ltd
Priority date: 2020-11-30
Filing date: 2020-11-30
Publication date: 2021-02-12
Anticipated expiration: 2040-11-30
Also published as: CN112363950B

Abstract

The embodiment of the application discloses a debugging method and device of an application program, and belongs to the technical field of computers. In the embodiment of the application, when the application program needs to be debugged, firstly, in the application program project, the target debugging file is obtained by compiling automatically according to the burning file of the boot loader and the engineering file of the application program project, then the target debugging file is burnt to the MCU through one-time burning, namely, the scheme only needs one-time burning, and the application program can be debugged, so that the problems of mistaken erasing and mistaken writing can be avoided, the correctness of the burnt data can be ensured, manual inspection is not needed, the operation of the whole process is simple, and the debugging efficiency is improved.

Description

Application program debugging method and device

Technical Field

The embodiment of the application relates to the technical field of computers, in particular to a debugging method and device for an application program.

Background

At present, the control of devices such as mobile phones, PC (personal computer) peripherals, remote controllers, automotive electronic devices, industrial motors, and the like is realized by an MCU (Micro Controller Unit) in the devices, which is also called a single-chip microcomputer or a single-chip microcomputer and is a chip-level processor. A Bootloader and an Application are burnt in a produced MCU product, the Bootloader is responsible for starting and refreshing the Application, the Application is responsible for realizing the actual functions of the product, and the operation of the Application depends on the Bootloader. Before MCU product production, the Application needs to be debugged, or before the Application is upgraded, the Application needs to be debugged.

In the related art, a computer device acquires a source file of Bootloader and a source file of Application. Compiling a source file of the Bootloader to obtain a burning file B and a debugging file B, and compiling an Application source file to obtain a burning file A and a debugging file A. And burning the burning file B or the debugging file B to an MCU connected with the computer equipment, and burning the debugging file A to the MCU. And then, when a debugging instruction is received, the computer equipment controls the MCU to run the burned debugging file A so as to debug the application program. When a file is burned into the MCU, an erase operation needs to be performed on a part of the memory space of the MCU, and then the file is written into the memory space.

In the related art, in the case of debugging Application, two times of burning are required, in the second burning process, over-range erasing and/or over-range writing error may occur, and a part of the burned burning file B or the debugging file B is erased and/or written error, so that the burned data is erroneous.

Disclosure of Invention

The embodiment of the Application provides a debugging method and device of an Application program, when the Application is debugged based on Bootloader, errors of burnt data are not prone to occurring, manual check is not needed, and debugging efficiency is effectively improved. The technical scheme is as follows:

in one aspect, a method for debugging an application program is provided, where the method includes:

when a compiling instruction aiming at an Application project is received, determining a target project file according to a first burning file and a project file of the Application project, wherein the first burning file is a burning file for guiding a loader program Bootloader, and the target project file comprises operation related data of the Bootloader and debugging related data of the Application;

compiling the target engineering file to obtain a target debugging file;

and burning the target debugging file to a Micro Control Unit (MCU) to debug the Application.

Optionally, the determining a target project file according to the first burning file and the project file of the Application project includes:

determining a first source code file according to the first burning file;

and merging the first source code file and the engineering file of the Application project to obtain the target engineering file.

Optionally, before determining the first source code file according to the first burning file, the method further includes:

copying the first burning file to a first directory of the Application project according to the file path of the first burning file;

the determining a first source code file according to the first burning file includes:

and converting the first burning file copied to the first directory into the first source code file through a format conversion tool.

Optionally, the Application project corresponds to a first memory space, the first source code file corresponds to a second memory space, and the first memory space and the second memory space are different.

Optionally, the project files of the Application project are stored in a directory to be compiled of the Application project;

the merging the first source code file and the engineering file of the Application project to obtain a target engineering file includes:

copying a first source code file under the first directory to the directory to be compiled;

and taking the first source code file under the directory to be compiled and the project file of the Application project as the target project file.

Optionally, after copying the first source code file in the first directory to the directory to be compiled, the method further includes:

and deleting the first burning file and the first source code file in the first directory.

Optionally, the format conversion tool is a HexView tool.

Optionally, before determining the target project file according to the first burning file and the project file of the Application project when receiving a compiling instruction about an Application project, the method further includes:

when a compiling instruction about the Bootloader project is received, compiling the project file of the Bootloader project to obtain the first burning file, wherein the project file of the Bootloader project comprises a plurality of source files.

In another aspect, an apparatus for debugging an application is provided, the apparatus including:

the system comprises a determining module and a processing module, wherein the determining module is used for determining a target engineering file according to a first burning file and an engineering file of an Application project when a compiling instruction for the Application project of an Application program is received, the first burning file is a burning file for guiding a loader Bootloader, and the target engineering file comprises operation related data of the Bootloader and debugging related data of the Application;

the first compiling module is used for compiling the target engineering file to obtain a target debugging file;

and the debugging module is used for burning the target debugging file to a Micro Control Unit (MCU) so as to debug the Application.

Optionally, the determining module includes:

the determining unit is used for determining a first source code file according to the first burning file;

and the source code merging unit is used for merging the first source code file and the engineering file of the Application engineering to obtain the target engineering file.

Optionally, the determining module further comprises:

the copying unit is used for copying the first burning file to a first directory of the Application project according to the file path of the first burning file;

the determination unit includes:

and the conversion subunit is used for converting the first burning file copied to the first directory into the first source code file through a format conversion tool.

the source code merging unit includes:

the replication sub-unit is used for replicating the first source code file under the first directory to the directory to be compiled;

and the determining subunit is used for taking the first source code file under the directory to be compiled and the engineering file of the Application engineering as the target engineering file.

Optionally, the source code merging unit further includes:

and the deleting subunit is used for deleting the first burning file and the first source code file in the first directory.

Optionally, the format conversion tool is a HexView tool.

Optionally, the apparatus further comprises:

and the second compiling module is used for compiling the engineering file of the Bootloader engineering to obtain the first burning file when receiving a compiling instruction about the Bootloader engineering, and the engineering file of the Bootloader engineering comprises a plurality of source files.

In another aspect, a computer device is provided, where the computer device includes a processor, a communication interface, a memory, and a communication bus, where the processor, the communication interface, and the memory complete mutual communication through the communication bus, the memory is used to store a computer program, and the processor is used to execute the program stored in the memory to implement the steps of the debugging method for the application program.

In another aspect, a computer-readable storage medium is provided, in which a computer program is stored, and the computer program, when executed by a processor, implements the steps of the debugging method for the application program.

In another aspect, a computer program product is provided comprising instructions which, when run on a computer, cause the computer to perform the steps of the method for debugging an application as described above.

The technical scheme provided by the embodiment of the application can at least bring the following beneficial effects:

in the embodiment of the Application, when the Application needs to be debugged, firstly, in the Application project, a target debugging file is obtained by compiling automatically according to a burning file of a Bootloader and an engineering file of the Application project, and then the target debugging file is burnt to an MCU (microprogrammed control unit) through one-time burning, namely, the scheme only needs one-time burning, so that the Application can be debugged, the problems of mistaken erasing and mistaken writing can be avoided, the correctness of burnt data is ensured, manual check is not needed, the operation of the whole process is simple, and the debugging efficiency is improved.

Drawings

In order to more clearly illustrate the technical solutions in the embodiments of the present application, the drawings needed to be used in the description of the embodiments are briefly introduced below, and it is obvious that the drawings in the following description are only some embodiments of the present application, and it is obvious for those skilled in the art to obtain other drawings based on these drawings without creative efforts.

Fig. 1 is a system architecture diagram according to a debugging method of an application provided in an embodiment of the present application;

fig. 2 is a flowchart of a debugging method of an application program according to an embodiment of the present application;

fig. 3 is a flowchart of a method for obtaining a target debug file according to an embodiment of the present application;

fig. 4 is a flowchart of another method for obtaining a target debug file according to an embodiment of the present application;

fig. 5 is a schematic structural diagram of a debugging apparatus for an application program according to an embodiment of the present application;

fig. 6 is a schematic structural diagram of a computer device according to an embodiment of the present application.

Detailed Description

To make the objects, technical solutions and advantages of the embodiments of the present application more clear, the embodiments of the present application will be further described in detail with reference to the accompanying drawings.

In order to facilitate understanding of the embodiments of the present application, a part of terms related to the embodiments of the present application will be explained first.

MCU: a Micro control Unit, also called a Single Chip microcomputer (mcu) or a Single Chip microcomputer (mcu), is to reduce the frequency and specification of a CPU (Central processing Unit) properly, and integrate peripheral interfaces such as a memory (memory), a counter (timer), a USB (Universal Serial Bus), an a/D Converter (Analog to Digital Converter), and even an LCD (Liquid Crystal Display) driving circuit on a Single Chip, so as to form a Chip-level Computer, which is used for different applications and different combination controls.

Refreshing: and modifying the action of the program content through the program programming instruction.

Bootloader: and the boot loader is responsible for starting and refreshing the Application program in the MCU, and the Bootloader can be abbreviated as BLD in the embodiment of the Application.

Application: the Application program is a program in charge of running the actual functions of the product in the MCU, and in the embodiment of the Application, the Application can be abbreviated as APP.

Hex: a file format of a compiled binary executable program, an Intel standard file, a file suffix.

S19: a program compiled binary executable file format, Motorola standard, file suffix.s 19.

IDE: an Integrated Development Environment (Integrated Development Environment) is an application program for providing a program Development Environment, generally includes tools such as a code editor, a compiler, a debugger, a graphical user interface and the like, and integrates a Development software service suite with integration of a code compiling function, an analyzing function, a compiling function, a debugging function and the like.

Recording a file: a binary file, which is compiled by IDE and can only be used for chip (hardware) running programs, is generally in Hex format or S19 format.

Debugging the file: a file containing program running process information is generated after source codes are compiled by an IDE, so that not only can a chip run, but also the IDE can control the chip to run on line to debug a program, and the control comprises setting program breakpoints, observing/modifying variables and the like. The debugging file comprises data of the burning file and debugging information output to the debugger. There is typically an AXF format, an LMF format or an ELF format.

Engineering: and the software development debugging environment is established based on the IDE.

HexView: a binary file processing tool can process files in a hex/s19 format, and in the embodiment of the application, HexView can be abbreviated as HexV.

Batch processing: batch, also called Batch scripting, is a simplified scripting language for Batch processing of an object, and can be applied to DOS (Disk Operating System) and Windows systems.

Script: script, which is an executable file written according to a certain format using a specific descriptive language.

The MCU is a chip-scale processor and is widely used in various electronic devices, such as mobile phones, remote controllers, automotive electronics, industrial motors, and the like. And burning Bootloader and Application in the MCU to start and refresh an Application program through the Bootloader, and realizing the actual functions of the product through the Application, such as controlling a car lamp, a key and the like. Before MCU is produced or before Application is upgraded (such as new functions are added), Application needs to be debugged, the debugging method of the Application program provided by the embodiment of the Application can be used for debugging the Application, user operation can be simplified, errors of burnt data can be avoided, a user does not need to check the correctness of the burnt data, and debugging efficiency is improved.

Next, a system architecture related to the method for debugging an application provided in the embodiment of the present application is described.

Fig. 1 is a system architecture diagram according to a debugging method of an application provided in an embodiment of the present application. Referring to fig. 1, the system architecture includes a computer device 101 and an MCU102, and the MCU102 connects the computer device 101 in a wired manner to transmit data to each other.

The computer device 101 is provided with an IDE, and a developer may establish a project in the IDE by connecting an input device (such as a keyboard, a mouse, etc.) of the computer device 101 and compile project files in the project, such as establishing a Bootloader project and an Application project respectively, compiling project files of the Bootloader project in the Bootloader project and compiling project files of the Application project in the Application project. The computer device 101 is further configured to receive a compiling instruction for the project, and compile the project file through the IDE after receiving the compiling instruction to obtain a burning file and a debugging file. The computer device 101 is further configured to burn a target debugging file obtained according to the debugging method of the Application program provided in the embodiment of the present Application onto the MCU102, receive a debugging instruction through a debugger in the IDE, and control the MCU to run the target debugging file, so as to debug the Application.

MCU102 is used for receiving the target debugging file that computer equipment 101 transmitted, burns the target debugging file to MCU102 in, MCU102 is still used for receiving the debugging instruction of IDE in computer equipment 101 to run the target debugging file according to the debugging instruction, in order to realize the debugging to Application.

In the embodiment of the present application, the computer device 101 is a desktop computer, a notebook computer, a tablet computer, a mobile phone, and the like, which can be connected to the MCU102 and interact with a user, and the MCU102 is a single chip microcomputer of various types.

Next, a method for debugging an application provided in an embodiment of the present application will be explained in detail.

Fig. 2 is a flowchart of a method for debugging an application program according to an embodiment of the present application. Referring to fig. 2, the method includes the following steps.

Step 201: when a compiling instruction aiming at an application program APP project is received, determining a target project file according to a first burning file and the project file of the APP project, wherein the first burning file is a burning file for guiding a loader BLD, and the target project file comprises operation related data of the BLD and debugging related data of the APP.

In the embodiment of the application, the computer device is provided with an IDE, which is an application program for providing a program development environment, generally includes tools such as a code editor, a compiler, a debugger, a graphical user interface and the like, and integrates an integrated development software service set such as a code compiling function, an analyzing function, a compiling function, a debugging function and the like. A developer can establish a project in an IDE through input equipment (such as a keyboard, a mouse and the like) connected with computer equipment through a code editor, an image user interface and other tools, and compile a project file in the project. After the debugging file is burned to the MCU connected with the computer equipment, a debugging instruction of a developer is received through a debugger in the IDE, and the burned debugging file is controlled to run by the MCU according to the debugging instruction, so that program debugging is realized.

In the embodiment of the Application, developers respectively establish a Bootloader project and an Application project in an IDE through computer equipment, respectively write source codes in the Bootloader project to obtain project files of the Bootloader project, and write the source codes in the Application project to obtain project files of the Application project, wherein the project files are source files containing the source codes, the project files of the Bootloader project comprise a plurality of source files, and the project files of the Application project also comprise a plurality of source files.

Before the computer equipment compiles the Application project through a compiler in the IDE, compiling the Bootloader project through the compiler in the IDE, namely when a compiling instruction about the Bootloader project is received, compiling the project files of the Bootloader project to obtain a first burning file, wherein the first burning file is the burning file of the Bootloader.

Illustratively, a developer clicks an IDE compiling control displayed on a computer device through a mouse to trigger a compiling instruction about the Bootloader project, and after receiving the compiling instruction, the computer device compiles a project file of the Bootloader project to obtain a burning file and a debugging file of the Bootloader. It should be noted that, in the embodiment of the present application, since the debug file of the Bootloader is not needed subsequently, the debug file of the Bootloader obtained by compiling may be deleted or not processed. Or the debugging file of the Bootloader can be burned to the MCU for debugging the Bootloader.

In the embodiment of the present application, the first burning file contains the operation-related data of Bootloader, and the file format of the first burning file is. hex or. s 19.

Optionally, in this embodiment of the present Application, for code writing, compiling, debugging, and the like of the Bootloader project, the code writing, compiling, debugging, and the like may also be implemented on other computer devices, a developer establishes the Bootloader project, writes a code, and clicks on compiling through an IDE on the other computer devices, the other computer devices obtain a first burning file after compiling the project file of the Bootloader project, and copy the first burning file from the other computer devices to the computer devices for compiling the Application project through a tool such as a usb disk, or send the first burning file to the computer devices for compiling the Application project through the other computer devices.

After obtaining the first burning file, the computer equipment determines a target project file according to the first burning file and the project file of the Application project when receiving a compiling instruction about the Application project through a compiler in the IDE.

In the embodiment of the application, the target engineering file is obtained by merging the source codes before compiling. That is, the computer device determines the first source code file according to the first burning file, and then merges the first source code file and the engineering file of the Application engineering to obtain the target engineering file.

In an embodiment of the present application, the computer device converts the first burning file into a first source code file through a format conversion tool.

Optionally, the format conversion tool is a HexView tool, and the format of the first source code file is.

Illustratively, the computer device converts the first burning file in the hex or s19 format into the first source code file in the C format through a HexView tool, the first source code file being a C array file.

In the embodiment of the application, in order to realize automation, simplify user operations, and improve debugging efficiency, a developer may create a first directory in an IDE through a computer device for storing a first burning file and a first source code file.

Before determining the first source code file according to the first burning file, the computer device copies the first burning file to a first directory of an Application project according to a file path of the first burning file, and then converts the first burning file copied to the first directory into the first source code file through a format conversion tool.

The computer device automatically copies the first burning file to a first directory of an Application project according to the file path of the first burning file stored in the Application project when detecting a compiling instruction for the Application project.

Because absolute independence of memory resources used by Bootloader and Application needs to be ensured in the MCU, a memory space corresponding to the Bootloader and a memory space corresponding to the Application need to be defined, that is, operating memory address ranges corresponding to the Bootloader and the Application are respectively defined, and absolute opposition between the Bootloader and the Application is ensured.

In the embodiment of the Application, when an Application project is established, the Application project is set to correspond to a first memory space, when a Bootloader project is established, the Bootloader project is set to correspond to a second memory space, the second memory space corresponding to the Bootloader project is stored in the Application project, when a first burning file is converted into a first source code file through a HexView tool, the second memory space corresponding to the Bootloader project is obtained, and the second memory space is used as the memory space corresponding to the first source code file. That is, in the embodiment of the present Application, the Application process corresponds to the first memory space, the first source code file corresponds to the second memory space, and the first memory space and the second memory space are different.

As can be seen from the above, in the embodiment of the present Application, the memory space corresponding to the Application project is defined in a global definition manner, that is, the Application project is defined in a global definition manner to correspond to the first memory space in the Application project, so that the project files of the Application project all correspond to the first memory space, that is, the globally defined memory space acts on all the files in the Application project except the locally defined memory space. The memory space corresponding to the first source code file is locally limited in the Application project in a locally limited manner, and the first source code file can be understood as a special file in the Application project.

Exemplarily, the memory space (memory address range) corresponding to the Application project is globally limited to 0x20000000-0x20004000 by setting the global parameters of the Application project, and the global parameters act on all files except the locally limited files in the Application project. The method includes the steps of locally limiting a memory space corresponding to a first source code file through a tag form, and specifying a second memory space in the converted first source code file through the tag form, where the first source code file includes a start tag and an end tag, the start tag is located at the forefront of a code and indicates that the code starting from the beginning corresponds to the second memory space, and the end tag is located at the rearmost of the code and indicates that the code before the end corresponds to the second memory space, where the start tag includes information of the second memory space, for example, the start tag is "HG 00203B5D4H3D 7", where "00" indicates a start address of the second memory space, and "20" indicates an end address of the second memory space.

In the embodiment of the Application, the project files of the Application project are stored in a to-be-compiled directory of the Application project, after the first source code file is obtained, the computer device automatically copies the first source code file in the first directory to the to-be-compiled directory, and the first source code file in the to-be-compiled directory and the project files of the Application project are used as target project files. That is, the computer device obtains the target project file by means of source code merging.

Optionally, after copying the first source code file in the first directory to the directory to be compiled, the computer device deletes the first burning file and the first source code file in the first directory. That is, in the embodiment of the present application, the first burning file and the first source code file in the first directory are temporary files, and after being used, they may be optionally deleted.

Optionally, in this embodiment of the present application, in order to facilitate management of engineering and implementation of an automation scheme, a developer also stores the HexView tool in the first directory through a computer device, so as to facilitate conversion of the first burning file in the first directory into the first source code file. Of course, the HexView tool may also be stored in other directories in the Application project.

Alternatively, in the embodiment of the present application, the first directory may be referred to as a UserTool directory.

It should be noted that, the process of determining the first source code file according to the first burning file, and merging the first source code file and the engineering file of the Application project to obtain the target engineering file may be automatically completed through a batch processing script before compiling. In the embodiment of the Application, a developer can set a batch processing script before compiling in an Application project in an IDE through computer equipment, and when a compiling instruction about the Application project is received, the IDE automatically triggers and runs the batch processing script to complete the steps of converting a first burning file into a first source code file and copying the first source code file to a directory to be compiled in the Application project.

In addition, because there may be empty rows and the like in the first burning file (hex/s19), in the process of converting the first burning file into the first source code file through the HexView tool, the first burning file is subjected to FF filling through the HexView tool first to fill the empty rows in the first burning file with FFs, and then the first burning file filled with FFs is converted into the first source code file through the HexView tool, so as to ensure that no error occurs in the conversion process and no data is lost, and ensure that the data of the first source code file obtained after conversion is correct.

Through the process, the computer equipment obtains a target engineering file to be compiled, wherein the target engineering file comprises the operation related data of the Bootloader and the debugging related data of the Application.

Step 202: and compiling the target engineering file to obtain a target debugging file.

In the embodiment of the application, after obtaining the target engineering file, the computer device compiles the target engineering file to obtain the target debugging file.

It should be noted that, the process from the time when the computer device receives the compiling instruction about the Application project to the time when the computer device obtains the target debugging file is a fully automatic process, and the process can be completed without the tedious operation of a developer. That is, the automation scheme is implemented by pre-compiled batch scripts and HexView tools.

In addition, after the target engineering file is compiled, a burning file containing the operation related data of the Bootloader and the operation related data of the Application can be obtained, and the burning file can be called as a second burning file.

Step 203: and burning the target debugging file onto the MCU to debug the APP.

In the embodiment of the Application, after the computer device obtains the target debugging file, when a burning instruction of a developer is received, the target debugging file is burned to the MCU, and the MCU is controlled to run the target debugging file to debug the Application according to the debugging instruction received by the debugger in the IDE. For example, the computer device sends the debugging instruction to the MCU through the debugger, and the MCU runs the target debugging file according to the debugging instruction.

Illustratively, a developer may set program breakpoints, modify variables, etc. through the IDE to generate debug instructions to debug the Application. For example, a developer clicks a line of codes in the middle of a program of a target debugging file displayed in an IDE through a mouse, a program breakpoint is set at the line of codes, then a debugging key is clicked to generate a debugging instruction, the debugging instruction carries information of the program breakpoint, the debugger sends the debugging instruction to the MCU, the MCU starts to run the target debugging file according to the debugging instruction, and stops running when a line of codes corresponding to the program breakpoint is run, when the program breakpoint is run, the values of current variables in the program are displayed on a computer device, and the developer can view the variables, modify the variables, and the like.

It should be noted that, as can be seen from the above description, the computer device can also obtain the second burning file after compiling the target engineering file, and if it is determined that the target debugging file has good performance and does not have a place to be improved after the Application is debugged, that is, it is determined that the source code of the Application engineering does not need to be modified, then the second burning file can be burned to the MCU by one-time burning, and put into use, that is, the MCU into which the second burning file is burned can control the operation of the electronic device and realize the product function.

That is, while solving various problems caused by twice burning during Application debugging, the scheme can also solve the problems caused by twice burning (firstly burning the burning file of the Bootloader and then burning the burning file of the Application) during MCU production or MCU upgrade, also provides a scheme for merging the burning files, obtains the burning files containing the operation related data of the Bootloader and the operation related data of the Application through the scheme, obtains the MCU capable of operating the Bootloader and the Application through one-time burning, improves the burning efficiency during MCU production or upgrade and ensures the correctness of the burning data.

It should be noted that, as can be seen from the foregoing description, the format of the debug file includes an AXF format, an LMF format, or an ELF format, none of these formats corresponds to a public standard, the file format difference is large, and there is no tool capable of directly merging the debug file, that is, the scheme of directly merging the debug file at present is difficult to implement. If the subsequent open standard related to the format of the debugging file ensures the standardization of the file format, and a tool capable of directly combining the debugging file appears along with the development of computer technology, the debugging file of Bootloader and the debugging file of Application can be directly combined through the tool, the Application debugging is realized through one-time burning subsequently, the problem of mistaken erasing or mistaken writing cannot be caused by one-time burning, the burnt data is not easy to make mistakes, manual check is not needed, and the debugging efficiency is effectively improved.

Under the condition that the scheme of directly combining debugging files is difficult to implement at present, the scheme provides a universal solution, is not influenced by the format difference of the debugging files, compiling environment and a compiling tool, so that the operation steps and the method of Application online debugging and Bootloader online debugging are kept consistent, namely only one burning process (burning files of Bootloader) is needed in the operation steps of Bootloader online debugging, the Application online debugging only needs one burning process (burning target debugging files), the operation complexity of Application online debugging is reduced, and the online debugging efficiency is improved.

Fig. 3 is a flowchart of a method for obtaining a target debug file according to an embodiment of the present application, and a method for obtaining a target debug file according to a debugging method of an application program according to an embodiment of the present application is explained with reference to fig. 3. Referring to fig. 3, in the Bootloader (bld) project, the engineering file (source code) of the Bootloader project is compiled to obtain a first burning file (b.hex or b.s19) and a first debugging file (B '), in the Application (APP) project, the b.hex or b.s19 is converted into a first source code file (b.c) by a hexview (hexv) tool, the b.c is merged with the engineering file (source code) of the APP project to obtain a target engineering file (AB source code), and the target engineering file is compiled to obtain a second burning file (ab.hex or ab.s19) and a target debugging file (AB').

The above process of obtaining the target debug file is described again with reference to the IDE. Fig. 4 is a flowchart of another method for obtaining a target debug file according to an embodiment of the present application. Referring to fig. 4, in the APP project, a developer clicks a compiling control in the IDE, triggers the computer device to execute the APP IDE compiling, first invokes a batch script before compiling, completes a first burning file (assumed to be b.hex) to be converted into a first source code file (b.c) through the batch script, copies the b.c to a directory to be compiled in the APP project to merge source codes, and then executes the compiling of files (including the b.c) in the directory to be compiled in the APP project to obtain a target debugging file and a second burning file (merged burning file).

The process of calling the batch script before compiling mainly comprises the steps of copying B.hex to a first directory (which can be called as a temporary directory), calling a HexView (HexV) tool to fill FF in the B.hex, calling the HexView tool to convert the B.hex after filling FF into B.c, copying the B.c to a directory to be compiled of an APP project, and deleting a temporary file, wherein the temporary file comprises a first burning file and a first source code file in the first directory.

As can be seen from the above embodiments and the related descriptions in fig. 3 and fig. 4, the present solution converts the burning file (hex/s19 format) into the source code file (c format) so as to complete the source code merging before compiling, and converts into the first source code file so as to locally limit the memory address range and ensure the independence of the memory space. In addition, source code combination is automatically completed before compiling through a batch script and a HexView tool, a target debugging file is obtained, and an automatic implementation scheme can be implemented without complex operation.

The scheme can be applied to various situations needing to debug the Application based on the Bootloader, for example, when a MCU is newly developed and the Application of the MCU is upgraded, the Bootloader of the MCU needs to debug the Application when the Bootloader of the MCU is upgraded to have certain influence on the Application, and the debugging efficiency of the Application is improved through the general scheme provided by the embodiment of the Application.

Optionally, in some other embodiments, the engineering file (source code) of the Bootloader engineering and the engineering file (source code) of the Application engineering are merged, and all the merged files are compiled to obtain a debugging file and a burning file, the obtained debugging file is used as a target debugging file, and the obtained burning file is used as a second burning file, so that the purpose of debugging the Application in one burning process can also be achieved. For example, the project files of the Bootloader project are copied to the to-be-compiled directory of the Application project to merge the source codes, and all the merged files are compiled in the Application project to obtain the target debugging files. Or copying the engineering files of the Application engineering to a to-be-compiled directory of a Bootloader engineering to merge the source codes, and compiling all the merged files in the Bootloader engineering to obtain a target debugging file.

In this scheme, it is assumed that the engineering files of the Bootloader project are copied to a to-be-compiled directory of the Application project to merge source codes, and all the merged files are compiled in the Application project, so that a memory address range corresponding to each source file included in the engineering files of the Bootloader project needs to be locally limited in the Application project, and if the engineering files of the subsequent Bootloader project have newly-written source files, a memory address range corresponding to the newly-added source file needs to be specified. Similarly, if the engineering file of the Application project is copied to the directory to be compiled of the Bootloader project to merge the source codes, and all the merged files are compiled in the Bootloader project, the memory address range corresponding to each source file included in the engineering file of the Application project needs to be locally limited in the Bootloader project, and for a newly added source file in the Application project, the memory address range corresponding to the newly added source file needs to be specified.

In the method for converting the first burning file into the first source code file and obtaining the target debugging file by the source code merging manner introduced in the embodiment of the application, only the memory space corresponding to the first burning file needs to be locally limited once, so that the operation is simple, and the scheme is beneficial to implementation of developers.

Fig. 5 is a schematic structural diagram of an application debugging apparatus 500 according to an embodiment of the present application, where the application debugging apparatus 500 may be implemented as part or all of a computer device by software, hardware, or a combination of the two. Referring to fig. 5, the apparatus 500 includes: a determination module 501, a first compiling module 502 and a debugging module 503.

The determining module 501 is configured to determine a target engineering file according to a first burning file and an engineering file of an Application project when a compiling instruction for the Application project is received, where the first burning file is a burning file of a Bootloader, and the target engineering file includes operation related data of the Bootloader and debugging related data of the Application;

a first compiling module 502, configured to compile the target engineering file to obtain a target debugging file;

and the debugging module 503 is configured to burn the target debugging file onto the MCU to debug the Application.

Optionally, the determining module 501 includes:

and the source code merging unit is used for merging the first source code file and the project file of the Application project to obtain a target project file.

Optionally, the determining module 501 further includes:

the copying unit is used for copying the first burning file to a first directory of an Application project according to the file path of the first burning file;

the determination unit includes:

and the conversion subunit is used for converting the first burning file copied to the first directory into a first source code file through a format conversion tool.

the source code merging unit includes:

the replication sub unit is used for replicating the first source code file under the first directory to a directory to be compiled;

and the determining subunit is used for taking the first source code file and the engineering file of the Application project under the directory to be compiled as target engineering files.

Optionally, the source code merging unit further includes:

Optionally, the format conversion tool is a HexView tool.

Optionally, the apparatus 500 further comprises:

and the second compiling module is used for compiling the engineering files of the Bootloader engineering to obtain a first burning file when a compiling instruction about the Bootloader engineering is received, and the engineering files of the Bootloader engineering comprise a plurality of source files.

It should be noted that: in the application program debugging apparatus provided in the above embodiment, only the division of the functional modules is exemplified when the application program is debugged, and in practical applications, the function distribution may be completed by different functional modules according to needs, that is, the internal structure of the apparatus is divided into different functional modules to complete all or part of the functions described above. In addition, the debugging apparatus of the application program and the debugging method embodiment of the application program provided in the above embodiments belong to the same concept, and specific implementation processes thereof are detailed in the method embodiments and are not described herein again.

Fig. 6 is a block diagram of a computer device 600 according to an embodiment of the present disclosure. The computer device 600 may be a smartphone, a tablet computer, a laptop computer, a desktop computer, or the like.

Generally, the computer device 600 includes: a processor 601 and a memory 602.

The processor 601 may include one or more processing cores, such as a 4-core processor, an 8-core processor, and so on. The processor 601 may be implemented in at least one hardware form of a DSP (Digital Signal Processing), an FPGA (Field-Programmable Gate Array), and a PLA (Programmable Logic Array). The processor 601 may also include a main processor and a coprocessor, where the main processor is a processor for Processing data in an awake state, and is also called a Central Processing Unit (CPU); a coprocessor is a low power processor for processing data in a standby state. In some embodiments, the processor 601 may be integrated with a GPU (Graphics Processing Unit), which is responsible for rendering and drawing the content that the display screen needs to display. In some embodiments, processor 601 may also include an AI (Artificial Intelligence) processor for processing computational operations related to machine learning.

The memory 602 may include one or more computer-readable storage media, which may be non-transitory. The memory 602 may also include high-speed random access memory, as well as non-volatile memory, such as one or more magnetic disk storage devices, flash memory storage devices. In some embodiments, a non-transitory computer readable storage medium in memory 602 is used to store at least one instruction for execution by processor 601 to implement a debugging method for an application program provided by method embodiments herein.

In some embodiments, the computer device 600 may further optionally include: a peripheral interface 603 and at least one peripheral. The processor 601, memory 602, and peripheral interface 603 may be connected by buses or signal lines. Various peripheral devices may be connected to the peripheral interface 603 via a bus, signal line, or circuit board. Specifically, the peripheral device includes: at least one of a radio frequency circuit 604, a display 605, a camera assembly 606, an audio circuit 607, a positioning component 608, and a power supply 609.

The peripheral interface 603 may be used to connect at least one peripheral related to I/O (Input/Output) to the processor 601 and the memory 602. In some embodiments, the processor 601, memory 602, and peripheral interface 603 are integrated on the same chip or circuit board; in some other embodiments, any one or two of the processor 601, the memory 602, and the peripheral interface 603 may be implemented on a separate chip or circuit board, which is not limited in this embodiment.

The Radio Frequency circuit 604 is used for receiving and transmitting RF (Radio Frequency) signals, also called electromagnetic signals. The radio frequency circuitry 604 communicates with communication networks and other communication devices via electromagnetic signals. The rf circuit 604 converts an electrical signal into an electromagnetic signal to transmit, or converts a received electromagnetic signal into an electrical signal. Optionally, the radio frequency circuit 604 comprises: an antenna system, an RF transceiver, one or more amplifiers, a tuner, an oscillator, a digital signal processor, a codec chipset, a subscriber identity module card, and so forth. The radio frequency circuitry 604 may communicate with other computer devices via at least one wireless communication protocol. The wireless communication protocols include, but are not limited to: the world wide web, metropolitan area networks, intranets, generations of mobile communication networks (2G, 3G, 4G, and 5G), Wireless local area networks, and/or WiFi (Wireless Fidelity) networks. In some embodiments, the radio frequency circuit 604 may further include a circuit related to NFC (Near Field Communication), which is not limited in this application.

The display 605 is used to display a UI (User Interface). The UI may include graphics, text, icons, video, and any combination thereof. When the display screen 605 is a touch display screen, the display screen 605 also has the ability to capture touch signals on or over the surface of the display screen 605. The touch signal may be input to the processor 601 as a control signal for processing. At this point, the display 605 may also be used to provide virtual buttons and/or a virtual keyboard, also referred to as soft buttons and/or a soft keyboard. In some embodiments, the display 605 may be one, disposed on the front panel of the computer device 600; in other embodiments, the display 605 may be at least two, respectively disposed on different surfaces of the computer device 600 or in a folded design; in other embodiments, the display 605 may be a flexible display disposed on a curved surface or on a folded surface of the computer device 600. Even more, the display 605 may be arranged in a non-rectangular irregular pattern, i.e., a shaped screen. The Display 605 may be made of LCD (Liquid Crystal Display), OLED (Organic Light-Emitting Diode), and the like.

The camera assembly 606 is used to capture images or video. Optionally, camera assembly 606 includes a front camera and a rear camera. Generally, a front camera is disposed on a front panel of a computer apparatus, and a rear camera is disposed on a rear surface of the computer apparatus. In some embodiments, the number of the rear cameras is at least two, and each rear camera is any one of a main camera, a depth-of-field camera, a wide-angle camera and a telephoto camera, so that the main camera and the depth-of-field camera are fused to realize a background blurring function, and the main camera and the wide-angle camera are fused to realize panoramic shooting and VR (Virtual Reality) shooting functions or other fusion shooting functions. In some embodiments, camera assembly 606 may also include a flash. The flash lamp can be a monochrome temperature flash lamp or a bicolor temperature flash lamp. The double-color-temperature flash lamp is a combination of a warm-light flash lamp and a cold-light flash lamp, and can be used for light compensation at different color temperatures.

Audio circuitry 607 may include a microphone and a speaker. The microphone is used for collecting sound waves of a user and the environment, converting the sound waves into electric signals, and inputting the electric signals to the processor 601 for processing or inputting the electric signals to the radio frequency circuit 604 to realize voice communication. For stereo capture or noise reduction purposes, the microphones may be multiple and located at different locations on the computer device 600. The microphone may also be an array microphone or an omni-directional pick-up microphone. The speaker is used to convert electrical signals from the processor 601 or the radio frequency circuit 604 into sound waves. The loudspeaker can be a traditional film loudspeaker or a piezoelectric ceramic loudspeaker. When the speaker is a piezoelectric ceramic speaker, the speaker can be used for purposes such as converting an electric signal into a sound wave audible to a human being, or converting an electric signal into a sound wave inaudible to a human being to measure a distance. In some embodiments, audio circuitry 607 may also include a headphone jack.

The Location component 608 is used to locate the current geographic Location of the computer device 600 to implement navigation or LBS (Location Based Service). The Positioning component 608 can be a Positioning component based on the Global Positioning System (GPS) in the united states, the beidou System in china, or the galileo System in russia.

The power supply 609 is used to supply power to the various components in the computer device 600. The power supply 609 may be ac, dc, disposable or rechargeable. When the power supply 609 includes a rechargeable battery, the rechargeable battery may be a wired rechargeable battery or a wireless rechargeable battery. The wired rechargeable battery is a battery charged through a wired line, and the wireless rechargeable battery is a battery charged through a wireless coil. The rechargeable battery may also be used to support fast charge technology.

In some embodiments, the computer device 600 also includes one or more sensors 610. The one or more sensors 610 include, but are not limited to: acceleration sensor 611, gyro sensor 612, pressure sensor 613, fingerprint sensor 614, optical sensor 615, and proximity sensor 616.

The acceleration sensor 611 may detect the magnitude of acceleration in three coordinate axes of a coordinate system established with the computer apparatus 600. For example, the acceleration sensor 611 may be used to detect components of the gravitational acceleration in three coordinate axes. The processor 601 may control the display screen 605 to display the user interface in a landscape view or a portrait view according to the gravitational acceleration signal collected by the acceleration sensor 611. The acceleration sensor 611 may also be used for acquisition of motion data of a game or a user.

The gyro sensor 612 may detect a body direction and a rotation angle of the computer apparatus 600, and the gyro sensor 612 may cooperate with the acceleration sensor 611 to acquire a 3D motion of the user on the computer apparatus 600. The processor 601 may implement the following functions according to the data collected by the gyro sensor 612: motion sensing (such as changing the UI according to a user's tilting operation), image stabilization at the time of photographing, game control, and inertial navigation.

The pressure sensor 613 may be disposed on a side bezel of the computer device 600 and/or underneath the display screen 605. When the pressure sensor 613 is disposed on the side frame of the computer device 600, the holding signal of the user to the computer device 600 can be detected, and the processor 601 performs left-right hand recognition or shortcut operation according to the holding signal collected by the pressure sensor 613. When the pressure sensor 613 is disposed at the lower layer of the display screen 605, the processor 601 controls the operability control on the UI interface according to the pressure operation of the user on the display screen 605. The operability control comprises at least one of a button control, a scroll bar control, an icon control and a menu control.

The fingerprint sensor 614 is used for collecting a fingerprint of a user, and the processor 601 identifies the identity of the user according to the fingerprint collected by the fingerprint sensor 614, or the fingerprint sensor 614 identifies the identity of the user according to the collected fingerprint. Upon identifying that the user's identity is a trusted identity, the processor 601 authorizes the user to perform relevant sensitive operations including unlocking the screen, viewing encrypted information, downloading software, paying, and changing settings, etc. The fingerprint sensor 614 may be disposed on the front, back, or side of the computer device 600. When a physical key or vendor Logo is provided on the computer device 600, the fingerprint sensor 614 may be integrated with the physical key or vendor Logo.

The optical sensor 615 is used to collect the ambient light intensity. In one embodiment, processor 601 may control the display brightness of display screen 605 based on the ambient light intensity collected by optical sensor 615. Specifically, when the ambient light intensity is high, the display brightness of the display screen 605 is increased; when the ambient light intensity is low, the display brightness of the display screen 605 is adjusted down. In another embodiment, the processor 601 may also dynamically adjust the shooting parameters of the camera assembly 606 according to the ambient light intensity collected by the optical sensor 615.

The proximity sensor 616, also known as a distance sensor, is typically disposed on the front panel of the computer device 600. The proximity sensor 616 is used to capture the distance between the user and the front of the computer device 600. In one embodiment, the processor 601 controls the display screen 605 to switch from the bright screen state to the dark screen state when the proximity sensor 616 detects that the distance between the user and the front face of the computer device 600 is gradually decreased; when the proximity sensor 616 detects that the distance between the user and the front of the computer device 600 is gradually increasing, the display screen 605 is controlled by the processor 601 to switch from the breath-screen state to the bright-screen state.

Those skilled in the art will appreciate that the configuration shown in FIG. 6 does not constitute a limitation of the computer device 600, and may include more or fewer components than those shown, or combine certain components, or employ a different arrangement of components.

In some embodiments, a computer-readable storage medium is also provided, in which a computer program is stored, and the computer program, when executed by a processor, implements the steps of the debugging method of the application program in the above embodiments. For example, the computer readable storage medium may be a ROM, a RAM, a CD-ROM, a magnetic tape, a floppy disk, an optical data storage device, and the like.

It is noted that the computer-readable storage medium referred to in the embodiments of the present application may be a non-volatile storage medium, in other words, a non-transitory storage medium.

It should be understood that all or part of the steps for implementing the above embodiments may be implemented by software, hardware, firmware or any combination thereof. When implemented in software, may be implemented in whole or in part in the form of a computer program product. The computer program product includes one or more computer instructions. The computer instructions may be stored in the computer-readable storage medium described above.

That is, in some embodiments, there is also provided a computer program product containing instructions which, when run on a computer, cause the computer to perform the steps of the method for debugging an application program as described above.

It is to be understood that reference herein to "at least one" means one or more and "a plurality" means two or more. In the description of the embodiments of the present application, "/" means "or" unless otherwise specified, for example, a/B may mean a or B; "and/or" herein is merely an association describing an associated object, and means that there may be three relationships, e.g., a and/or B, which may mean: a exists alone, A and B exist simultaneously, and B exists alone. In addition, in order to facilitate clear description of technical solutions of the embodiments of the present application, in the embodiments of the present application, terms such as "first" and "second" are used to distinguish the same items or similar items having substantially the same functions and actions. Those skilled in the art will appreciate that the terms "first," "second," etc. do not denote any order or quantity, nor do the terms "first," "second," etc. denote any order or importance.

The above-mentioned embodiments are provided not to limit the present application, and any modification, equivalent replacement, improvement, etc. made within the spirit and principle of the present application should be included in the protection scope of the present application.

Claims

1. A method for debugging an application program, the method comprising:

when a compiling instruction for an application program project is received, determining a target project file according to a first burning file and a project file of the application program project, wherein the first burning file is a burning file of a boot loader, and the target project file comprises operation related data of the boot loader and debugging related data of the application program;

compiling the target engineering file to obtain a target debugging file;

and burning the target debugging file to a Micro Control Unit (MCU) so as to debug the application program.

2. The method of claim 1, wherein determining a target project file from the first burnt file and the project file of the application project comprises:

determining a first source code file according to the first burning file;

and merging the first source code file and the engineering file of the application program engineering to obtain the target engineering file.

3. The method of claim 2, wherein determining the first source code file from the first burnt file is preceded by:

copying the first burning file to a first directory of the application program project according to the file path of the first burning file;

4. The method of claim 3, wherein the application program project corresponds to a first memory space, wherein the first source code file corresponds to a second memory space, and wherein the first memory space and the second memory space are different.

5. The method according to claim 3, wherein the project files of the application project are stored in a directory to be compiled of the application project;

the merging the first source code file and the engineering file of the application program project to obtain a target engineering file includes:

copying a first source code file under the first directory to the directory to be compiled, and deleting a first burning file and a first source code file under the first directory;

and taking the first source code file under the directory to be compiled and the engineering file of the application program engineering as the target engineering file.

6. The method according to any one of claims 1-5, wherein before determining the target project file according to the first burning file and the project file of the application project when receiving the compiling instruction about the application project, further comprising:

when a compiling instruction about the bootstrap loader project is received, compiling the project file of the bootstrap loader project to obtain the first burning file, wherein the project file of the bootstrap loader project comprises a plurality of source files.

7. An apparatus for debugging an application program, the apparatus comprising:

the system comprises a determining module and a processing module, wherein the determining module is used for determining a target engineering file according to a first burning file and an engineering file of an application program project when a compiling instruction for the application program project is received, the first burning file is a burning file of a boot loader, and the target engineering file comprises operation related data of the boot loader and debugging related data of the application program;

and the debugging module is used for burning the target debugging file to a Micro Control Unit (MCU) so as to debug the application program.

8. The apparatus of claim 7, wherein the determining module comprises:

and the source code merging unit is used for merging the first source code file and the project file of the application program project to obtain the target project file.

9. The apparatus of claim 8, wherein the determining module further comprises:

the copying unit is used for copying the first burning file to a first directory of the application program project according to the file path of the first burning file;

the determination unit includes:

10. The apparatus of claim 9, wherein the application program project corresponds to a first memory space, wherein the first source code file corresponds to a second memory space, and wherein the first memory space and the second memory space are different.

11. The apparatus of claim 9, wherein the project files of the application project are stored in a directory of the application project to be compiled;

the source code merging unit includes:

a deleting subunit, configured to delete the first burning file and the first source code file in the first directory;

and the determining subunit is used for taking the first source code file under the directory to be compiled and the project file of the application program project as the target project file.

12. The apparatus of any of claims 7-11, further comprising:

and the second compiling module is used for compiling the project file of the bootloader project to obtain the first burning file when receiving a compiling instruction about the bootloader project, wherein the project file of the bootloader project comprises a plurality of source files.