An experimental procedure design method, apparatus and equipment

By using experimental design tools and compilers to achieve visual drag-and-drop configuration and parameter verification of experimental procedures, the problems of low efficiency and error-proneness in traditional experimental design are solved, and efficient and reliable experimental scheme management and execution are provided.

CN123114446APending Publication Date: 2026-11-17SHENZHEN INST OF ADVANCED TECH CHINESE ACAD OF SCI
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
CN202510835623.9
Authority / Receiving Office
CN · China
Patent Type
Applications(China)
Current Assignee / Owner
Priority Date
2025-05-15
Filing Date
2025-06-20
Publication Date
2026-11-17

AI Technical Summary

Technical Problem

Existing technologies lack intuitive means of constructing visual experimental processes, and parameter configuration and verification are scattered, making it difficult to meet the needs of visualization, compilation and version management of experimental methods, resulting in low design efficiency and easy errors.

Method used

This invention provides an experimental method design tool and compiler that enables visual drag-and-drop configuration of experimental processes, parameter input validation, compilation and error prompting through a modular approach. It also integrates compilation history version management and generates executable flowchart configuration files.

Benefits of technology

It significantly improves the efficiency and reliability of experimental design, ensures parameter consistency, reduces the experimental threshold and labor costs, and is suitable for automated execution in complex experimental scenarios.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN123114446A_ABST
    Figure CN123114446A_ABST
Patent Text Reader

Abstract

This specification relates to the field of laboratory automation technology, and more particularly to an experimental workflow design method, apparatus, and equipment. This solution generates experimental components based on historical experimental data, then sorts these components according to user operations, simultaneously acquiring the attribute panels and configuration parameters of the experimental components; it validates the attribute panels and configuration parameters of the experimental components; and compiles the validated experimental components to generate a flowchart configuration file; finally, it loads the component parameter structure from the flowchart configuration file, provides a visual preview of the component parameter structure, and uses it to execute automated experiments. It integrates workflow design, code generation, and version management functions, achieving closed-loop automation from experimental scheme design to execution. Users can complete design, compilation, execution, and version control within the same platform, improving the maintainability and traceability of experimental schemes.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] The embodiments in this specification relate to the field of laboratory automation technology, and in particular to an experimental process design method, apparatus and equipment. Background Technology

[0002] With the increasing complexity of experimental methods in scientific research and industrial production, how to quickly and intuitively design, configure, and run complex experimental processes has become an urgent technical problem to be solved. Traditional experimental method design usually relies on manually writing process scripts and drivers, which is cumbersome, error-prone, and inefficient. Current technology lacks a unified graphical experimental method design and execution platform. Users cannot intuitively drag and drop to build component processes when designing experimental schemes, and parameter configuration and verification need to be completed in different systems or text files, making it difficult to meet the needs of experimental method visualization, compilation, and version management. Therefore, it is necessary to provide an experimental method design tool and compiler that enables users to quickly build experimental processes through visual operations and generate flowchart configuration files for deployment and operation, thereby improving design efficiency and reliability.

[0003] Existing technologies suffer from the following main drawbacks: First, traditional experimental design methods lack intuitive visual process construction tools, requiring users to manually write process scripts or configuration files, which is cumbersome and prone to errors. Second, the configuration and verification of parameters for each component during the experiment usually need to be completed in different development environments or configuration files, making it difficult to promptly detect parameter input errors or incompatibility issues between parameters. Third, existing tools generally lack unified compilation and error reporting functions, preventing users from quickly obtaining feedback on the correctness of their solutions after process design and failing to automatically generate flowchart configuration files. Fourth, there is a lack of visual form design tools for device-driven systems; existing general-purpose form designers cannot meet the customization needs of professional component attributes, requiring developers to repeatedly write parameter structures manually. Finally, the lack of version management and history mechanisms makes it difficult to track and trace changes to experimental schemes. Based on this, the purpose of this specification is to provide an experimental method design tool and compiler that enables visual drag-and-drop configuration of the experimental process, parameter input validation, compilation and error prompting through a modular approach, and integrates compilation history version management functions; at the same time, it provides a dedicated component property form design tool, providing a visual property editing interface for device driver development, enabling customization of component property forms, export of JSON structures and preview functions, thereby greatly improving the efficiency and reliability of experimental scheme design.

[0004] There is an urgent need for an experimental workflow design methodology that integrates compilation and version management functions, allowing users to generate unified error verification prompts and historical records after modifying experimental plans. This would solve the problem of not being able to effectively support the rapid iteration and management of experimental methods. Summary of the Invention

[0005] To address the problems of low process iteration efficiency, large human error, and lack of systematic management in existing technologies, this specification provides an experimental process design method, apparatus, and equipment. It can automatically generate executable instructions based on standardized experimental components and achieve intelligent control of experimental equipment through multiple driver modules, significantly improving experimental efficiency and reliability. By integrating compilation and version management functions, users can generate unified error verification prompts and historical records after modifying experimental plans. After loading, a visual preview is displayed, and automated experimental execution is achieved. This provides an efficient, accurate, and traceable intelligent experimental platform, particularly suitable for experimental scenarios requiring high frequency and multiple parameter combinations.

[0006] The specific technical solutions of the embodiments in this specification are as follows:

[0007] On the one hand, the embodiments of this specification provide an experimental procedure design method, including:

[0008] Multiple experimental components are generated based on historical experimental data. The experimental components include a device driver module and a data processing module.

[0009] The experimental components are sorted according to user operations, and the attribute panel and configuration parameters of the experimental components are obtained.

[0010] The property panel and configuration parameters of the experimental components are validated.

[0011] The experimental components that have passed the verification are compiled to generate an executable flowchart configuration file;

[0012] Load the flowchart configuration file to generate a visualization of the parameter structure and execution logic of the experimental components.

[0013] Furthermore, experimental components are generated based on historical experimental data. These components include a device driver module and a data processing unit.

[0014] A preprocessing component is generated based on the historical experimental data, including material objects, data objects, and file objects;

[0015] The preprocessing component generates the input and output of the experimental procedure, and the experimental component is generated by combining the input and output with historical experimental data.

[0016] Furthermore, sorting the experimental components according to user operations further includes,

[0017] The experimental components provide a visual editing interface and can be pre-configured or expanded with various experimental unit modules.

[0018] Based on the user's operation, obtain the sorting instructions and parameter input instructions for the experimental components;

[0019] In response to the sorting command, a corresponding attribute editing panel is dynamically generated;

[0020] Real-time verification of whether the parameter input conforms to the preset data type, numerical range, and business rule constraints.

[0021] Furthermore, sorting the experimental components according to user operations further includes,

[0022] The sequencing of the experimental components involves complex control logic including concurrent execution, loop execution, and conditional judgment.

[0023] The sorting of experimental components also includes multiple start nodes and end nodes.

[0024] Furthermore, the verification of the property panel and configuration parameters of the experimental components further includes,

[0025] Verify whether the attribute panel and configuration parameters conform to preset rules based on the input and output of the experimental process;

[0026] If the verification fails, the generation process is paused and an error message is generated.

[0027] Furthermore, the verified experimental components are compiled to generate a flowchart configuration file, which further includes...

[0028] During the compilation process, the connection relationships and parameter configurations of the experimental components are verified according to predefined rules.

[0029] When verification fails, a detailed error report is provided, including the identifier of the faulty component, the error type, and correction instructions.

[0030] Furthermore, the experimental components are divided into pre-set components and equipment functional components;

[0031] The preset components are experimental components that the system can use by default in historical experimental data;

[0032] The device functional components are experimental components that are visually generated based on requirements using a component form design tool.

[0033] On the other hand, embodiments of this specification also provide an experimental procedure design apparatus, the apparatus comprising:

[0034] The component generation module is used to generate multiple experimental components based on historical experimental data. The experimental components include a device driver module and a data processing module.

[0035] The user operation module is used to dynamically sort and logically connect the experimental components according to user operations, and to obtain the attribute panel and configuration parameters of the experimental components.

[0036] A configuration parameter verification module is used to verify the property panel and configuration parameters of the experimental components.

[0037] The compilation module is used to compile the verified experimental components and generate an executable flowchart configuration file;

[0038] The form export module is used to load the flowchart configuration file and generate a visualization of the parameter structure and execution logic of the experimental components.

[0039] On the other hand, embodiments of this specification also provide a computer device, including a memory, a processor, and a computer program stored in the memory, wherein the processor executes the computer program to implement the above-described method.

[0040] On the other hand, embodiments of this specification also provide a computer-readable storage medium storing a computer program that, when executed by a processor, implements the above-described method.

[0041] Finally, this specification also provides a computer program product, which includes a computer program that, when executed by a processor, implements the above-described method.

[0042] This specification provides an experimental method design tool and compiler, which achieves visual drag-and-drop configuration of the experimental process, parameter input validation, compilation, and error prompting in a modular manner, and integrates compilation history version management functions. This solution generates multiple experimental components based on historical experimental data. These components include a device driver module and a data processing module. Users draw automated experimental processes according to experimental requirements, sort the experimental components based on user operations, and obtain the attribute panels and configuration parameters of each component. The attribute panels and configuration parameters of the experimental components are validated. The validated experimental components are compiled to generate a flowchart configuration file. The component parameter structure of the flowchart configuration file is loaded to generate a visual representation of the component parameter structure. The generated experimental flowchart configuration file can be loaded and previewed visually, and is ultimately used to execute automated experiments. A dedicated component attribute form design tool is provided, offering a visual attribute editing interface for device driver development. This tool enables customization of component attribute forms, export of JSON structures, and preview functions, thereby significantly improving the efficiency and reliability of experimental scheme design. It also ensures parameter consistency between different experimental schemes. This solution is particularly suitable for complex experimental scenarios. While ensuring data accuracy, it transforms the experimental configuration work that traditionally required professional personnel into a standardized process that researchers can operate independently, significantly reducing the experimental threshold and labor costs. Attached Figure Description

[0043] To more clearly illustrate the technical solutions in the embodiments of this specification or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the embodiments of this specification. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0044] Figure 1 The figure shown is a schematic diagram of the implementation system of an experimental process design method in an embodiment of this specification;

[0045] Figure 2 The diagram shown is a schematic representation of the experimental design method in the embodiments of this specification.

[0046] Figure 3 The diagram shown is a flowchart illustrating the process of generating experimental components based on historical experimental data in an embodiment of this specification.

[0047] Figure 4 The diagram shown is a flowchart illustrating the sorting of experimental components according to user operations in an embodiment of this specification.

[0048] Figure 5The diagram shown is a flowchart illustrating the verification process of the attribute panel and configuration parameters of the experimental components in an embodiment of this specification.

[0049] Figure 6 The diagram shown is a flowchart illustrating the compilation logic in an embodiment of this specification.

[0050] Figure 7 The diagram shown is a schematic representation of the specific structure of the experimental procedure design device in this embodiment.

[0051] Figure 8 The diagram shown is a structural schematic of the computer device in an embodiment of this specification.

[0052] [Explanation of Figure Markers]:

[0053] 101. Terminal;

[0054] 102. Server;

[0055] 701. Component Generation Module;

[0056] 702. User Operation Module;

[0057] 703. Configure parameter verification module;

[0058] 704, Compilation Module;

[0059] 705. Form Export Module;

[0060] 802. Computer equipment;

[0061] 804. Processing equipment;

[0062] 806. Storage resources;

[0063] 808. Drive system;

[0064] 810. Input / Output Module;

[0065] 812. Input devices;

[0066] 814. Output devices;

[0067] 816. Presentation equipment;

[0068] 818. Graphical User Interface;

[0069] 820. Network interface;

[0070] 822. Communication link;

[0071] 824. Communication bus. Detailed Implementation

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

[0073] It should be noted that the terms "first," "second," etc., in the description, claims, and accompanying drawings of the embodiments herein are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence. It should be understood that such data can be interchanged where appropriate so that embodiments of the embodiments described herein can be implemented in orders other than those illustrated or described herein. Furthermore, the terms "comprising" and "having," and any variations thereof, are intended to cover non-exclusive inclusion; for example, a process, method, apparatus, product, or device that includes a series of steps or units is not necessarily limited to those steps or units explicitly listed, but may include other steps or units not explicitly listed or inherent to such processes, methods, products, or devices.

[0074] It should be noted that the acquisition, storage, use, and processing of data in the technical solutions of the embodiments of this specification all comply with the relevant provisions of national laws and regulations.

[0075] It should be noted that in the embodiments of this specification, certain software, components, models and other existing solutions in the industry may be mentioned. These should be regarded as exemplary and are only intended to illustrate the feasibility of implementing the technical solution of this application. However, they do not mean that the applicant has used or necessarily used the solution.

[0076] like Figure 1 The diagram illustrates an implementation system for an experimental workflow design method according to an embodiment of this specification, including a terminal 101 and a server 102. The terminal 101 and server 102 can communicate via a network, which may include a local area network (LAN), a wide area network (WAN), the Internet, or a combination thereof, and be connected to a website, user equipment (e.g., computing devices), and a backend system. Optionally, server 102 may be a node in a cloud computing system, or each server may be a separate cloud computing system comprising multiple computers interconnected by a network and operating as a distributed processing system.

[0077] Terminal 101 obtains user operations and sorts the experimental components according to the user operations and sends them to server 102. Server 102 verifies the sorting and compiles the data. After compilation, it generates a flowchart configuration file, loads the component parameter structure of the flowchart configuration file, and returns it to terminal 101.

[0078] In addition, it should be noted that, Figure 1 The examples shown are merely one application environment provided by the embodiments in this specification. In actual applications, other application environments may also be included, and this specification does not impose any limitations.

[0079] To address the problems existing in the prior art, this specification provides an experimental procedure design method. In this specification embodiment, Figure 2 The diagram shown is a schematic representation of the experimental procedure design method in an embodiment of this specification. The experimental procedure design process is described in this diagram. The order of steps listed in the embodiment is merely one possible execution order among many steps and does not represent the only possible execution order. In actual system or device products, the methods shown in the embodiments or accompanying drawings can be executed sequentially or in parallel. Specifically, as shown... Figure 2 As shown, the method may include:

[0080] Step 201: Generate multiple experimental components based on historical experimental data. The experimental components include a device driver module and a data processing module.

[0081] Step 202: Dynamically sort and logically connect the experimental components according to user operations, and obtain the attribute panel and configuration parameters of the experimental components;

[0082] Step 203: Verify the property panel and configuration parameters of the experimental component;

[0083] Step 204: Compile the verified experimental components to generate an executable flowchart configuration file;

[0084] Step 205: Load the flowchart configuration file to generate a visualization of the component parameter structure and execution logic relationship.

[0085] This specification provides an experimental method design tool and compiler, which achieves visualized drag-and-drop configuration of the experimental process, parameter input verification, compilation, and error prompting in a modular manner, and integrates compilation history version management functions. This solution generates multiple experimental components based on historical experimental data. These components include a device driver module and a data processing module. The experimental components are sorted according to user operations, and their attribute panels and configuration parameters are obtained. The attribute panels and configuration parameters of the experimental components are verified. The verified experimental components are compiled to generate a flowchart configuration file. The component parameter structure of the flowchart configuration file is loaded to generate a visualized component parameter structure. A dedicated component attribute form design tool is provided, offering a visualized attribute editing interface for device driver development. This allows for customization of component attribute forms, export of JSON structures, and preview functions, thereby significantly improving the efficiency and reliability of experimental scheme design. It also ensures parameter consistency between different experimental schemes. This solution is particularly suitable for complex experimental scenarios. While ensuring data accuracy, it transforms the experimental configuration work, which traditionally required professional personnel, into a standardized process that researchers can operate independently, significantly reducing the experimental threshold and labor costs.

[0086] In scientific research and industrial production, designing and executing complex experimental procedures is a common requirement. Experimental procedures typically consist of multiple steps, each corresponding to a specific device or operating unit, requiring the setting of corresponding parameters and sequences. In existing technologies, the design and implementation of experimental methods are often separated: researchers analyze experimental requirements, write descriptive scripts or process configuration files, and then convert them into executable instructions for the device. For example, in the field of automation control, there are some general-purpose process design tools or workflow engines that configure tasks and conditions through flowcharts or scripting languages. However, these tools are mainly used for general business processes and lack sufficient support for interactive processes driven by experimental equipment. Furthermore, device-driven attribute configuration interfaces usually rely on hard-coding or manually writing JSON / XML files, lacking visual editing tools and resulting in low development efficiency. Although some form generators or visual editing frameworks exist, they are often too general and cannot meet the attribute customization needs of specific experimental components (modular instruments or processing units). In addition, existing experimental design tools rarely integrate compilation and version management functions, and users lack a unified error verification prompt and history mechanism after modifying experimental plans. In summary, existing technologies have not yet provided a unified platform that integrates the visual design of experimental procedures, the customization and compilation of parameter forms, and cannot effectively support the rapid iteration and management of experimental methods.

[0087] This specification proposes an experimental method design tool and compiler, whose technical solution comprises two main parts: a compiler module and a component form design tool. The compiler module employs a visual interface and component-based design principles to achieve visual drag-and-drop configuration of the experimental process: users can drag and drop experimental components (such as device driver modules, data processing units, etc.) onto a canvas and input and configure parameters through the component property panel. The system automatically validates the input parameters and provides error messages. After design completion, the compiler module automatically compiles the process, generates a flowchart configuration file, and provides compilation history version management functionality. The component form design tool provides device driver developers with a visual configuration interface design environment, supporting the editing of component properties in a graphical editing interface, including adding attribute fields, setting types, setting data sources, default values, and validation rules. It can export defined forms in JSON format for loading component parameter structures into the main system and also supports component preview functionality. Through the cooperation of these modules, this specification achieves an automated process from experimental scheme design to generation.

[0088] In one embodiment of this specification, such as Figure 3 As shown, experimental components are generated based on historical experimental data. These components include a device driver module and a data processing unit, which further include...

[0089] Step 301: Based on the experimental steps and parameter configurations of the historical experimental data, generate preprocessing components, including material objects, data objects, and file objects;

[0090] Step 302: Generate the input and output of the experimental process based on the preprocessing component, and dynamically generate reusable experimental components by combining the input and output with historical experimental data.

[0091] Specifically, a preprocessing component is generated based on the historical experimental data, including the explicit definitions of material, data, and file objects: Material objects include all physical materials in the system, specifically the material objects used in the process flow. Material objects have two affiliations: a public library (available to all platform users) and a personal library (available only to the user who created the object and the administrator); Data objects include data generated and used in the process flow, belonging to the variable library (output variables, archived after task completion) and runtime variables (variables during task execution, not viewable if output is not defined or the task terminates); File objects include input and output file objects used to support the transfer of data and materials.

[0092] This embodiment provides preprocessing components and input / output specifications for the experimental process. The specific implementation is as follows: Based on historical experimental data, three types of standardized preprocessing components are generated: Material objects are defined as all physical consumables / samples used in the experiment, with their respective libraries divided into a public library shared across the entire platform and a personal library accessible only to the creator and administrator; Data objects are divided into variable library data (output results) automatically archived upon task completion and runtime variables (temporary process data) automatically cleared upon abnormal task termination; File objects support material parameter transmission through labeled input files (initial scheme / configuration template) and output files (result reports / datasets). Before the experimental process starts, the core inputs are configured through the preprocessing components: including initial materials (consumables / samples), data variables (startup parameters), and initial files / folders (protocol documents); after the process ends, standardized outputs are generated: final materials (experimental products / waste), result data (measured values / statistical values), and result files / folders (analysis reports). Furthermore, in step 302, the input and output of the experimental procedure are generated based on the preprocessing component. The main steps include: first, defining the preprocessing component: performing relevant preparatory work before the experimental procedure, including core inputs such as materials, data, and files. Then, defining the experimental procedure input and output: Input: initial materials (consumables / samples), data variables, and initial files / folders. Output: final materials (experimental products, discarded consumables), result data (experimental data), and result files / folders. Finally, combining the input and output with historical experimental data generates the experimental component.

[0093] In one embodiment of this specification, such as Figure 4 As shown, sorting the experimental components according to user operations further includes,

[0094] Step 401: The experimental components provide a visual editing interface and can pre-set or expand various experimental unit modules;

[0095] Step 402: Obtain the sorting instructions and parameter input instructions for the experimental components based on the user's operation;

[0096] Step 403: In response to the sorting instruction, dynamically generate the corresponding attribute editing panel;

[0097] Step 404: Verify in real time whether the parameter input conforms to the preset data type, numerical range and business rule constraints.

[0098] The sorting of the experimental components based on user operations further includes...

[0099] The sequencing of the experimental components involves complex control logic including concurrent execution, loop execution, and conditional judgment.

[0100] The sorting of experimental components also includes multiple start nodes and end nodes.

[0101] Specifically, during the user's sorting of the experimental components, the compiler module employs a visual interface and component-based design to achieve visual drag-and-drop configuration of the experimental process: users can drag and drop experimental components (such as device driver modules, data processing units, etc.) on the canvas, input and configure parameters through the component property panel, and define complex control logic such as concurrent execution, loop execution, and conditional judgments within the experimental process to meet diverse experimental needs. Multiple start and end nodes can be defined within the experimental process to support more flexible process design. Simultaneously, during compilation, the connection relationships and parameter configurations of the experimental process are rigorously checked to ensure compliance with predefined rules, such as connection rules between components, required fields, type, and range validation of component attributes, etc. Detailed error information is provided when compilation fails to help users quickly locate and resolve problems. A complete experimental process definition is provided, including declarations of materials, data, and files; declarations of inputs and outputs; a complete flowchart; and process parameters and referenced materials, data, and files for each process.

[0102] In one embodiment of this specification, a control component system supporting the design of complex experimental procedures is provided, comprising the following core functional modules:

[0103] 1. Collection of concurrent components – supports the convergence of multiple independent processes to the same node, and supports the synchronous start of all processes from this node, realizing the parallel triggering of experimental tasks;

[0104] 2. Loop Component – ​​A closed loop is formed by a loop start node and a loop end node. Its internal process can be repeatedly executed based on preset conditions (such as the number of loops or termination rules), which is suitable for experimental steps that need to be repeatedly verified.

[0105] 3. Judgment Component – ​​Implements process branch control through logical expressions (such as "temperature > 30℃"), automatically flows to two preset nodes based on the expression result, and supports conditional experimental paths;

[0106] 4. Multiple entry / exit mechanism – Allows setting multiple start nodes (such as starting independent processes under different trigger conditions) and multiple end nodes (such as separating success / failure paths) to meet the flexible arrangement of experiments in multiple scenarios.

[0107] In one embodiment of this specification, the experimental method design tool and compiler are implemented using a client / server architecture. The front-end uses technologies such as HTML (Hypertext Markup Language) + Vue.js (a progressive JavaScript framework for building user interfaces) to provide a graphical interface, while the back-end is responsible for data storage. The front-end and back-end work together to perform compilation and checking processes. It mainly includes two key modules: a compiler module and a component form design tool.

[0108] For example, the compiler module adopts a visual interface and a component-based design philosophy. Users can drag and drop experimental components on a canvas. The system logic flow includes: Component form definition: Users use the component form design tool to edit the attribute form for new components and export a JSON file. Component selection and drag-and-drop: In the compiler module's design canvas, users select the required components from the component library and drag them onto the canvas for layout. Parameter configuration: Users select components on the canvas sequentially and enter parameter values ​​in the attribute editing panel. The system verifies the validity of the input in real time and prompts for errors. Automatic compilation: After the user completes the process configuration, the compilation operation is triggered. The system parses the process structure and parameters and generates a flowchart configuration file. Saving and management: The system saves the current design as a version and updates the compilation history version list, allowing users to revert or restore previous solutions at any time.

[0109] In one embodiment of this specification, such as Figure 5 As shown, the verification of the property panel and configuration parameters of the experimental component further includes,

[0110] Step 501: Verify whether the attribute panel and configuration parameters conform to the preset rules based on the input and output of the experimental process;

[0111] Step 502: If the verification fails, pause the generation process and generate an error message.

[0112] Step 503: During the compilation process, the sorting relationship and parameter configuration between the experimental components are verified according to predefined rules;

[0113] Step 504: When the verification fails, provide a detailed error report including the faulty component identifier, error type, and correction instructions.

[0114] Specifically, the embodiments in this specification improve the rationality of the experimental process through dual logic of parameter validation and process validation. This includes, at the parameter level, obtaining error information from form validation and validating data values, formats, and referenced data sources. And at the process level, validating the execution order of flowchart structure components and checking the composition logic of components to ensure the legality of the process.

[0115] In one embodiment of this specification, the components in the compiler are divided into pre-built components and device function components. Pre-built components are those available by default in the system; device function components are generated visually using a component form design tool according to requirements, and then registered to the component library for use. The pre-built components are further divided into process components, material management components, data operation components, and file management components. The preprocessing components can perform relevant preparatory work before the experimental process, including core inputs such as materials, data, and files. The pre-built components are as follows:

[0116]

[0117]

[0118]

[0119] The compilation rules for the experimental process include: all start components have only one output; all end components have only one input; preprocessing components are not allowed to have input or output; aggregation components are allowed to have only two inputs but only one output; judgment components are allowed to have only one input and two outputs; concurrent collection components are allowed to have multiple inputs and multiple outputs, and the inputs and outputs do not have to be equal; loop components and judgment components are not allowed to be used interchangeably, such as "loop start → judgment → loop end → aggregation"; in addition to the above components, there can only be one input and one output; the flowchart must contain at least one start component; the flowchart must contain at least one end component; loop components must exist in pairs, and the loop start and loop end must correspond one-to-one according to their IDs; judgment and aggregation components must exist in pairs, and the judgment and aggregation must correspond one-to-one according to their IDs; check whether the components in the canvas have been disabled, merged, or do not exist in the component bar (not existing means the component ID does not match, not the component name); loop processes and judgment processes cannot be used interchangeably, that is, they can be used within a loop process; required fields in the component form must be filled in, the input content must be valid, and the referenced materials / data / files must be valid.

[0120] In another embodiment of this specification, such as Figure 6As shown, the user interface provides a component library panel and a design canvas. The component library contains pre-built or expandable experimental unit modules (such as process processing modules, equipment function modules, data processing modules, etc.). Users can add required components to the canvas by dragging and dropping, and input and configure parameters in the property editing panel. The property editing panel is automatically generated according to the component form definition, including controls such as text boxes and drop-down lists, as well as corresponding label prompts. The system uses a rule engine to validate input parameters, ensuring that data types, numerical ranges, and required conditions conform to preset specifications. Once an input that does not meet the requirements is detected, the interface will provide an error message or highlight a flag. The experimental process can define control logic such as sequential execution, conditional judgment, or parallel execution. The compiler module can parse the process structure and convert it into an internal description model. During the compilation phase, if an error occurs, the system will locate the specific component or step and prompt the error reason, making it convenient for users to modify. The designed experimental process and parameters can be saved to a database or version repository. The system generates a version number for each compilation, realizing compilation history version management, so as to trace and compare the differences between different versions.

[0121] In one embodiment of this specification, the experimental components are divided into preset components and device functional components;

[0122] The preset components are experimental components that the system can use by default in historical experimental data;

[0123] The device functional components are experimental components that are visually generated based on requirements using a component form design tool.

[0124] Specifically, the component form design tool provides a visual configuration interface for device driver development, used to design the attribute forms for each component. In the tool's WYSIWYG editing environment, developers can create or edit form controls, supporting the addition of various attribute fields (such as text input boxes, numeric input boxes, radio buttons, checkboxes, dropdown menus, etc.), and specifying labels, names, data sources, default values, and validation rules for each field. After design, the tool can export the form definition as a JSON file, containing information such as the component parameter names, types, and a list of possible values. After the compiler module loads this JSON structure, the corresponding controls can be automatically generated in the attribute panel. The form design tool also has a preview function, allowing users to preview the form's effect in the actual interface and verify whether the field layout and interactive functions meet expectations.

[0125] Component design rules: Each component form follows the following structure, for example:

[0126]

[0127] }

[0128] Through the modules and processes described above, a closed-loop control system from component design to process design is achieved. Users can design and deploy complex experimental methods through a graphical interface without writing underlying code.

[0129] For example, a complete experimental procedure may also include:

[0130] Visual modeling and rule definition of component form structure: Supports the assembly of experimental process components by dragging and dropping on a visual design canvas, realizing graphical configuration of the process.

[0131] Error-guided interaction mechanism in the compiler: Compilation error messages are bound to components, and clicking on the prompt can automatically locate and highlight the component's position, improving user interaction efficiency.

[0132] Compilation history tracking and version rollback mechanism: Each compilation generates a version snapshot, including component layout and parameter status; users can restore historical versions with one click.

[0133] The system employs a dual logic engine for parameter validation and process validation: At the parameter level, it retrieves error messages from form validation and validates data values, formats, and referenced data sources. At the process level, it validates the execution order of flowchart structure components, checks the composition logic of components, and ensures the legality of the process.

[0134] A complete experimental procedure definition includes declarations of materials, data, and documents; declarations of inputs and outputs; a complete flowchart; and the process parameters and referenced materials, data, and documents for each step.

[0135] Through the above experimental steps, the efficiency of experimental process design is significantly improved: The visual drag-and-drop process design eliminates the need for users to write cumbersome scripts, greatly simplifying the design process and significantly improving efficiency compared to traditional manual process design. It also reduces the error rate: Built-in parameter validation and real-time error feedback enable timely detection and correction of parameter input errors during the design phase, reducing runtime debugging and troubleshooting time and significantly improving the reliability of the experimental scheme. Furthermore, the integrated process management system combines process design, code generation, and version management functions, achieving closed-loop automation from experimental scheme design to execution. Users can complete design, compilation, execution, and version control within the same platform, improving the maintainability and traceability of the experimental scheme. Moreover, by providing a visual component form design tool and standardized JSON export, this invention makes component development and reuse easier, reducing development complexity. In addition, the component library can be flexibly expanded as needed to adapt to different experimental requirements. On the other hand, the user interface of the embodiments in this specification is intuitive and user-friendly, supporting WYSIWYG editing and preview, lowering the barrier to entry and enabling non-professional developers to quickly design experimental processes. Improving experimental consistency and reproducibility: A unified platform for process design and parameter management ensures that all experimental steps and parameters are traceable, helping to guarantee the consistency and reproducibility of experimental execution and enhancing the reliability and comparability of experimental results. As one example of this specification, reference may also be made to... Figure 7 The diagram shown is a schematic representation of the experimental procedure design device in this embodiment.

[0136] The component generation module 701 is used to generate multiple experimental components based on historical experimental data. The experimental components include a device driver module and a data processing module.

[0137] User operation module 702 is used to dynamically sort and logically connect the experimental components according to user operations, and obtain the attribute panel and configuration parameters of the experimental components.

[0138] The configuration parameter verification module 703 is used to verify the property panel and configuration parameters of the experimental component.

[0139] The compilation module 704 is used to compile the experimental components that have passed the verification and generate an executable flowchart configuration file;

[0140] The form export module 705 is used to load the flowchart configuration file and generate a visualization of the component parameter structure and execution logic relationship.

[0141] Since the principle of the above-mentioned device in solving the problem is similar to that of the above-mentioned method, the implementation of the above-mentioned system can refer to the implementation of the above-mentioned method, and the repeated parts will not be described again.

[0142] like Figure 8 The diagram shown is a structural schematic of a computer device according to an embodiment of this specification. The computer device in this embodiment can run the methods described in this specification.

[0143] Computer device 802 may include one or more processing devices 804, such as one or more central processing units (CPUs), each of which may implement one or more hardware threads. Computer device 802 may also include any storage resource 806 for storing information of any kind, such as code, settings, data, etc. Non-limitingly, for example, storage resource 806 may include any combination of one or more of the following: any type of RAM, any type of ROM, flash memory devices, hard disks, optical disks, etc. More generally, any storage resource can use any technology to store information.

[0144] Furthermore, any storage resource can provide volatile or non-volatile retention of information.

[0145] Furthermore, any storage resource can represent a fixed or removable component of the computer device 802. In one case, when the processing device 804 executes associated instructions stored in any storage resource or combination of storage resources, the computer device 802 can perform any operation of the associated instructions. The computer device 802 also includes one or more drive systems 808 for interacting with any storage resource, such as a hard disk drive system, an optical disk drive system, etc.

[0146] Computer device 802 may also include an input / output module 810 (I / O) for receiving various inputs (via input device 812) and providing various outputs (via output device 814). A specific output mechanism may include a presentation device 816 and an associated graphical user interface 818 (GUI). In other embodiments, the input / output module 810 (I / O), input device 812, and output device 814 may be omitted, and the device may function solely as a computer device within a network. Computer device 802 may also include one or more network interfaces 820 for exchanging data with other devices via one or more communication links 822. One or more communication buses 824 couple the components described above together.

[0147] Communication link 822 can be implemented in any way, such as via a local area network, a wide area network (e.g., the Internet), a point-to-point connection, or any combination thereof. Communication link 822 may include any combination of hardwired links, wireless links, routers, gateway functions, name servers, etc., governed by any protocol or combination of protocols.

[0148] This specification also provides a computer-readable storage medium storing a computer program that, when executed by a processor, implements the above-described method.

[0149] This specification also provides computer-readable instructions, wherein when a processor executes the instructions, the program therein causes the processor to perform the above-described method.

[0150] It should be understood that in the various embodiments of this specification, the sequence number of each process does not imply the order of execution. The execution order of each process should be determined by its function and internal logic, and should not constitute any limitation on the implementation process of the embodiments of this specification.

[0151] It should also be understood that, in the embodiments of this specification, the term "and / or" is merely a description of the relationship between related objects, indicating that three relationships can exist. For example, A and / or B can represent: A existing alone, A and B existing simultaneously, and B existing alone. Furthermore, in the embodiments of this specification, the character " / " generally indicates that the preceding and following related objects have an "or" relationship.

[0152] Those skilled in the art will recognize that the units and algorithm steps of the various examples described in conjunction with the embodiments disclosed in this specification can be implemented in electronic hardware, computer software, or a combination of both. To clearly illustrate the interchangeability of hardware and software, the components and steps of each example have been generally described in terms of functionality in the foregoing description. Whether these functions are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementations should not be considered beyond the scope of the embodiments in this specification.

[0153] Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the specific working processes of the systems, devices, and units described above can be referred to the corresponding processes in the foregoing method embodiments, and will not be repeated here.

[0154] In the embodiments provided in this specification, it should be understood that the disclosed systems, apparatuses, and methods can be implemented in other ways. For example, the apparatus embodiments described above are merely illustrative; for instance, the division of units is only a logical functional division, and in actual implementation, there may be other division methods. For example, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the couplings or direct couplings or communication connections shown or discussed may be indirect couplings or communication connections through some interfaces, devices, or units, or they may be electrical, mechanical, or other forms of connection.

[0155] The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the units can be selected to achieve the purpose of the embodiments described in this specification, depending on actual needs.

[0156] Furthermore, the functional units in the various embodiments of this specification can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit. The integrated unit can be implemented in hardware or as a software functional unit.

[0157] If the integrated unit is implemented as a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the technical solutions of the embodiments of this specification, in essence, or the parts that contribute to the prior art, or all or part of the technical solutions, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the methods described in the various embodiments of this specification. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

[0158] This specification describes the principles and implementation methods of the embodiments using specific examples. The above descriptions of the embodiments are only for the purpose of helping to understand the methods and core ideas of the embodiments in this specification. At the same time, for those skilled in the art, there will be changes in the specific implementation methods and application scope based on the ideas of the embodiments in this specification. Therefore, the content of this specification should not be construed as a limitation on the embodiments in this specification.

Claims

1. An experimental protocol design method, characterized by, The method includes, Multiple experimental components are generated based on historical experimental data. The experimental components include a device driver module and a data processing module. The experimental components are dynamically sorted and logically connected according to user operations, and the attribute panel and configuration parameters of the experimental components are obtained. The property panel and configuration parameters of the experimental components are validated. The experimental components that have passed the verification are compiled to generate an executable flowchart configuration file; Load the flowchart configuration file to generate a visualization of the parameter structure and execution logic of the experimental components.

2. The experimental protocol design method of claim 1, wherein, Experimental components are generated based on historical experimental data. These experimental components include a device driver module and a data processing unit, which further include... Based on the experimental steps and parameter configurations of the historical experimental data, a preprocessing component is generated, including material objects, data objects, and file objects; The preprocessing component generates the input and output of the experimental process, and the input and output, along with historical experimental data, are used to dynamically generate reusable experimental components.

3. The experimental protocol design method of claim 2, wherein, Sorting the experimental components according to user operations further includes... The experimental components provide a visual editing interface and can be pre-configured or expanded with various experimental unit modules. Based on the user's operation, obtain the sorting instructions and parameter input instructions for the experimental components; In response to the sorting command, a corresponding attribute editing panel is dynamically generated; Real-time verification of whether the parameter input conforms to the preset data type, numerical range and business rule constraints.

4. The experimental protocol design method of claim 2, wherein, Sorting the experimental components according to user operations further includes... The sequencing of the experimental components involves complex control logic including concurrent execution, loop execution, and conditional judgment. The sorting of experimental components also includes multiple start nodes and end nodes.

5. The experimental protocol design method of claim 2, wherein, The validation of the property panel and configuration parameters of the experimental components further includes, Verify whether the attribute panel and configuration parameters conform to preset rules based on the input and output of the experimental process; If the verification fails, the generation process is paused and an error message is generated.

6. The experimental protocol design method of claim 1, wherein, The validated experimental components are compiled to generate a flowchart configuration file, which further includes... During the compilation process, the sorting relationships and parameter configurations between the experimental components are verified according to predefined rules; When verification fails, a detailed error report is provided, including the identifier of the faulty component, the error type, and correction instructions.

7. The experimental protocol design method of claim 1, wherein, The experimental components are divided into pre-set components and equipment functional components; The preset components are experimental components that the system can use by default in historical experimental data; The device functional components are experimental components that are visually generated based on requirements using a component form design tool.

8. An experimental protocol designing apparatus characterized by comprising: The device includes: The component generation module is used to generate multiple experimental components based on historical experimental data. The experimental components include a device driver module and a data processing module. The user operation module is used to dynamically sort and logically connect the experimental components according to user operations, and to obtain the attribute panel and configuration parameters of the experimental components. A configuration parameter verification module is used to verify the property panel and configuration parameters of the experimental components. The compilation module is used to compile the verified experimental components and generate an executable flowchart configuration file; The form export module is used to load the flowchart configuration file and generate a visualization of the parameter structure and execution logic of the experimental components.

9. A computer device comprising a memory, a processor, and a computer program stored on the memory, wherein, When the processor executes the computer program, it implements the method according to any one of claims 1 to 7.

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

11. A computer program product, characterized in that, The computer program product includes a computer program that, when executed by a processor, implements the method of any one of claims 1 to 7.