Finite-state machine automatic generation method and system and related equipment

Abstract

The invention relates to the technical field of embedded software development, and discloses a finite-state machine automatic generation method and system and related equipment, and the method comprises the steps: obtaining a table path corresponding to a preset table; wherein the configuration generated by the state machine code framework filled by the user is stored in the preset table; on the basis of the table path, configuration in a preset table is captured through a python script, and a state machine code framework is generated; and storing the state machine code framework in a preset storage path specified by a user, so that the user can check the state machine code framework. According to the method and the device, the state machine code framework is automatically generated through the script written by the python language, so that the complexity of personally writing the code by a developer is avoided, and the development efficiency is improved.

Description

Technical Field

[0001] The present disclosure relates to the technical field of embedded software development, and in particular to a finite state machine automatic generation method, system, and related equipment. Background Art

[0002] A finite state machine (FSM) is a computational model that has a finite number of states at any given moment. It consists of a set of states, a set of input symbols, a set of transition rules, an initial state, and a set of accepting states. FSMs are often used to describe systems or processes that can be represented by a finite number of states. They are characterized by a limited number of states, state transition rules, and a wide range of applications. A FSM has a finite set of states, typically representing different states of a system. Based on the current state and input symbols, the machine can transition between states, making it widely used in compiler design, automatic control systems, protocol analysis, and other fields. Based on the relationship between input and output, FSMs can be further divided into Mealy and Moore state machines. The output of the former depends not only on the current state but also on the current input; the output of the latter depends solely on the current state and is independent of the input.

[0003] The code structure of most communication systems using state machines typically requires defining state attributes and incorporating them into a data structure that acts as a controller. During runtime, this controller controls state changes based on conditions and performs corresponding actions within each state to complete the communication system's tasks. However, for developers, building state machine code requires defining the state machine code framework in real time, which not only consumes a lot of time but also reduces development efficiency. Summary of the Invention

[0004] In order to overcome the problem that the code framework of the state machine needs to be defined in real time during the process of building the state machine code, which consumes a lot of time and reduces development efficiency, the present disclosure provides a finite state machine automatic generation method, system and related equipment.

[0005] In a first aspect, in order to solve the above technical problems, the present disclosure provides a method for automatically generating a finite state machine, comprising:

[0006] Get the table path corresponding to the preset table; wherein the preset table stores the configuration generated by the state machine code framework filled in by the user;

[0007] Based on the table path, the configuration in the preset table is captured through the Python script to generate the state machine code framework;

[0008] The state machine code framework is stored in a preset storage path specified by the user, so that the user can view the state machine code framework.

[0009] In a second aspect, the present disclosure provides a finite state machine automatic generation system, comprising:

[0010] A table path acquisition module is used to obtain the table path corresponding to a preset table; wherein the preset table stores the configuration generated by the state machine code framework filled in by the user;

[0011] The state machine code framework generation module is used to capture the configuration in the preset table through Python script based on the table path and generate the state machine code framework;

[0012] The state machine code framework storage module is used to store the state machine code framework in a preset storage path specified by the user so that the user can view the state machine code framework.

[0013] In a third aspect, the present disclosure provides a computing device comprising a memory, a processor, and a program stored in the memory and running on the processor, wherein the processor implements the above-mentioned method for automatically generating a finite state machine when executing the program.

[0014] In a fourth aspect, the present disclosure provides a computer-readable storage medium storing instructions. When the instructions are executed on a terminal device, the terminal device executes a finite state machine automatic generation method as described above.

[0015] The present invention has the following beneficial effects: obtaining a pre-configured preset table, and directly using a Python script to capture the configuration of the state machine code framework based on the table path, and then generating the state machine code framework, and finally storing it in a preset storage path for the user to view. The present invention realizes the automatic generation of the state machine code framework through a script written in Python, eliminating the tedious code writing by the developer and improving development efficiency. BRIEF DESCRIPTION OF THE DRAWINGS

[0016] In order to more clearly illustrate the embodiments of the present disclosure or the technical solutions in the prior art, the present disclosure is further described below with reference to the accompanying drawings and embodiments.

[0017] Figure 1 A flowchart of a method for automatically generating a finite state machine according to an embodiment of the present disclosure;

[0018] Figure 2 is a schematic diagram of the first worksheet;

[0019] Figure 3 A schematic diagram of connecting the controller in the first working sheet to the second working sheet;

[0020] Figure 4 A schematic diagram of connecting the status members in the second worksheet to the third worksheet;

[0021] Figure 5 This is a schematic diagram of the third worksheet;

[0022] Figure 6 This is a schematic diagram of the structure of a finite state machine automatic generation system according to an embodiment of the present disclosure;

[0023] Figure 7 Schematic diagram of the structure of a computing device according to an embodiment of the present disclosure. DETAILED DESCRIPTION

[0024] The following examples are provided to further explain and supplement the present disclosure and do not constitute any limitation to the present disclosure.

[0025] The following describes a finite state machine automatic generation method, system and related devices according to an embodiment of the present disclosure in conjunction with the accompanying drawings.

[0026] like Figure 1 As shown, the embodiment of the present disclosure provides a method for automatically generating a finite state machine, including:

[0027] S1. Obtain a table path corresponding to a preset table; wherein the preset table stores a configuration generated by a state machine code framework filled in by a user.

[0028] S2. Based on the table path, the configuration in the preset table is captured through the Python script to generate the state machine code framework.

[0029] S3. The state machine code framework is stored in a preset storage path specified by the user, so that the user can view the state machine code framework.

[0030] S4. Adjust the control parameters of the traction control system according to the current working conditions, traction control conditions and weights to determine target control parameters.

[0031] In this embodiment, a pre-configured table is obtained, and based on the table path, the configuration of the state machine code framework is directly captured through a Python script, and the state machine code framework is generated and finally stored in a preset storage path for the user to view. The present disclosure realizes the automatic generation of the state machine code framework through a script written in Python, eliminating the tedious code writing by the developer and improving development efficiency.

[0032] In this embodiment, the preset table is an Excel table. The Python script will read the state machine related configuration filled in by the user in the Excel table, generate the state machine code framework in C language, and generate ".c" and ".h" files for the user to use. Among them, the ".h" file is the header file of the C language, which is used to declare the functions, structures, macro definitions, etc. required for the state machine, helping the code to be modular and reusable. The ".c" file is the C language source code file, which contains the implementation part of the program. At the same time, the specific framework code of the state machine will be generated for the user to implement the specific programs and functions of each state. The code generated by these two files can be modified by the user according to their own needs and connected or put into the user's code project or project, reducing the user's workload for the project and saving time for the user.

[0033] Optionally, the preset form includes multiple worksheets, wherein:

[0034] At least one controller is configured in the first working table, and the controller is connected to the second working table;

[0035] At least one state member corresponding to the controller is configured in the second working table, and each state member is connected to the third working table;

[0036] The states of the finite state machine are mapped in the third worksheet;

[0037] The worksheets include at least a first worksheet, a second worksheet, and a third worksheet.

[0038] like Figure 2 As shown, the first worksheet may be named "Defines", and include at least three columns, wherein the first column is named "Optional Type", the second column is named "Variable Name", and the third column is named "Value".

[0039] Among them, the "Optional Type" column includes five types of configurable items: ProjectName, Controller, Define, Global, and HeaderFile.

[0040] ProjectName is the project, and the value filled in VariableName is the project name. It can only be configured once. The other four items can be configured multiple times.

[0041] Define is the macro definition, VariableName is the macro definition name, and Value is the macro definition content.

[0042] Global is the extended global variable, VariableName is the name of the global variable, and Value is the type of the variable.

[0043] HeaderFile is the included header file, VariableName is the header file name, and Value has no effect.

[0044] The most important item is Controller, which is a class that acts as a controller in the code. A Controller item needs to be connected to another second worksheet as the configuration of the Controller. Therefore, for the Controller, the value of the Value column configured in the preset table is the name of the second worksheet it is connected to, for example Figure 3 As shown, it can be seen that the corresponding second work table is configured for "ControllerCFG" and "SpiControllerCFG" (the position indicated by the arrow is the second work table).

[0045] In this embodiment, the controller is actually a data structure used to control the state of the state machine. The script will first generate its type definition in the ".h" header file, and then initialize the member default values ​​specified by the user in the ".c". The script will force the allocation of at least one state machine member to each controller. This state machine member will be separated from the state machine members of other controllers. In other words, during code generation, a switch statement (a switch statement is a conditional control structure in the C language that selects different code blocks to execute based on the value of an expression) will be assigned to each controller, unless the user connects them when implementing specific functions.

[0046] For the Controller configuration, the script will add a status member for all users and search for a status member with the word "Status". The status member will be added to the Controller class as a status control item.

[0047] For status members with the word "Status," the script uses a string substring match statement to search the first column of the second worksheet, "ControllerMembers," from top to bottom, for all status members with the word "Status" in their names (e.g., XXStatus, Status_XX, XXStatusXX, etc.; see Python's "in" syntax for details). Each status member has two properties: "Types" and "Default Values." Types represents the type of the status member, and Default Values ​​represents the default value. The default value is the value to which the status member is initialized when the Controller is declared.

[0048] like Figure 4 As shown, for the "Status" status member, it needs to connect to an additional third worksheet as a configuration. The default value property ("Default Values") of the "Status" status member in the second worksheet is the name of the third worksheet it is connected to (such as Figure 4 The position pointed by the arrow is the third worksheet).

[0049] The principle behind connecting to the third worksheet via the default value property is that in the second worksheet, state members can be added according to the state diagram, and the direction each state member can jump to can be set. Similar to a power set, users can add state members to the second worksheet, but each state member can only jump to a state in the current set (including the current state) or not jump at all. Therefore, the number of jump directions that can be set does not exceed the number of states that can be set. Based on the jump direction, the jump is directly to the third worksheet with the same name.

[0050] Optionally, at least one state member corresponding to the controller is configured in the second working table, each state member is connected to the third working table, and further includes:

[0051] The state corresponding to the first state member from top to bottom in the second worksheet is used as the main state of the finite state machine.

[0052] In this embodiment, a Controller can have multiple "Status" state members, but only the first added "Status" state member will serve as the main state of the state machine and play an important role in the judgment during code generation. The remaining added "Status" state members will exist as subsidiary state control items in the Controller class and will not be used as judgment conditions for the switch statement.

[0053] In this embodiment, the Controller transforms its own state by changing the value of the "Status" state member. The value of the main state member in the code will generate corresponding statements according to the third worksheet, and the sub-state member will be generated in each switch case statement, and all statements will be generated for users to use according to the direction in the third worksheet.

[0054] For example, Figure 5 As shown, "Status" is the main state, and through "Default Values" you can jump to the third worksheet, namely "SpiStatusCFG". In the third worksheet, the "StatusName (main state name)" and the conversion of the two states "Direction1" and "Direction2" are defined.

[0055] Optionally, based on the table path, a Python script is used to grab the configuration in the preset table and generate a state machine code framework, including:

[0056] Based on the table path, the python script grabs the controller from the first worksheet;

[0057] Grab at least one state member from the second worksheet corresponding to the controller;

[0058] The state of the finite state machine is captured from the third worksheet corresponding to each state member, and a state machine code skeleton is generated.

[0059] In this embodiment, a first worksheet named "Defines" is first required. This first worksheet has at least 3 columns and no limit on rows. The first row will not participate in code generation and can be used for interpretation. The first column is named "Optional Type", the second column is named "Variable Name", and the third column is named "Value".

[0060] Secondly, users need to add a second worksheet with the corresponding name according to the name of the Controller configuration they set.

[0061] For the second worksheet of Controller configuration, the first row will not be involved in code generation and can be used for explanation. The column names are named in order: "ControllerMembers" (controller class members), "Types" (member types), and "DefaultValues" (default values).

[0062] Only the first three columns of the above two sheets are involved in code generation, so special symbols cannot be filled in to affect the compilation effect of the generated code.

[0063] Finally, the user needs to jump to the third worksheet with the corresponding name according to the jump direction of the status member with "Status" set by the user.

[0064] Similarly, the first row of the third worksheet is not generated and can be used for explanation. All other rows are generated. It is recommended that the first column be named StatusName, and the second and subsequent columns be represented by serial numbers. There is no limit to the number of rows and columns, but the number of columns cannot exceed the number of rows. At least one of each of the above three worksheets should be added, and the first worksheet can only have one. Special symbols cannot be used to generate code.

[0065] like Figure 6 As shown, the present disclosure provides a finite state machine automatic generation system, comprising:

[0066] A table path acquisition module is used to obtain the table path corresponding to a preset table; wherein the preset table stores the configuration generated by the state machine code framework filled in by the user;

[0067] The state machine code framework generation module is used to capture the configuration in the preset table through Python script based on the table path and generate the state machine code framework;

[0068] The state machine code framework storage module is used to store the state machine code framework in a preset storage path specified by the user so that the user can view the state machine code framework.

[0069] Optionally, the system further includes a preset table configuration module, specifically configured to:

[0070] At least one controller is configured in the first working table, and the controller is connected to the second working table;

[0071] At least one state member corresponding to the controller is configured in the second working table, and each state member is connected to the third working table;

[0072] The states of the finite state machine are mapped in the third worksheet;

[0073] The worksheets include at least a first worksheet, a second worksheet, and a third worksheet.

[0074] Optionally, the preset table configuration module is further used to:

[0075] The state corresponding to the first state member from top to bottom in the second worksheet is used as the main state of the finite state machine.

[0076] Optionally, a state machine code framework generation module is specifically used to:

[0077] Based on the table path, the python script grabs the controller from the first worksheet;

[0078] Grab at least one state member from the second worksheet corresponding to the controller;

[0079] The state of the finite state machine is captured from the third worksheet corresponding to each state member, and a state machine code skeleton is generated.

[0080] A computing device according to an embodiment of the present disclosure includes a memory, a processor, and a computer program stored in the memory and executable on the processor. When the processor executes the computer program, the aforementioned method for automatically generating a finite state machine is implemented. That is, a computing device according to an embodiment of the present disclosure may include, but is not limited to: a processor and a memory; the memory is used to store the computer program; and the processor is used to execute the method for automatically generating a finite state machine as shown in any embodiment of the present disclosure by calling the computer program.

[0081] In an alternative embodiment, a computing device is provided, such as Figure 7 As shown, Figure 7 The computing device 4000 shown includes a processor 4001 and a memory 4003. The processor 4001 and the memory 4003 are connected, for example, via a bus 4002. Optionally, the computing device 4000 may also include a transceiver 4004, which can be used for data exchange between the computing device and other computing devices, such as data transmission and / or data reception. It should be noted that in actual applications, the number of transceivers 4004 is not limited to one, and the structure of the computing device 4000 does not constitute a limitation on the embodiments of the present disclosure.

[0082] Processor 4001 may be a CPU (Central Processing Unit), a general-purpose processor, a DSP (Digital Signal Processor), an ASIC (Application Specific Integrated Circuit), an FPGA (Field Programmable Gate Array), or other programmable logic devices, transistor logic devices, hardware components, or any combination thereof. It may implement or execute the various exemplary logic blocks, modules, and circuits described in conjunction with the present disclosure. Processor 4001 may also be a combination that implements computing functions, such as a combination of one or more microprocessors, a combination of a DSP and a microprocessor, and the like.

[0083] Bus 4002 may include a path for transmitting information between the above components. Bus 4002 may be a PCI (Peripheral Component Interconnect) bus or an EISA (Extended Industry Standard Architecture) bus. Bus 4002 may be divided into an address bus, a data bus, a control bus, etc. For ease of representation, Figure 7 In the figure, only one thick line is used to represent the bus 4002, but this does not mean that there is only one bus or one type of bus.

[0084] The memory 4003 may be a ROM (Read Only Memory) or other types of static storage devices that can store static information and instructions, a RAM (Random Access Memory) or other types of dynamic storage devices that can store information and instructions, or an EEPROM (Electrically Erasable Programmable Read Only Memory), a CD-ROM (Compact Disc Read Only Memory) or other optical disk storage, optical disk storage (including compact discs, laser discs, optical discs, digital versatile discs, Blu-ray discs, etc.), a magnetic disk storage medium or other magnetic storage device, or any other medium that can be used to carry or store desired program code in the form of instructions or data structures and can be accessed by a computer, but is not limited to these.

[0085] The memory 4003 is used to store application code (computer program) for executing the solution of the present disclosure, and the execution is controlled by the processor 4001. The processor 4001 is used to execute the application code stored in the memory 4003 to implement the content shown in the above method embodiment.

[0086] Among them, the computing device can also be a terminal device, and the terminal device can be any device that can install applications, including at least one of a smartphone, a tablet computer, a laptop computer, a desktop computer, a smart speaker, a smart watch, a smart TV, and a smart car device.

[0087] It should be noted that Figure 7 The computing device shown is only an example and should not bring any limitation to the functionality and scope of use of the embodiments of the present disclosure.

[0088] A computer-readable storage medium according to an embodiment of the present disclosure stores a computer program, which implements the above-mentioned method for automatically generating a finite state machine when executed by a processor.

[0089] Alternatively, the computer-readable storage medium may be a read-only memory (ROM), a random access memory (RAM), a compact disc (CD-ROM), a magnetic tape, a floppy disk, an optical data storage device, or the like.

[0090] In an exemplary embodiment, a computer program product or computer program is also provided. The computer program product or computer program includes computer instructions stored in a computer-readable storage medium. A processor of a computing device reads the computer instructions from the computer-readable storage medium and executes the computer instructions, causing the computing device to perform the aforementioned method for automatically generating a finite state machine.

[0091] Computer program code for performing the operations of the present disclosure may be written in one or more programming languages, or a combination thereof, including object-oriented programming languages ​​such as Java, Smalltalk, C++, and conventional procedural programming languages ​​such as "C" or similar programming languages. The program code may be executed entirely on the user's computer, partially on the user's computer, as a stand-alone software package, partially on the user's computer and partially on a remote computer, or entirely on the remote computer or server. In cases involving a remote computer, the remote computer may be connected to the user's computer through any type of network, including a local area network (LAN) or a wide area network (WAN), or may be connected to an external computer (e.g., through the Internet using an Internet service provider).

[0092] It should be understood that the flowcharts and block diagrams in the accompanying drawings illustrate the possible implementation architecture, functions and operations of the methods and computer program products according to various embodiments of the present disclosure. In this regard, each box in the flowchart or block diagram can represent a module, program segment, or a part of code, and the module, program segment, or a part of code contains one or more executable instructions for realizing the specified logical function. It should also be noted that in some alternative implementations, the functions marked in the box can also occur in a different order than that marked in the accompanying drawings. For example, two boxes represented in succession can actually be executed substantially in parallel, and they can sometimes be executed in the opposite order, depending on the functions involved. It should also be noted that each box in the block diagram and / or flowchart, and the combination of the boxes in the block diagram and / or flowchart, can be implemented by a dedicated hardware-based system that performs the specified function or operation, or can be implemented by a combination of dedicated hardware and computer instructions.

[0093] The computer-readable storage medium provided in the embodiments of the present disclosure may be, but is not limited to, an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, device or component, or any combination thereof. More specific examples of computer-readable storage media may include, but are not limited to, an electrical connection with one or more wires, a portable computer disk, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EEPROM or flash memory), an optical fiber, a portable compact disk read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination thereof. In the present disclosure, a computer-readable storage medium may be any tangible medium containing or storing a program that can be used by or in combination with an instruction execution system, device, or device.

[0094] The computer-readable storage medium carries one or more programs. When the one or more programs are executed by the computing device, the computing device executes the method shown in the above embodiment.

[0095] The above description is merely a preferred embodiment of the present disclosure and an illustration of the technical principles employed. Those skilled in the art should understand that the scope of disclosure involved in the present disclosure is not limited to the technical solutions formed by the specific combination of the above-mentioned technical features, but also includes other technical solutions formed by any combination of the above-mentioned technical features or their equivalents without departing from the above-mentioned disclosed concepts. For example, a technical solution formed by replacing the above-mentioned features with (but not limited to) technical features with similar functions disclosed in this disclosure.

[0096] It should be noted that the terms "first," "second," and the like in the specification and claims of this application are used to distinguish similar objects and to define a specific order or precedence. Where appropriate, the order used for similar objects may be interchanged, such that the embodiments of the present application described herein can be implemented in an order other than the order shown or described.

[0097] Those skilled in the art will appreciate that the present disclosure may be implemented as a system, method, or computer program product. Therefore, the present disclosure may be implemented in the following forms: entirely in hardware, entirely in software (including firmware, resident software, microcode, etc.), or in a combination of hardware and software, generally referred to herein as a "circuit," "module," or "system." Furthermore, in some embodiments, the present disclosure may be implemented in the form of a computer program product embodied in one or more computer-readable media, wherein the computer-readable media contains computer-readable program code.

[0098] Although the embodiments of the present disclosure have been shown and described above, it is understood that the above embodiments are illustrative and are not to be construed as limitations on the present disclosure. A person skilled in the art may change, modify, replace and vary the above embodiments within the scope of the present disclosure.

Claims

1. A method for automatically generating a finite state machine, characterized in that: include: Obtaining a table path corresponding to a preset table; wherein the preset table stores a configuration generated by a state machine code framework filled in by a user; Based on the table path, the configuration in the preset table is captured by a Python script to generate a state machine code framework; The state machine code framework is stored in a preset storage path specified by the user, so that the user can view the state machine code framework.

2. The method according to claim 1, characterized in that The preset table includes multiple worksheets, wherein: At least one controller is configured in the first working table, and the controller is connected to the second working table; At least one state member corresponding to the controller is configured in the second working table, and each state member is connected to a third working table; The states of the finite state machine are mapped in the third working table; The worksheets at least include the first worksheet, the second worksheet, and the third worksheet.

3. The method according to claim 2, characterized in that The second working table is configured with at least one state member corresponding to the controller, each state member is connected to a third working table, and further includes: The state corresponding to the first state member from top to bottom in the second working table is used as the main state of the finite state machine.

4. The method according to claim 3, characterized in that The method of capturing the configuration in the preset table based on the table path through a Python script to generate a state machine code framework includes: Based on the table path, the Python script grabs the controller from the first worksheet; Capture at least one state member from the second work table corresponding to the controller; The state of the finite state machine is captured from the third worksheet corresponding to each state member, and a state machine code framework is generated.

5. A finite state machine automatic generation system, characterized in that: include: A table path acquisition module is used to obtain a table path corresponding to a preset table; wherein the preset table stores a configuration generated by a state machine code framework filled in by the user; A state machine code framework generation module is used to capture the configuration in the preset table through a Python script based on the table path to generate a state machine code framework; The state machine code framework storage module is used to store the state machine code framework in a preset storage path specified by the user, so that the user can view the state machine code framework.

6. The system according to claim 5, characterized in that The system also includes a preset table configuration module, specifically used to: At least one controller is configured in the first working table, and the controller is connected to the second working table; At least one state member corresponding to the controller is configured in the second working table, and each state member is connected to a third working table; The states of the finite state machine are mapped in the third working table; The worksheets at least include the first worksheet, the second worksheet, and the third worksheet.

7. The system according to claim 6, characterized in that The preset table configuration module is also used for: The state corresponding to the first state member from top to bottom in the second working table is used as the main state of the finite state machine.

8. The system according to claim 7, characterized in that State machine code framework generation module, specifically used for: Based on the table path, the Python script grabs the controller from the first worksheet; Capture at least one state member from the second work table corresponding to the controller; The state of the finite state machine is captured from the third worksheet corresponding to each state member, and a state machine code framework is generated.

9. A computing device comprising a memory, a processor, and a program stored in the memory and running on the processor, characterized in that: When executing the program, the processor implements the method for automatically generating a finite state machine as described in any one of claims 1 to 4.

10. A computer-readable storage medium, characterized in that The computer-readable storage medium stores instructions, and when the instructions are executed on a terminal device, the terminal device executes a finite state machine automatic generation method according to any one of claims 1 to 4.

Images