A generative large model-based auxiliary design method for electromechanical products
By dividing the auxiliary design process of electromechanical products into four stages of RFLP model, and using SysML model code to preserve and iterate the design results, the problem of context length limitation of generative large models in auxiliary design is solved, achieving more efficient assisted design and resource utilization.
Patent Information
- Application Number
- CN202411170306.1
- Authority / Receiving Office
- CN · China
- Patent Type
- Patents(China)
- Current Assignee / Owner
- Filing Date
- 2024-08-26
- Publication Date
- 2024-11-12
- Estimated Expiration
- 2044-08-26
AI Technical Summary
In the prior art, when the electromechanical product auxiliary design is based on a generative large model, a complete and continuous auxiliary design cannot be carried out. Because the model has limitations on the context length, it leads to large calculation volume and high memory requirements, and the complete technical content cannot be remembered. Give an incorrect answer when approaching the context upper limit or cannot add new content.
The auxiliary design process of electromechanical products is divided into four independent stages according to the RFLP (Requirements-Functions-Logic-Physical) model. Each stage can be independently carried out, using the SysML model code as the carrier of the design results, and through the generative big model API Gradually generate and save model code for each stage to avoid designing in the same context.
Reduces the consumption of context tokens, saves costs, improves auxiliary design efficiency, and allows parallel design at different stages. Product developers can iterate and improve the design results, avoiding the increase in computing volume and memory requirements during generative big model dialogue. .
Smart Images

Figure CN118673634B_ABST
Abstract
Description
Technical Field
[0001] The present invention belongs to the technical field of artificial intelligence-assisted design, and in particular relates to an assisted design method for electromechanical products based on a generative large model. Background Art
[0002] With the emergence of pre-trained natural language processing large models based on the Transformer architecture, such as ChatGPT, it is possible to complete a variety of tasks in the form of question and answer, such as answering technical questions, translation, summarization, generating text, etc. By conducting multiple rounds of question and answer with the generative large model, it is possible to interactively discuss a technical issue to obtain better results.
[0003] At present, when using generative big models for auxiliary design of electromechanical products, most of them are single questions and answers and discussions on certain technical issues, or professional knowledge bases are built to let generative big models reason and answer technical questions. It is impossible to use generative big models to conduct complete and continuous auxiliary design of a certain electromechanical product, and it is impossible to form a final product solution.
[0004] The above problems are mainly determined by the technical characteristics of the production-type large model itself. Most of the generative large models represented by ChatGPT use the attention mechanism, which enables the generative large model to dynamically focus on the most relevant part of the word currently being processed, while capturing long-distance dependencies and understanding the relationship between words that are far apart in the sentence. However, the attention mechanism requires the model to calculate the association score between the current word and every other word in the context, so the amount of calculation and memory requirements will increase quadratically with the length of the context. Therefore, there is a certain limit to the length of context that the large model can understand and process, and the longer the conversation is, the more memory and calculation are consumed, and the greater the financial cost.
[0005] The above technical characteristics determine that when using generative large models for mechanical and electrical product auxiliary design, it is impossible to carry out complete and continuous auxiliary design. When using generative large models for auxiliary design, as the technical details continue to expand and deepen, the context size will gradually approach the upper limit of the generative large model. When continuing to ask questions, the generative large model will forget the previous technical content and give wrong answers. On the other hand, due to the large length of the context, the amount of calculation each time is very large, and the cost is also very high.
[0006] Therefore, in the prior art, when using generative big models for assisting the design of electromechanical products, there is a problem that the generative big models cannot remember the complete technical content. At the same time, since the generative big models must remember all the previous conversation content every time a conversation is conducted, when the context limit is approached, the generative big models cannot add new content. Therefore, the prior art cannot use the production big models for complete and continuous assisting the design of electromechanical products. Summary of the invention
[0007] In order to solve the problem in the prior art that it is impossible to carry out complete and continuous auxiliary design of electromechanical products in a generative large model dialogue environment, a method for auxiliary design of electromechanical products based on generative large models is provided. The generative large model auxiliary design process of electromechanical products is divided into four stages according to the RFLP (Requirements-Functions-Logic-Physical) model, and each stage can be carried out independently.
[0008] The objective of the present invention is achieved through the following technical solutions:
[0009] A method for auxiliary design of electromechanical products based on a generative large model comprises the following steps:
[0010] Step 1: Product developers provide a text description of the application scenarios and target users of electromechanical products;
[0011] Step 2: Call the generative big model API. The prompt during the call contains two parts. The first part is the application scenario and target user description of electromechanical products, and the second part is the specific work required for the generative big model to perform.
[0012] Step 3: Product developers generate product demand models based on the generative big model API output;
[0013] Step 4: Save the SysML code of the product requirement model output by the generative big model API to the data storage module;
[0014] Step 5: Call the generative big model API. The prompt during the call contains two parts. The first part is the specific work required for the generative big model to be carried out; the second part is the SysML code of the product requirement model, which can be retrieved from the data storage module.
[0015] Step 6: Product developers output product function models based on the generative big model API;
[0016] Step 7: Save the SysML code of the product function model output by the generative big model API to the data storage module;
[0017] Step 8: Call the generative big model API. The prompt during the call contains two parts. The first part is the specific work required for the generative big model to be carried out; the second part is the SysML code of the product function model, which can be retrieved from the data storage module.
[0018] Step 9: Product developers output the product logic model based on the generative big model API;
[0019] Step 10: Save the SysML code of the product logic model output by the generative big model API to the data storage module;
[0020] Step 11: Call the generative big model API. The prompt during the call contains two parts. The first part is the specific work required for the generative big model to be performed; the second part is the SysML code of the product logic model, which can be retrieved from the data storage module.
[0021] Step 12: Product developers output the product physical model based on the generative big model API;
[0022] Step 13: Save the product physical model SysML code output by the generative large model API to the data storage module.
[0023] Preferably, the four stages of step 2 to step 4, step 5 to step 7, step 8 to step 10 and step 11 to step 13 are not prioritized, and each stage can be carried out independently.
[0024] Preferably, repeat steps 2 to 4 to form a final product requirement model; repeat steps 5 to 7 to form a final product function model; repeat steps 8 to 10 to form a final product logic model; repeat steps 11 to 13 to form a final product physical model.
[0025] Preferably, in the step 2, based on the above description, according to the system engineering theory and the RFLP model, a stakeholder identification analysis is performed, a product requirement model is proposed, and a complete description is performed using SysML syntax so that it can be read in a SysML editor.
[0026] Preferably, the product requirement model SysML code is converted into a product requirement model diagram in a SysML editor to facilitate understanding by product developers.
[0027] Preferably, in step five, based on system engineering theory and RFLP model, a product function model is given according to the following product requirement model SysML code. The product function model must fully implement all the contents in the requirement model and be fully described using SysML syntax so that it can be read in a SysML editor.
[0028] Preferably, the product function model SysML code is converted into a product function model diagram in a SysML editor to facilitate understanding by product developers.
[0029] Preferably, in step eight, based on system engineering theory and RFLP model, a product logic model is given according to the following product functional model SysML code. The product logic model must fully implement all contents in the functional model and be fully described using SysML syntax so that it can be read in a SysML editor.
[0030] Preferably, the logical model SysML code is converted into a product logical model diagram in a SysML editor to facilitate understanding by product developers.
[0031] Preferably, in step eleven, based on system engineering theory and RFLP model, a product physical model is given according to the following product logical model SysML code. The physical model must fully implement all contents in the logical model and be fully described using SysML syntax so that it can be read in a SysML editor.
[0032] Preferably, the product physical model SysML code is converted into a product physical model diagram in a SysML editor to facilitate understanding by product developers.
[0033] The beneficial effects of this technical solution are as follows:
[0034] 1. The present invention provides a generative large model-based electromechanical product auxiliary design method, which divides the generative large model-assisted design process of electromechanical products into four stages according to the RFLP model, and each stage can be carried out independently.
[0035] 2. The present invention provides an auxiliary design method for electromechanical products based on a generative large model. The auxiliary design process at different stages does not need to be kept in the same context environment, which reduces the consumption of context tokens, saves costs, and improves the efficiency of auxiliary design.
[0036] 3. The present invention provides an auxiliary design method for electromechanical products based on a generative large model. The auxiliary design process at different stages can be carried out separately by different product developers to achieve parallel design and improve auxiliary design efficiency.
[0037] 4. The present invention provides an auxiliary design method for electromechanical products based on a generative big model, and proposes to use SysML model code as a carrier of the design results of the generative big model, so that product developers can specifically require the production big model to iteratively improve the design results. BRIEF DESCRIPTION OF THE DRAWINGS
[0038] Figure 1 The process of the present invention is shown in FIG. Figure 1 ;
[0039] Figure 2 The process of the present invention is shown in FIG. Figure 2 ;
[0040] Figure 3 This is a product demand model diagram in Example 2 of the present invention;
[0041] Figure 4 The product function model in Example 2 of the present invention Figure 1 ;
[0042] Figure 5 The product function model in Example 2 of the present invention Figure 2 ;
[0043] Figure 6 The product logic model in Example 2 of the present invention Figure 1 ;
[0044] Figure 7 The product logic model in Example 2 of the present invention Figure 2 ;
[0045] Figure 8 This is a physical model diagram of the product in Example 2 of the present invention. DETAILED DESCRIPTION
[0046] The present invention is further described in detail below in conjunction with examples, but the embodiments of the present invention are not limited thereto.
[0047] Example 1
[0048] like Figure 1 and Figure 2 As shown, a method for auxiliary design of electromechanical products based on a generative large model includes the following steps:
[0049] Step 1: Product developers provide a text description of the application scenarios and target users of electromechanical products;
[0050] Step 2: Call the generative big model API. The prompt during the call contains two parts. The first part is the application scenario and target user description of electromechanical products, and the second part is the specific work required for the generative big model to perform.
[0051] Step 3: Product developers generate product demand models based on the generative big model API output;
[0052] Step 4: Save the SysML code of the product requirement model output by the generative big model API to the data storage module;
[0053] Step 5: Call the generative big model API. The prompt during the call contains two parts. The first part is the specific work required for the generative big model to be carried out; the second part is the SysML code of the product requirement model, which can be retrieved from the data storage module.
[0054] Step 6: Product developers output product function models based on the generative big model API;
[0055] Step 7: Save the SysML code of the product function model output by the generative big model API to the data storage module;
[0056] Step 8: Call the generative big model API. The prompt during the call contains two parts. The first part is the specific work required for the generative big model to be carried out; the second part is the SysML code of the product function model, which can be retrieved from the data storage module.
[0057] Step 9: Product developers output the product logic model based on the generative big model API;
[0058] Step 10: Save the SysML code of the product logic model output by the generative big model API to the data storage module;
[0059] Step 11: Call the generative big model API. The prompt during the call contains two parts. The first part is the specific work required for the generative big model to be performed; the second part is the SysML code of the product logic model, which can be retrieved from the data storage module.
[0060] Step 12: Product developers output the product physical model based on the generative big model API;
[0061] Step 13: Save the product physical model SysML code output by the generative large model API to the data storage module.
[0062] Among them, the four stages of step 2 to step 4, step 5 to step 7, step 8 to step 10 and step 11 to step 13 are not in order, and each stage can be carried out independently.
[0063] Among them, repeat steps 2 to 4 to form the final product demand model; repeat steps 5 to 7 to form the final product function model; repeat steps 8 to 10 to form the final product logic model; repeat steps 11 to 13 to form the final product physical model.
[0064] Among them, in the step 2, based on the above description, according to the system engineering theory and the RFLP (Requirements-Functions-Logic-Physical) model, a stakeholder identification analysis is carried out, a product requirement model is proposed, and a complete description is performed using SysML syntax so that it can be read in a SysML editor.
[0065] Among them, the product requirement model SysML code is converted into a product requirement model diagram in the SysML editor to facilitate the understanding of product developers.
[0066] Among them, in step 5, based on system engineering theory and RFLP model, according to the following product requirement model SysML code, the product function model is given. The product function model must fully implement all the contents in the requirement model and use SysML syntax for a complete description so that it can be read in the SysML editor. In particular, when calling the generative large model API in this step, it is not necessary to maintain the same context environment as step 2, because the previous design results have all been saved in the product requirement model SysML code. The generative large model API does not need to remember the previous conversation content, so as to reduce the consumption of the number of context tokens and improve the efficiency of auxiliary design.
[0067] Among them, the product function model SysML code is converted into a product function model diagram in the SysML editor to facilitate product developers to understand.
[0068] Among them, in step eight, based on system engineering theory and RFLP model, according to the following product functional model SysML code, the product logical model is given. The product logical model must fully implement all the contents in the functional model and use SysML syntax to fully describe it so that it can be read in the SysML editor. When calling the generative large model API in this step, it is not necessary to maintain the same context environment as step five.
[0069] Among them, the logical model SysML code is converted into a product logical model diagram in the SysML editor to facilitate product developers to understand.
[0070] Among them, in step 11, based on system engineering theory and RFLP model, according to the following product logical model SysML code, the product physical model is given. The physical model must fully implement all the contents in the logical model and use SysML syntax to fully describe it so that it can be read in the SysML editor. In particular, when calling the generative large model API in this step, it is not necessary to maintain the same context environment as step 8.
[0071] Among them, the product physical model SysML code is converted into a product physical model diagram in the SysML editor to facilitate product developers to understand.
[0072] Example 2
[0073] The following is an example of an auxiliary design method for electromechanical products (electric office lifting table) based on a generative large model:
[0074] 1. The product developers shall give a text description of the application scenarios and target users of the office electric lift table. Specifically, we need to design a chair that is mainly designed for office workers who sit for a long time, hoping to reduce the health problems caused by long-term sitting and relieve the pressure on the cervical and lumbar vertebrae.
[0075] 2. Call the generative big model API. The prompt word during the call contains two parts. The first part is the application scenario and target user description of the office electric lift table. The second part is the specific work required for the generative big model to carry out. The complete prompt word content is: We need to design an office electric lift table. This office electric lift table is mainly designed for office sedentary people. We hope to reduce the health problems caused by long-term sitting and relieve the pressure on the cervical and lumbar vertebrae. Based on the above description, according to the system engineering theory and the RFLP (Requirements-Functions-Logic-Physical) model, we conduct stakeholder identification and analysis, propose a product demand model, and use SysML syntax to fully describe it so that it can be read in the PlantUML open source SysML editor.
[0076] The SysML code of the office electric lift table requirement model given by the generative big model API is:
[0077] @startuml
[0078] title "Electric height adjustable table demand model and stakeholder analysis"
[0079] ' Definition of stakeholders
[0080] actor as user
[0081] actor producer
[0082] actor as maintainer
[0083] actor as buyer
[0084] actor as designer
[0085] actor supplier
[0086] actor environmental organization as eco_organization
[0087] actor as regulator
[0088] actor as safety_tester
[0089] actor quality_controller
[0090] 'Requirement definition
[0091] rectangle "ergonomic design" as ergonomic_design
[0092] rectangle "Reduce cervical and lumbar pressure" as reduce_tension
[0093] rectangle "height adjustable" as height_adjustable
[0094] rectangle "Operational Requirements" as operational
[0095] rectangle "ease of use" as ease_of_use
[0096] rectangle "memory function" as memory_function
[0097] rectangle "safety requirements" as safety
[0098] rectangle "Low Noise" as low_noise
[0099] rectangle "Safety Lock" as safety_lock
[0100] rectangle "Durability" as durability
[0101] rectangle "Anti-wear design" as anti_wear
[0102] rectangle "Low maintenance" as low_maintenance
[0103] rectangle "aesthetics" as aesthetics
[0104] rectangle "simple design" as simple_design
[0105] rectangle "in line with the office environment" as office_appropriate
[0106] 'Demand breakdown
[0107] ergonomic_design -->reduce_tension
[0108] ergonomic_design -->height_adjustable
[0109] operational --> ease_of_use
[0110] operational -->memory_function
[0111] safety -->low_noise
[0112] safety -->safety_lock
[0113] durability -->anti_wear
[0114] durability --> low_maintenance
[0115] aesthetics --> simple_design
[0116] aesthetics -->office_appropriate
[0117] 'Demand allocation
[0118] user -->ergonomic_design
[0119] user -->operational
[0120] user -->safety
[0121] user -->aesthetics
[0122] manufacturer -->height_adjustable
[0123] manufacturer -->ease_of_use
[0124] manufacturer -->safety_lock
[0125] manufacturer -->anti_wear
[0126] maintainer -->low_maintenance
[0127] maintainer -->low_noise
[0128] buyer -->memory_function
[0129] buyer -->low_noise
[0130] buyer -->office_appropriate
[0131] designer -->ergonomic_design
[0132] designer -->operational
[0133] designer -->durability
[0134] designer -->aesthetics
[0135] supplier -->anti_wear
[0136] eco_organization -->low_maintenance
[0137] regulator -->safety
[0138] safety_tester -->safety_lock
[0139] quality_controller -->ergonomic_design
[0140] quality_controller -->operational
[0141] quality_controller -->safety
[0142] quality_controller -->durability
[0143] quality_controller -->aesthetics
[0144] @enduml
[0145] 3. The SysML code of the product requirement model can be converted into a product requirement model diagram in the SysML editor, which is easy for product developers to understand. In this example, the PlantUML open source editor is used to draw the product requirement model diagram. The graphical result is as follows: Figure 3 shown.
[0146] 4. Product developers further request the improvement of the office electric lift table demand model output by the generative big model API to form the final office electric lift table demand model. This step is the same as the general generative big model dialogue process.
[0147] 5. Save the SysML code of the office electric lift table requirement model output by the generative large model API to the data storage module.
[0148] 6. Call the generative big model API. The prompt word during the call contains two parts. The first part is the specific work required for the generative big model to carry out. The content is: Based on the system engineering theory and the RFLP (Requirements-Functions-Logic-Physical) model, according to the following office electric lift table requirement model SysML code, the office electric lift table function model is given. The product function model must fully implement all the contents in the requirement model and use SysML syntax for a complete description so that it can be read in the SysML editor. The second part is the office electric lift table requirement model SysML code, which can be taken out from the data storage module.
[0149] The SysML code of the office electric lift table function model given by the generative large model API is:
[0150] @startuml
[0151] title "Electric lifting table function model"
[0152] 'Main function definition
[0153] package "Height Control System" {
[0154] usecase "Electric Adjustment System" as ElectricAdjustment
[0155] usecase "manual control device" as ManualControl
[0156] }
[0157] package "User Interaction System" {
[0158] usecase "touchscreen interface" as TouchInterface
[0159] usecase "physical buttons" as Buttons
[0160] usecase "display interface" as Display
[0161] usecase "preset height memory" as PresetMemory
[0162] }
[0163] package "Security System" {
[0164] usecase "overload protection" as OverloadProtection
[0165] usecase "Automatic Lock" as AutoLock
[0166] usecase "noise reduction" as NoiseReduction
[0167] }
[0168] package "Structure and Materials" {
[0169] usecase "wear-resistant material" as WearResistantMaterial
[0170] usecase "Easy Cleaning Design" as EasyCleaning
[0171] }
[0172] package "Maintenance and Services" {
[0173] usecase "modular components" as ModularComponents
[0174] usecase "Minimize Maintenance" as MinimalMaintenance
[0175] }
[0176] package "Aesthetic Design" {
[0177] usecase "Modern Appearance" as Modern Appearance
[0178] usecase "Diverse Material Color Selection" as DiverseMaterials
[0179] }
[0180] ' Definition of relationships between functions
[0181] ElectricAdjustment -->TouchInterface : "Control via touch screen"
[0182] ManualControl -->Buttons : "Control by physical buttons"
[0183] TouchInterface -->Display: "Display current height information"
[0184] TouchInterface -->PresetMemory: "Set and call preset height"
[0185] OverloadProtection -->ElectricAdjustment : "Protect the electric adjustment system"
[0186] AutoLock -->ManualControl : "Lock manual control"
[0187] NoiseReduction -->ElectricAdjustment : "Reduce operating noise"
[0188] WearResistantMaterial -->ElectricAdjustment : "Improve durability"
[0189] EasyCleaning -->WearResistantMaterial : "Wear-resistant material is easy to clean"
[0190] ModularComponents --> WearResistantMaterial : "Modular and easy to replace"
[0191] MinimalMaintenance -->ModularComponents : "Reduce maintenance requirements"
[0192] ModernAppearance -->DiverseMaterials : "Appearance design depends on material and color selection"
[0193] 'Requirements and Functionality Mapping
[0194] "Ergonomic design" --> ElectricAdjustment: "Meet ergonomic design requirements"
[0195] "Height adjustable" --> ElectricAdjustment : "Meet height adjustable requirements"
[0196] "Ease of use" --> TouchInterface : "Simplify user interaction"
[0197] "Memory function" -->PresetMemory: "Provide memory function"
[0198] "Safety requirements" --> OverloadProtection: "Ensure safe use"
[0199] "Low noise" --> NoiseReduction : "Achieve low noise operation"
[0200] "Safety Lock" --> AutoLock: "Increase automatic locking security"
[0201] "Durability" --> WearResistantMaterial : "Improve product durability"
[0202] "Anti-wear design" --> WearResistantMaterial : "Corresponding to wear-resistant requirements"
[0203] "Low maintenance" -->MinimalMaintenance : "Reduce maintenance requirements"
[0204] "Aesthetic requirements" --> ModernAppearance : "Meet the aesthetic design requirements"
[0205] "Simple design" --> ModernAppearance : "In line with the trend of simple design"
[0206] "Suitable for office environment" -->DiverseMaterials : "Materials and color choices suitable for office environment"
[0207] @enduml
[0208] 7. The product function model SysML code can be converted into a product function model diagram in the SysML editor, which is easy for product developers to understand. In this example, the PlantUML open source editor is used to draw the product function model diagram. The graphical result is as follows: Figure 4 and Figure 5 shown.
[0209] 8. The product developer further requires the office electric lift table function model output by the generative big model API to be improved to form the final office electric lift table function model. This step is the same as the general generative big model dialogue process.
[0210] 9. Save the SysML code of the product function model output by the generative big model API to the data storage module.
[0211] 10. Call the generative big model API. The prompt word during the call contains two parts. The first part is the specific work required for the generative big model to carry out. The content is: Based on the system engineering theory and the RFLP (Requirements-Functions-Logic-Physical) model, according to the following office electric lift table functional model SysML code, the office electric lift table logical model is given. The logical model must fully implement all the contents in the functional model and use SysML syntax for a complete description so that it can be read in the SysML editor. The second part is the office electric lift table functional model SysML code, which can be taken out from the data storage module.
[0212] The SysML code of the office electric lift table logic model given by the generative large model API is:
[0213] @startuml
[0214] title "Logical Model of Office Electric Lift Table"
[0215] ' Electronics and control system components
[0216] package "Control System" {
[0217] [Central Control Unit] asCentralControl
[0218] [User Interface Controller] as UIControl
[0219] [Drive interface] asDriveInterface
[0220] }
[0221] package "Display and Interaction" {
[0222] [Display Control Module] asDisplayControl
[0223] [User Interface] asUserInterface
[0224] }
[0225] package "Drive and Actuator" {
[0226] [Motor drive unit] asMotorDriveUnit
[0227] [Lift Motor] asLiftMotor
[0228] }
[0229] package "Safety & Security" {
[0230] [Safety Monitoring Unit] asSafetyMonitor
[0231] [Auto Lock System] asAutoLockSystem
[0232] }
[0233] package "inputdevice" {
[0234] [Touch screen input system] asTouchInput
[0235] [Physical button panel] asButtonPanel
[0236] }
[0237] ' Mechanical structure components
[0238] package "Mechanical Structure" {
[0239] [Tabletop] asTableTop
[0240] [Table leg support] asLegSupport
[0241] [Mechanical Links] asMechanicalLinks
[0242] [Stabilizer] asStabilizer
[0243] }
[0244] ' Power supply system
[0245] package "Power System" {
[0246] [Power Unit] asPowerUnit
[0247] [Power Management] asPowerManagement
[0248] }
[0249] ' Relationships between components
[0250] CentralControl -->UIControl: Control instructions
[0251] UIControl --> DriveInterface: parameter passing
[0252] DriveInterface -->MotorDriveUnit : Drive signal
[0253] MotorDriveUnit -->LiftMotor: Execute command
[0254] UIControl -->DisplayControl: User interface data
[0255] DisplayControl -->UserInterface: Visual Output
[0256] SafetyMonitor -->CentralControl: Safety feedback
[0257] CentralControl -->AutoLockSystem: Lock command
[0258] TouchInput --> UIControl : User command
[0259] ButtonPanel --> UIControl: Physical Input
[0260] CentralControl -->SafetyMonitor: Status query
[0261] LiftMotor -->[Position sensor]: Position feedback
[0262] [Position Sensor] --> MotorDriveUnit: Real-time Adjustment
[0263] LiftMotor -down->LegSupport: Desktop lifting
[0264] TableTop -right->LegSupport: Fixed connection
[0265] MechanicalLinks -left->TableTop: Fixed architecture
[0266] MechanicalLinks -down->LegSupport: Connect table legs
[0267] PowerUnit -->PowerManagement: Power allocation
[0268] PowerManagement -->MotorDriveUnit: Provides power
[0269] PowerManagement -->DisplayControl: Power supply
[0270] ' Stakeholder Interaction
[0271] actor user
[0272] Actor Maintenance Technician
[0273] Actor Security Manager
[0274] User-->UserInterface: User interface interaction
[0275] User-->TouchInput: Touch input
[0276] User-->ButtonPanel: Button operation
[0277] Maintenance Technician --> CentralControl: Maintenance System
[0278] Safety Administrator-->SafetyMonitor: monitor safety system
[0279] @enduml
[0280] 11. The product logic model SysML code can be converted into an office electric lift table logic model diagram in the SysML editor, which is easy for product developers to understand. In this example, the PlantUML open source editor is used to draw the office electric lift table logic model diagram. The graphical result is as follows: Figure 6 and Figure 7 shown.
[0281] 12. The product developer further requires the office electric lift table logic model output by the generative big model API to be improved to form the final office electric lift table logic model. This step is the same as the general generative big model dialogue process.
[0282] 13. Save the SysML code of the office electric lift table logic model output by the generative large model API to the data storage module.
[0283] 14. Call the generative big model API. The prompt during the call contains two parts. The first part is the specific work required for the generative big model to be carried out. The content is: Based on the system engineering theory and the RFLP (Requirements-Functions-Logic-Physical) model, according to the following SysML code of the office electric lift table logical model, give the physical model of the office electric lift table. The physical model must fully implement all the contents in the logical model and use SysML syntax for a complete description so that it can be read in the SysML editor.
[0284] The SysML code of the physical model of the office electric lift table given by the generative large model API is:
[0285] @startuml
[0286] title "Physical Model of Office Electric Lift Table"
[0287] 'Product structure diagram
[0288] frame "Electric lifting table system architecture" {
[0289] package "Control and Communication Components" {
[0290] [Main control unit: STM32F407\nMaterial: Microcontroller\nSpecification: 168 MHz ARMCortex-M4\nQuantity: 1]as MCU
[0291] [User Interface Controller: Arduino Uno\nMaterial: Microcontroller\nSpecification: 16 MHz ATmega328\nQuantity: 1]as UIC
[0292] [Touch screen system: Raspberry Pi touch display\nMaterial: Touch screen\nSpecification: 7 inches\nQuantity: 1] as TIS
[0293] [Button Panel: Homemade PCB with touch buttons\nMaterial: Printed Circuit Board\nSpecification: Standard Size\nQuantity: 1] as BP
[0294] }
[0295] package "Display and Output Components" {
[0296] [Display module: 7'' TFT LCD\nMaterial: LCD screen\nSpecification: 800x480pixels\nQuantity: 1]as DM
[0297] [Security Monitoring Unit: Raspberry Pi 3\nMaterial: Microcomputer\nSpecification: 1.2 GHzQuad-Core ARM Cortex-A53\nQuantity: 1]as SCM
[0298] [Locking mechanism: electromagnetic lock\nMaterial: electromagnet\nSpecification: 12V high torque\nQuantity: 1] asLM
[0299] }
[0300] package "Driver and Execution Components" {
[0301] [Motor drive interface: L298N H-Bridge\nMaterial: Drive module\nSpecification: Dual channel, high current\nQuantity: 1] as MDI
[0302] [Motor drive unit: NEMA 17 stepper motor drive\nMaterial: Stepper motor drive\nSpecification: Compatible with NEMA 17\nQuantity: 4] as MDD
[0303] [Lifting motor: NEMA 17\nMaterial: Stepper motor\nSpecification: 1.8° step\nQuantity: 4]as LM
[0304] }
[0305] package "Mechanical Structure Components" {
[0306] [Tabletop: Reinforced Laminated MDF\nMaterial: Medium Density Fiberboard\nDimensions: 1200 x 800 mm, Thickness 30 mm\nQuantity: 1]as TP
[0307] [Table leg support: aluminum alloy\nMaterial: aluminum alloy\nSpecification: Height 700 mm\nQuantity: 4] asLS
[0308] [Connectors: Stainless steel fasteners\nMaterial: Stainless steel\nSpecifications: Standard size\nQuantity: Multiple] as CH
[0309] [Stabilizer: Stabilizer bar\nMaterial: Aluminum alloy\nSpecification: Standard long bar\nQuantity: 4] as SB
[0310] }
[0311] package "Power Management Components" {
[0312] [Power Module: AC-DC Power Supply\nMaterial: Power Supply Unit\nSpecifications: 110-240 VAC to 24 V DC\nQuantity: 1]as PM
[0313] [Energy Management System: Integrated Energy Controller\nMaterial: Controller\nSpecification: Energy Optimization Management\nQuantity: 1] as EM
[0314] }
[0315] }
[0316] ' Information flow and control logic between components
[0317] MCU -->UIC: Control instructions
[0318] UIC -->TIS : Data Transfer
[0319] UIC -->BP : Data Transfer
[0320] UIC -->DM: Data Display
[0321] UIC -->MDI: Control commands
[0322] MDI -->MDD: drive signal
[0323] MDD -->LM: Lift and lower execution
[0324] TP -down->LS : Mechanical support
[0325] LS -down->CH : stable structure
[0326] PM -right->EM : Power supply
[0327] EM -down->MDD: Regulate power
[0328] EM -down->DM : Power supply
[0329] ' Define the interactions with stakeholders
[0330] actor as User
[0331] actor technician
[0332] actor System Administrator as Admin
[0333] User -->TIS : Operation Input
[0334] User -->BP : Key operation
[0335] User -->DM : Feedback View
[0336] Technician -->MCU: Perform diagnostics
[0337] Technician -->MDD : Perform maintenance
[0338] Admin --> SCM: System Monitoring
[0339] Admin -->LM: Security Control
[0340] @enduml
[0341] 15. The product physical model SysML code can be converted into the office electric lift table physical model diagram in the SysML editor, which is easy for product developers to understand. In this example, the PlantUML open source editor is used to draw the office electric lift table logical model diagram. The graphical result is as follows: Figure 8 shown.
[0342] 16. The product developer further requires the office electric lift table physical model output by the generative big model API to be improved to form the final office electric lift table physical model. This step is the same as the general generative big model dialogue process.
[0343] 17. Save the SysML code of the office electric lift table physical model output by the generative large model API to the data storage module.
[0344] Finally, it should be noted that the above embodiments are only used to illustrate rather than limit the technical solutions of the present invention. Although the present invention has been described in detail with reference to the above embodiments, those skilled in the art should understand that the present invention can still be modified or replaced by equivalents. Any modification or partial replacement that does not depart from the spirit and scope of the present invention should be included in the scope of the claims of the present invention.
Claims
1. A method for auxiliary design of electromechanical products based on generative large models, It is characterized in that The following steps are involved: Step 1: Product developers provide a text description of the application scenarios and target users of electromechanical products; Step 2: Call the generative big model API. The prompt during the call contains two parts. The first part is the application scenario and target user description of electromechanical products, and the second part is the specific work required for the generative big model to perform. Step 3: Product developers generate product demand models based on the generative big model API output; Step 4: Save the SysML code of the product requirement model output by the generative big model API to the data storage module; Step 5: Call the generative big model API. The prompt during the call contains two parts. The first part is the specific work required for the generative big model to be carried out; the second part is the SysML code of the product requirement model, which can be taken out from the data storage module. In step 5, based on the system engineering theory and the RFLP model, the product function model is given according to the following SysML code of the product requirement model. The product function model must fully implement all the contents in the requirement model and be fully described using SysML syntax so that it can be read in the SysML editor. Step 6: Product developers output product function models based on the generative big model API; Step 7: Save the SysML code of the product function model output by the generative big model API to the data storage module; Step 8: Call the generative big model API. The prompt during the call contains two parts. The first part is the specific work required for the generative big model to be carried out; the second part is the SysML code of the product function model, which can be retrieved from the data storage module. Step 9: Product developers output the product logic model based on the generative big model API; Step 10: Save the SysML code of the product logic model output by the generative big model API to the data storage module; Step 11: Call the generative big model API. The prompt during the call contains two parts. The first part is the specific work required for the generative big model to be performed; the second part is the SysML code of the product logic model, which can be retrieved from the data storage module. Step 12: Product developers output the product physical model based on the generative big model API; Step 13: Save the product physical model SysML code output by the generative large model API to the data storage module.
2. According to claim 1, a method for auxiliary design of electromechanical products based on generative large models, Features: The four stages of step 2 to step 4, step 5 to step 7, step 8 to step 10 and step 11 to step 13 are not prioritized, and each stage can be carried out independently.
3. According to claim 1, a method for auxiliary design of electromechanical products based on generative large models, Features: Repeat steps 2 to 4 to form the final product requirement model; repeat steps 5 to 7 to form the final product function model; repeat steps 8 to 10 to form the final product logic model; repeat steps 11 to 13 to form the final product physical model.
4. The electromechanical product auxiliary design method based on generative large model according to claim 1, Features: In the step 2, based on the above description, according to the system engineering theory and the RFLP model, a stakeholder identification analysis is performed, a product requirement model is proposed, and a complete description is performed using SysML syntax so that it can be read in a SysML editor.
5. According to claim 4, a method for auxiliary design of electromechanical products based on generative large models, Features: Convert the product requirement model SysML code into a product requirement model diagram in the SysML editor to facilitate product developers to understand.
6. The electromechanical product auxiliary design method based on generative large model according to claim 1, Features: Convert the product function model SysML code into a product function model diagram in the SysML editor to facilitate product developers to understand.
7. The electromechanical product auxiliary design method based on generative large model according to claim 1, Features: In step eight, based on system engineering theory and RFLP model, the product logic model is given according to the following product functional model SysML code. The product logic model must fully implement all the contents in the functional model and use SysML syntax to fully describe it so that it can be read in the SysML editor.
8. The electromechanical product auxiliary design method based on generative large model according to claim 7, Features: Convert the logical model SysML code into a product logical model diagram in the SysML editor to facilitate product developers to understand.
9. The electromechanical product auxiliary design method based on generative large model according to claim 1, Features: In step 11, based on system engineering theory and RFLP model, the product physical model is given according to the following product logical model SysML code. The physical model must fully implement all the contents in the logical model and use SysML syntax to fully describe it so that it can be read in the SysML editor.
10. The electromechanical product auxiliary design method based on generative large model according to claim 9, Features: Convert the product physical model SysML code into a product physical model diagram in the SysML editor to facilitate product developers to understand.
