Debugging data modification method and device, electronic equipment and storage medium

Abstract

The invention relates to a debugging data modification method and device, electronic equipment and a storage medium, and the method comprises the steps: when it is monitored that a debugging session is in a starting state, loading and rendering a visual interaction interface, the debugging session is used for debugging the debugging session in a lightweight integrated development environment, and the debugging session is used for debugging the debugging session; establishing communication connection for debugging data interaction between the code debugging plug-in and the debugger; after loading and rendering on the interactive interface are completed, a data initialization request is issued to the code debugging plug-in, initialization data obtained by the code debugging plug-in from the debugger based on the data initialization request are received and displayed on the interactive interface, and the initialization data are in an editable state; when a debugging instruction aiming at the initialized data is detected, issuing the debugging instruction to a debugger through the code debugging plug-in, so that the debugger executes data debugging operation; and receiving and displaying a data debugging result fed back by the code debugging plug-in on the interactive interface. According to the invention, the debugging data modification process is simplified.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of computer, and particularly relates to a debugging data modification method and device, electronic equipment and storage medium. BACKGROUND

[0002] In the field of embedded program development, the read-write operation of various types of debugging data in the debugging link, such as the read-write operation of debugging data such as register data, memory unit data, peripheral configuration parameters and core variable state, is a key means to verify the running state of the program, locate the logic defects of the code and flexibly adjust the execution flow of the program. At present, the traditional mainstream embedded integrated development environment represented by Eclipse+CDT and Visual Studio has realized the visual read-write function of full debugging core data in the debugging process, and the developer can conveniently view and modify various types of debugging data in the native interface without the need to additionally master complex debugger instructions, which greatly reduces the technical threshold of debugging and effectively improves the efficiency and flexibility of embedded program debugging.

[0003] With the popularization of lightweight integrated development tools, VS Code (Visual Studio Code, Visual Studio Code) has gradually become an important tool for embedded program development due to its rich plug-in ecosystem and strong cross-platform compatibility. However, the debugging function of VS Code needs to rely on the Debug Adapter Protocol (DAP, Debug Adapter Protocol) to realize the communication interaction between the debugger and the front-end interface, and the protocol has functional limitations in the design level, only the visual viewing permission of various types of debugging core data is opened, and the write operation on the debugging data in the native interface is not supported.

[0004] If the developer needs to modify the debugging data, he can only manually input the debugger instructions through the debugging console to complete the operation, which not only has a complicated operation process and low efficiency, but also requires the developer to be proficient in the debugger command syntax, and the technical threshold of debugging work is high. SUMMARY

[0005] The present application provides a debugging data modification method and device, electronic equipment and storage medium to solve the problem of complicated debugging data modification process.

[0006] In a first aspect, the present application provides a debugging data modification method, which comprises: loading and rendering a visual interactive interface when a debugging session is in a starting state, wherein the debugging session is used to build a communication connection for debugging data interaction between a code debugging plug-in and a debugger in a lightweight integrated development environment; after the interactive interface is loaded and rendered, a data initialization request is issued to the code debugging plug-in, initialization data obtained by the code debugging plug-in from the debugger based on the data initialization request is received and displayed on the interactive interface, and the initialization data is in an editable state; when a debugging instruction for the initialization data is detected, the debugging instruction is issued to the debugger by the code debugging plug-in, so that the debugger performs a data debugging operation; the data debugging result fed back by the code debugging plug-in is received and displayed on the interactive interface.

[0007] Optionally, when it is detected that the debugging session is in the started state, loading and rendering the visual interactive interface include: the debugging listener continuously monitors the state of the debugging session; if the debugging listener detects that the debugging session is in the started state, the debugging session is added to a debugging queue, and a rendering view signal is sent to an interface manager, wherein the debugging queue is used to manage the life cycle of the debugging session; the interface manager loads the visual interactive interface and completes the rendering of the debugging function of the interface based on the rendering view signal.

[0008] Optionally, after the interactive interface is loaded and rendered, a data initialization request is issued to the code debugging plug-in, initialization data obtained by the code debugging plug-in from the debugger based on the data initialization request is received and displayed on the interactive interface, and the initialization data is in an editable state. after the interactive interface is loaded and rendered, the interface manager sends a data initialization request to the interface manager; the interface manager forwards the data initialization request to the debugging listener through an internal remote procedure call; the debugging listener issues the data initialization request to the code debugging plug-in through a debugging adapter protocol, so that the code debugging plug-in issues a data acquisition instruction to the debugger and performs analysis and processing on the data returned by the debugger; the debugging listener receives the initialization data returned by the code debugging plug-in and pushes the initialization data to the interactive interface through the interface manager; the interactive interface completes interface data rendering based on the initialization data, so that the initialization data enters an editable state.

[0009] Optionally, when a debugging instruction for the initialization data is detected, the debugging instruction is issued to the debugger by the code debugging plug-in, so that the debugger performs a data debugging operation. When detecting an editing operation on the initialization data, the interaction interface sends a debugging instruction carrying an adjustment object name and an adjustment value to the interface manager; The interface manager forwards the debugging instruction to the debugging listener through an internal remote procedure call; The debugging listener forwards the debugging instruction to the code debugging plug-in through a debugging adapter protocol, so that the code debugging plug-in issues the debugging instruction to the debugger, and the debugger completes data debugging based on the debugging instruction and generates a data debugging result.

[0010] Optionally, receiving and displaying the data debugging result fed back by the code debugging plug-in on the interaction interface comprises: The debugging listener obtains the data debugging result from the code debugging plug-in and pushes the data debugging result to the interaction interface through the interface manager; The interaction interface receives the data debugging result and completes the update and display of interface data.

[0011] Optionally, after receiving and displaying the data debugging result fed back by the code debugging plug-in on the interaction interface, the method further comprises: The debugging listener synchronously updates data in the native interface based on the data debugging result, so that the data in the native interface is consistent with the data in the interaction interface.

[0012] Optionally, after synchronously updating the data in the native interface, the method further comprises: When the debugging listener detects that the debugging session is in an end state, the debugging session is removed from the debugging queue, and an interface destruction instruction is sent to the interface manager; The interface manager executes a destruction operation of the interaction interface based on the interface destruction instruction.

[0013] In a second aspect, the present application provides a debugging data modification device, which comprises: A loading and rendering module is configured to load and render a visual interaction interface when a debugging session is in a start state, wherein the debugging session is used to build a debugging data interaction communication connection for a code debugging plug-in and a debugger in a lightweight integrated development environment; An initialization module is configured to issue a data initialization request to the code debugging plug-in after the interaction interface is loaded and rendered, and display initialization data obtained by the code debugging plug-in from the debugger based on the data initialization request on the interaction interface, wherein the initialization data is in an editable state; The debugging module is configured to, when detecting a debugging instruction for the initialization data, send the debugging instruction to the debugger through the code debugging plug-in, so that the debugger performs a data debugging operation. The display module is configured to receive and display a data debugging result fed back by the code debugging plug-in on the interactive interface.

[0014] In a third aspect, the present application provides an electronic device, comprising: at least one communication interface; at least one bus connected to the at least one communication interface; at least one processor connected to the at least one bus; and at least one memory connected to the at least one bus.

[0015] In a fourth aspect, the present application further provides a computer storage medium storing computer executable instructions for executing the modification method of the debugging data.

[0016] Compared with the prior art, the above technical solutions provided by the embodiments of the present application have the following advantages: After the development debugging plug-in listens to the code debugging plug-in starting a debugging session, the development debugging plug-in loads and renders the visual interactive interface built-in itself. After the interactive interface is loaded, the development debugging plug-in sends a data initialization request to the code debugging plug-in, so as to make the code debugging plug-in complete data interaction with the underlying debugger and parse the initialization data of the debugging data. These initialization data are presented in the interactive interface and set to be editable. Thus, the function short board of the debugging adapter protocol that only opens the data viewing permission is bypassed. When the user initiates a modification operation in the interface, the development debugging plug-in sends a debugging instruction to the debugger through the code debugging plug-in, thereby replacing the traditional operation of manually inputting a complex debugging command in the console. After the debugger completes the operation, the result is synchronously fed back to the interactive interface for display. The present application can modify the debugging data by bypassing the debugging adapter protocol. The user can directly modify the debugging data in the interactive interface. Through the intuitive and convenient interface visual operation, the debugging data modification process is simplified. BRIEF DESCRIPTION OF DRAWINGS

[0017] The accompanying drawings, which are incorporated into and form a part of the specification, illustrate embodiments consistent with the present application and, together with the description, serve to explain the principles of the application.

[0018] In order to more clearly illustrate the technical solutions in the embodiments of the present application or the prior art, the accompanying drawings needed to be used in the embodiments or prior art description will be briefly introduced. Obviously, for those skilled in the art, other drawings can also be obtained without creative labor based on these drawings.

[0019] One or more embodiments are illustrated by way of example with reference numerals in the accompanying drawings. These illustrations do not constitute a limitation on the embodiments. Elements with the same reference numerals in the drawings are denoted as similar elements. Unless otherwise stated, the figures in the drawings are not to be limited by scale.

[0020] Figure 1 This is a schematic diagram of the debugging data modification architecture provided in the embodiments of this application; Figure 2 A flowchart illustrating a method for modifying debugging data provided in this application embodiment; Figure 3 This is a schematic diagram of the internal process of developing and debugging plugins provided in an embodiment of this application; Figure 4 This is a schematic diagram of the data flow in the first stage provided in an embodiment of this application; Figure 5 This is a schematic diagram of the data flow in the second stage provided in an embodiment of this application; Figure 6 This is a schematic diagram of a device for modifying debugging data provided in an embodiment of this application; Figure 7 This is a schematic diagram of the structure of an electronic device provided in an embodiment of this application. Detailed Implementation

[0021] To make the objectives, technical solutions, and advantages of the embodiments of this application clearer, the technical solutions of the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.

[0022] The following disclosure provides numerous different embodiments or examples for implementing various structures of this application. To simplify the disclosure, specific examples of components and arrangements are described below. These are merely examples and are not intended to limit the scope of this application. Furthermore, reference numerals and / or letters may be repeated in different examples. Such repetition is for simplification and clarity and does not in itself indicate a relationship between the various embodiments and / or arrangements discussed.

[0023] Figure 1 This is a schematic diagram of the debugging data modification architecture provided in this application, which includes three levels. The content and interaction logic of each level are shown below.

[0024] Top layer: VS Code. VS Code serves as the basic development tool platform, providing a debugging UI interface and interacting with cpptools in the plugin layer to present debugging data.

[0025] Middle layer: Plugin layer, including cpptools (code debugging plugin) and IntewellDeveloper (development debugging plugin).

[0026] cpptools: A code debugging plugin responsible for interacting with the underlying debugger, sending and receiving debugging data, and rendering the data to the native debugging interface of VS Code through the Debug Adapter Protocol (DAP).

[0027] IntewellDeveloper: The main body of this application, implemented as a plugin, interacts directly with cpptools, and is responsible for listening to the debugging sessions managed by cpptools, and realizing the relay and distribution of debugging data.

[0028] At the bottom layer: gdb is a dedicated debugger, the tool that actually performs debugging operations, and interacts with cpptools at the underlying level for debugging data.

[0029] The interaction logic of each component in this application is as follows.

[0030] VS Code cpptools: Through the DAP protocol, cpptools transmits debugging data to VS Code, enabling data display in the native debugging interface.

[0031] cpptools gdb: Directly sends and receives low-level debugging data. After gdb performs debugging operations, it sends the results back to cpptools.

[0032] Intewell Developer cpptools: Intewell Developer listens to the debug session started by cpptools and uses this session to transfer debug data (breaking through the functional limitations of DAP).

[0033] The architecture of this application is built on VS Code and cpptools, and implements a debugging proxy mechanism through Intewell Developer. By listening to the debugging session of cpptools, it transfers various debugging data, is no longer limited by the VS Code debugging adapter protocol, supports the rendering of custom debugging interfaces, and expands the flexibility of VS Code debugging functions.

[0034] The following will describe in detail a method for modifying debugging data provided in this application embodiment, taking its application in the development and debugging plugin Intewell Developer as an example. Figure 2 As shown, the specific steps are as follows: Step 201: When the debug session is detected to be in the running state, load and render the visual interactive interface. The debug session is used to establish a communication connection for code debugging plugins and debuggers to exchange debugging data in a lightweight integrated development environment. Step 202: After the interactive interface is loaded and rendered, send a data initialization request to the code debugging plugin, receive and display the initialization data obtained by the code debugging plugin from the debugger based on the data initialization request in the interactive interface, wherein the initialization data is in an editable state; Step 203: When a debugging instruction for initialization data is detected, the debugging instruction is sent to the debugger through the code debugging plugin so that the debugger can perform data debugging operations; Step 204: Receive and display the debugging results from the code debugging plugin in the interactive interface.

[0035] In step 201, after the development debugging plugin starts, it continuously monitors the full lifecycle status of the debugging sessions managed by the code debugging plugin. The full lifecycle status of the debugging session includes startup, running, paused, and termination. The debugging session is a session carrier that carries debugging data interaction on the communication link established between the code debugging plugin and the debugger based on the debugging adapter protocol in the lightweight integrated development environment, and at the same time provides the development debugging plugin with an entry point for session status awareness.

[0036] When the development and debugging plugin detects that the debugging session has switched to the startup state, it will trigger its built-in visual interactive interface to complete loading and rendering. This interactive interface is an internal module of the development and debugging plugin and can be customized according to the needs of different embedded debugging scenarios. For example, it can set up a dedicated display block for the peripheral parameters of industrial-grade chips, or configure multi-format display options for the core variables of real-time systems.

[0037] In this application, the interactive interface can be customized according to the needs of different embedded debugging scenarios, and the data display layout, function buttons and other modules can be flexibly configured. For example, a dedicated display block can be set for the peripheral parameters of industrial-grade chips, and multiple display options can be configured for the core variables of real-time systems.

[0038] In step 202, after the visual interactive interface of the development debugging plugin is loaded and rendered, it will automatically send an initialization request for debugging data to the code debugging plugin. The debugging data in this application can be key embedded debugging information such as memory unit data, peripheral configuration parameters or core variable status.

[0039] After receiving the initialization request, the code debugging plugin interacts with the underlying debugger to complete the debugging data exchange and parses the raw debugging data. Then, it sends the parsed initialization data back to the development debugging plugin. The initialization data refers to the core running state data of the debug program at the beginning of the debugging session. It covers the initial values ​​of global and local variables in the program, the raw data of specified memory units, the initial configuration parameters of chip peripherals, the core state information of the program running context, and other key debugging data.

[0040] Since the interactive interface is a built-in component of the development and debugging plugin, the initialization data is rendered and displayed directly within this interface. Simultaneously, the development and debugging plugin automatically sets this initialization data to an editable state. This process successfully circumvents the functional limitations of the debug adapter protocol, which only grants viewing permissions for debug data and does not support direct editing operations on the interface. The development and debugging plugin, however, achieves this editability through its own data flow logic.

[0041] In step 203, the development debugging plugin captures user operations on its built-in interactive interface in real time. When it detects that the user has initiated an editing operation on editable data, such as the user modifying the value of a variable or adjusting the parameters of an external device on the interactive interface, the development debugging plugin extracts the core information such as the object being adjusted and the value being adjusted in the editing operation, and generates debugging instructions to ensure that the debugging instructions can be recognized by the code debugging plugin and the debugger.

[0042] Developing a debugging plugin leverages the inherent communication link between the code debugging plugin and the debugger to precisely send debugging commands to the debugger, prompting the debugger to execute corresponding debugging operations. This process bypasses a key limitation of the debug adapter protocol, which does not provide a dedicated interface for writing debug data. In the traditional model, developers can only manually input complex commands through the debug console to complete modifications. However, the development debugging plugin achieves the sending of debugging commands through its own collaborative mechanism with the code debugging plugin.

[0043] In step 204, after the code debugging plugin receives and parses the data debugging results returned by the debugger, it synchronously sends the data debugging results back to the development debugging plugin. After obtaining the data debugging results, the development debugging plugin directly updates and displays the data in real time in its built-in interactive interface, clearly presenting the modified variable values ​​and adjusted peripheral parameter statuses to the user.

[0044] This application monitors the debugging session status within the VS Code environment and leverages a development debugging plugin to relay, distribute, and update debugging data. This successfully bypasses the limitations of the debugging adapter protocol within the code debugging plugin, enabling visual modification of debugging data. A complete debugging data modification process can be divided into two core stages: steps 201-202 constitute the first stage, which initializes the debugging data; steps 203-204 constitute the second stage, which modifies the debugging data. For each debugging session, the first stage only needs to be executed once, while the second stage of data modification can be executed multiple times until the debugging session ends.

[0045] In this application, after the development debugging plugin detects that the code debugging plugin has started a debugging session, it loads and renders its built-in visual interactive interface. Once the interactive interface is loaded, the development debugging plugin sends a data initialization request to the code debugging plugin, prompting the code debugging plugin to complete data interaction with the underlying debugger and parse out the initialization data of the debugging data. This initialization data is presented in the interactive interface and set to an editable state, bypassing the limitation of the debug adapter protocol, which only allows data viewing permissions. When the user initiates a modification operation in the interface, the development debugging plugin sends debugging commands to the debugger through the code debugging plugin, replacing the traditional operation of manually entering complex debugging commands in the console. After the debugger completes the operation, the results are synchronously sent back to the interactive interface for display. This application can bypass the debug adapter protocol to modify debugging data, and users can directly modify debugging data in the interactive interface, simplifying the debugging data modification process through intuitive and convenient visual operation.

[0046] Figure 3 This is a flowchart illustrating the internal workflow of Intewell Developer. The functions of each module are shown below.

[0047] WebView (interactive interface): is a user-facing visual interface. Its core functions are: sending data requests to WebViewProvider via postMessage; and listening to data from the backend via addEventListener when the interface is mounted, thereby enabling dynamic rendering of the interface content.

[0048] WebViewProvider (UI Manager) is a background management instance of WebView, responsible for managing the lifecycle and message interaction of WebView: it can send data or commands to WebView via postMessage, and can also listen for messages sent by WebView via onDidReceiveMessage; at the same time, it will use the internal RPC communication of Intewell Developer to complete the transmission of messages and data with DebugWatcher.

[0049] DebugWatcher is a core relay and session management component with two main functions: 1. Debug Session Management: It maintains the debug queue started by cpptools. When a debug session starts, it stores the session in the queue and sends a request to the WebViewProvider to activate the WebView (i.e., a view rendering signal). When a debug session ends, it removes the session from the queue and sends a request to the WebViewProvider to destroy the read / write interface, preventing users from performing unnecessary operations. 2. Data Relay: As a bridge for data interaction between upper and lower layers, it sends messages or data to the WebViewProvider via the emit event and interacts with cpptools via the Debug Adapter Protocol (DAP) to issue debug commands and acquire debug data.

[0050] In addition, cpptools (the code debugging plugin) interacts with DebugWatcher through the Debug Adapter Protocol (DAP), and is responsible for starting debugging sessions, executing debugging commands issued by DebugWatcher, and sending data back to DebugWatcher.

[0051] As an optional implementation, in step 201, when the debug session is detected to be in a running state, loading and rendering the visual interactive interface includes: Step S11: The debug listener continuously monitors the status of the debug session; Step S12: If the debug listener detects that the debug session is in the started state, the debug session is added to the debug queue and a render view signal is sent to the interface manager. The debug queue is used to manage the lifecycle of the debug session. Step S13: The interface manager loads the visual interactive interface based on the rendering view signal and completes the rendering of the interface's debugging functions.

[0052] When the development debugging plugin starts, it registers a debugging listener. After registration, the debugging listener enters a continuous running state, continuously monitoring the entire lifecycle of the debugging session on the code debugging plugin side, including key state nodes such as session startup, running, pause, and termination, to ensure that state changes of the debugging session can be captured as soon as possible.

[0053] When a user initiates a debugging command for a real-time or non-real-time application in the development and debugging plugin, such as clicking the "Start Real-Time Program Debugging" button or selecting the "Run Debug" option, the code debugging plugin will then start the corresponding debugging session.

[0054] Because VS Code is a lightweight integrated development environment, it supports the simultaneous installation of multiple debugging plugins. These plugins may all initiate debugging sessions through the code debugging plugin. After detecting the startup of a debugging session, the debug listener determines whether it is the debugging session corresponding to the development debugging plugin itself based on the session identifier. If it is determined that it is not the debugging session corresponding to the development debugging plugin itself, the process ends to avoid the debug listener mistakenly processing debugging sessions started by other plugins and interfering with the normal debugging process of other plugins.

[0055] If it is determined that the debugging session corresponds to the development and debugging plugin itself, the debugging listener will include the debugging session in a preset debugging queue for unified management. The debugging queue can control the entire lifecycle of the debugging session, avoiding operational conflicts when multiple sessions are running concurrently, as well as the problem of triggering invalid debugging actions after the debugging session ends. At the same time, the debugging listener will send a rendering view signal to the interface manager to clarify the loading and rendering process of the visual interactive interface.

[0056] Upon receiving the rendering view signal from the debug listener, the interface manager immediately responds and initiates the loading process for the interactive interface. During loading, the interface manager first completes the setup of the visual interactive interface, and then, based on the debug scenario configuration information carried in the signal, completes the targeted rendering of the interface debugging functions, including the deployment of core functional modules such as the debug data display module, editable operation areas, and data interaction buttons. Once loading and rendering are complete, a visual interactive interface that supports viewing and modifying debug data is officially ready, providing a platform for subsequent debug data initialization and user operations.

[0057] In this application, the debugging plugin first registers the debugging listener upon startup, enabling it to continuously monitor the debugging session status of the code debugging plugin. This step addresses the pain point of the native VS Code environment's inability to autonomously perceive the start and stop of debugging sessions, providing a status awareness entry point for subsequent functional linkage. When the debugging listener captures the startup status of a real-time or non-real-time application debugging session, it includes the session in the debugging queue for unified management. This avoids operational conflicts when multiple sessions run concurrently and enables precise control over the entire lifecycle of the session. Simultaneously, the sent rendering view signal directly triggers the loading process of the custom interface, bypassing the fixed form constraints of the debug adapter protocol on the native interface. After the interface manager responds to the signal, it completes the loading of the interactive interface and the rendering of the debugging function, successfully building a dedicated interactive carrier that is independent of the native interface framework. This not only provides interface support for the initial display and editable operation of subsequent debugging data but also realizes the customized deployment of the native interface, breaking the limitations of the debug adapter protocol on the debugging interface functionality.

[0058] As an optional implementation, in step 202, after the interactive interface has been loaded and rendered, a data initialization request is sent to the code debugging plugin, and the initialization data obtained by the code debugging plugin from the debugger based on the data initialization request is received and displayed on the interactive interface, including: Step S21: After the interactive interface has finished loading and rendering, it sends a data initialization request to the interface manager; Step S22: The UI manager forwards the data initialization request to the debug listener via an internal remote procedure call; Step S23: The debug listener sends a data initialization request to the code debugging plugin through the debug adapter protocol, so that the code debugging plugin sends a data acquisition instruction to the debugger and parses and processes the data returned by the debugger; Step S24: The debug listener receives the initialization data returned by the code debugging plugin and pushes it to the interactive interface after being relayed by the interface manager; Step S25: The interactive interface completes the rendering of interface data based on the initialization data, so that the initialization data enters the editable state.

[0059] In step S21, after the visual interactive interface built into the development and debugging plugin completes loading and debugging function rendering, it will automatically trigger the preset initialization data request interface. This interface is a core communication entry point defined during the interface mounting phase. It will send a standardized data initialization request to the background interface manager through the postMessage mechanism. The data initialization request explicitly includes key information such as the type of debugging data to be obtained and the data format requirements, thereby initiating the debugging data initialization flow process.

[0060] In step S22, after the UI Manager receives a data initialization request from the interactive interface via onDidReceiveMessage, it immediately initiates its internal data forwarding logic. Since the UI Manager and the debug listener are different functional modules of the development and debugging plugin, they communicate via the plugin's built-in Remote Procedure Call (RPC) mechanism. The UI Manager encapsulates the received data initialization request to ensure it can be recognized by the debug listener, and then accurately forwards the request to the debug listener via the RPC link.

[0061] In step S23, after receiving the forwarded data initialization request, the debug listener converts the data initialization request into a debug command format recognizable by the code debugging plugin based on the communication specifications of the debug adapter protocol, and sends the data initialization request to the code debugging plugin. As a native compiled code debugging plugin of VS Code, the code debugging plugin establishes a data interaction link directly with the underlying debugger after receiving the data initialization request, and sends a debug data acquisition command to the debugger; after the debugger returns the raw debug data, the code debugging plugin will parse and convert the non-standardized raw debug data to generate initialization data with a unified structure, preparing for subsequent interface display.

[0062] In step S24, after the code debugging plugin completes data parsing, it sends the processed initialization data back to the debugging listener. Upon receiving the initialization data, the debugging listener first verifies the data to ensure that there are no missing or incorrectly formatted data. Then, it forwards the initialization data to the interface manager via `emitInitData`. The interface manager listens for data sent by the debugging listener based on `onInitData`. After listening for the data, the interface manager pushes the initialization data to the interactive interface it manages via the `postMessage` mechanism, completing the end-to-end data transfer within the plugin.

[0063] In step S25, after receiving the initialization data pushed by the interface manager, the interactive interface will complete the interface data rendering according to the preset display logic. For example, it will categorize and display register data of different functional categories and configure multiple display options such as hexadecimal or decimal for the data. At the same time, the development and debugging plugin will automatically enable editable permissions for these rendered debugging data, so that the debugging data that can only be viewed in the native VS Code interface will enter an editable state in this custom interactive interface, waiting for the user to initiate subsequent debugging and modification operations.

[0064] This application first establishes a custom data communication link independent of the VS Code native debug adapter protocol by leveraging the collaborative interaction of the development and debugging plugin's interactive interface, interface manager, and debug listener. This solves the problem that the native protocol only grants data viewing permissions, providing basic communication support for the editability of debug data. Second, end-to-end data transfer and format adaptation ensure that debug data such as registers can be accurately and completely transferred from the underlying debugger to the custom interactive interface. Furthermore, customized interface rendering makes the data display more aligned with the actual needs of embedded debugging, reducing the cognitive cost for developers dealing with complex debug data. Finally, the automatic activation of the editable data state directly removes obstacles for subsequent debugging command issuance and data modification. This not only fills the gap in VS Code's inability to visualize debug data modification in embedded debugging but also provides a general implementation solution for customized interaction of various debug data, significantly improving the customizability and ease of use of the debugging function.

[0065] As an optional implementation, in step 203, when a debugging instruction for initialization data is detected, the debugging instruction is sent to the debugger via the code debugging plugin so that the debugger performs data debugging operations, including: Step S31: When an editing operation on the initialization data is detected, the interactive interface will send a debugging command carrying the name of the object to be adjusted and the value to be adjusted to the interface manager. Step S32: The interface manager forwards the debugging instructions to the debug listener through an internal remote procedure call; Step S33: The debug listener forwards the debug instructions to the code debugging plugin through the debug adapter protocol, so that the code debugging plugin sends the debug instructions to the debugger, and the debugger completes the data debugging based on the debug instructions and generates the data debugging results.

[0066] In step S31, when a user initiates an editing operation on the initialization data that has entered an editable state in the built-in visual interactive interface of the development and debugging plugin, such as directly modifying the hexadecimal value of a register or adjusting the threshold of peripheral configuration parameters, the interactive interface will immediately capture the operation. Subsequently, the interactive interface will automatically standardize and encapsulate the operation information, generating a debugging command that includes the name of the object to be adjusted (such as the physical address of the register, the identifier name of the peripheral parameter) and the target adjustment value (such as auxiliary information such as data format and value range). Then, through the postMessage communication mechanism, the debugging command is accurately sent to the interface manager in the background to ensure that the debugging command can be effectively recognized.

[0067] In step S32, after the UI Manager receives the debugging command from the interactive interface through the onDidReceiveMessage listener interface, it first performs a completeness check on the debugging command to confirm that the core information such as the object to be adjusted and the value to be adjusted is not missing or has an incorrect format. Since the UI Manager and the debugging listener belong to different functional modules of the development and debugging plugin, they complete cross-module message transmission through the plugin's built-in remote procedure call link. Therefore, the UI Manager will encapsulate the verified debugging command in RPC protocol format and then forward the command to the debugging listener through this dedicated communication link.

[0068] In step S33, after receiving the forwarded debugging command, the debug listener first converts the command into a debugging command format recognizable by the code debugging plugin according to the communication specifications of the debug adapter protocol, and attaches a unique identifier for the debugging session to avoid command mis-sending when multiple sessions are running in parallel. After completing the format adaptation, the debug listener sends the debugging command to the code debugging plugin through the debug adapter protocol. As a native compiled code debugging plugin of VS Code, the code debugging plugin, after receiving the command, directly establishes a command interaction link with the underlying debugger, further converting the debugging command into low-level commands executable by the debugger and sending them out. After receiving the command, the debugger immediately executes the corresponding data debugging operation, such as writing a target value to a specified register address or updating peripheral parameter configuration. After the operation is completed, it generates a data debugging result containing the execution status and data change results.

[0069] In this application, the process establishes a full-link command channel from front-end visual operation to the underlying debugger. Through the collaborative interaction of the development debugging plugin's interactive interface, interface manager, and debug listener, standardized encapsulation and cross-module flow of debugging commands are achieved. This bypasses the functional limitations of debug adapter protocols that only provide data viewing permissions and lack write interfaces, allowing users to modify debug data directly through the interface without manually entering complex low-level commands in the debugging console, significantly lowering the barrier to entry for embedded program debugging. Secondly, the full-link command verification and format adaptation mechanism ensures the accuracy and compatibility of debug command transmission, avoiding command mis-sending issues when multiple debugging sessions are running concurrently, and ensuring that debug commands can be effectively recognized and executed by the code debugging plugin and the underlying debugger, improving the stability and reliability of debugging operations. Finally, this debug command flow scheme has universal extensibility; simply replacing the data type identifier in the debug command allows modification of other debug data such as memory units and peripheral parameters, enhancing the customizability and scenario adaptability of debugging functions.

[0070] As an optional implementation, in step 204, receiving and displaying the data debugging results fed back by the code debugging plugin on the interactive interface includes: the debugging listener obtains the data debugging results from the code debugging plugin and pushes the data debugging results to the interactive interface via the interface manager; the interactive interface receives the data debugging results and completes the update and display of the interface data.

[0071] After the underlying debugger completes the data debugging operation corresponding to the debugging command, it sends the raw debugging results, including the operation execution status, data change details, and result verification identifier, back to the code debugging plugin. The code debugging plugin first parses the raw debugging results, transforming the non-standardized underlying feedback data into structured data conforming to the debug adapter protocol specification. Then, it synchronizes the standardized data debugging results to the debug listener through the debug adapter protocol link. Upon receiving the data debugging results, the debug listener first performs data validity verification to confirm that there are no execution exceptions or data format errors in the results. It also associates the results with the unique identifier of the corresponding debugging session to avoid confusion between results from multiple sessions. Since the debug listener and the interface manager achieve cross-module interaction through the remote procedure call link built into the development debugging plugin, the debug listener encapsulates the verified data debugging results using the RPC protocol and then forwards the data debugging results to the interface manager through this dedicated link. After receiving the data debugging results, the interface manager further adapts them to the display format of the front-end interactive interface and then accurately pushes the data debugging results to the visual interactive interface it manages through the postMessage communication mechanism.

[0072] After receiving the data debugging results pushed by the interface manager through the addEventListener listening interface, the visual interactive interface will immediately trigger the interface data update logic. On one hand, the interface will complete customized rendering according to preset display rules, such as highlighting the modified register values, synchronously displaying the comparison of values ​​before and after the data modification, and popping up prompts for abnormal execution results, allowing developers to intuitively perceive the effectiveness of the debugging operation. On the other hand, the development debugging plugin will synchronously trigger the data update mechanism of the VS Code native interface. The debugging listener actively captures the latest data debugging results and synchronizes the data debugging results to the native interface through the debugging adapter protocol, ensuring that the data state of the custom interactive interface is consistent with the VS Code native interface, and avoiding data deviations that may affect the developer's debugging judgment.

[0073] In this application, the process establishes a complete result feedback channel from the underlying debugger to the front-end custom interface, filling the functional gap where the debug adapter protocol only supports the issuance of debug commands and does not realize the synchronization of results from custom interfaces. This allows data modification to form a closed loop from command issuance to result feedback, ensuring the integrity and traceability of debugging operations. Secondly, the newly added multi-node data verification and format adaptation mechanism, as well as the data synchronization logic between the custom interactive interface and the native interface, solve the problem of inconsistent data across multiple interfaces in VS Code debugging scenarios, improve the reliability of debugging data, and provide developers with a unified debugging data reference benchmark. Furthermore, the customized result display format of the interactive interface replaces the plain text feedback mode of the traditional debug console, reducing the cost for developers to interpret result information and significantly improving the intuitiveness and convenience of debugging operations. Finally, this result feedback link has universal adaptability. By simply adjusting the adaptation rules for result parsing and display, it can support the result feedback of other debugging data such as memory units and peripheral parameters, enhancing the customizability and scenario expansion capabilities of debugging functions.

[0074] After synchronizing and updating the data in the native interface, the method also includes: when the debug listener detects that the debug session is in an ended state, removing the debug session from the debug queue and sending an interface destruction command to the interface manager; the interface manager executes the destruction operation of the interactive interface based on the interface destruction command.

[0075] When the debugging process is complete, the user manually terminates the debugging operation, or an exception occurs in the real-time or non-real-time application causing the debugging process to be interrupted, the debugger will send a debugging session termination signal to the code debugging plugin. Upon receiving this signal, the code debugging plugin will synchronously update the status flag of the debugging session. At this time, the debugging listener built into the development debugging plugin is still in a working mode of continuously monitoring the debugging session status. After capturing the signal that the debugging session on the code debugging plugin side has switched to the terminated state, it will immediately initiate the session cleanup and control process. First, the debugging listener will accurately locate and remove the instance of the debugging session from its maintained debugging queue based on the unique identifier of the debugging session, thereby cleaning up redundant data in the debugging queue, avoiding the problem of excessive memory consumption caused by multiple sessions overlapping, and eliminating the risk of terminated sessions being mistakenly triggered by subsequent debugging commands. Subsequently, the debugging listener will generate a standardized interface destruction command. This interface destruction command contains the unique identifier of the interactive interface, the reason for session termination, and other supplementary information. Then, through the remote procedure call chain within the plugin, the interface destruction command is accurately sent to the interface manager, explicitly instructing it to perform the destruction operation of the corresponding interactive interface.

[0076] After receiving the UI destruction command from the debug listener via the onDidReceiveMessage interface, the UI Manager first verifies the completeness and validity of the command, confirming that the UI identifier is not mismatched and the session termination state has been synchronized. Upon successful verification, the UI Manager immediately initiates the full-link destruction process for the UI: firstly, it terminates the postMessage communication link with the UI and closes the UI's addEventListener data listening interface to prevent data transmission anomalies during destruction; secondly, it releases the memory resources occupied by the UI, clears cached debug data within the UI, such as register initial values ​​and modified parameter records, and completely destroys the front-end instance of the UI, ensuring that the UI is completely removed from the VS Code plugin runtime environment. Furthermore, the UI Manager sends a feedback signal indicating that the UI destruction is complete back to the debug listener, forming a closed-loop control for session termination. This fundamentally eliminates the possibility of users performing invalid operations on registers and other debug data in an ended debug session, ensuring the standardization of the debugging process and the stability of the runtime environment.

[0077] In this application, a complete debugging data modification process can be divided into two stages: the first stage is to initialize the debugging data in the interactive interface; the second stage is to modify the debugging data in the interactive interface.

[0078] The data flow in the first phase is as follows: Figure 4 As shown, it includes the following content.

[0079] 1. Development and debugging plugin startup and debugging listener registration: When the development and debugging plugin starts, the debugging listener is automatically registered. After the debugging listener starts, it will continuously monitor the status of various debugging sessions started by the code debugging plugin.

[0080] 2. Initiate a debugging session: Users can initiate debugging commands for real-time or non-real-time applications in the development debugging plugin, triggering the code debugging plugin to start the corresponding debugging session.

[0081] 3. Determine if it is the debugging session corresponding to the development and debugging plugin itself: After the debugging listener detects the start operation of the debugging session, it determines whether it is the debugging session corresponding to the development and debugging plugin itself. If not, the process ends; if yes, the next step is executed.

[0082] 4. The debug session is added to the debug queue, and the interactive interface is loaded. The debug listener adds the debug session to the debug queue for unified lifecycle management, and simultaneously sends a view rendering signal to the interface manager. Upon receiving the view rendering signal, the interface manager initiates the loading and rendering process of the interactive interface, completing the construction of the interactive interface and the deployment of basic functions.

[0083] 5. Sending data initialization request from the interactive interface: After the interactive interface is loaded and the function is rendered, the interactive interface sends a debug data initialization request to the interface manager through the preset initialization data request interface.

[0084] 6. Data Initialization Request Forwarding and Initialization Data Acquisition: The UI Manager forwards the initialization request to the debug listener via an internal remote procedure call within the plugin. The debug listener sends a data acquisition command to the code debugging plugin via the debug adapter protocol. Upon receiving the command, the code debugging plugin interacts with the underlying debugger to acquire the initialization data and completes its parsing. The code debugging plugin then sends the parsed initialization data back to the debug listener, which, after being relayed through the UI Manager, pushes the data to the interactive interface.

[0085] 7. Data Feedback and Interface Rendering: The debug listener pushes data to the interactive interface via the interface manager; after receiving the data, the interactive interface completes the interface rendering and sets the debug data to an editable state, waiting for subsequent user operations.

[0086] The data flow in the second phase is as follows: Figure 5 As shown, it includes the following content.

[0087] 1. User-triggered modification operation: When a user performs a modification operation on the initialization data (such as adjusting the register value) in the interactive interface that has entered the editable state, the interactive interface captures the operation and sends a debugging command containing the name of the object to be adjusted and the value to be adjusted to the interface manager.

[0088] 2. Debugging commands are sent across modules to the debugger: After the interface manager completes the integrity verification of the debugging commands, it forwards the debugging commands to the debug listener through the plugin's internal remote procedure call; the debug listener adapts the debugging commands to the debug adapter protocol specification, and then sends the debugging commands to the code debugging plugin.

[0089] 3. The debugger executes debugging commands: After receiving the adapted debugging commands, the code debugging plugin further converts them into commands that the underlying debugger can recognize and issues them; the debugger executes the commands to complete the modification operation on the debugging data.

[0090] 4. Update native and interactive interfaces: The debug listener listens for debugger command execution feedback, obtains modified debugging data from the code debugging plugin, and pushes it to the interactive interface after being relayed through the interface manager, completing the custom interactive interface data update; at the same time, the debug listener actively listens for variable retrieval commands of the debug adapter protocol, triggering the synchronous refresh of debug data in the VSCode native interface, ensuring that the data state of the interactive interface is consistent with that of the native interface.

[0091] 5. After the debugging session ends, the debugging session is removed from the queue and the interactive interface is destroyed: When the debugging process is completed, the user manually terminates the debugging, or the debugging session ends due to an application exception, the debugging listener detects the end status of the session, removes the debugging session from the debugging queue, and sends an interface destruction command to the interface manager; after receiving the command, the interface manager executes the destruction operation of the interactive interface, releases related resources, and terminates the interface communication link.

[0092] This application also provides a device for modifying debugging data, such as Figure 6 As shown, the device includes: The loading and rendering module 601 is used to load and render the visual interactive interface when the debugging session is detected to be in the startup state. The debugging session is used to establish a communication connection for debugging data interaction between the code debugging plugin and the debugger in a lightweight integrated development environment. The initialization module 602 is used to send a data initialization request to the code debugging plugin after the interactive interface is loaded and rendered, receive and display the initialization data obtained by the code debugging plugin from the debugger based on the data initialization request in the interactive interface, wherein the initialization data is in an editable state; The debugging module 603 is used to send the debugging command to the debugger through the code debugging plugin when a debugging command for initialization data is detected, so that the debugger can perform data debugging operations. The display module 604 is used to receive and display the debugging results of the code debugging plugin in the interactive interface.

[0093] Optionally, the loading and rendering module 601 is used for: The debug listener continuously monitors the status of the debug session; If the debug listener detects that the debug session is in the running state, it adds the debug session to the debug queue and sends a render view signal to the interface manager. The debug queue is used to manage the lifecycle of the debug session. The interface manager loads the visual interactive interface based on the rendering view signal and completes the rendering of the interface's debugging functions.

[0094] Optionally, the initialization module 602 is used for: After the interactive interface has finished loading and rendering, it sends a data initialization request to the interface manager. The UI manager forwards data initialization requests to the debug listener via an internal remote procedure call; The debug listener sends a data initialization request to the code debugging plugin through the debug adapter protocol, so that the code debugging plugin sends a data acquisition instruction to the debugger and parses and processes the data returned by the debugger; The debug listener receives initialization data returned by the code debugging plugin and pushes it to the interactive interface after being relayed through the interface manager. The interactive interface renders the interface data based on the initialization data, so that the initialization data becomes editable.

[0095] Optionally, the debug module 603 is used for: When an editing operation on the initialization data is detected, the interactive interface will send a debugging command with the name of the object to be adjusted and the value to be adjusted to the interface manager; The interface manager forwards debugging commands to the debug listener via internal remote procedure calls; The debug listener forwards debug commands to the code debugging plugin via the debug adapter protocol, so that the code debugging plugin can send debug commands to the debugger. The debugger then performs data debugging based on the debug commands and generates data debugging results.

[0096] Optionally, the display module 604 is used for: The debug listener obtains data debugging results from the code debugging plugin and pushes the data debugging results to the interactive interface via the interface manager. The interactive interface receives the data debugging results and updates and displays the interface data.

[0097] Optionally, the device is also used for: The debug listener updates the data in the native interface synchronously based on the data debugging results, so that the data in the native interface and the interactive interface are consistent.

[0098] Optionally, the device is also used for: When the debug listener detects that the debug session is in an ended state, the debug session is removed from the debug queue and a UI destruction command is sent to the UI manager. The interface manager executes the destruction operation of the interactive interface based on the interface destruction command.

[0099] like Figure 7 As shown, this application provides an electronic device including a processor 701, a communication interface 702, a memory 703, and a communication bus 704, wherein the processor 701, the communication interface 702, and the memory 703 communicate with each other through the communication bus 704.

[0100] Memory 703 is used to store computer programs.

[0101] In one embodiment of this application, the processor 701, when executing a program stored in the memory 703, implements the debugging data modification method provided in any of the foregoing method embodiments.

[0102] This application also provides a computer-readable storage medium storing a computer program thereon, which, when executed by a processor, implements the steps of the debugging data modification method provided in any of the foregoing method embodiments.

[0103] The device embodiments described above are merely illustrative. The units described as separate components may or may not be physically separate, and the components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the modules can be selected to achieve the purpose of this embodiment according to actual needs.

[0104] Through the above description of the embodiments, those skilled in the art can clearly understand that each embodiment can be implemented using software plus a general-purpose hardware platform, or of course, using hardware. Based on this understanding, the above technical solutions, in essence or the parts that contribute to the related technology, can be embodied in the form of a software product. This computer software product can be stored in a computer-readable storage medium, such as ROM / RAM, magnetic disk, optical disk, etc., and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute the methods described in the various embodiments or some parts of the embodiments.

[0105] It should be understood that the terminology used herein is for the purpose of describing particular exemplary embodiments only and is not intended to be limiting. Unless the context clearly indicates otherwise, the singular forms “a,” “an,” and “described” as used herein may also include the plural forms. The terms “comprising,” “including,” “containing,” and “having” are inclusive and therefore indicate the presence of the stated features, steps, operations, elements, and / or components, but do not exclude the presence or addition of one or more other features, steps, operations, elements, components, and / or combinations thereof. The method steps, processes, and operations described herein are not construed as requiring them to be performed in a particular order described or illustrated unless the order of performance is explicitly indicated. It should also be understood that additional or alternative steps may be used.

[0106] The above description is merely a specific embodiment of this application, enabling those skilled in the art to understand or implement this application. Various modifications to these embodiments will be readily apparent to those skilled in the art, and the general principles defined herein may be implemented in other embodiments without departing from the spirit or scope of this application. Therefore, this application is not to be limited to the embodiments shown herein, but is to be accorded the widest scope consistent with the principles and novel features claimed herein.

Claims

1. A method for modifying debugging data, characterized in that, The method includes: When the debugging session is detected to be in the running state, a visual interactive interface is loaded and rendered. The debugging session is used to establish a communication connection for debugging data interaction between the code debugging plugin and the debugger in a lightweight integrated development environment. After the interactive interface is loaded and rendered, a data initialization request is sent to the code debugging plugin. The code debugging plugin receives and displays the initialization data obtained from the debugger based on the data initialization request on the interactive interface. The initialization data is in an editable state. When a debugging instruction for the initialization data is detected, the debugging instruction is sent to the debugger through the code debugging plugin, so that the debugger performs data debugging operations. Receive and display the debugging results from the code debugging plugin on the interactive interface.

2. The method according to claim 1, characterized in that, When the debug session is detected as running, the visual interactive interface is loaded and rendered, including: The debug listener continuously monitors the status of the debug session; If the debug listener detects that the debug session is in the started state, it adds the debug session to the debug queue and sends a render view signal to the interface manager, wherein the debug queue is used to manage the lifecycle of the debug session; The interface manager loads the visual interactive interface and completes the rendering of the interface debugging function based on the rendering view signal.

3. The method according to claim 2, characterized in that, After the interactive interface is loaded and rendered, a data initialization request is sent to the code debugging plugin. The code debugging plugin receives and displays the initialization data obtained from the debugger based on the data initialization request on the interactive interface, including: After the interactive interface completes loading and rendering, it sends a data initialization request to the interface manager. The interface manager forwards the data initialization request to the debug listener via an internal remote procedure call; The debug listener sends the data initialization request to the code debugging plugin through the debug adapter protocol, so that the code debugging plugin sends a data acquisition instruction to the debugger and parses and processes the data returned by the debugger; The debug listener receives the initialization data returned by the code debugging plugin, and pushes it to the interactive interface after being relayed by the interface manager; The interactive interface renders the interface data based on the initialization data, so that the initialization data becomes editable.

4. The method according to claim 2, characterized in that, When a debugging instruction for the initialization data is detected, the code debugging plugin sends the debugging instruction to the debugger so that the debugger performs data debugging operations, including: When an editing operation is detected on the initialization data, the interactive interface will send a debugging command carrying the name of the object to be adjusted and the value to be adjusted to the interface manager; The interface manager forwards the debugging instructions to the debugging listener via an internal remote procedure call; The debug listener forwards the debug instructions to the code debugging plugin via the debug adapter protocol, so that the code debugging plugin sends the debug instructions to the debugger, and the debugger completes data debugging and generates data debugging results based on the debug instructions.

5. The method according to claim 2, characterized in that, The data debugging results received and displayed by the code debugging plugin on the interactive interface include: The debugging listener obtains the data debugging results from the code debugging plugin and pushes the data debugging results to the interactive interface via the interface manager. The interactive interface receives the data debugging results and updates and displays the interface data.

6. The method according to claim 5, characterized in that, After receiving and displaying the debugging results from the code debugging plugin on the interactive interface, the method further includes: The debug listener updates the data in the native interface synchronously based on the data debugging results, so that the data in the native interface and the interactive interface are consistent.

7. The method according to claim 6, characterized in that, After synchronously updating the data in the native interface, the method further includes: When the debug listener detects that the debug session is in an ended state, it removes the debug session from the debug queue and sends an interface destruction command to the interface manager. The interface manager executes the destruction operation of the interactive interface based on the interface destruction command.

8. A device for modifying debugging data, characterized in that, The device includes: The loading and rendering module is used to load and render a visual interactive interface when the debugging session is detected to be in the startup state. The debugging session is used to establish a communication connection for debugging data interaction between the code debugging plugin and the debugger in a lightweight integrated development environment. An initialization module is used to send a data initialization request to the code debugging plugin after the interactive interface is loaded and rendered, receive and display the initialization data obtained by the code debugging plugin from the debugger based on the data initialization request in the interactive interface, wherein the initialization data is in an editable state. The debugging module is used to send the debugging instruction to the debugger through the code debugging plugin when a debugging instruction for the initialization data is detected, so that the debugger can perform data debugging operations. The display module is used to receive and display the data debugging results fed back by the code debugging plugin in the interactive interface.

9. An electronic device, characterized in that, It includes a processor, a communication interface, a memory, and a communication bus, wherein the processor, the communication interface, and the memory communicate with each other through the communication bus; Memory, used to store computer programs; A processor, when executing a program stored in memory, implements the method described in any one of claims 1-7.

10. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores a computer program that, when executed by a processor, implements the method described in any one of claims 1-7.

Images