Digital development environment integration method
By obtaining software and engineering information in the FPGA and IC integrated development environment, building file structures and obtaining module dependencies, the problem of poor cross-platform portability is solved, rich code prompts and documented processing are achieved, and design convenience and portability are improved.
Patent Information
- Application Number
- CN202510563567.8
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2025-04-30
- Publication Date
- 2025-08-19
AI Technical Summary
The existing FPGA and IC integrated development environments cannot achieve efficient cross-platform portability, and lack the ability to document the code prompts and completions in real time and code outlines, dependencies, annotations, and version modifications in the design process.
By obtaining the software itself and engineering information, building the file structure by itself and enabling the engineering change monitor, obtaining the dependencies between modules, and providing corresponding functional services based on user trigger information, including code prompts and engineering operations.
It provides specific and rich code prompts and completions in one software, supports documented previews of code outlines, dependencies, annotations, and version modifications, improving the portability and convenience of engineering design between different digital design solutions.
Smart Images
Figure CN120508284A_ABST
Abstract
Description
Technical Field
[0001] The invention relates to a digital development environment integration method, belonging to the technical field of software management. Background Art
[0002] Currently, the methods used in FPGA (field programmable gate array) and IC (integrated circuit) integrated development environments require the creation of their own virtual projects before users can add the design source files to the project. Users then simply complete the code design in the software.
[0003] Currently, the software used in FPGA (field programmable gate array) and IC (integrated circuit) integrated development environments requires the creation of separate virtual projects before users can add design source files to the project. The file and project structures are separate, significantly reducing portability between different digital design solutions. Existing methods also fail to provide detailed and comprehensive prompts and completions in real time based on the dependencies between design modules during the user's editing process. Furthermore, they fail to document important information such as the code outline, dependencies, comments, and version changes after editing. Furthermore, they cannot use third-party EDA (electronic design automation) software to develop additional functionality based on dependencies. Summary of the Invention
[0004] The purpose of the present invention is to overcome the shortcomings of the existing technology and provide a digital development environment integration method to achieve the convenience of improving the HDL language development and design process and the versatility in the face of cross-platform porting;
[0005] In order to achieve the above objectives / solve the above technical problems, the present invention is implemented by adopting the following technical solutions:
[0006] A digital development environment integration method, the method comprising:
[0007] Step a, obtaining software information and project information is to obtain the user's installed software information and the user's project information;
[0008] Step b: Based on the relevant information of the project established by the user, the file structure is automatically constructed, and the project change monitor is enabled to obtain the interdependencies between the design modules;
[0009] Step c: Based on the mutual dependency relationship between the obtained design modules, wait for the user to trigger the relevant functions in the software and complete the corresponding functional services according to the trigger information.
[0010] Optionally, the software information itself includes software version information, installation location and system type.
[0011] Optionally, the project information includes tool chain type, project name, project path, device type and project configuration properties.
[0012] Optionally, step a includes:
[0013] Obtain the user's installed path and the project path built by the user, and then obtain the software version information, library file path, tool chain type, project name, device type, and basic project configuration property information in turn. Together with the system type, they form the operating parameter global variables and are stored in the software backend;
[0014] Obtain all the basic information required to run the entire software through the software installation path, the user project path, and the project configuration property file under the corresponding path.
[0015] Optionally, step b includes:
[0016] The software builds a standard file structure based on the user's project path and project configuration file. The file structure here is also the project structure of the user's entire project, and the project change monitor is enabled. When the user changes a file, the corresponding file will also be changed in the project, so that the user can complete the update of the project structure while building the file structure.
[0017] After the update, the design source files provided by the user are traversed from the file structure and parsed by the parser. The dependency relationships of the parsed results are constructed to obtain the dependency relationships between all modules in the entire project.
[0018] Optionally, step c includes:
[0019] Step Sc1: completing relevant language services according to the trigger information provided by the user;
[0020] Step Sc2: completing related engineering services based on the provided trigger information;
[0021] Step Sc3: Trigger the software to close and save related operations.
[0022] Optionally, step Sc1 includes:
[0023] When the user triggers the language service on the code editing page, this module is enabled and provides the corresponding trigger information. After receiving the trigger information, the software combines the obtained dependencies to complete the language service desired by the user.
[0024] Based on the retained trigger information, a search is performed in the dependency relationships.
[0025] Optionally, if the software obtains the currently typed character, the position of the character in the context, and all the content in the context, the software will infer the content to be completed by the software based on the typed character, the position of the character in the context, and the dependency relationship, and directly help the user complete the code completion; if the software obtains relevant information such as the function name, code file path, etc., the software will complete the corresponding function based on the information obtained and the dependency relationship obtained.
[0026] Optionally, step Sc2 includes:
[0027] This module is enabled and provides corresponding trigger information when the user triggers the engineering service function from the toolbar given in the software interface, the dependency relationship presented in the interface, or the code editing page.
[0028] Optionally, after receiving the trigger information, the software obtains the project configuration properties and dependencies to complete the engineering services required by the user. At the same time, when the project monitor detects changes in the design source files, it will update the changes in the project structure in real time according to the changes.
[0029] Compared with the prior art, the present invention has the following beneficial effects:
[0030] This digital development environment integration method, based on the present invention, enables users to obtain detailed and comprehensive code prompts and completions within a single software, while also providing a documented preview of important information such as the code outline, dependencies, comments, and version changes after editing. Furthermore, during engineering design, this method allows users to focus more on file design and organization, without having to worry about changes to the corresponding third-party EDA software engineering structure. This allows users to quickly build projects and understand their design requirements, significantly improving portability between different digital design solutions. BRIEF DESCRIPTION OF THE DRAWINGS
[0031] Figure 1 Shown is a flow chart of a method for integrating a digital development environment provided by software in an embodiment of the present invention. DETAILED DESCRIPTION
[0032] In order to make the technical means, creative features, objectives and effects achieved by the present invention easier to understand, the present invention is further described below in conjunction with specific implementation methods.
[0033] In the description of the present invention, it should be understood that the terms "center", "longitudinal", "lateral", "up", "down", "front", "back", "left", "right", "vertical", "horizontal", "top", "bottom", "inside", "outside" and the like indicate orientations or positional relationships based on the orientations or positional relationships shown in the accompanying drawings, and are only for the convenience of describing the present invention and simplifying the description, rather than indicating or implying that the device or element referred to must have a specific orientation, be constructed and operated in a specific orientation, and therefore cannot be understood as limiting the present invention. In addition, the terms "first", "second", etc. are only used for descriptive purposes and cannot be understood as indicating or implying relative importance or implicitly indicating the number of the indicated technical features. Therefore, features defined as "first", "second", etc. may explicitly or implicitly include one or more of the features. In the description of the present invention, unless otherwise specified, "multiple" means two or more.
[0034] In the description of the present invention, it should be noted that, unless otherwise expressly specified or limited, the terms "mounted," "connected," and "connected" should be understood in a broad sense. For example, they may refer to fixed connections, detachable connections, or integral connections; mechanical connections or electrical connections; direct connections or indirect connections through an intermediate medium; and internal communication between two components. Those skilled in the art will understand the specific meanings of the above terms in the present invention based on specific circumstances.
[0035] like Figure 1 As shown, a digital development environment integration method is disclosed, comprising the following steps:
[0036] Step 10: The software obtains its own information and project information to obtain the user's installed software and the user's project information.
[0037] Step 20: Based on the user-defined project configuration properties, the software automatically builds the file structure and enables the project change monitor to obtain the interdependencies between modules
[0038] Step 30: The software waits for the user to trigger the relevant function in the software and completes the corresponding functional service according to the trigger information
[0039] Complete relevant language services based on the trigger information provided by the user;
[0040] Complete related engineering services based on the trigger information provided;
[0041] Save related operations when the software is triggered to close.
[0042] In the specific implementation process of this embodiment, step 10 is described as follows:
[0043] Software information includes software version information, installation location, system type, etc.
[0044] Project information includes tool chain type, project name, project path, device type, project configuration properties, etc.
[0045] In this embodiment, obtaining the software information and project information is to obtain the user's own information about the installed software and the user's project information;
[0046] The specific steps are as follows: the software automatically obtains the path installed by the user and the project path built by the user, and based on this, obtains the software version information, library file path, tool chain type, project name, device type, project configuration properties and other basic information, and together with the system type, it forms the OpeParam (operation parameter) global variable and stores it in the software backend.
[0047] Get all the basic information needed to run the entire software through the software installation path, the user project path, and the property.json (project configuration property file) in the corresponding path.
[0048] In the specific implementation process of this embodiment, step 20 is described as follows:
[0049] In order to simplify project design, the software provides a file structure, namely the design method of the project structure. The standard file structure provided by the software is constructed according to the path of the user's project and the project configuration file. At the same time, the file structure here is also the project structure of the user's entire project, and the project change monitor is enabled. When the user makes a file change, the corresponding file will also be changed in the project, so that the user can complete the update of the project structure while completing the construction of the file structure.
[0050] The software will then traverse the design source files provided by the user from the file structure, hand them over to the parser for parsing, and construct dependency relationships based on the parsed results to obtain the dependency relationships between all modules in the entire project.
[0051] In one embodiment, after obtaining the project configuration property file, the software constructs three main folders: .vscode, prj, and user. The .vscode folder contains a project configuration file named property.json. The content of this file is customized by the user and is used to define the properties of the entire project. The specific content has been described in detail in the project information of the S10 module; the prj folder is used to store project files, such as intermediate files when a third-party simulation tool is running or intermediate files generated when a third-party original manufacturer is running; the user folder is used to store user-designed source files, including an ip folder for storing project ip code; a bd folder for storing project block design source code; a data folder for storing data files and constraint files; a sim folder for storing user-designed simulation code; a src folder for storing user design source code; and an sdk folder for storing software or firmware code.
[0052] After building the above file structure, users can place the design content according to the structure definition. At this point, the project has been built for the software. After the user completes the placement, the software will obtain all design sources and send them to the parser backend named lsp-server to parse out the modules contained in each design source file and form a set (module u10: {dependency: {module u11: null, module u12: null},.......}, module u11: {dependency: {},.......}, module u12: {dependency: {module u20: null},.......}, module u20: {dependency: {},.......}) Each module is a data structure, where It includes the names of other dependent modules, their file paths, the parameters defined in the modules, the ports defined in the modules, and other internal information of the modules. At this time, the software will traverse each module and find the corresponding module entity according to the module name it depends on, that is, the entire data structure of the corresponding module name, thus obtaining the entire tree structure that can be searched downward in sequence (module u10: {dependency: {module u11: {dependency: {},.......}, module u12: {dependency: {module u20: {dependency: {},.......}},.......}},.......}). At this point, the dependency relationship between all modules in the entire project is obtained.
[0053] In the specific implementation process of this embodiment, step 30 is described as follows:
[0054] In this embodiment, the software will first present the dependency relationship obtained in S20 to the user through the interface. The user can enable the corresponding service provided by the software from the code editing page, from the dependency relationship presented in the interface, or from the toolbar provided in the software interface. S30 is the process of waiting for the user to trigger the service. The services that the software can provide are specifically divided into three categories: language service, engineering service, and close and save service. The specific implementation methods of each are as follows:
[0055] S31: Complete relevant language services according to the trigger information provided by the user.
[0056] When the user triggers the language service on the code editing page, this module is activated and the corresponding trigger information is provided. After receiving the trigger information, the software combines the dependency relationship obtained in S20 to complete the language service desired by the user.
[0057] In one embodiment: when the user moves the mouse cursor to a certain identifier, the software will extract and retain the string of the identifier, its position in the context, and all the contents of the context. When the user inputs characters on the code editing page, the software will also extract and retain the currently typed characters, the position of the characters in the context, and all the contents of the context. Or the user directly right-clicks the mouse on the code editing page, and the software will give a corresponding function list. The user can directly select the required function in the list and click to complete the function triggering. At this time, the software will retain the function name, code file path and other related information. The above methods are all ways for users to trigger language services, but are not limited to the above three methods.
[0058] Then the software searches in the dependency relationship in S20 according to the retained trigger information, and provides the following but not limited to functional services, such as: when the software obtains the string of the identifier, the position in the context and all the contents of the context, it finds the definition of the identifier according to the dependency relationship, analyzes the context information at the definition, and puts the definition information and the annotation content on the mouse cursor as a prompt, and at the same time the user can jump directly to the definition location through the shortcut key. If the software obtains the currently typed characters, the position of the characters in the context and all the contents of the context, the software will infer the content to be completed by the software based on the typed characters, the position of the characters in the context and the dependency relationship, and directly help the user complete the code completion. If the software obtains relevant information such as the function name, code file path, etc., the software will complete the corresponding function based on the information obtained and the dependency relationship obtained in S20.
[0059] S32: Complete related engineering services according to the provided trigger information.
[0060] When the user triggers the engineering service function from the toolbar on the software interface, the dependency relationship displayed on the interface, or the code editing page, this module is enabled and provides the corresponding trigger information. After receiving the trigger information, the software combines the engineering configuration properties obtained in S10 and the dependency relationship obtained in S20 to complete the engineering service desired by the user:
[0061] 1. Compatible with third-party EDA software and complete corresponding engineering operations in it;
[0062] 2. Realize one-click simulation service;
[0063] 3. Realize one-click project preview.
[0064] At the same time, when the project monitor detects changes in the design source file, it will update the changes in the project structure in real time according to the changes.
[0065] In one embodiment, when a user clicks on a corresponding function service in the toolbar provided by the software interface, the software will complete the corresponding service based on the function information clicked by the user and the project configuration properties obtained in S10. For example, when the user clicks on Generate Project, the software will first obtain the running path of the third-party EDA software from the project configuration properties obtained in S10, then traverse all dependencies and all design source files (design files in folders such as ip, bd, data, sim, src, etc.), and use the docking interface provided by the third-party EDA software to add all the above design source files to the project created by the third-party EDA software, thus completing the project generation. The software provides a set of standard function entries to unify the development of other different FPGA types. The function entry Launch is used to start the entire project. If there is no project, it will be created. If there is one, it will be opened directly. The function entry Refresh is used to refresh the entire project and update the design of the entire project. The function entry Simulate uses the simulation tool that comes with the current tool chain to simulate the entire project. The GUI interface is not opened by default. This function entry also contains two small function entries, one is SimGUI, which opens the GUI interface after the simulation is successful, and the other is SimCLI, which does not open the GUI interface after the simulation is successful. The function entry Build is used to build the entire project and finally output the bitstream file. This function entry also contains 4 small function entries, Synth for project synthesis, Impl for project implementation, Bits for project bitstream file output, Boot for generating curable firmware; Function entry Program, bitstream file download; Function entry Bootload firmware file download, Function entry GUI, open the tool chain GUI interface, Function entry Exit, close the project, and after clicking Exit, the plug-in will automatically move the user's IP and bd design to the user / src / directory. And after the project generation is completed, the project monitor starts to start. When the user moves the design source file, the corresponding monitor will automatically delete the path of the new design source file added at the original address in the third-party EDA software in real time. Similarly, when the user creates or deletes a design source file, the monitor will also automatically create or delete the path of the design source file in the third-party EDA software in real time.
[0066] When the user enables the one-click simulation service in the dependency relationship presented on the interface, the software will use the module clicked by the user as the top-level simulation module, and combine its information with the dependency relationship obtained in S20 to obtain all other dependent modules required for the top-level simulation module. The simulation script is then generated and executed together with the information of the top-level simulation module and its dependent modules to complete the entire one-click simulation service.
[0067] When a user enables the one-click project preview service on the code editing page, the software will use the file path of the code editing page clicked by the user and the dependency relationships obtained by the S20 to find the modules written in the code file and all the dependent files of these modules. Finally, this information is combined with the module information in the code file to generate a document page with diagrams and text for the user to preview the design.
[0068] S33: Trigger software shutdown and save related operations.
[0069] When the user closes the software, the software will save the cache and dependencies locally for use the next time it is reopened.
[0070] The above is only a preferred embodiment of the present invention. It should be pointed out that for ordinary technicians in this technical field, several improvements and modifications can be made without departing from the technical principles of the present invention. These improvements and modifications should also be regarded as the scope of protection of the present invention.
Claims
1. A digital development environment integration method, characterized in that: The method comprises: Step a, obtaining software information and project information is to obtain the user's installed software information and the user's project information; Step b: Based on the relevant information of the project established by the user, the file structure is automatically constructed, and the project change monitor is enabled to obtain the interdependencies between the design modules; Step c: Based on the mutual dependency relationship between the obtained design modules, wait for the user to trigger the relevant functions in the software and complete the corresponding functional services according to the trigger information.
2. The digital development environment integration method according to claim 1, characterized in that: The software information includes software version information, installation location and system type.
3. The digital development environment integration method according to claim 1, characterized in that: The project information includes tool chain type, project name, project path, device type and project configuration properties.
4. The digital development environment integration method according to claim 1, characterized in that: The step a comprises: Obtain the user's installed path and the project path built by the user, and then obtain the software version information, library file path, tool chain type, project name, device type, and basic project configuration property information in turn. Together with the system type, they form the operating parameter global variables and are stored in the software backend; Obtain all the basic information required to run the entire software through the software installation path, the user project path, and the project configuration property file under the corresponding path.
5. The digital development environment integration method according to claim 1, characterized in that: The step b comprises: The software builds a standard file structure based on the user's project path and project configuration file. The file structure here is also the project structure of the user's entire project, and the project change monitor is enabled. When the user changes a file, the corresponding file will also be changed in the project, so that the user can complete the update of the project structure while building the file structure. After the update, the design source files provided by the user are traversed from the file structure and parsed by the parser. The dependency relationships of the parsed results are constructed to obtain the dependency relationships between all modules in the entire project.
6. The digital development environment integration method according to claim 1, characterized in that: The step c comprises: Step Sc1: completing relevant language services according to the trigger information provided by the user; Step Sc2: completing related engineering services based on the provided trigger information; Step Sc3: Trigger the software to close and save related operations.
7. The digital development environment integration method according to claim 6, characterized in that: The step Sc1 comprises: When the user triggers the language service on the code editing page, this module is enabled and provides the corresponding trigger information. After receiving the trigger information, the software combines the obtained dependencies to complete the language service desired by the user. Based on the retained trigger information, a search is performed in the dependency relationships.
8. The digital development environment integration method according to claim 7, characterized in that: If the software obtains the currently typed characters, the position of the characters in the context, and all the content in the context, the software will infer the content to be completed based on the typed characters, the position of the characters in the context, and the dependency relationship, and directly help the user complete the code; if the software obtains relevant information such as the function name, code file path, etc., the software will complete the corresponding function based on the information obtained and the dependency relationship obtained.
9. The digital development environment integration method according to claim 6, characterized in that: The step Sc2 comprises: This module is enabled and provides corresponding trigger information when the user triggers the engineering service function from the toolbar given in the software interface, the dependency relationship presented in the interface, or the code editing page.
10. The digital development environment integration method according to claim 6, characterized in that: After receiving the trigger information, the software obtains the project configuration properties and dependencies to complete the engineering services required by the user. At the same time, when the project monitor detects changes in the design source files, it will update the changes in the project structure in real time according to the changes.