Modularized robot automatic design method and system based on large language model

Abstract

The invention discloses a modular robot automatic design method and system based on a large language model, and aims to realize full-process automation from natural language input to modular robot structure generation. The method comprises the following steps: constructing a module library comprising basic components and composite components; receiving a natural language description input by a user; performing semantic analysis by using a large language model, and automatically generating a component planning list; calculating spatial positions and connection relations of the components based on recursive assembly reasoning; and generating a three-dimensional assembly code and outputting the structure model. The system comprises an input module, a planner module, an assembler module, a module library and an output module, and all the modules cooperate to realize an automatic design process from a text to a structure model. According to the method, the use threshold of non-professional users is lowered, and the method has good adaptability and expansibility and is suitable for various robot structure design tasks.

Description

Technical Field

[0001] This invention belongs to the field of robot design and manufacturing technology, specifically a modular robot automatic design method and system based on a large language model. Background Technology

[0002] Modular robots are robot systems composed of a group of relatively independent, standardized modular units combined according to certain connection rules. Compared with traditional integrated robots, modular robots have advantages such as flexible structure, easy reconfiguration, and rapid adaptation to various application scenarios, and have been widely used in industrial manufacturing, education and scientific research, and special operations in recent years.

[0003] Current modular robot design primarily relies on two methods: The first is a graphical user interface-based approach, where users manually drag and drop components from a module library using professional modeling software (such as SolidWorks, ROS development environment, Robotics Toolbox, etc.) or a customized interface, gradually building the robot model by adjusting connections and parameters. This method is intuitive, but it requires a high level of robotics knowledge and modeling skills from the user. Complex structures require multiple iterations and modifications, resulting in low design efficiency. Furthermore, model verification (such as interference detection and range of motion analysis) depends on later simulations, making the overall workflow time-consuming and cumbersome.

[0004] The second approach is based on script- or programmatically defined design. Users define components and assembly logic by writing configuration scripts (such as OpenSCAD, URDF files, or custom description languages), and the system generates robot models based on the scripts. This method is widely used in scientific research and engineering, and is suitable for batch generation and version management. However, it still requires mastering script syntax and configuring robotic parameters, and the component assembly relationships need to be manually and accurately described, resulting in a high error rate. It is also extremely unfriendly to non-professional users, making it difficult to promote to widespread application.

[0005] In recent years, to improve the automation of design, some studies have introduced evolutionary algorithms, optimization algorithms, or deep learning for structure generation. For example, some scholars have proposed automatic structure search based on genetic algorithms or graph generation models to optimize robot stability, energy consumption, or mobility. Other methods generate component combinations through high-level task constraints, but still require manual setting of task parameters and configuration of module libraries. Although these methods have achieved certain results in specific tasks (such as terrain adaptation and specific motion trajectories), they often lack versatility, still rely heavily on manual intervention, and cannot meet the flexible and diverse design needs.

[0006] With the significant progress made by large language models (LLMs) in fields such as natural language understanding, code generation, and reasoning planning, some works have begun to explore the use of LLMs for program generation or 3D object description. However, there is still a lack of a systematic approach to using large language models for the entire process design of modular robots, especially an end-to-end solution from natural language input to component planning, recursive assembly reasoning, and standardized modeling code output.

[0007] Therefore, how to fully leverage the capabilities of large language models in semantic understanding and reasoning generation to achieve fully automated design for modular robots, reduce the barrier to entry for non-professional users, and meet diverse task requirements remains a pressing technical challenge.

[0008] The differences compared to existing technologies are as follows:

[0009] Technical comparison with patent CN 117234525 A "Robot building method, device, electronic device and storage medium";

[0010] Patent CN 117234525 A requires the user to manually select a language model tool and determine the first configuration parameters of the tool code. Its robot construction relies on manual settings. In contrast, this patent only requires the user to input advanced instructions, even vague or ambiguous ones. Parameter configuration and component planning are all handled by a single intelligent agent based on a large model. The agent automatically analyzes the advanced instructions and intelligently plans the components. There is a fundamental difference between the two technologies.

[0011] Patent CN 117234525 A provides users with selectable modules and tools, and its automation lies in the fact that once the specific tools are determined, the large model will automatically complete the remaining tasks. This patent, however, employs two intelligent agents working together: one agent selects the modules, and the other assembles them, achieving overall automation. The two patents differ fundamentally in their implementation approaches.

[0012] Technical comparison with patent CN 119128062 A "Automated Process Generation Method, Intelligent Agent and Automated Process Generation System";

[0013] Patent CN 119128062 A uses an intelligent agent to assist users in completing basic tasks in robot production, such as data processing. This patent, however, utilizes an intelligent agent to directly generate the robot structure. The two differ fundamentally in their methodological implementation.

[0014] Patent CN 119128062 A extracts information from the input language by monitoring keywords, while this patent analyzes the entire input natural language directly at a high semantic level. The two have fundamentally different technical approaches. Summary of the Invention

[0015] This invention aims to overcome the problems of poor versatility, complex operation, and low automation in existing modular robot design methods. This invention proposes an automatic modular robot design method and system based on a large language model, which can directly generate modular robot assembly code and 3D models that meet the requirements through natural language input, effectively reducing the design threshold for non-professionals and improving design efficiency and accuracy.

[0016] To achieve the above objectives, the technical solution adopted by the present invention is as follows:

[0017] A modular automatic robot design method based on a large language model, the specific steps of which are as follows:

[0018] S1, building a module library:

[0019] Establish a module library containing basic components and composite components, wherein the components include geometric parameters, interface definitions, functional descriptions, and callable modeling script code for 3D modeling;

[0020] S2, receives natural language input:

[0021] The input module receives natural language text from users describing the robot's structure and functions, including functional goals, structural requirements, or environmental constraints.

[0022] The text input can include qualitative descriptions (e.g., "capable of omnidirectional movement on flat ground") and quantitative constraints (e.g., "arm length not less than 500 mm").

[0023] S3, perform component planning:

[0024] Using a large language model, semantic parsing of natural language text is performed to extract design elements, match module library components, and automatically generate a component planning list. The list includes the type, quantity, functional description, and logical connection relationship of each component with other components.

[0025] S4, Perform assembly reasoning:

[0026] Based on the component planning list and module interface information, the component assembly sequence, interface matching and three-dimensional spatial position are inferred by recursive algorithm to determine the absolute coordinates and attitude parameters of each component in the robot structure.

[0027] S5 generates assembly code;

[0028] Based on component type, interface definition, and spatial relationship, standardized assembly code is automatically generated. The assembly code is in OpenSCAD or other script format that supports 3D model rendering.

[0029] S6 generates assembly code and outputs the results:

[0030] Based on the assembly reasoning results, a 3D modeling script is generated and a 3D structural model file is exported for visualization rendering and subsequent simulation verification.

[0031] As a further improvement to the design method of the present invention, the specific steps of step S1, which involve constructing the module library, are as follows:

[0032] The module library is a collection of component resources used to support robot structure modeling, containing various modular components, including but not limited to:

[0033] Basic components include chassis, standard linkages, joints, and wheels;

[0034] Composite components: including leg module, leg wheel assembly module, six-DOF robotic arm module, and Mecanum wheel module;

[0035] Connection information: Each component contains a well-defined interface description, which includes the interface number, interface direction, and connection type. The connection type includes planar connection, rotational connection, and sliding connection.

[0036] Parameter information includes geometric parameters, such as size, shape, and hole positions; physical properties, such as weight and material; and functional descriptions, such as support, drive, and rotation.

[0037] Each component in the module library is defined as callable code, such as OpenSCAD functions, which support the direct generation of 3D models through code.

[0038] As a further improvement to the design method of the present invention, the component planning in step S3 is as follows:

[0039] High-level semantic parsing of input text is performed using a large language model, including:

[0040] Identify and extract key design elements, including robot type, motion pattern, and number of degrees of freedom;

[0041] Identify the module categories corresponding to functional requirements, including robotic arms, mobile chassis, and wheel assemblies;

[0042] Match applicable components based on the module library;

[0043] Generate a component planning list, which includes:

[0044] Each component has a unique identifier, type, quantity, and functional description, which includes its role in the overall structure and its logical connections with other components.

[0045] In this step, the large language model utilizes pre-set example prompts and a few-shot learning mechanism to enhance its understanding of domain semantics and its ability to match module attributes through multiple rounds of prompts.

[0046] As a further improvement to the design method of the present invention, the assembly reasoning in step S4 is specifically performed as follows:

[0047] Assembly reasoning includes:

[0048] Determine the assembly order between components based on the logical connection relationships defined in the component planning list;

[0049] Based on the interface information of each component, its position and orientation in three-dimensional space are recursively inferred:

[0050] First, determine the initial coordinates and orientation of the reference component;

[0051] Based on the connection relationship, determine the offset and rotation angle of the next level component in the coordinate system of the previous level component in turn;

[0052] The local coordinates of each component are converted into global coordinates using a recursive algorithm.

[0053] Assign 3D position parameters x, y, z and attitude parameters including rotation angle to each component;

[0054] If the component planning includes quantitative constraints, then cumulative calculations are performed based on the parameter information of the module library during inference.

[0055] As a further improvement to the design method of the present invention, step S5, which generates assembly code, is as follows:

[0056] The calling statements for each component;

[0057] Corresponding translation and rotation commands

[0058] Component comments facilitate later maintenance and verification.

[0059] As a further improvement to the design method of the present invention, in step S6, when generating assembly code and outputting results, the user can choose to import the results into simulation software for kinematic verification, interference detection, and performance testing to confirm that the generated model meets the functional requirements.

[0060] The component planning and assembly reasoning are completed by two independent large language model reasoning processes, avoiding context loss and reasoning errors caused by one-time generation, and improving the stability and accuracy of the model. Preferably, the method supports multi-round interactive input, allowing users to modify and supplement the component list or assembly results. Preferably, the assembly reasoning process generates the global position recursively through offset and rotation matrices based on the interface number and orientation identifier of each component.

[0061] This invention relates to a modular automatic robot design method based on a large language model:

[0062] It includes an input module, a planner module, an assembler module, a module library, and an output module. The functions and interrelationships of each module are as follows:

[0063] (1) Input module;

[0064] The input module is used to receive natural language text descriptions input by users and preprocess the input content. The preprocessing includes segmenting the text, removing noise, and standardizing it to convert the user description into a unified text format. The input module can support multi-turn dialogue input, allowing users to supplement or correct the description content during the interaction process, ensuring that the system obtains complete and clear design requirement information.

[0065] (2) Planner module;

[0066] The planner module performs high-level semantic parsing of standardized text based on a large language model to identify functional requirements, structural requirements, constraints, and target tasks. It generates a component planning list through keyword extraction, contextual understanding, and reasoning. The component planning list includes the type, quantity, functional description, logical connection relationship with other components, and key parameters including size and load capacity for each component. The planner module is based on a few-shot learning mechanism to enhance the large language model's understanding of semantics in specific robotic domains by inputting examples, thereby improving the accuracy of generation.

[0067] (3) Assembler module;

[0068] The assembler module receives the component planning list and performs assembly reasoning based on a recursive algorithm. The reasoning process includes determining the component assembly order, matching interface numbers, calculating spatial relative positions and orientations. The assembler module first selects a reference component as the origin of the global coordinate system, and then recursively calculates the offset and rotation angle of the next-level component in the coordinate system of the previous-level component. It converts local coordinates into global coordinates through matrix operations. The module also verifies interface compatibility and constraints to ensure that the component combination meets functional requirements and structural rationality.

[0069] (4) Module library;

[0070] The module library is used to store various standardized module components and their definition information, including component type, geometric parameters, interface description, physical properties and code templates. The module library supports classification by function and hierarchical classification by complexity, including both basic components and composite components. Each component definition contains code files for generating 3D models and interface parameters, which can be called by the assembler module.

[0071] (5) Output module;

[0072] The output module generates standardized assembly code based on the reasoning results of the assembler module. The code is in OpenSCAD or other modeling script format and includes component calls, translation and rotation instructions and comments. The output module exports the assembly code and 3D model files for users to download or preview. It can also transfer the results to the simulation environment for motion verification, interference detection and performance testing. The output module supports outputting the generated results in multiple file formats to adapt to different subsequent development and verification tools.

[0073] As a further improvement to the system of the present invention, the planner module and the assembler module are integrated into the same large language model framework or deployed independently and interact through an intermediate data structure.

[0074] This invention, through the division of labor and collaboration among the aforementioned modules, combined with phased reasoning and recursive assembly calculations, forms a fully automated method from natural language input to 3D model generation. This system significantly lowers the design threshold for non-professional users, improves design efficiency and accuracy, and possesses good versatility, scalability, and adaptability, making it applicable to various robot structure design scenarios.

[0075] Compared with the prior art, the present invention, employing the above technical solution, has the following technical effects:

[0076] This invention discloses a modular robot automatic design method and system based on a large language model, aiming to automate the entire process from natural language input to modular robot structure generation. The method includes: constructing a module library containing basic and composite components; receiving natural language descriptions input by the user; performing semantic parsing using a large language model to automatically generate a component planning list; calculating the spatial positions and connections of components based on recursive assembly reasoning; generating 3D assembly code and outputting a structural model. The system includes an input module, a planner module, an assembler module, a module library, and an output module. These modules work together to achieve the automatic design process from text to a structural model. This invention lowers the barrier to entry for non-professional users, possesses good adaptability and scalability, and is suitable for various robot structure design tasks. Attached Figure Description

[0077] Figure 1 This is a schematic flowchart of the method of the present invention;

[0078] Figure 2 This is a schematic diagram of the system of the present invention. Detailed Implementation

[0079] To further illustrate the present invention, the following detailed description is provided in conjunction with specific embodiments. Those skilled in the art should understand that the following embodiments are for illustrative purposes only and do not limit the scope of protection of the present invention.

[0080] 1. System Structure

[0081] The modular robot automatic design system of this invention has the following process: Figure 1 As shown, the system structure is as follows: Figure 2 As shown, the system includes an input module, a planner module, an assembler module, a module library, and an output module. The input module receives and preprocesses the natural language text input by the user. The planner module performs high-level semantic parsing of the input text based on a large language model, extracting functional requirements and structural constraints to generate a component planning list. The assembler module uses a recursive algorithm to reason about the connection relationships and spatial positions of each component. The module library stores the code definitions, interface information, and parameter attributes of various standardized robot components. The output module outputs the generated assembly code and 3D model files to the user for further rendering and verification.

[0082] The system employs a modular architecture to decouple components and divide functions, with modules interacting through data interfaces. The planner and assembler modules can be deployed within the same large language model framework, or they can call different models for inference.

[0083] 2. Example 1: Design of a Six-DOF Robotic Arm

[0084] This embodiment demonstrates the process of the system generating a six-degree-of-freedom robotic arm.

[0085] Input text:

[0086] "Please design a six-degree-of-freedom robotic arm for grasping objects on a table, with an arm length of no less than 500 millimeters."

[0087] Execution steps:

[0088] (1) Component planning

[0089] The planner module performs semantic parsing on the input text, extracting elements such as "six-degree-of-freedom robotic arm," "grasping objects," and "arm length not less than 500 mm," and matches the following components from the module library:

[0090] Part 1: Chassis

[0091] Part 2: Base Rotation Joint

[0092] Part 3: Shoulder Joint

[0093] Part 4: Elbow Joint

[0094] Part 5: Wrist Joint

[0095] Part 6: End Effector

[0096] Meanwhile, based on the arm length constraint, multiple standard linkage combinations are selected to meet the arm length requirements.

[0097] (2) Assembly reasoning

[0098] The assembler module determines the assembly order of components and recursively calculates position and orientation based on interface definitions:

[0099] part_1 serves as the reference component, with coordinates [0,0,0].

[0100] part_2 is offset by 200 mm on the Z-axis relative to part_1.

[0101] Parts 3 through 5 are stacked sequentially along the Z-axis, with each connecting rod segment approximately 150 mm in length.

[0102] Part 6 is installed at the end effector interface, maintaining its orientation consistent with the joint end effector.

[0103] (3) Assembly code generation

[0104] The system generates an OpenSCAD script containing component function calls and translation / rotation commands:

[0105] translate([0,0,0]) chassis();

[0106] translate([0,0,200]) rotate([0,0,0]) joint();

[0107] translate([0,0,350]) rotate([0,0,0]) link();

[0108] ...

[0109] translate([0,0,800]) gripper();

[0110] (4) Output and Verification

[0111] The assembly code is output, and the user renders the 3D model in OpenSCAD and performs motion verification in simulation software to confirm that the arm length and degree of freedom requirements meet the design goals.

[0112] 3. Example 2: Design of a Four-Mecanum Wheel Mobility Platform

[0113] This embodiment demonstrates the process of the system generating an omnidirectional mobile robot.

[0114] Input text:

[0115] “Design a mobile robot with a four-Mecanum wheel chassis for omnidirectional movement on a plane.”

[0116] Execution steps:

[0117] (1) Component planning

[0118] The planner module parses keywords such as "Mecanum wheel" and "planar omnidirectional movement" and selects them from the module library:

[0119] Part 1: Rectangular chassis

[0120] Part 2~Part 5: Four Mecanum Wheels

[0121] The component planning list clearly states that the four wheels must be installed at the four corners of the chassis.

[0122] (2) Assembly reasoning

[0123] The assembler module calculates the three-dimensional positions of the four wheels based on the chassis's four wheel mounting interfaces:

[0124] Part 2: Coordinates of the front left corner [-300, 300, 0]

[0125] Part 3: Coordinates of the front right corner [300, 300, 0]

[0126] Part 4: Rear left corner coordinates [-300, -300, 0]

[0127] Part 5: Right corner coordinates [300, -300, 0]

[0128] The rotation direction of each wheel is set according to the omnidirectional drive requirements.

[0129] (3) Assembly code generation

[0130] Generate OpenSCAD code:

[0131] chassis();

[0132] translate([-300,300,0]) m_wheel();

[0133] translate([300,300,0]) m_wheel();

[0134] translate([-300,-300,0]) m_wheel();

[0135] translate([300,-300,0]) m_wheel();

[0136] (4) Output and Verification

[0137] Output the script, render the model, and verify the motion characteristics in the simulation environment.

[0138] 4. Applicability and Expansion Description

[0139] The method described in this invention can be applied to various robot structure design tasks, supports expanding new component types by adjusting the module library, and also supports adapting more semantic descriptions by updating prompt templates. If the input text description is complex and diverse, the system can continuously optimize component planning and assembly reasoning during multiple rounds of interaction to meet customized needs.

[0140] Those skilled in the art should understand that the above embodiments are only for illustrating the principles of the present invention and should not be considered as limiting the scope of protection of the present invention. Any obvious improvements or equivalent substitutions without departing from the spirit and substance of the present invention should fall within the scope of protection of the present invention.

Claims

1. A modular automatic robot design method based on a large language model, characterized in that, The specific steps are as follows: S1, building a module library: Establish a module library containing basic components and composite components, wherein the components include geometric parameters, interface definitions, functional descriptions, and callable modeling script code for 3D modeling; S2, receives natural language input: The input module receives natural language text from users describing the robot's structure and functions, including functional goals, structural requirements, or environmental constraints. S3, perform component planning: Using a large language model, semantic parsing of natural language text is performed to extract design elements, match module library components, and automatically generate a component planning list. The list includes the type, quantity, functional description, and logical connection relationship of each component with other components. S4, Perform assembly reasoning: Based on the component planning list and module interface information, the component assembly sequence, interface matching and three-dimensional spatial position are inferred by recursive algorithm to determine the absolute coordinates and attitude parameters of each component in the robot structure. S5 generates assembly code; Based on component type, interface definition, and spatial relationship, standardized assembly code is automatically generated. The assembly code is in OpenSCAD or other script format that supports 3D model rendering. S6 generates assembly code and outputs the results: A 3D modeling script is generated based on the assembly reasoning results, and a 3D structural model file is exported for visualization rendering and subsequent simulation verification.

2. The modular robot automatic design method based on a large language model according to claim 1, characterized in that: The specific steps for constructing the module library in step S1 are as follows: The module library is a collection of component resources used to support robot structure modeling, containing various modular components, including but not limited to: Basic components include chassis, standard linkages, joints, and wheels; Composite components: including leg module, leg wheel assembly module, six-DOF robotic arm module, and Mecanum wheel module; Connection information: Each component contains a well-defined interface description, which includes the interface number, interface direction, and connection type. The connection type includes planar connection, rotational connection, and sliding connection. Parameter information includes geometric parameters, such as size, shape, and hole positions; physical properties, such as weight and material; and functional descriptions, such as support, drive, and rotation.

3. The modular robot automatic design method based on a large language model according to claim 2, characterized in that: The specific steps of component planning in step S3 are as follows: High-level semantic parsing of input text using a large language model includes: Identify and extract key design elements, including robot type, motion pattern, and number of degrees of freedom; Identify the module categories corresponding to functional requirements, including robotic arms, mobile chassis, and wheel assemblies; Match applicable components based on the module library; Generate a component planning list, which includes: The unique component identifier, component type, quantity, functional description, role of each component in the overall structure, and logical connection relationship with other components.

4. The modular robot automatic design method based on a large language model according to claim 1, characterized in that: The assembly reasoning performed in step S4 is as follows: Assembly reasoning includes: Determine the assembly order between components based on the logical connection relationships defined in the component planning list; Based on the interface information of each component, its position and orientation in three-dimensional space are recursively inferred: First, determine the initial coordinates and orientation of the reference component; Based on the connection relationship, determine the offset and rotation angle of the next level component in the coordinate system of the previous level component in turn; The local coordinates of each component are converted into global coordinates using a recursive algorithm. Assign 3D position parameters x, y, z and attitude parameters including rotation angle to each component; If the component planning includes quantitative constraints, then cumulative calculations are performed based on the parameter information of the module library during inference.

5. The modular robot automatic design method based on a large language model according to claim 1, characterized in that: The specific steps for generating assembly code in step S5 are as follows: The calling statements for each component; Corresponding translation and rotation commands Component comments facilitate later maintenance and verification.

6. The modular robot automatic design method based on a large language model according to claim 1, characterized in that: In step S6, when generating assembly code and outputting results, the user can choose to import the results into simulation software for kinematic verification, interference detection, and performance testing to confirm that the generated model meets the functional requirements.

7. A system using the modular robot automatic design method based on a large language model as described in any one of claims 1-6, characterized in that: It includes an input module, a planner module, an assembler module, a module library, and an output module. The functions and interrelationships of each module are as follows: (1) Input module; The input module is used to receive natural language text descriptions input by users and preprocess the input content. The preprocessing includes segmenting the text, removing noise, and standardizing it to convert the user description into a unified text format. The input module can support multi-turn dialogue input, allowing users to supplement or correct the description content during the interaction process, ensuring that the system obtains complete and clear design requirement information. (2) Planner module; The planner module performs high-level semantic parsing of standardized text based on a large language model to identify functional requirements, structural requirements, constraints, and target tasks. It generates a component planning list through keyword extraction, contextual understanding, and reasoning. The component planning list includes the type, quantity, functional description, logical connection relationship with other components, and key parameters including size and load capacity for each component. The planner module is based on a few-shot learning mechanism to enhance the large language model's understanding of semantics in specific robotic domains by inputting examples, thereby improving the accuracy of generation. (3) Assembler module; The assembler module receives the component planning list and performs assembly reasoning based on a recursive algorithm. The reasoning process includes determining the component assembly order, matching interface numbers, calculating spatial relative positions and orientations. The assembler module first selects a reference component as the origin of the global coordinate system, and then recursively calculates the offset and rotation angle of the next-level component in the coordinate system of the previous-level component. It converts local coordinates into global coordinates through matrix operations. The module also verifies interface compatibility and constraints to ensure that the component combination meets functional requirements and structural rationality. (4) Module library; The module library is used to store various standardized module components and their definition information, including component type, geometric parameters, interface description, physical properties and code templates. The module library supports classification by function and hierarchical classification by complexity, including both basic components and composite components. Each component definition contains code files for generating 3D models and interface parameters, which can be called by the assembler module. (5) Output module; The output module generates standardized assembly code based on the reasoning results of the assembler module. The code is in OpenSCAD or other modeling script format and includes component calls, translation and rotation instructions, and comments. The output module exports the assembly code and 3D model files for users to download or preview. It can also transfer the results to the simulation environment for motion verification, interference detection, and performance testing. The output module supports outputting the generated results in multiple file formats to adapt to different subsequent development and verification tools.

8. The system of the modular robot automatic design method based on a large language model according to claim 7, characterized in that: The planner module and the assembler module are integrated within the same large language model framework or deployed independently and interact through an intermediate data structure.

Images