CN117648081B - Visual software integrated development method, system and storage medium - Google Patents
Visual software integrated development method, system and storage medium Download PDFInfo
- Publication number
- CN117648081B CN117648081B CN202410122981.0A CN202410122981A CN117648081B CN 117648081 B CN117648081 B CN 117648081B CN 202410122981 A CN202410122981 A CN 202410122981A CN 117648081 B CN117648081 B CN 117648081B
- Authority
- CN
- China
- Prior art keywords
- code
- design
- state machine
- software
- operation instruction
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
- 238000011161 development Methods 0.000 title claims abstract description 57
- 238000000034 method Methods 0.000 title claims abstract description 48
- 230000000007 visual effect Effects 0.000 title claims abstract description 27
- 238000003860 storage Methods 0.000 title claims abstract description 9
- 238000013461 design Methods 0.000 claims abstract description 188
- 230000006399 behavior Effects 0.000 claims description 126
- 230000006870 function Effects 0.000 claims description 86
- 230000004044 response Effects 0.000 claims description 26
- 238000012545 processing Methods 0.000 claims description 9
- 230000010354 integration Effects 0.000 claims description 8
- 238000004806 packaging method and process Methods 0.000 claims description 8
- 238000012423 maintenance Methods 0.000 abstract description 7
- 230000009471 action Effects 0.000 abstract description 4
- 238000006243 chemical reaction Methods 0.000 abstract description 4
- 238000012800 visualization Methods 0.000 abstract description 4
- 238000005538 encapsulation Methods 0.000 description 6
- 230000007704 transition Effects 0.000 description 6
- 238000010586 diagram Methods 0.000 description 5
- 238000005516 engineering process Methods 0.000 description 5
- 230000008901 benefit Effects 0.000 description 4
- 230000008569 process Effects 0.000 description 4
- 230000007246 mechanism Effects 0.000 description 3
- 230000002093 peripheral effect Effects 0.000 description 3
- 238000000638 solvent extraction Methods 0.000 description 3
- 230000009286 beneficial effect Effects 0.000 description 2
- 238000004590 computer program Methods 0.000 description 2
- 238000010276 construction Methods 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 238000012986 modification Methods 0.000 description 2
- 238000011022 operating instruction Methods 0.000 description 2
- 238000013459 approach Methods 0.000 description 1
- 230000003542 behavioural effect Effects 0.000 description 1
- 230000008859 change Effects 0.000 description 1
- 238000004891 communication Methods 0.000 description 1
- 230000000295 complement effect Effects 0.000 description 1
- 230000007547 defect Effects 0.000 description 1
- 230000001627 detrimental effect Effects 0.000 description 1
- 238000009826 distribution Methods 0.000 description 1
- 230000006872 improvement Effects 0.000 description 1
- 210000001503 joint Anatomy 0.000 description 1
- 238000004519 manufacturing process Methods 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 238000005457 optimization Methods 0.000 description 1
- 238000012360 testing method Methods 0.000 description 1
Landscapes
- Stored Programmes (AREA)
Abstract
The invention belongs to the technical field of software development, and particularly discloses a visual software integrated development method, a visual software integrated development system and a visual software integrated development storage medium; the development mode of two-dimensional visualization comprising a state machine and a behavior tree is combined on the basis of the development of the software code in the traditional one-dimensional text form, so that the speed of software function identification, code understanding and code design can be greatly improved, and the software development efficiency is improved; because the state machine and the action tree are graphical expression forms, the method has good intuitiveness, the whole situation of the software project is clear at a glance, the development personnel can easily grasp the conversion between the states and the task execution, the maintenance and the handover of the software project are easier, and even if the development personnel or the maintenance personnel are replaced by the later software project, the structure of the project can be grasped very quickly for the person who contacts the project for the first time, so that the time and the cost are saved, and the efficiency is improved.
Description
Technical Field
The invention belongs to the technical field of software development, and particularly relates to a visual software integrated development method, a visual software integrated development system and a storage medium.
Background
With the continuous development of information technology, various industries are free from developing software. Currently, a large number of people are engaged in software development work, and this number is continuously increasing with advances in information technology. Software design and development has penetrated into various industries such as education, finance, manufacturing, logistics, medical, etc.
Currently, popular integrated development environments in the field of software development include Visual Studio Code, visual C++, qt Creator, eclipse and the like, and most of these stations focus on auxiliary functions of codes, such as grammar highlighting, code complement, intelligent prompt and the like, in terms of development, and the defect that the intuitiveness of the codes cannot be greatly improved as long as the codes do not deviate from texts.
The code text information is one-dimensional, a developer needs to read row by row to clear the logic flow, for a huge software system, different functional modules have different importance degrees, the text-form code cannot directly show the primary-secondary relationship and the logic relationship, and the developer needs to read more carefully to slowly understand the functional distribution of the software and the general context of the running logic. This results in inefficient development of the software project and is detrimental to subsequent maintenance and handover of the software project.
Disclosure of Invention
The invention aims to provide a visual software integrated development method, a visual software integrated development system and a storage medium, which are used for solving the problems in the prior art.
In order to achieve the above purpose, the present invention adopts the following technical scheme:
in a first aspect, a method for developing visual software integration is provided, including:
Acquiring the design content of the software project, and visually displaying the design content of the software project;
receiving a software function module dividing parameter set input by a user, wherein the software function module dividing parameter comprises a code part dividing parameter, a state machine part dividing parameter and a behavior tree part dividing parameter;
Determining a code writing functional module of the software project according to the code part dividing parameters, determining a state machine design functional module of the software project according to the state machine part dividing parameters, and determining a behavior tree design functional module of the software project according to the behavior tree part dividing parameters;
Acquiring a written code input by a user in a code writing functional module, and configuring the code writing functional module by using the written code;
the method comprises the steps of calling a state machine to visually perform software logic graphical description in response to a first operation instruction of a user, generating a state machine design code according to a software logic graphical description result, and configuring the state machine design function module by using the state machine design code;
calling a behavior tree to visually perform software logic tree description in the behavior tree design function module in response to a second operation instruction of a user, generating a behavior tree design code according to a software logic tree description result, and configuring the behavior tree design function module by using the behavior tree design code;
And responding to compiling instructions of users, compiling codes corresponding to the code compiling functional modules, state machine design codes corresponding to the state machine design functional modules and behavior tree design codes corresponding to the behavior tree design functional modules into running programs through a compiler, and generating executable files according to the running programs.
In one possible design, the method further comprises:
Calling a corresponding packed code module in a function module library to configure the code writing function module in response to a third operation instruction of a user, wherein the third operation instruction comprises a drag operation instruction;
Calling a corresponding state machine design code module packaged in a function module library to configure a state machine design function module in response to a fourth operation instruction of a user, wherein the fourth operation instruction comprises a drag operation instruction;
And in the behavior tree design function module, calling a corresponding behavior tree design code module packaged in the function module library to configure the behavior tree design function module in response to a fifth operation instruction of a user, wherein the fifth operation instruction comprises a drag operation instruction.
In one possible design, the method further comprises:
packaging the corresponding writing codes of the code writing functional module into corresponding writing code modules, and storing the writing code modules into a functional module library;
Packaging state machine design codes corresponding to the state machine design function modules into corresponding state machine design code modules, and storing the state machine design code modules into a function module library;
And packaging the behavior tree design codes corresponding to the behavior tree design function modules into corresponding behavior tree design code modules, and storing the behavior tree design code modules into a function module library.
In one possible design, the method further comprises:
When configuring the code writing functional module, responding to a sixth operation instruction of a user, and nesting the packaged state machine design code module and/or the behavior tree design code module in the code writing functional module, wherein the sixth operation instruction comprises a drag operation instruction;
When configuring the state machine design function module, responding to a seventh operation instruction of a user, and nesting the packaged writing code module and/or the behavior tree design code module in the state machine design function module, wherein the seventh operation instruction comprises a drag operation instruction;
when configuring the behavior tree design function module, the packaged writing code module and/or the state machine design code module are nested in the behavior tree design function module in response to an eighth operation instruction of a user, wherein the eighth operation instruction comprises a drag operation instruction.
In one possible design, the first and second operating instructions each comprise a drag operating instruction.
In one possible design, the method is performed in an integrated development environment, the method further comprising: and calling a code auxiliary function component of the integrated development environment to perform corresponding code auxiliary processing on the written code, the state machine design code and the behavior tree design code in response to a ninth operation instruction of the user.
In one possible design, after generating the executable file, the method further comprises: and executing the executable file, and visually displaying the execution result of the executable file.
In a second aspect, a visual software integrated development system is provided, including an acquisition unit, a receiving unit, a dividing unit, a first design unit, a second design unit, a third design unit, and a compiling unit, wherein:
the acquisition unit is used for acquiring the design content of the software project and visually displaying the design content of the software project;
the system comprises a receiving unit, a processing unit and a processing unit, wherein the receiving unit is used for receiving a software function module dividing parameter set input by a user, and the software function module dividing parameter comprises a code part dividing parameter, a state machine part dividing parameter and a behavior tree part dividing parameter;
The dividing unit is used for determining a code writing functional module of the software project according to the code part dividing parameters, determining a state machine design functional module of the software project according to the state machine part dividing parameters and determining a behavior tree design functional module of the software project according to the behavior tree part dividing parameters;
The first design unit is used for acquiring a written code input by a user from the code writing functional module and configuring the code writing functional module by using the written code;
The second design unit is used for calling the state machine to visually perform software logic graphical description in response to a first operation instruction of a user, generating a state machine design code according to a software logic graphical description result, and configuring the state machine design function module by utilizing the state machine design code;
The third design unit is used for calling the behavior tree to visually perform software logic tree description in response to a second operation instruction of the user in the behavior tree design function module, generating a behavior tree design code according to a software logic tree description result, and configuring the behavior tree design function module by utilizing the behavior tree design code;
And the compiling unit is used for responding to compiling instructions of users, compiling codes corresponding to the compiling functional modules, state machine design codes corresponding to the state machine design functional modules and behavior tree design codes corresponding to the behavior tree design functional modules into running programs through a compiler, and generating executable files according to the running programs.
In a third aspect, a visual software integration development system is provided, including:
A memory for storing execution instructions;
and a processor for reading the execution instruction stored in the memory and executing the method according to any one of the first aspect.
In a fourth aspect, there is provided a computer readable storage medium having stored thereon execution instructions which, when run on a computer, cause the computer to perform the method of any of the first aspects. Also provided is a computer program product comprising instructions which, when run on a computer, cause the computer to perform the method of any of the first aspects.
The beneficial effects are that: according to the invention, on the basis of the development of the software code in the traditional one-dimensional text form, the speed of software function identification, code understanding and code design can be greatly improved by combining the two-dimensional visual development mode comprising a state machine and a behavior tree, and the software development efficiency is improved. Meanwhile, the state machine and the behavior tree are graphical expression forms, so that the method has good intuitiveness, the whole situation of the software project is clear at a glance, developers can easily grasp the conversion between states and the task execution, the maintenance and the handover of the software project are easier, and even if the developers or maintenance personnel are replaced by the later software project, the structure of the project can be grasped very quickly for the person who contacts the project for the first time, so that the time and the cost are saved, and the efficiency is improved.
Drawings
In order to more clearly illustrate the embodiments of the invention or the technical solutions in the prior art, the drawings that are required in the embodiments or the description of the prior art will be briefly described, it being obvious that the drawings in the following description are only some embodiments of the invention, and that other drawings may be obtained according to these drawings without inventive effort for a person skilled in the art.
FIG. 1 is a schematic diagram showing the steps of the method of example 1 of the present invention;
FIG. 2 is a schematic diagram showing the construction of a system in embodiment 2 of the present invention;
FIG. 3 is a schematic diagram showing the construction of a system in embodiment 3 of the present invention.
Detailed Description
It should be noted that the description of these examples is for aiding in understanding the present invention, but is not intended to limit the present invention. Specific structural and functional details disclosed herein are merely representative of example embodiments of the invention. This invention may, however, be embodied in many alternate forms and should not be construed as limited to the embodiments set forth herein.
It will be appreciated that the term "coupled" is to be interpreted broadly, and may be a fixed connection, a removable connection, or an integral connection, for example, unless explicitly stated and limited otherwise; can be mechanically or electrically connected; can be directly connected or indirectly connected through an intermediate medium, and can be communication between two elements. The specific meaning of the terms in the embodiments can be understood by those of ordinary skill in the art according to the specific circumstances.
In the following description, specific details are provided to provide a thorough understanding of example embodiments. However, it will be understood by those of ordinary skill in the art that the example embodiments may be practiced without these specific details. For example, a system may be shown in block diagrams in order to avoid obscuring the examples with unnecessary detail. In other embodiments, well-known processes, structures, and techniques may be shown without unnecessary detail in order to avoid obscuring the embodiments.
Example 1:
The present embodiment provides a visual software integrated development method, which can be applied to a corresponding software development terminal, where the terminal deploys an integrated development environment (INTEGRATED DEVELOPMENT ENVIRONMENT, abbreviated as IDE, which is an integrated software development tool, and can help developers to perform software development work, provide text editing, debugging, compiling, compiler and other development tools, greatly reduce development time and cost, and provide high-quality results), and based on the existing IDE technology, use a state machine and a behavior tree to perform function expansion. As shown in fig. 1, the method comprises the steps of:
S1, acquiring design content of a software project, and visually displaying the design content of the software project.
In the implementation, the software project design content is acquired firstly, and then the software project design content is visually displayed, so that a user can divide corresponding software function modules according to the displayed software project design content.
S2, receiving a software function module dividing parameter set input by a user, wherein the software function module dividing parameter comprises a code part dividing parameter, a state machine part dividing parameter and a behavior tree part dividing parameter.
In specific implementation, a software function module division parameter set fed back and input by a user is received, wherein the software function module division parameters comprise a code part division parameter, a state machine part division parameter and a behavior tree part division parameter.
S3, determining a code writing functional module of the software project according to the code part dividing parameters, determining a state machine design functional module of the software project according to the state machine part dividing parameters, and determining a behavior tree design functional module of the software project according to the behavior tree part dividing parameters.
In particular, code writing function modules of the software items may be determined based on the code portion partitioning parameters, state machine design function modules of the software items may be determined based on the state machine portion partitioning parameters, and behavior tree design function modules of the software items may be determined based on the behavior tree portion partitioning parameters. For software project design, the main functional module can be designed by adopting a visual state machine and a behavior tree, and the secondary functional module can be written by adopting traditional codes, so that the main and secondary states are kept clear.
S4a, acquiring a written code input by a user in the code writing functional module, and configuring the code writing functional module by using the written code.
In specific implementation, for the code writing functional module, the terminal can acquire writing codes input by a user, and the code writing functional module is configured by using the writing codes; and, the corresponding code writing code of the code writing functional module can be packaged into the corresponding code writing module, and the code writing module is stored in the functional module library. Or may call a corresponding written code module packaged in the library of functional modules to configure the code written functional module in response to a third operational instruction by the user, the third operational instruction comprising a drag-type operational instruction.
S4b, in the state machine design function module, responding to a first operation instruction of a user, calling the state machine to visually perform software logic graphical description, generating a state machine design code according to a software logic graphical description result, and configuring the state machine design function module by using the state machine design code.
In the specific implementation, for the state machine design function module, the state machine can be called to carry out visual software logic graphical description in response to a first operation instruction of a user, a state machine design code is generated according to a software logic graphical description result, the state machine design function module is configured by using the state machine design code, and the first operation instruction comprises a drag operation instruction; and, the state machine design code corresponding to the state machine design function module can be packaged into the corresponding state machine design code module, and the state machine design code module is stored in the function module library. Or may call the corresponding state machine design code module packaged in the function module library to configure the state machine design function module in response to a fourth operation instruction by the user, the fourth operation instruction including a drag operation instruction.
A state machine is a model for describing and controlling a system that can help developers achieve behavior management and state transitions of the system. The state machine can bring the following benefits to development: the system has strong readability, the structure of the state machine is clear, and the state conversion of the system is displayed in a visual mode, so that the internal logic of the system is clearer and more understandable. It is easy to understand and debug that each state of the state machine is independent, transitions between states depend on specific input events, and this architecture makes the functions and states of the system more obvious, facilitating debugging and testing. The reusability is strong, the state machine can well describe and manage the state of the system, and repeated development labor can be reduced and development efficiency is improved through encapsulation and reuse. The expansibility is strong, the design of the state machine is very flexible, new states and transition events can be added according to the needs, and the system is suitable for the change and development of the system. The visualization degree is high, and the workflow of the state machine can be conveniently observed and adjusted through the visualization tool, so that the development and optimization are convenient. In general, the state machine can effectively improve the readability, maintainability and expandability of the system, reduce the development cost and risk, and has high practical value for the development of software and hardware.
S4c, calling the behavior tree to visually perform software logic tree description in the behavior tree design function module in response to a second operation instruction of the user, generating a behavior tree design code according to a software logic tree description result, and configuring the behavior tree design function module by using the behavior tree design code.
In the implementation, for the behavior tree design function module, the behavior tree can be called to visually perform software logic tree description in response to a second operation instruction of a user, a behavior tree design code is generated according to a software logic tree description result, and the behavior tree design function module is configured by utilizing the behavior tree design code, wherein the second operation instruction comprises a drag operation instruction; and, the behavior tree design codes corresponding to the behavior tree design function modules can be packaged into corresponding behavior tree design code modules, and the behavior tree design code modules are stored in the function module library. Or may call the corresponding behavior tree design code module packaged in the function module library to configure the behavior tree design function module in response to a fifth operation instruction of the user, the fifth operation instruction including a drag operation instruction.
Behavior trees are a formalized graphical modeling language that uses well-defined symbols to explicitly represent hundreds or even thousands of natural language requirements that are commonly used to express stakeholder requirements for large-scale software integrated systems. The behavior tree can bring the following benefits to the development: it is easy to understand and maintain, the behavior tree is a tree structure composed of individual nodes, each node representing a behavior, and the branches representing the conditions of the behavior. This approach makes the behavioral tree easy to understand and maintain, reducing the possibility of error. The behavior tree is easy to expand and modify, and has good expandability and modification. The behavior of the behavior tree can be extended or modified by adding or deleting a node. Parallel execution is supported, parallel execution is supported by the behavior tree, and a plurality of nodes can be executed simultaneously, so that the running speed of a program can be increased. Supporting decision logic, the behavior tree can also be used to implement decision logic, and the optimal behavior can be selected according to the current state and condition.
Both behavior trees and state machines are models that describe the state of the system and its transitions, but they differ as follows:
Architecture: the behavior tree is a tree structure, consisting of leaf nodes and parent nodes, and the state machine is a finite state automaton, which uses the concept of a turing machine to describe the transitions between states.
The use scenario: the behavior tree is more suitable for describing complex decision processes, and the state machine is more suitable for describing single behaviors or states.
Update mechanism: the behavior tree is updated under given conditions, and the state machine performs state transition based on event triggering.
Control mechanism: the behavior tree control algorithm is more complex, and the state machine control mechanism is relatively simple.
The two technologies have advantages and disadvantages and are suitable for different application scenes, so that the method uses the state machine and the behavior tree to carry out software design.
The software design of the method starts from three aspects, namely a code part, a state machine part and a behavior tree part; the code part mainly comprises code writing, including division, inheritance, polymorphism application and the like of functions, classes and modules; the state machine part mainly describes the relation among the parts of the system through a state machine and determines when and what operation the system performs; the behavior tree part describes complex logic and decision process by adopting a tree diagram mode. The design configuration of the code writing functional module, the state machine design functional module and the behavior tree design functional module can be mutually applied in a nested mode; that is, in the code section, the abstract concepts of state machines and behavior trees can be used for flow control; in the state machine part, the functions of codes and behavior trees can be utilized; in the part of the behavior tree, the expansion can be performed by calling codes or state machines; in general, these three techniques combine to provide a complete software design. But the mutual nesting references of the three are to be based on the completion of the encapsulation of the corresponding functional modules: namely, when configuring the code writing functional module, responding to a sixth operation instruction of a user, and nesting the packaged state machine design code module and/or the behavior tree design code module in the code writing functional module, wherein the sixth operation instruction comprises a drag operation instruction; when configuring the state machine design function module, responding to a seventh operation instruction of a user, and nesting the packaged writing code module and/or the behavior tree design code module in the state machine design function module, wherein the seventh operation instruction comprises a drag operation instruction; when configuring the behavior tree design function module, the packaged writing code module and/or the state machine design code module are nested in the behavior tree design function module in response to an eighth operation instruction of a user, wherein the eighth operation instruction comprises a drag operation instruction.
The encapsulation of the functional modules means hiding the implementation details of the code and providing only the necessary interfaces and methods for the external user. In this way, the encapsulation may improve maintainability and scalability of the code and may be beneficial in preventing data leakage, and may also help developers save time and effort, as they need only focus on the core functionality of the code, and not on implementation details. The advantages of the package are as follows: 1. the maintainability is improved; by packaging, a developer can put focus on core functionality without spending too much time considering implementation details. 2. Scalability; packaged code is easier to expand because they can reuse existing components and modules without having to re-write all code. 3. Data security; through encapsulation, developers can avoid accessing unnecessary data, and the risk of data leakage is reduced. 5. Time is saved; the packaging can shorten the development period and improve the development efficiency. 6. Cross-platform compatibility; the encapsulation may enable cross-platform compatibility, which may improve the usability of the code.
State machines and action trees are only parts of the software design that cannot be directly changed into actual programs themselves, and therefore, when software design is performed by using state machines and action trees, logic described by the state machines and action trees needs to be converted into specific codes by means of corresponding code generation technologies so as to configure corresponding design functional modules. The terminal responds to various operation instructions of the user and can comprise a drag type operation instruction, the drag type operation is a user-friendly and visual operation mode, the use experience of the user can be simplified, and the operation efficiency is improved.
S5, responding to compiling instructions of users, compiling codes corresponding to all code compiling functional modules, state machine design codes corresponding to all state machine design functional modules and behavior tree design codes corresponding to all behavior tree design functional modules into running programs through a compiler, and generating executable files according to the running programs.
In specific implementation, the terminal responds to a compiling instruction of a user, compiles compiling codes corresponding to all code compiling functional modules, state machine design codes corresponding to all state machine design functional modules and behavior tree design codes corresponding to all behavior tree design functional modules into an operating program through a compiler, and then generates an executable file according to the operating program to complete software development. After the executable file is developed and generated, the terminal executes the executable file and visually displays the execution result of the executable file so that a developer can check the execution result.
The method is carried out under an Integrated Development Environment (IDE), and in the process, a code auxiliary functional component of the integrated development environment can be called in response to a ninth operation instruction of a user to carry out corresponding code auxiliary processing on written codes, state machine design codes and behavior tree design codes. The various auxiliary functions provided by the traditional integrated development environment are verified practical functions, and the method does not discard the characteristics, but inherits and promotes the characteristics, and the functions include but are not limited to: text editing, file management, grammar highlighting, code completion, intelligent hints, breakpoint windows, call stack windows, monitor windows, and the like.
The method of the embodiment can greatly improve the speed of software function identification, code understanding and code design and improve the software development efficiency by combining the development mode of two-dimensional visualization comprising a state machine and a behavior tree on the basis of the development of the software code in the traditional one-dimensional text form. Meanwhile, the state machine and the behavior tree are graphical expression forms, so that the method has good intuitiveness, the whole situation of the software project is clear at a glance, developers can easily grasp the conversion between states and the task execution, the maintenance and the handover of the software project are easier, and even if the developers or maintenance personnel are replaced by the later software project, the structure of the project can be grasped very quickly for the person who contacts the project for the first time, so that the time and the cost are saved, and the efficiency is improved.
Example 2:
the embodiment provides a visual software integrated development system, as shown in fig. 2, including an acquisition unit, a receiving unit, a dividing unit, a first design unit, a second design unit, a third design unit and a compiling unit, wherein:
the acquisition unit is used for acquiring the design content of the software project and visually displaying the design content of the software project;
the system comprises a receiving unit, a processing unit and a processing unit, wherein the receiving unit is used for receiving a software function module dividing parameter set input by a user, and the software function module dividing parameter comprises a code part dividing parameter, a state machine part dividing parameter and a behavior tree part dividing parameter;
The dividing unit is used for determining a code writing functional module of the software project according to the code part dividing parameters, determining a state machine design functional module of the software project according to the state machine part dividing parameters and determining a behavior tree design functional module of the software project according to the behavior tree part dividing parameters;
The first design unit is used for acquiring a written code input by a user from the code writing functional module and configuring the code writing functional module by using the written code;
The second design unit is used for calling the state machine to visually perform software logic graphical description in response to a first operation instruction of a user, generating a state machine design code according to a software logic graphical description result, and configuring the state machine design function module by utilizing the state machine design code;
The third design unit is used for calling the behavior tree to visually perform software logic tree description in response to a second operation instruction of the user in the behavior tree design function module, generating a behavior tree design code according to a software logic tree description result, and configuring the behavior tree design function module by utilizing the behavior tree design code;
And the compiling unit is used for responding to compiling instructions of users, compiling codes corresponding to the compiling functional modules, state machine design codes corresponding to the state machine design functional modules and behavior tree design codes corresponding to the behavior tree design functional modules into running programs through a compiler, and generating executable files according to the running programs.
Example 3:
the embodiment provides a visual software integrated development system, as shown in fig. 3, at a hardware level, including:
the data interface is used for establishing data butt joint between the processor and the user peripheral equipment;
A memory for storing execution instructions;
And the processor is used for reading the execution instruction stored in the memory and executing the visual software integration development method in the embodiment 1 according to the execution instruction.
Optionally, the system further comprises an internal bus. The processor and memory and data interfaces may be interconnected by an internal bus, which may be an ISA (Industry Standard Architecture ) bus, a PCI (PERIPHERAL COMPONENT INTERCONNECT, peripheral component interconnect standard) bus, or EISA (Extended Industry Standard Architecture ) bus, among others. The buses may be classified as address buses, data buses, control buses, etc.
The Memory may include, but is not limited to, random access Memory (Random Access Memory, RAM), read Only Memory (ROM), flash Memory (Flash Memory), first-in first-Out Memory (First Input First Output, FIFO), and/or first-in last-Out Memory (FIRST IN LAST Out, FILO), etc. The processor may be a general-purpose processor including a central processing unit (Central Processing Unit, CPU), a network processor (Network Processor, NP), etc.; but may also be a digital signal Processor (DIGITAL SIGNAL Processor, DSP), application SPECIFIC INTEGRATED Circuit (ASIC), field-Programmable gate array (Field-Programmable GATE ARRAY, FPGA) or other Programmable logic device, discrete gate or transistor logic device, discrete hardware components.
Example 4:
The present embodiment provides a computer-readable storage medium having stored thereon execution instructions that, when executed on a computer, cause the computer to execute the visualization software integration development method in embodiment 1. The computer readable storage medium refers to a carrier for storing data, and may include, but is not limited to, a floppy disk, an optical disk, a hard disk, a flash Memory, and/or a Memory Stick (Memory Stick), etc., where the computer may be a general purpose computer, a special purpose computer, a computer network, or other programmable system.
The present embodiment also provides a computer program product comprising execution instructions that, when executed on a computer, cause the computer to perform the visualization software integration development method of embodiment 1. Wherein the computer may be a general purpose computer, a special purpose computer, a computer network, or other programmable system.
Finally, it should be noted that: the foregoing description is only of the preferred embodiments of the invention and is not intended to limit the scope of the invention. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of the present invention should be included in the protection scope of the present invention.
Claims (7)
1. The visual software integrated development method is characterized by comprising the following steps of:
Acquiring the design content of the software project, and visually displaying the design content of the software project;
receiving a software function module dividing parameter set input by a user, wherein the software function module dividing parameter comprises a code part dividing parameter, a state machine part dividing parameter and a behavior tree part dividing parameter;
Determining a code writing functional module of the software project according to the code part dividing parameters, determining a state machine design functional module of the software project according to the state machine part dividing parameters, and determining a behavior tree design functional module of the software project according to the behavior tree part dividing parameters;
Acquiring a written code input by a user in a code writing functional module, and configuring the code writing functional module by using the written code;
the method comprises the steps of calling a state machine to visually perform software logic graphical description in response to a first operation instruction of a user, generating a state machine design code according to a software logic graphical description result, and configuring the state machine design function module by using the state machine design code;
calling a behavior tree to visually perform software logic tree description in the behavior tree design function module in response to a second operation instruction of a user, generating a behavior tree design code according to a software logic tree description result, and configuring the behavior tree design function module by using the behavior tree design code;
Responding to compiling instructions of users, compiling codes corresponding to all code compiling functional modules, state machine design codes corresponding to all state machine design functional modules and behavior tree design codes corresponding to all behavior tree design functional modules into running programs through a compiler, and generating executable files according to the running programs;
Packaging the writing codes corresponding to the code writing functional modules into corresponding writing code modules, storing the writing code modules into a functional module library, packaging the state machine design codes corresponding to the state machine design functional modules into corresponding state machine design code modules, storing the state machine design code modules into a functional module library, packaging the behavior tree design codes corresponding to the behavior tree design functional modules into corresponding behavior tree design code modules, and storing the behavior tree design code modules into a functional module library;
When configuring the code writing functional module, responding to a sixth operation instruction of a user, and nesting the packaged state machine design code module and/or the behavior tree design code module in the code writing functional module, wherein the sixth operation instruction comprises a drag operation instruction;
When configuring the state machine design function module, responding to a seventh operation instruction of a user, and nesting the packaged writing code module and/or the behavior tree design code module in the state machine design function module, wherein the seventh operation instruction comprises a drag operation instruction;
when configuring the behavior tree design function module, the packaged writing code module and/or the state machine design code module are nested in the behavior tree design function module in response to an eighth operation instruction of a user, wherein the eighth operation instruction comprises a drag operation instruction.
2. The method for integrated development of visual software according to claim 1, further comprising:
Calling a corresponding packed code module in a function module library to configure the code writing function module in response to a third operation instruction of a user, wherein the third operation instruction comprises a drag operation instruction;
Calling a corresponding state machine design code module packaged in a function module library to configure a state machine design function module in response to a fourth operation instruction of a user, wherein the fourth operation instruction comprises a drag operation instruction;
And in the behavior tree design function module, calling a corresponding behavior tree design code module packaged in the function module library to configure the behavior tree design function module in response to a fifth operation instruction of a user, wherein the fifth operation instruction comprises a drag operation instruction.
3. The method of claim 1, wherein the first operation instruction and the second operation instruction each comprise a drag operation instruction.
4. The method of claim 1, wherein the method is performed in an integrated development environment, the method further comprising: and calling a code auxiliary function component of the integrated development environment to perform corresponding code auxiliary processing on the written code, the state machine design code and the behavior tree design code in response to a ninth operation instruction of the user.
5. The method for integrated development of visual software according to claim 1, wherein after generating the executable file, the method further comprises: and executing the executable file, and visually displaying the execution result of the executable file.
6. A visualization software integration development system, comprising:
A memory for storing execution instructions;
And the processor is used for reading the execution instruction stored in the memory and executing the visual software integration development method according to any one of the claims 1-5 according to the execution instruction.
7. A computer readable storage medium having stored thereon execution instructions which, when executed on a computer, cause the computer to perform the visualization software integration development method of any one of claims 1-5.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202410122981.0A CN117648081B (en) | 2024-01-30 | 2024-01-30 | Visual software integrated development method, system and storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202410122981.0A CN117648081B (en) | 2024-01-30 | 2024-01-30 | Visual software integrated development method, system and storage medium |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN117648081A CN117648081A (en) | 2024-03-05 |
| CN117648081B true CN117648081B (en) | 2024-05-07 |
Family
ID=90045490
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202410122981.0A Active CN117648081B (en) | 2024-01-30 | 2024-01-30 | Visual software integrated development method, system and storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN117648081B (en) |
Citations (7)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN113703749A (en) * | 2021-09-06 | 2021-11-26 | 河北雄安新区公安局 | Information system based on visual programming technology and construction method thereof |
| CN113946343A (en) * | 2021-10-15 | 2022-01-18 | 国汽智控(北京)科技有限公司 | Method and device for generating automatic driving code model based on behavior tree |
| CN115964033A (en) * | 2023-01-16 | 2023-04-14 | 北京计算机技术及应用研究所 | Model-based visual software development tool implementation method |
| WO2023142061A1 (en) * | 2022-01-29 | 2023-08-03 | 西门子股份公司 | Workflow generation method, device and system, medium, and program product |
| CN116775012A (en) * | 2023-05-17 | 2023-09-19 | 北京仿真中心 | Visual model construction system |
| CN117215558A (en) * | 2023-09-26 | 2023-12-12 | 中国建设银行股份有限公司 | Visual software development method, device, equipment and medium for android |
| CN117369788A (en) * | 2023-10-13 | 2024-01-09 | 成都市运泰利自动化设备有限公司 | Drag type business logic editing system method |
-
2024
- 2024-01-30 CN CN202410122981.0A patent/CN117648081B/en active Active
Patent Citations (7)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN113703749A (en) * | 2021-09-06 | 2021-11-26 | 河北雄安新区公安局 | Information system based on visual programming technology and construction method thereof |
| CN113946343A (en) * | 2021-10-15 | 2022-01-18 | 国汽智控(北京)科技有限公司 | Method and device for generating automatic driving code model based on behavior tree |
| WO2023142061A1 (en) * | 2022-01-29 | 2023-08-03 | 西门子股份公司 | Workflow generation method, device and system, medium, and program product |
| CN115964033A (en) * | 2023-01-16 | 2023-04-14 | 北京计算机技术及应用研究所 | Model-based visual software development tool implementation method |
| CN116775012A (en) * | 2023-05-17 | 2023-09-19 | 北京仿真中心 | Visual model construction system |
| CN117215558A (en) * | 2023-09-26 | 2023-12-12 | 中国建设银行股份有限公司 | Visual software development method, device, equipment and medium for android |
| CN117369788A (en) * | 2023-10-13 | 2024-01-09 | 成都市运泰利自动化设备有限公司 | Drag type business logic editing system method |
Also Published As
| Publication number | Publication date |
|---|---|
| CN117648081A (en) | 2024-03-05 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN105022630B (en) | A kind of assembly management system and assembly management method | |
| CN105739983B (en) | Shell script editing device and its implementation | |
| US20140359569A1 (en) | Graphical function specialization | |
| CN106293664A (en) | Code generating method and device | |
| JP2005530238A (en) | Systems, methods, and media for providing dynamic model / code binding | |
| EP1576439A2 (en) | A method, a language and a system for the definition and implementation of software solutions | |
| Gonzalez et al. | Verifying GSM-based business artifacts | |
| CN104133588B (en) | A kind of protective relaying device graphical development method based on script | |
| US10585648B2 (en) | Systems and methods for aggregating implicit and explicit event code of executable models | |
| CN108037913B (en) | Method for converting xUML4MC model into MSVL (modeling, simulation and verification language) program and computer-readable storage medium | |
| CN112148278A (en) | Visual block chain intelligent contract framework and intelligent contract development and deployment method | |
| CN109032056B (en) | Programmable logic controller programming language conversion method | |
| CN111880784A (en) | SIMSCRIPT language-oriented discrete event simulation graphical modeling method | |
| Hopsu et al. | On portability of IEC 61499 compliant structures and systems | |
| CN108959058B (en) | Configuration debugger implementation method of virtual controller | |
| CN107479866A (en) | The method that open terminal applies data and function are realized based on reconfiguration technique | |
| CN105573763B (en) | A kind of Embedded System Modeling method for supporting RTOS | |
| CN117648081B (en) | Visual software integrated development method, system and storage medium | |
| Herrmannsdörfer et al. | Library concepts for model reuse | |
| Serna et al. | Dash: A new language for declarative behavioural requirements with control state hierarchy | |
| CN112784417B (en) | Avionics distributed joint simulation method and system based on SysML | |
| Vepsäläinen et al. | Tool support for the UML automation profile-for domain-specific software development in manufacturing | |
| JP2010049439A (en) | System construction method using software model and modeling device | |
| Apostol et al. | UML to code, and code to UML, a view inside implementation challenges and cost | |
| Hawa | A Graphical User Interface for the ns-3 Simulator |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |