CN115616973A - Method, system, device and medium for realizing breakpoint debugging function - Google Patents
Method, system, device and medium for realizing breakpoint debugging function Download PDFInfo
- Publication number
- CN115616973A CN115616973A CN202211321052.XA CN202211321052A CN115616973A CN 115616973 A CN115616973 A CN 115616973A CN 202211321052 A CN202211321052 A CN 202211321052A CN 115616973 A CN115616973 A CN 115616973A
- Authority
- CN
- China
- Prior art keywords
- breakpoint
- instruction
- current
- software program
- soft plc
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
Images
Classifications
-
- G—PHYSICS
- G05—CONTROLLING; REGULATING
- G05B—CONTROL OR REGULATING SYSTEMS IN GENERAL; FUNCTIONAL ELEMENTS OF SUCH SYSTEMS; MONITORING OR TESTING ARRANGEMENTS FOR SUCH SYSTEMS OR ELEMENTS
- G05B19/00—Programme-control systems
- G05B19/02—Programme-control systems electric
- G05B19/04—Programme control other than numerical control, i.e. in sequence controllers or logic controllers
- G05B19/05—Programmable logic controllers, e.g. simulating logic interconnections of signals according to ladder diagrams or function charts
- G05B19/054—Input/output
-
- G—PHYSICS
- G05—CONTROLLING; REGULATING
- G05B—CONTROL OR REGULATING SYSTEMS IN GENERAL; FUNCTIONAL ELEMENTS OF SUCH SYSTEMS; MONITORING OR TESTING ARRANGEMENTS FOR SUCH SYSTEMS OR ELEMENTS
- G05B2219/00—Program-control systems
- G05B2219/10—Plc systems
- G05B2219/13—Plc programming
- G05B2219/13094—Using a-d convertor as function
Landscapes
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Engineering & Computer Science (AREA)
- Automation & Control Theory (AREA)
- Debugging And Monitoring (AREA)
Abstract
The invention relates to the technical field of industrial automation control, and discloses a method, a system, equipment and a medium for realizing a breakpoint debugging function. The method for realizing the breakpoint debugging function is applied to a system for realizing the breakpoint debugging function, and the system for realizing the breakpoint debugging function comprises a user development environment tool and a soft PLC (programmable logic controller). According to the invention, breakpoint information in a software program is obtained through a user development environment tool, and the breakpoint information is sent to a soft PLC controller; replacing the real instruction of the current breakpoint with a breakpoint instruction according to the breakpoint information through the soft PLC; when the software program runs to the breakpoint instruction, triggering the illegal instruction to be abnormal, and completing breakpoint processing through an abnormal processing program of the soft PLC controller; restarting the running task of the software program through the user development environment tool, and restoring the breakpoint instruction to a real instruction; therefore, the breakpoint debugging function is realized by directly running the soft PLC on the PC through the code migration technology, and the breakpoint debugging accuracy is improved.
Description
Technical Field
The invention relates to the technical field of industrial automation control, in particular to a method, a system, equipment and a medium for realizing a breakpoint debugging function.
Background
PLC (programmable logic controller) is widely used in the field of industrial control. The logic control, analog quantity control, motion control and the like of various mechanical and electrical systems are completed by loading a (program) control instruction written by a user into a memory and scheduling and executing the control instruction by a CPU according to a task cycle configured by the user. In practical application, a PLC system usually detects the correctness and completeness of a program design by adopting breakpoint debugging; breakpoint debugging intervenes in the running process of the operation task of the controller through breakpoints in the control logic, wherein the execution mechanism of the controller on the control logic is involved.
Currently, breakpoint debugging includes software breakpoints and hardware breakpoints; hardware breakpoints typically require setting the values of registers in the processor to generate the breakpoint. The software breakpoint needs to modify a running code instruction, the instruction at the breakpoint position is modified into a special breakpoint instruction (int 3 soft interrupt instruction), when the program runs to the breakpoint instruction position, an interrupt signal or an abnormal event is generated, the corresponding breakpoint service program takes over the processing, and when the breakpoint is cancelled, the instruction at the breakpoint position can be restored to the original byte content.
However, current software breakpoints typically use a mechanism of system signal capture to implement breakpoint location exception callback handling, a common way to capture exceptions is to use structured exceptions and uncaptured exceptions. While Windows X64 cannot capture all exceptions using the two approaches described above.
Disclosure of Invention
The invention mainly aims to provide a method, a system, equipment and a medium for realizing a breakpoint debugging function, which aim to realize the breakpoint debugging function by directly running on a PC (personal computer) based on a soft PLC (programmable logic controller) through a code migration technology and improve the accuracy of breakpoint debugging.
In order to achieve the above object, the present invention provides a method for implementing a breakpoint debugging function, which is applied to a system for implementing a breakpoint debugging function, wherein the system for implementing a breakpoint debugging function includes a user development environment tool and a soft PLC controller, and the method for implementing a breakpoint debugging function includes the following steps:
acquiring breakpoint information in a software program through the user development environment tool, and sending the breakpoint information to the soft PLC;
replacing the real instruction of the current breakpoint by the breakpoint instruction according to the breakpoint information through the soft PLC;
when the software program runs to the breakpoint instruction, triggering an illegal instruction exception, and completing breakpoint processing through an exception handling program of the soft PLC controller;
and restarting the running task of the software program through the user development environment tool, and restoring the breakpoint instruction to the real instruction.
Preferably, the step of obtaining breakpoint information in a software program through the user development environment tool and sending the breakpoint information to the soft PLC controller includes:
setting a breakpoint in a software program through the user development environment tool, acquiring breakpoint information corresponding to the breakpoint, and sending the breakpoint information to the soft PLC through a TCP socket service interface; the breakpoint information comprises a memory area number of a breakpoint position, a memory offset address, a breakpoint insertion instruction size, a breakpoint entry callback function pointer, a breakpoint exit callback function pointer and a successor breakpoint memory offset address.
Preferably, the step of replacing the real instruction of the current breakpoint with the breakpoint instruction according to the breakpoint information by the soft PLC controller includes:
when the soft PLC receives the breakpoint information, storing a real instruction of a current breakpoint to a corresponding position of a heap area memory pool of the soft PLC through memory addressing and copying, wherein the breakpoint information comprises a memory offset address of the current breakpoint, a current instruction size, a breakpoint instruction byte code and a subsequent breakpoint position offset address;
and copying the byte codes of the breakpoint instructions to the memory offset address of the current breakpoint in a memory copy mode through the soft PLC according to the breakpoint information, and refreshing a processor cache of a system for realizing the breakpoint debugging function.
Preferably, the breakpoint instruction includes a memory offset address of a current breakpoint, when the software program runs to the breakpoint instruction, an illegal instruction exception is triggered, and the step of completing breakpoint processing through a process exception handler of the soft PLC controller includes:
when the software program runs to the breakpoint instruction, executing the breakpoint instruction through a processor of the soft PLC controller, triggering an illegal instruction exception, and distributing the exception to an exception handling program of the soft PLC controller by an operating system of the soft PLC controller;
storing a current environment context through the exception handler, acquiring current task information, and finding breakpoint information corresponding to the breakpoint instruction from the heap memory pool according to the fact that an IP register value of the current environment context is equal to a memory offset address of the current breakpoint; wherein the current environment context comprises an IP register value, an SP register value and a BP register value;
setting the current software program state as breakpoint pause, and informing a task scheduler of the soft PLC controller to stop scheduling of the current task, wherein the task of the current software program enters a debugging cycle; wherein the software program stops at the current breakpoint.
Preferably, the step of restarting the running task of the software program by the user development environment tool includes:
restarting the task or single-step operation of the software program through the user development environment tool, switching the current task state to an operation state, and exiting the debugging cycle by the task of the current software program;
and informing a task scheduler of the soft PLC controller to recover the scheduling of the current task and controlling the software program to leave breakpoint processing.
Preferably, the step of restoring the breakpoint instruction to the real instruction comprises:
according to the position offset address of the subsequent breakpoint in the heap area memory pool, copying the byte code of the breakpoint instruction to the position offset address of the subsequent breakpoint in a memory copy mode through the soft PLC, and refreshing the processor cache of the system for realizing the breakpoint debugging function so as to replace the real instruction of the subsequent breakpoint with the next breakpoint instruction;
and writing the memory offset address of the current breakpoint in a memory copy mode according to the memory offset address of the current breakpoint in the heap memory pool and the size of the current instruction so as to restore the breakpoint instruction of the current breakpoint to the real instruction.
Preferably, after the step of restarting the running task of the software program through the user development environment tool and restoring the breakpoint instruction to the real instruction, the method further includes:
entering next breakpoint debugging, returning to the step: and acquiring breakpoint information in a software program through the user development environment tool, and sending the breakpoint information to the soft PLC.
In addition, in order to achieve the above object, the present invention further provides a system for implementing a breakpoint debugging function, where the system for implementing a breakpoint debugging function includes:
the system comprises a user development environment tool, a soft PLC controller and a software program, wherein the user development environment tool is used for acquiring breakpoint information in a software program and sending the breakpoint information to the soft PLC controller;
the soft PLC is used for replacing the real instruction at the breakpoint with the breakpoint instruction according to the breakpoint information;
the system is also used for triggering an illegal instruction exception when the software program runs to the breakpoint instruction, and completing breakpoint processing through an exception handling program of the soft PLC controller;
and the user development environment tool is also used for restarting the running task of the software program and restoring the breakpoint instruction to the real instruction.
In addition, to achieve the above object, the present invention also provides a computer device comprising: the method comprises the steps of a memory, a processor and a program for realizing the breakpoint debugging function, wherein the program for realizing the breakpoint debugging function is stored on the memory and can run on the processor, and when the program for realizing the breakpoint debugging function is executed by the processor, the method for realizing the breakpoint debugging function realizes the steps of the method for realizing the breakpoint debugging function.
In addition, in order to achieve the above object, the present invention further provides a computer-readable storage medium, where an implementation program of the breakpoint debugging function is stored, and when the implementation program of the breakpoint debugging function is executed by a processor, the steps of the implementation method of the breakpoint debugging function are implemented as described above.
The invention provides a method, a system, equipment and a medium for realizing a breakpoint debugging function; the method for realizing the breakpoint debugging function is applied to a system for realizing the breakpoint debugging function, and the system for realizing the breakpoint debugging function comprises a user development environment tool and a soft PLC (programmable logic controller). The method comprises the steps that firstly, breakpoint information in a software program is obtained through a user development environment tool, and the breakpoint information is sent to a soft PLC; replacing the real instruction of the current breakpoint with a breakpoint instruction according to the breakpoint information through the soft PLC; when the software program runs to the breakpoint instruction, triggering the illegal instruction to be abnormal, and completing breakpoint processing through an abnormal processing program of the soft PLC controller; restarting the running task of the software program through a user development environment tool, and restoring the breakpoint instruction to a real instruction; therefore, the breakpoint debugging function is realized by directly running the soft PLC on the PC through the code migration technology, and the breakpoint debugging accuracy is improved.
Drawings
Fig. 1 is a schematic device structure diagram of a hardware operating environment according to an embodiment of the present invention;
FIG. 2 is a flowchart illustrating a first embodiment of a method for implementing a breakpoint debugging function according to the present invention;
FIG. 3 is a schematic diagram of the breakpoint debugging interaction process of the present invention, in which a user development environment (IDE) tool and a soft PLC controller are combined;
FIG. 4 is a schematic diagram of the breakpoint debugging processing steps of the method for implementing the breakpoint debugging function according to the present invention;
FIG. 5 is a flowchart illustrating a second embodiment of a method for implementing a breakpoint debugging function according to the present invention;
FIG. 6 is a flowchart illustrating a third embodiment of a method for implementing a breakpoint debugging function according to the present invention;
FIG. 7 is a flowchart illustrating a fourth embodiment of a method for implementing a breakpoint debugging function according to the present invention;
FIG. 8 is a flowchart illustrating a fifth embodiment of a method for implementing a breakpoint debugging function according to the present invention;
FIG. 9 is a flowchart illustrating a sixth embodiment of a method for implementing a breakpoint debugging function according to the present invention;
fig. 10 is a functional block diagram of a system for implementing a breakpoint debugging function according to a first embodiment of the present invention.
The implementation, functional features and advantages of the objects of the present invention will be further explained with reference to the accompanying drawings.
Detailed Description
It should be understood that the specific embodiments described herein are merely illustrative of the invention and do not limit the invention.
As shown in fig. 1, fig. 1 is a schematic device structure diagram of a hardware operating environment according to an embodiment of the present invention.
The device of the embodiment of the invention can be a mobile terminal or a server device.
As shown in fig. 1, the apparatus may include: a processor 1001, e.g. a CPU, a network interface 1004, a user interface 1003, a memory 1005, a communication bus 1002. The communication bus 1002 is used to implement connection communication among these components. The user interface 1003 may include a Display screen (Display), an input unit such as a Keyboard (Keyboard), and the optional user interface 1003 may also include a standard wired interface, a wireless interface. The network interface 1004 may optionally include a standard wired interface, a wireless interface (e.g., WI-FI interface). The memory 1005 may be a high-speed RAM memory or a non-volatile memory (e.g., a magnetic disk memory). The memory 1005 may alternatively be a storage device separate from the processor 1001.
Those skilled in the art will appreciate that the configuration of the apparatus shown in fig. 1 is not intended to be limiting of the apparatus and may include more or fewer components than those shown, or some components may be combined, or a different arrangement of components.
As shown in fig. 1, a memory 1005, which is a kind of computer storage medium, may include therein an operating system, a network communication module, a user interface module, and an implementation program of a breakpoint debugging function.
The operating system is a program for managing and controlling terminal equipment and software resources, and supports the operation of a network communication module, a user interface module, a realization program of a breakpoint debugging function and other programs or software; the network communication module is used for managing and controlling the network interface 1002; the user interface module is used to manage and control the user interface 1003.
In the apparatus shown in fig. 1, the apparatus calls an implementation program of the breakpoint debugging function stored in the memory 1005 by the processor 1001 and performs operations in the embodiments of the implementation method of the breakpoint debugging function described below.
Based on the hardware structure, the embodiment of the method for realizing the breakpoint debugging function is provided.
Referring to fig. 2, fig. 2 is a flowchart illustrating a first embodiment of a method for implementing a breakpoint debugging function according to the present invention, where the method for implementing a breakpoint debugging function includes:
step S10, acquiring breakpoint information in a software program through the user development environment tool, and sending the breakpoint information to the soft PLC;
step S20, replacing the real instruction of the current breakpoint with a breakpoint instruction according to the breakpoint information through the soft PLC;
step S30, when the software program runs to the breakpoint instruction, triggering an illegal instruction exception, and completing breakpoint processing through an exception handling program of the soft PLC controller;
and step S40, restarting the running task of the software program through the user development environment tool, and restoring the breakpoint instruction to the real instruction.
In the embodiment, breakpoint information in a software program is acquired through a user development environment tool, and the breakpoint information is sent to a soft PLC controller; replacing the real instruction of the current breakpoint with a breakpoint instruction according to the breakpoint information through the soft PLC; when the software program runs to the breakpoint instruction, triggering the illegal instruction to be abnormal, and finishing breakpoint processing through an abnormal processing program of the soft PLC controller; restarting the running task of the software program through a user development environment tool, and restoring the breakpoint instruction to a real instruction; therefore, the breakpoint debugging function is realized by directly running the soft PLC on the PC through the code migration technology, and the breakpoint debugging accuracy is improved.
The respective steps will be described in detail below:
and S10, acquiring breakpoint information in a software program through the user development environment tool, and sending the breakpoint information to the soft PLC.
In this embodiment, the method for implementing a breakpoint debugging function is applied to an implementation system of a breakpoint debugging function, where the implementation system of the breakpoint debugging function includes a user development environment tool and a soft PLC controller. Wherein, the user Development Environment (IDE) tool is connected with the soft PLC controller, and the soft PLC controller and the IDE tool can run in the same PC or different PCs. User development environment (IDE) tools are mainly used for user program editing, compiling, downloading, debugging and monitoring. The soft PLC controller transplants the controller core running in the real PLC equipment to a Windows X64 platform through a code transplantation technology; the soft PLC controller inserts the UD2 instruction into the breakpoint position, the processor is triggered to be interrupted after the software program runs to the UD2 instruction position, vectorization exception registration is used for exception of the breakpoint position, and software and hardware exception generated by the processor or the system can be captured normally.
Referring to fig. 3, fig. 3 is a schematic diagram illustrating a breakpoint debugging interaction process of combining a user development environment (IDE) tool and a soft PLC controller; the invention provides a method for capturing vectorization abnormity to realize breakpoint processing, wherein the abnormity is realized by searching breakpoint position and replacing normal instruction with UD2 instruction, thereby triggering the abnormity of CPU to generate illegal instruction. In addition, breakpoint setting, breakpoint deleting, single step and operation and other breakpoint debugging functions are completed by combining with a user development environment (IDE) tool. In addition, the soft PLC controller and a user development environment (IDE) tool run on the same PC at the same time, and can be conveniently used for scenes such as teaching demonstration and the like.
Referring to fig. 4, fig. 4 is a schematic diagram of a breakpoint debugging processing step; specifically, refer to the set breakpoint information (21) in fig. 4; acquiring breakpoint information in a software program through a user development environment (IDE) tool, wherein the breakpoint information comprises a memory area number of a breakpoint position, a memory offset address, a breakpoint insertion instruction size, a breakpoint entering callback function pointer, a breakpoint leaving callback function pointer and a subsequent breakpoint memory offset address; and sending the acquired breakpoint information to the soft PLC.
And step S20, replacing the real instruction of the current breakpoint with a breakpoint instruction according to the breakpoint information through the soft PLC.
In this embodiment, referring to fig. 4, fig. 4 is a schematic diagram of a breakpoint debugging processing step; with particular reference to breakpoint instruction replacement (23) in fig. 4; when the soft PLC controller receives the breakpoint information, a UD2 instruction is inserted into a breakpoint position corresponding to the breakpoint information, the processor is triggered to interrupt after a software program runs to the UD2 instruction position, vectorization exception registration is used for exception of the breakpoint position, and software and hardware exception generated by the processor or the system can be captured normally; wherein, the real instruction refers to the original instruction at the current breakpoint; the UD2 instruction is also a breakpoint instruction, and the breakpoint instruction is an interrupt signal or an abnormal event generated when the software program reaches a breakpoint instruction position.
And S30, when the software program runs to the breakpoint instruction, triggering an illegal instruction exception, and finishing breakpoint processing through an exception handling program of the soft PLC controller.
In this embodiment, referring to fig. 4, fig. 4 is a schematic diagram of a breakpoint debugging processing step; with particular reference to UD2 instruction exception capture and breakpoint processing (24) in fig. 4; when the software program runs to the position of the breakpoint instruction, a processor of the system for realizing the breakpoint debugging function executes the replaced breakpoint instruction to trigger the illegal instruction exception; the operating system distributes the exception to a soft PLC process exception handling program, and the exception breakpoint handling is completed through the exception handling program of the soft PLC; the breakpoint processing means setting a current software program to be a breakpoint pause, notifying a task scheduler to stop scheduling of a current task, and entering a debug LOOP (LOOP) into the current task, where the debug LOOP (LOOP) means that the software program skips in place, a current breakpoint instruction is circularly executed, and the software program stops at a current breakpoint position.
And S40, restarting the running task of the software program through the user development environment tool, and restoring the breakpoint instruction to the real instruction.
In this embodiment, referring to fig. 4, fig. 4 is a schematic diagram of a breakpoint debugging processing step; with particular reference to breakpoint instruction recovery (25) in fig. 4; restarting the running task of the software program through an Integrated Development Environment (IDE) tool, switching the current task state to the running state, and restoring the breakpoint instruction of the current breakpoint position to the original instruction of the current breakpoint position, namely restoring the breakpoint instruction of the current breakpoint position to the real instruction; thereby realizing the breakpoint debugging function.
Further, in an embodiment, after step S40, the method for implementing a breakpoint debugging function further includes:
step S50, entering next breakpoint debugging, and returning to the execution step: and acquiring breakpoint information in a software program through the user development environment tool, and sending the breakpoint information to the soft PLC.
In this embodiment, after the current breakpoint instruction is restored to the real instruction, according to the breakpoint information, the breakpoint information includes a subsequent breakpoint memory offset address, that is, a position of a next breakpoint; entering next breakpoint debugging, and executing the steps of: and acquiring breakpoint information in a software program through the user development environment tool, and sending the breakpoint information to the soft PLC. According to the memory offset address of the subsequent breakpoint, acquiring next breakpoint information in the software program by using a user development environment tool, and sending the next breakpoint information to the soft PLC; after the soft PLC receives the next breakpoint information, the soft PLC inserts the instruction position of the next breakpoint into the UD2 instruction; after the software program resumes operation, the current instruction is normally executed, and breakpoint exception processing is triggered due to the next instruction, so that the software program stops at the next breakpoint position; completing debugging of breakpoints in the software program by repeating the operation; thereby improving the efficiency of breakpoint debugging.
In the embodiment, breakpoint information in a software program is acquired through a user development environment tool, and the breakpoint information is sent to a soft PLC controller; replacing the real instruction of the current breakpoint with a breakpoint instruction according to the breakpoint information through the soft PLC; when the software program runs to the breakpoint instruction, triggering the illegal instruction to be abnormal, and finishing breakpoint processing through an abnormal processing program of the soft PLC controller; restarting the running task of the software program through the user development environment tool, and restoring the breakpoint instruction to a real instruction; therefore, the breakpoint debugging function is realized by directly running the soft PLC on the PC through the code migration technology, and the breakpoint debugging accuracy is improved.
Further, based on the first embodiment of the method for implementing the breakpoint debugging function of the present invention, a second embodiment of the method for implementing the breakpoint debugging function of the present invention is provided.
The difference between the second embodiment of the method for implementing a breakpoint debugging function and the first embodiment of the method for implementing a breakpoint debugging function is that, in this embodiment, step S10 is to obtain breakpoint information in a software program through the user development environment tool, and send the breakpoint information to the refinement of the soft PLC controller, referring to fig. 5, this step specifically includes:
step S11, setting a breakpoint in a software program through the user development environment tool, acquiring breakpoint information corresponding to the breakpoint, and sending the breakpoint information to the soft PLC through a TCP socket service interface; the breakpoint information comprises a memory area number of a breakpoint position, a memory offset address, a breakpoint insertion instruction size, a breakpoint entry callback function pointer, a breakpoint exit callback function pointer and a successor breakpoint memory offset address.
In the embodiment, a breakpoint is set in a software program through a user development environment tool, breakpoint information corresponding to the breakpoint is obtained, and the breakpoint information is sent to a soft PLC controller through a TCP socket service interface; the breakpoint information comprises a memory area number of a breakpoint position, a memory offset address, a breakpoint insertion instruction size, a breakpoint entry callback function pointer, a breakpoint exit callback function pointer and a subsequent breakpoint memory offset address; therefore, the breakpoint debugging interaction process combining the user development environment tool and the soft PLC controller is realized through the soft PLC controller.
The respective steps will be described in detail below:
step S11, setting a breakpoint in a software program through the user development environment tool, acquiring breakpoint information corresponding to the breakpoint, and sending the breakpoint information to the soft PLC through a TCP socket service interface; the breakpoint information comprises a memory area number of a breakpoint position, a memory offset address, a breakpoint insertion instruction size, a breakpoint entry callback function pointer, a breakpoint exit callback function pointer and a successor breakpoint memory offset address.
In this embodiment, referring to fig. 4, fig. 4 is a schematic diagram of a breakpoint debugging processing step; specifically, refer to the set breakpoint information (21) in fig. 4; after debugging is started, setting breakpoints in a software program through an Integrated Development Environment (IDE) tool, wherein the positions and the number of the breakpoints can be set according to actual conditions, and each breakpoint has a unique breakpoint address; acquiring breakpoint information corresponding to the breakpoints; the breakpoint information comprises a memory area number of a breakpoint position, a memory offset address, a breakpoint insertion instruction size, a breakpoint entry callback function pointer, a breakpoint exit callback function pointer and a successor breakpoint memory offset address.
And sending the breakpoint information to the soft PLC through the TCP socket service interface so that the soft PLC carries out breakpoint instruction replacement on the current breakpoint according to the breakpoint information after receiving the breakpoint information.
In the embodiment, a breakpoint is set in a software program through a user development environment tool, breakpoint information corresponding to the breakpoint is obtained, and the breakpoint information is sent to a soft PLC controller through a TCP socket service interface; the breakpoint information comprises a memory area number of a breakpoint position, a memory offset address, a breakpoint insertion instruction size, a breakpoint entering callback function pointer, a breakpoint leaving callback function pointer and a subsequent breakpoint memory offset address; therefore, the breakpoint debugging interaction process combining the user development environment tool and the soft PLC controller is realized through the soft PLC controller.
Further, based on the first and second embodiments of the method for implementing a breakpoint debugging function of the present invention, a third embodiment of the method for implementing a breakpoint debugging function of the present invention is provided.
The difference between the third embodiment of the method for implementing a breakpoint debugging function and the first and second embodiments of the method for implementing a breakpoint debugging function is that in this embodiment, step S20 is performed, and the soft PLC controller replaces the real instruction of the current breakpoint with a breakpoint instruction according to the breakpoint information, with reference to fig. 6, the step specifically includes:
step S21, when the soft PLC controller receives the breakpoint information, storing a real instruction of the current breakpoint to a corresponding position of a heap area memory pool of the soft PLC controller through memory addressing and copying, wherein the breakpoint information comprises a memory offset address of the current breakpoint, a current instruction size, a breakpoint instruction byte code and a subsequent breakpoint position offset address;
and S22, according to the breakpoint information, copying the byte codes of the breakpoint instructions to the memory offset address of the current breakpoint in a memory copy mode through the soft PLC, and refreshing the processor cache of the system for realizing the breakpoint debugging function.
In this embodiment, when the soft PLC receives breakpoint information, the real instruction of the current breakpoint is saved to a corresponding location of the heap memory pool of the soft PLC through memory addressing and copying, where the breakpoint information includes a memory offset address of the current breakpoint, a current instruction size, a breakpoint instruction byte code, and a subsequent breakpoint location offset address; according to the breakpoint information, copying byte codes of breakpoint instructions to a memory offset address of a current breakpoint in a memory copy mode through a soft PLC (programmable logic controller), and refreshing a processor cache of a system for realizing a breakpoint debugging function; therefore, the real position of the current breakpoint is replaced by the breakpoint instruction through the soft PLC.
The respective steps will be described in detail below:
and step S21, when the soft PLC controller receives the breakpoint information, storing a real instruction of the current breakpoint to a corresponding position of a heap memory pool of the soft PLC controller through memory addressing and copying, wherein the breakpoint information comprises a memory offset address of the current breakpoint, a current instruction size, a breakpoint instruction byte code and a subsequent breakpoint position offset address.
In this embodiment, after the soft PLC controller receives breakpoint information, the breakpoint information specifically includes a memory offset address of a current breakpoint, a current instruction size, a breakpoint instruction byte code, and a subsequent breakpoint position offset address; the breakpoint information is uniformly managed in a heap area memory pool of the soft PLC, and the method specifically comprises the following steps: and storing each breakpoint information in a corresponding memory structure in a heap area memory pool, and storing the real instruction of the current breakpoint to the corresponding position of the memory structure in a memory addressing and copying mode.
And step S22, copying the byte codes of the breakpoint instructions to the memory offset address of the current breakpoint in a memory copy mode through the soft PLC according to the breakpoint information, and refreshing the processor cache of the system for realizing the breakpoint debugging function.
In this embodiment, according to the breakpoint information, the soft PLC controller copies the byte code of the UD2 instruction (that is, the breakpoint instruction) to the memory offset address corresponding to the current breakpoint in a memory copy manner; then, refreshing the processor cache of the system for realizing the breakpoint debugging function; after the steps are completed, the real instruction of the current breakpoint is replaced by the breakpoint instruction; therefore, when the software program runs to the position of the breakpoint instruction, the processor of the system for realizing the breakpoint debugging function can execute the replaced breakpoint instruction and trigger the illegal instruction exception.
In this embodiment, when the soft PLC controller receives breakpoint information, the real instruction of the current breakpoint is stored to a corresponding position of the heap area memory pool of the soft PLC controller by memory addressing and copying, where the breakpoint information includes a memory offset address of the current breakpoint, a current instruction size, a breakpoint instruction byte code, and a subsequent breakpoint position offset address; according to the breakpoint information, copying byte codes of breakpoint instructions to a memory offset address of a current breakpoint in a memory copy mode through a soft PLC (programmable logic controller), and refreshing a processor cache of a system for realizing a breakpoint debugging function; therefore, the real position of the current breakpoint is replaced by the breakpoint instruction through the soft PLC.
Further, based on the first, second, and third embodiments of the method for implementing a breakpoint debugging function of the present invention, a fourth embodiment of the method for implementing a breakpoint debugging function of the present invention is provided.
The fourth embodiment of the method for implementing a breakpoint debugging function is different from the first, second, and third embodiments of the method for implementing a breakpoint debugging function in that this embodiment is that, for step S30, when the software program runs to the breakpoint instruction, an illegal instruction exception is triggered, and the refinement of breakpoint processing is completed through a process exception handler of the soft PLC controller, referring to fig. 7, this step specifically includes:
step S31, when the software program runs to the breakpoint instruction, executing the breakpoint instruction through a processor of the soft PLC controller, triggering an illegal instruction exception, and distributing the exception to an exception handling program of the soft PLC controller by an operating system of the soft PLC controller;
step S32, saving the current environment context through the exception handling program, acquiring current task information, and finding out breakpoint information corresponding to the breakpoint instruction from the heap area memory pool according to the condition that the IP register value of the current environment context is equal to the memory offset address of the current breakpoint; wherein the current environment context comprises an IP register value, an SP register value and a BP register value;
step S33, setting the current software program state as breakpoint pause, and informing a task scheduler of the soft PLC controller to stop scheduling of the current task, wherein the task of the current software program enters a debugging cycle; wherein the software program stops at the current breakpoint.
In this embodiment, when the software program runs to the breakpoint instruction, the processor of the soft PLC controller executes the breakpoint instruction to trigger an illegal instruction exception, and completes breakpoint processing through the process exception handler of the soft PLC controller; therefore, the breakpoint debugging function is realized through the soft PLC.
The respective steps will be described in detail below:
and S31, when the software program runs to the breakpoint instruction, executing the breakpoint instruction through a processor of the soft PLC controller to trigger illegal instruction exception, and distributing the exception to an exception handling program of the soft PLC controller by an operating system of the soft PLC controller.
In this embodiment, when the software program normally runs to the current breakpoint position of the breakpoint position, the processor of the soft PLC controller executes the replaced UD2 instruction (that is, the breakpoint instruction), and triggers an illegal instruction exception; and the operating system of the soft PLC controller distributes the exception to an exception handling program of the soft PLC controller, and then breakpoint handling is completed in the exception handling program.
Step S32, saving the current environment context through the exception handling program, acquiring current task information, and finding out breakpoint information corresponding to the breakpoint instruction from the heap area memory pool according to the condition that the IP register value of the current environment context is equal to the memory offset address of the current breakpoint; wherein the current context includes an IP register value, an SP register value, and a BP register value.
In this embodiment, a current environment context is saved by an exception handler of the soft PLC controller, where the current environment context includes an IP register value, an SP register value, and a BP register value; acquiring current task information; under the condition that the IP register value of the current environment context is equal to the memory offset address of the current breakpoint, breakpoint information corresponding to the breakpoint instruction can be found out from the heap area memory pool of the soft PLC controller.
Step S33, setting the current software program state as breakpoint pause, and informing a task scheduler of the soft PLC controller to stop scheduling of the current task, wherein the task of the current software program enters a debugging cycle; wherein the software program stops at the current breakpoint.
In the embodiment, the current software program state is set as breakpoint pause, and a task scheduler of the soft PLC controller is informed to stop the scheduling of the current task, and simultaneously, the task of the current software program enters a debugging cycle; wherein the software program stops at the current breakpoint after the task of the current software program enters the debug loop.
In this embodiment, when the software program runs to the breakpoint instruction, the processor of the soft PLC controller executes the breakpoint instruction to trigger an illegal instruction exception, and completes breakpoint processing through the process exception handler of the soft PLC controller; therefore, the breakpoint debugging function is realized through the soft PLC.
Further, based on the first, second, third, and fourth embodiments of the method for implementing a breakpoint debugging function of the present invention, a fifth embodiment of the method for implementing a breakpoint debugging function of the present invention is provided.
The difference between the fifth embodiment of the method for implementing a breakpoint debugging function and the first, second, third, and fourth embodiments of the method for implementing a breakpoint debugging function is that in this embodiment, step S40 is detailed, where the running task of the software program is restarted by using the user development environment tool, and with reference to fig. 8, this step specifically includes:
step A10, restarting the task or single step operation of the software program through the user development environment tool, switching the current task state to an operation state, and quitting the task of the current software program from a debugging cycle;
and step A20, informing a task scheduler of the soft PLC to restore the scheduling of the current task, and controlling the software program to leave the breakpoint processing.
In the embodiment, the task or single-step operation of the software program is started again through the user development environment tool, the current task state is switched to the operation state, and the task of the current software program exits the debugging cycle; informing a task scheduler of the soft PLC to restore the scheduling of the current task, and controlling the software program to leave the breakpoint processing; therefore, after the soft PLC controller finishes breakpoint processing, the running task of the software program is restarted through the user development environment tool.
The respective steps will be described in detail below:
step A10, the task or single step operation of the software program is started again through the user development environment tool, the current task state is switched to the operation state, and the task of the current software program exits the debugging cycle.
In this embodiment, after the exception handler of the soft PLC controller completes the breakpoint processing, the task or single-step running of the software program is restarted by a user development environment (IDE) tool to switch the current task state of the software program to a running state; at the same time, the task of the current software program exits the debug LOOP (LOOP).
And step A20, informing a task scheduler of the soft PLC to restore the scheduling of the current task, and controlling the software program to leave the breakpoint processing.
In this embodiment, after the task of the current software program exits a debug LOOP (LOOP), the task scheduler of the soft PLC controller is notified to resume the scheduling of the current task, and the soft PLC controller controls the software program to leave the breakpoint processing; therefore, after the soft PLC completes breakpoint processing, the running task of the software program is restarted through the user development environment tool, and the software program is continuously executed through the soft PLC.
In this embodiment, the task or single-step operation of the software program is restarted by the user development environment tool, the current task state is switched to the operation state, and the task of the current software program exits the debugging cycle; informing a task scheduler of the soft PLC to restore the scheduling of the current task, and controlling the software program to leave the breakpoint processing; therefore, after the soft PLC finishes breakpoint processing, the running task of the software program is restarted through the user development environment tool.
Further, based on the first, second, third, fourth, and fifth embodiments of the method for implementing a breakpoint debugging function of the present invention, a sixth embodiment of the method for implementing a breakpoint debugging function of the present invention is provided.
The sixth embodiment of the method for implementing a breakpoint debugging function is different from the first, second, third, fourth, and fifth embodiments of the method for implementing a breakpoint debugging function in that the present embodiment refines step S40 of restoring the breakpoint instruction to the real instruction, and with reference to fig. 9, the step specifically includes:
b10, according to the position offset address of the subsequent breakpoint in the heap area memory pool, copying the byte codes of the breakpoint instruction to the position offset address of the subsequent breakpoint in a memory copy mode through the soft PLC, and refreshing a processor cache of a system for realizing the breakpoint debugging function so as to replace the real instruction of the subsequent breakpoint with the next breakpoint instruction;
and step B20, writing the memory offset address of the current breakpoint in a memory copying mode according to the memory offset address of the current breakpoint in the heap memory pool and the size of the current instruction, so as to restore the breakpoint instruction of the current breakpoint to the real instruction.
According to the method, according to the position offset address of the subsequent breakpoint in the heap memory pool, the byte codes of the breakpoint instructions are copied to the position offset address of the subsequent breakpoint in a memory copying mode through the soft PLC, and the processor cache of the system for realizing the breakpoint debugging function is refreshed, so that the real instruction of the subsequent breakpoint is replaced by the next breakpoint instruction; writing the memory offset address of the current breakpoint in a memory copy mode according to the memory offset address and the current instruction size of the current breakpoint in the heap area memory pool so as to restore the breakpoint instruction of the current breakpoint to a real instruction; therefore, after breakpoint processing is completed, the breakpoint instruction at the current breakpoint is restored to a real instruction through a user development environment tool.
The respective steps will be described in detail below:
and step B10, according to the position offset address of the subsequent breakpoint in the heap area memory pool, copying the byte codes of the breakpoint instruction to the position offset address of the subsequent breakpoint in a memory copy mode through the soft PLC, and refreshing a processor cache of a system for realizing the breakpoint debugging function so as to replace the real instruction of the subsequent breakpoint with the next breakpoint instruction.
In the embodiment, according to the subsequent breakpoint position offset address in the breakpoint information stored in the heap area memory pool, the byte code of the UD2 instruction (namely, the breakpoint instruction) is copied to the subsequent breakpoint position offset address in a memory copy manner through the soft PLC controller, so as to replace the real instruction of the subsequent breakpoint with the next breakpoint instruction; after the position instruction of the subsequent breakpoint is replaced, refreshing the processor cache of the system for realizing the breakpoint debugging function; after the steps are completed, the real instruction of the subsequent breakpoint is replaced by the breakpoint instruction; therefore, when the software program runs to the position of the breakpoint instruction of the subsequent breakpoint, the processor of the system for realizing the breakpoint debugging function can execute the breakpoint instruction after replacement, and illegal instruction exception is triggered.
And step B20, writing the memory offset address of the current breakpoint in a memory copy mode according to the memory offset address and the current instruction size of the current breakpoint in the heap area memory pool, so as to restore the breakpoint instruction of the current breakpoint to the real instruction.
In this embodiment, according to the memory offset address and the current instruction size of the current breakpoint in the heap area memory pool of the soft PLC controller, the memory offset address and the current instruction size of the current breakpoint are written into the memory offset address of the current breakpoint in a memory copy manner, so as to restore the breakpoint instruction of the current breakpoint to the real instruction; after the breakpoint instruction of the current breakpoint is restored to the real instruction, deleting the breakpoint; therefore, after breakpoint processing is completed, the breakpoint instruction at the current breakpoint is restored to the real instruction through the user development environment tool.
In this embodiment, according to the offset address of the position of the subsequent breakpoint in the heap area memory pool, the byte code of the breakpoint instruction is copied to the offset address of the position of the subsequent breakpoint in a memory copy manner through the soft PLC controller, and the processor cache of the system for realizing the breakpoint debugging function is refreshed, so as to replace the real instruction of the subsequent breakpoint with the next breakpoint instruction; writing the memory offset address of the current breakpoint in a memory copy mode according to the memory offset address and the current instruction size of the current breakpoint in the heap area memory pool so as to restore the breakpoint instruction of the current breakpoint to a real instruction; therefore, after breakpoint processing is completed, the breakpoint instruction at the current breakpoint is restored to the real instruction through the user development environment tool.
The invention also provides a device for realizing the breakpoint debugging function. Referring to fig. 10, the apparatus for implementing the breakpoint debugging function of the present invention includes:
the user development environment tool 10 is used for acquiring breakpoint information in a software program and sending the breakpoint information to the soft PLC;
the soft PLC controller 20 is used for replacing the real instruction at the breakpoint with the breakpoint instruction according to the breakpoint information;
the software program is also used for triggering illegal instruction exception when the software program runs to the breakpoint instruction, and completing breakpoint processing through an exception handling program of the soft PLC controller;
the user development environment tool 10 is further configured to restart the running task of the software program, and restore the breakpoint instruction to the real instruction.
In addition, the present invention also provides a computer readable storage medium, on which an implementation program of the breakpoint debugging function is stored, and the implementation program of the breakpoint debugging function implements the steps of the implementation method of the breakpoint debugging function as described above when being executed by a processor.
The method for implementing the breakpoint debugging function when the implementation program of the breakpoint debugging function running on the processor is executed may refer to each embodiment of the implementation method of the breakpoint debugging function of the present invention, and details are not described here.
It should be noted that, in this document, the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or system that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or system. Without further limitation, an element defined by the phrases "comprising one of 8230; \8230;" 8230; "does not exclude the presence of additional like elements in a process, method, article, or system that comprises the element.
The above-mentioned serial numbers of the embodiments of the present invention are only for description, and do not represent the advantages and disadvantages of the embodiments.
Through the above description of the embodiments, those skilled in the art will clearly understand that the method of the above embodiments can be implemented by software plus a necessary general hardware platform, and certainly can also be implemented by hardware, but in many cases, the former is a better implementation manner. Based on such understanding, the technical solution of the present invention or the portions contributing to the prior art may be embodied in the form of a software product, which is stored in a storage medium (such as ROM/RAM, magnetic disk, optical disk) as described above and includes several instructions for enabling a terminal device (which may be a mobile phone, a computer, a server, an air conditioner, or a network device) to execute the method according to the embodiments of the present invention.
The above description is only a preferred embodiment of the present invention, and is not intended to limit the scope of the present invention, and all equivalent structures or equivalent processes performed by the present specification and the attached drawings, or directly or indirectly applied to other related technical fields, are included in the scope of the present invention.
Claims (10)
1. A method for realizing a breakpoint debugging function is characterized in that the method for realizing the breakpoint debugging function is applied to a system for realizing the breakpoint debugging function, the system for realizing the breakpoint debugging function comprises a user development environment tool and a soft PLC (programmable logic controller), and the method for realizing the breakpoint debugging function comprises the following steps:
acquiring breakpoint information in a software program through the user development environment tool, and sending the breakpoint information to the soft PLC;
replacing the real instruction of the current breakpoint by the breakpoint instruction according to the breakpoint information through the soft PLC;
when the software program runs to the breakpoint instruction, triggering an illegal instruction exception, and completing breakpoint processing through an exception handling program of the soft PLC controller;
and restarting the running task of the software program through the user development environment tool, and restoring the breakpoint instruction to the real instruction.
2. The method for implementing the breakpoint debugging function according to claim 1, wherein the step of obtaining breakpoint information in a software program through a user development environment tool and sending the breakpoint information to the soft PLC controller includes:
setting a breakpoint in a software program through the user development environment tool, acquiring breakpoint information corresponding to the breakpoint, and sending the breakpoint information to the soft PLC through a TCP socket service interface; the breakpoint information comprises a memory area number of a breakpoint position, a memory offset address, a breakpoint insertion instruction size, a breakpoint entering callback function pointer, a breakpoint leaving callback function pointer and a successor breakpoint memory offset address.
3. The method for implementing a breakpoint debugging function according to claim 1, wherein the step of replacing the real instruction of the current breakpoint with the breakpoint instruction according to the breakpoint information by the soft PLC controller comprises:
when the soft PLC controller receives the breakpoint information, storing a real instruction of the current breakpoint to a corresponding position of a heap area memory pool of the soft PLC controller through memory addressing and copying, wherein the breakpoint information comprises a memory offset address of the current breakpoint, a current instruction size, a breakpoint instruction byte code and a subsequent breakpoint position offset address;
and copying the byte codes of the breakpoint instructions to the memory offset address of the current breakpoint in a memory copy mode through the soft PLC according to the breakpoint information, and refreshing a processor cache of a system for realizing the breakpoint debugging function.
4. The method for implementing a breakpoint debugging function according to claim 1, wherein the breakpoint instruction includes a memory offset address of a current breakpoint, and when the software program runs to the breakpoint instruction, an illegal instruction exception is triggered, and the step of completing breakpoint processing by a process exception handler of the soft PLC controller includes:
when the software program runs to the breakpoint instruction, executing the breakpoint instruction through a processor of the soft PLC controller, triggering an illegal instruction exception, and distributing the exception to an exception handling program of the soft PLC controller by an operating system of the soft PLC controller;
storing a current environment context through the exception handler, acquiring current task information, and finding breakpoint information corresponding to the breakpoint instruction from the heap memory pool according to the fact that an IP register value of the current environment context is equal to a memory offset address of the current breakpoint; wherein the current environment context comprises an IP register value, an SP register value and a BP register value;
setting the current software program state as breakpoint pause, and informing a task scheduler of the soft PLC controller to stop scheduling of the current task, wherein the task of the current software program enters a debugging cycle; wherein the software program stops at the current breakpoint.
5. The method for implementing the breakpoint debugging function according to claim 4, wherein the step of restarting the execution task of the software program through the user development environment tool comprises:
restarting the task or single-step operation of the software program through the user development environment tool, switching the current task state to an operation state, and exiting the debugging cycle by the task of the current software program;
and informing a task scheduler of the soft PLC controller to recover the scheduling of the current task and controlling the software program to leave the breakpoint processing.
6. A method for implementing a breakpoint debugging function according to claim 3, wherein the step of restoring the breakpoint instruction to the real instruction comprises:
according to the position offset address of the subsequent breakpoint in the heap area memory pool, copying the byte code of the breakpoint instruction to the position offset address of the subsequent breakpoint in a memory copy mode through the soft PLC, and refreshing the processor cache of the system for realizing the breakpoint debugging function so as to replace the real instruction of the subsequent breakpoint with the next breakpoint instruction;
and writing the memory offset address of the current breakpoint in a memory copy mode according to the memory offset address of the current breakpoint in the heap memory pool and the size of the current instruction so as to restore the breakpoint instruction of the current breakpoint to the real instruction.
7. The method for implementing a breakpoint debugging function according to claim 1, wherein after the step of restarting the execution task of the software program by using a user development environment tool and restoring the breakpoint instruction to the real instruction, the method further comprises:
entering next breakpoint debugging, and returning to the execution step: and acquiring breakpoint information in a software program through the user development environment tool, and sending the breakpoint information to the soft PLC.
8. An implementation system of a breakpoint debugging function, the implementation system of the breakpoint debugging function comprising:
the system comprises a user development environment tool, a soft PLC controller and a software program, wherein the user development environment tool is used for acquiring breakpoint information in a software program and sending the breakpoint information to the soft PLC controller;
the soft PLC is used for replacing the real instruction at the breakpoint with the breakpoint instruction according to the breakpoint information;
the software program is also used for triggering illegal instruction exception when the software program runs to the breakpoint instruction, and completing breakpoint processing through an exception handling program of the soft PLC controller;
and the user development environment tool is also used for restarting the running task of the software program and restoring the breakpoint instruction to the real instruction.
9. A computer device, characterized in that the computer device comprises a processor, a memory and a program for implementing a breakpoint debugging function stored in the memory, and when the program for implementing a breakpoint debugging function is executed by the processor, the steps of the method for implementing a breakpoint debugging function according to any one of claims 1 to 7 are implemented.
10. A computer storage medium, wherein an implementation program of a breakpoint debugging function is stored on the computer storage medium, and when the implementation program of the breakpoint debugging function is executed by a processor, the steps of the implementation method of the breakpoint debugging function according to any one of claims 1 to 7 are implemented.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202211321052.XA CN115616973A (en) | 2022-10-26 | 2022-10-26 | Method, system, device and medium for realizing breakpoint debugging function |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202211321052.XA CN115616973A (en) | 2022-10-26 | 2022-10-26 | Method, system, device and medium for realizing breakpoint debugging function |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN115616973A true CN115616973A (en) | 2023-01-17 |
Family
ID=84864192
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202211321052.XA Pending CN115616973A (en) | 2022-10-26 | 2022-10-26 | Method, system, device and medium for realizing breakpoint debugging function |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN115616973A (en) |
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN116089316A (en) * | 2023-04-07 | 2023-05-09 | 武汉凌久微电子有限公司 | Kernel driving data debugging method based on dynamic breakpoint |
| CN117170987A (en) * | 2023-11-03 | 2023-12-05 | 睿思芯科(深圳)技术有限公司 | Monitoring method, system and related equipment of embedded real-time operating system |
-
2022
- 2022-10-26 CN CN202211321052.XA patent/CN115616973A/en active Pending
Cited By (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN116089316A (en) * | 2023-04-07 | 2023-05-09 | 武汉凌久微电子有限公司 | Kernel driving data debugging method based on dynamic breakpoint |
| CN116089316B (en) * | 2023-04-07 | 2023-06-09 | 武汉凌久微电子有限公司 | Kernel driving data debugging method based on dynamic breakpoint |
| CN117170987A (en) * | 2023-11-03 | 2023-12-05 | 睿思芯科(深圳)技术有限公司 | Monitoring method, system and related equipment of embedded real-time operating system |
| CN117170987B (en) * | 2023-11-03 | 2024-03-08 | 睿思芯科(深圳)技术有限公司 | Monitoring method, system and related equipment of embedded real-time operating system |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN115616973A (en) | Method, system, device and medium for realizing breakpoint debugging function | |
| JP4388518B2 (en) | Thread debugging device, thread debugging method and program | |
| US8745596B2 (en) | Program debugging with dynamically inserted instrumentation | |
| US6931631B2 (en) | Low impact breakpoint for multi-user debugging | |
| CN108319555B (en) | Real-time debugging method based on embedded real-time system | |
| CN109086193B (en) | Monitoring method, device and system | |
| CN113111001A (en) | Remote software debugging method for embedded terminal | |
| US11704139B2 (en) | Service processing method and apparatus, electronic device, and storage medium | |
| CN113742237A (en) | Program debugging method, device, equipment and storage medium | |
| JP2000020349A (en) | Device and method for supporting program development and medium recording program for program development support | |
| CN106997313B (en) | Signal processing method and system of application program and terminal equipment | |
| CN110007935B (en) | Processing method, device and equipment for program upgrading | |
| CN108241543B (en) | Method, service server and system for executing service operation breakpoint | |
| CN107526622B (en) | Rapid exception handling method and device for Linux | |
| CN113342376B (en) | Method and device for upgrading operating system of Internet of things equipment | |
| JP6318214B2 (en) | PLC debugging method using a general-purpose microprocessor | |
| CN100403264C (en) | TTCN test example executing method | |
| JP2013041546A (en) | Debug support program, debug support method and debug support system | |
| CN111563000A (en) | File generation method, intelligent terminal and storage medium | |
| JP4295912B2 (en) | Debug system | |
| JP2012256279A (en) | Information processing device, method, and program | |
| JP2007249828A (en) | Programmable controller system, debut method of programmable controller, programming supporting program, and debut control program of programmable controller | |
| CN116737528A (en) | Debugging method of microcontroller software, debugging server and electronic equipment | |
| CN113051151A (en) | Task tracking method, device, equipment and computer readable storage medium | |
| JP2001166966A (en) | Method for managing execution environment of program to be tested in debugger |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination |