菜单
SolidWorks自动化建模skill，内置完整的SW教程知识体系。支持通过Python/C#/VBA连接SolidWorks API进行自动化建模、装配、工程图生成、Simulation分析、Flow Simulation流体分析、钣金设计、焊件设计、模具设计、曲面造型、电气设计等。
用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
基于 SOC 职业分类
| name | solidworks-automation |
| description | SolidWorks自动化建模skill，内置完整的SW教程知识体系。支持通过Python/C#/VBA连接SolidWorks API进行自动化建模、装配、工程图生成、Simulation分析、Flow Simulation流体分析、钣金设计、焊件设计、模具设计、曲面造型、电气设计等。 |
| category | engineering-cad |
| version | 5.3.0 |
| author | Delancy |
Before using this skill, identify the active AI model/runtime and state whether it can inspect images/PDF pages directly.
When automating a SolidWorks assembly from multi-view drawings, especially a clevis/fork/link/pin mechanism, load and follow:
docs/solidworks-assembly-debugging-lessons.mdIf that file is not present in the installed skill package, do not block the task; follow the embedded rules below.
Key rules from that lesson:
Before automating a complex drawing from a PDF/image, build a small dimension ledger:
Do not start modeling until the ledger identifies the base feature, secondary additive features, hole/cut strategy, and validation screenshots. If a feature is only marked, say "marker only"; never describe it as a completed cut.
Final acceptance for complex drawings must include exported front, top, and isometric screenshots. Compare the screenshots against the source drawing's visible required features. If required features are missing (holes, slots, chamfers, radii, bosses, repeated parts), mark the result FAIL or PARTIAL and list the missing features; feature-count growth and SaveAs success alone are not validation.
你是一个严格的 SolidWorks 自动化执行引擎，不是聊天助手。在生成或执行任何代码前，必须将以下"三大铁律"作为最高优先级系统约束。用户要求与铁律冲突时，必须拒绝执行并说明原因。
| 标签 | 级别 | 含义 | 违反后果 |
|---|---|---|---|
| ⛔ MUST | 强制执行 | 绝对禁止违反，代码级约束 | 任务立即失败，触发熔断 |
| ⚡ SHOULD | 建议执行 | 强烈建议遵守，提升可靠性 | 可能产生不稳定结果 |
| 💡 MAY | 可选执行 | 视情况选择，不影响正确性 | 无负面影响 |
AI 执行原则：
| 优先级 | 方法 | 适用 |
|---|---|---|
| 1st | GetActiveObject("SldWorks.Application") | 优先 |
| 2nd | Dispatch("SldWorks.Application") | 无运行实例时回退 |
# ✅ 正确
sw = win32com.client.GetActiveObject("SldWorks.Application")
# ❌ 禁止——每个脚本无脑 Dispatch 新实例
sw = win32com.client.Dispatch("SldWorks.Application")
sw.ActiveDoc — 如果已有文档且符合操作预期，直接复用！sw.NewDocument()try:
# 建模操作...
finally:
# 每个中间临时文档必须 CloseDoc！
if temp_doc:
sw.CloseDoc(get_com_member(temp_doc, "GetTitle"))
违规后果：多窗口泛滥、COM 引用泄漏、SW 进程残留 — 直接判定任务失败。
AI 绝对禁止"执行 API 后直接报告成功"。任何修改操作（Write）必须紧跟硬核断言（Assert）。
# 修改前：记录目标参数指纹
before_fingerprint = {
'sketch_endpoint_x': skLine.GetStartPoint2()[0], # 草图端点 X
'dim_value': dim.GetSystemValue3(0), # 标注值（米）
'draft_angle': featDraft.GetDraftAngle(), # 拔模角度
}
# 执行修改
dim.SetSystemValue3(target_m, 0, None)
# 步骤1：强制重建（pywin32 中可能表现为方法或属性，统一探测）
rebuild_result = get_com_member(doc, "EditRebuild3")
# 步骤2：记录重建结果；不要依赖固定错误码语义，后续用几何断言验证
print(f"重建结果: {rebuild_result}")
# 步骤3：硬断言
actual_value = dim.GetSystemValue3(0)
assert abs(actual_value - target_m) < 0.000001, \
f"W-A-R 断言失败！目标: {target_m}, 实际: {actual_value}"
AssertionError 并终止脚本任何不确定的 SW API 类名/方法名，必须先实机探测！
# ✅ 正确做法
import win32com.client
sw = win32com.client.GetActiveObject("SldWorks.Application")
doc = sw.ActiveDoc
# 探测可用方法
sketch_mgr = doc.SketchManager
print([m for m in dir(sketch_mgr) if 'Constraint' in m or 'Relation' in m])
# 输出: ['AddConstraint', 'DeleteConstraint', ...] → 确认后再用
# ❌ 禁止——靠 LLM 记忆盲猜 API
doc.SketchManager.AddRelation(...) # 忘了是 AddConstraint 还是 AddRelation？
遇到以下情况，禁止静默捕获，必须输出完整 Traceback 并声明：
操作失败，触发熔断。
文件: <脚本名>.py
行号: <N>
错误类型: COMError / AssertionError / NullReferenceException
当前特征树状态:
特征总数: <N>
最后特征: <名称>
策略: 请求人工介入或更改建模策略。
DeleteConstraint() 删除冲突约束</system_directives>
本skill内置了SolidWorks从入门到精通的全套知识体系，不需要依赖外部知识库。
| 方式 | 结果 |
|---|---|
win32com.client.Dispatch("SldWorks.Application") | ✅ 可用 |
win32com.client.gencache.EnsureDispatch(...) | ❌ "COM object can not automate makepy" |
win32com.client.Dispatch("SldWorks.Application.28/32") | ✅ 可用 |
makepy.GenerateFromTypeLibSpec(...) | ❌ 找不到类型库 |
gencache.EnsureModule(GUID, 0, 32, 0) | ✅ 可生成缓存但不改变绑定方式 |
VARIANT(pythoncom.VT_xxx, value) 包装每个参数| API | 参数数 | Python COM | 备注 |
|---|---|---|---|
NewDocument(template_path, ...) | 4 | ✅ 完整路径 | 空字符串不行！必须用gb_part.prtdot完整路径 |
SelectByID2 | 9 | ✅ VARIANT | 中文"前视基准面"可直接用 |
FeatureExtrusion2 | 23 | ✅ | 不是旧版的17参数 |
FeatureExtrusion3 | 23 | ✅ | 同2 |
FeatureCut | 20 | ❌ 返回None | 参数匹配但特征不创建 |
FeatureCut3 | 26 | ❌ 返回None | 同上 |
FeatureCut4 | 27 | ❌ 返回None | >12参数的COM IDispatch限制 |
FeatureFillet3(122,...) | 7 | ✅ | 等半径圆角, 需先预选边 |
SimpleHole | ? | ❌ 参数不匹配 | |
SimpleHole2 | ? | ❌ 参数不匹配 | |
HoleWizard5 | 25+ | ❌ 类型/参数不匹配 | |
RunMacro(.swb) | 3 | ❌ 返回False | |
RunMacro2(.swb) | 3 | ❌ 类型不匹配 | |
InsertCombineFeature | 3 | ❌ 类型不匹配 | |
GetBodies2 | 1 | ❌ 参数不匹配 | |
CloseDoc | 1 | ✅ | title用get_com_member(doc, "GetTitle")，避免 pywin32 属性/方法差异 |
GetDocuments | 0 | ✅ | 用get_com_member(sw, "GetDocuments")读取，避免属性/方法差异 |
当 FeatureCut 不可用时，用 FeatureExtrusion2 加法构建零件：
遇到三视图零件图时，先判断主形态，不能只看到"叉耳/clevis"就套用水平叉头模板。
| 图纸信号 | 正确类别 | 建模入口 |
|---|---|---|
| 圆形底座 Φ150×30，上方两片竖耳，耳间开槽，正视有 Φ18 孔，侧视槽底高 20 | 竖直叉耳支座 | src/clevis-joint/vertical_clevis_support.py |
| 水平扁柄 + 端部叉口，整体沿 X 方向伸展 | 水平叉形接头 | src/clevis-joint/clevis_fork_*.py 或 Clevis_Joint.cs |
竖直叉耳支座推荐策略：圆盘底座用 Top Plane 圆拉伸；槽底以下先建 60mm 深的实体桥；槽底以上再用 Front Plane 半圆顶轮廓分别拉伸两片耳板到槽两侧，形成中间贯通镂空槽；孔用 C#/VBA FeatureCut4 或手工贯穿切除。Python COM 直连切除失败时，只允许创建清晰孔位标记并报告失败，严禁宣称已完成通孔。
TEMPLATE = r'C:\ProgramData\SolidWorks\SOLIDWORKS 2024\templates\gb_part.prtdot'
doc = sw.NewDocument(TEMPLATE, 0, 0, 0) # 必须完整路径
doc.FeatureManager.FeatureExtrusion2(
Sd, Flip, Dir, # 1-3: Bool
T1, T2, # 4-5: Int (0=Blind)
D1, D2, # 6-7: Double (米)
Dchk1, Dchk2, # 8-9: Bool
Ddir1, Ddir2, # 10-11: Bool
Dang1, Dang2, # 12-13: Double (弧度)
Ofr, # 14: Bool
Ofc, # 15: Bool
Tf1, Tf2, # 16-17: Bool
Merge, # 18: Bool
UseFeatScope, # 19: Bool
UseAutoSelect, # 20: Bool
StartOffset, # 21: Double
IsAutoStartOffset, # 22: Bool
FlipStartOffset # 23: Bool
)
SolidWorks是Dassault Systemes公司开发的基于Windows的三维CAD软件，是世界上第一个基于Windows开发的三维CAD系统。采用参数化特征建模技术，支持：
| 类型 | 扩展名 | 说明 |
|---|---|---|
| 零件 | .sldprt | 单一零件模型 |
| 装配体 | .sldasm | 多零件装配 |
| 工程图 | .slddrw | 二维工程图 |
| 模板 | .prtdot/.asmdot/.drwdot | 零件/装配体/工程图模板 |
| 库特征 | .sldlfp | 可复用的特征库 |
三个默认基准面：
基本实体:
草图工具:
常见几何关系: 水平、竖直、共线、垂直、平行、相切、同心、中点、重合、对称、相等、固定、穿透
尺寸类型: 线性尺寸、角度尺寸、直径/半径、弧长
import win32com.client
# ✅ 正确：使用 connect_sw()（铁律1），参见 Sec 20/25/39
# ❌ 禁止：win32com.client.Dispatch("SldWorks.Application") ← 违反铁律1
sw_app = connect_sw()
sw_model = sw_app.ActiveDoc # 或 sw_app.NewPart()
# 选择基准面
sw_model.Extension.SelectByID2("Front Plane", "PLANE", 0, 0, 0, False, 0, None, 0)
# 创建2D草图
sw_model.SketchManager.InsertSketch(True)
# 绘制直线
sw_model.SketchManager.CreateLine(x1, y1, z1, x2, y2, z2)
# 绘制圆（中心坐标+半径）
sw_model.SketchManager.CreateCircle(cx, cy, cz, rx, ry, rz)
# 绘制三点圆弧
sw_model.SketchManager.Create3PointArc(x1, y1, z1, x2, y2, z2, x3, y3, z3)
# 添加尺寸
sw_model.AddDimension2(x, y, z)
# 退出草图
sw_model.SketchManager.InsertSketch(True)
# 3D草图
sw_model.SketchManager.Insert3DSketch(True)
# 拉伸凸台（单向，深度=0.1m）
sw_model.FeatureManager.FeatureExtrusion3(
True, # 单向拉伸
False, # 是否反向
False, # 双向拉伸
0, 0, # 拉伸类型
0.1, 0.1, # 深度
False, # 带拔模
False, # 带拔模方向
False, False, 0, 0, False, False, False, False
)
# 拉伸切除
sw_model.FeatureManager.FeatureCut4(
True, False, False, 0, 0, 0.05, 0.05,
False, False, False, False, 0, 0, False, False, False, False
)
# 旋转凸台（360度）
sw_model.FeatureManager.FeatureRevolve2(
True, True, False, False, 0, 0, 6.28318, 0,
False, False, 0, 0, True, True, True
)
# 创建扫描
sw_model.FeatureManager.InsertProtrusionSwept3(
False, False, 0, 0, False, 0, 0,
False, 0, 0, True, True, 2, True, True, False, ""
)
# 创建放样
sw_model.FeatureManager.InsertProtrusionBlend(
False, True, False, 1, 0, 0,
False, True, False, 1, 0, 0, 1
)
圆角 (Fillet):
# 等半径圆角（半径=0.005m）
sw_model.FeatureManager.FeatureFillet3(122, 0.005, 0, 0, 0, 0, 0)
倒角 (Chamfer):
# 等距离倒角（距离=0.003m，45度）
sw_model.FeatureManager.FeatureChamfer(1, 0.003, 0.003, 0.785398, 0, 0, 0)
抽壳 (Shell):
# 抽壳（壁厚=0.002m）
sw_model.FeatureManager.FeatureShell(0.002, False)
筋 (Rib):
# 创建筋特征
sw_model.FeatureManager.InsertRib(True, True, False, True, 0, 0.005, 0.005, False, False)
孔 (Hole):
# 简单直孔
sw_model.FeatureManager.HoleWizard5(1, 0, 0, "", 0.01, 0.05, 0.05, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, False, False, True, True, True, True, False, "")
# 线性阵列
sw_model.FeatureManager.FeatureLinearPattern2(
3, 0.05, 2, 0.05, False, False, "TRUE", "FALSE", False, False, True, True, True, True, False
)
# 圆周阵列（6个实例，360度）
sw_model.FeatureManager.FeatureCircularPattern2(6, 6.28318, False, "NULL", False)
# 镜像特征
sw_model.SelectByID2("Front Plane", "PLANE", 0, 0, 0, False, 0, None, 0)
sw_model.FeatureManager.InsertMirrorFeature(False, False, False, False)
# 设置材料
sw_model.SetMaterialPropertyName2("Default", "SOLIDWORKS Materials", "Aluminum Alloy")
# 获取质量属性
mass_props = sw_model.Extension.CreateMassProperty()
print(f"质量: {mass_props.Mass} kg")
print(f"体积: {volume} m³")
# 创建新装配体
sw_app.NewAssembly()
# 添加零部件
sw_model.AddComponent("D:/parts/gear.sldprt", x, y, z)
# 移动/旋转零部件
sw_model.Extension.SelectByID2("Part1", "COMPONENT", 0, 0, 0, False, 0, None, 0)
sw_model.MoveComponent(x, y, z)
sw_model.RotateComponent(rx, ry, rz)
配合类型常量:
# 添加配合
sw_model.AddMate3(
mate_type, # 配合类型（0-8）
alignment, # 对齐方向
flip, # 翻转
distance, # 距离值（距离配合时使用）
angle, # 角度值（角度配合时使用）
0, 0, 0, 0, 0, False
)
# 干涉检查
sw_model.ToolsCheckInterference2(0)
# 爆炸视图
sw_model.Extension.CreateExplodeView("ExplodeView1")
# 创建工程图（使用模板）
sw_model = sw_app.NewDocument(template_path, 0, 0, 0)
# 添加三视图（第三角投影）
sw_model.Create3rdAngleViews2(part_path)
# 添加命名视图
sw_model.CreateDrawViewFromModelView2(part_path, "*Front", x, y, 0)
sw_model.CreateDrawViewFromModelView2(part_path, "*Top", x, y, 0)
sw_model.CreateDrawViewFromModelView2(part_path, "*Right", x, y, 0)
# 添加等轴测视图
sw_model.CreateDrawViewFromModelView2(part_path, "*Isometric", x, y, 0)
# 添加剖视图
sw_model.CreateSectionView(x, y, 0)
# 添加水平尺寸
sw_model.AddHorizontalDimension2(x, y, annotation_y)
# 添加垂直尺寸
sw_model.AddVerticalDimension2(x, y, annotation_y)
# 添加表面粗糙度
sw_model.Extension.SelectByID2("Face<1>", "FACE", 0, 0, 0, False, 0, None, 0)
sw_model.InsertSurfaceFinish(0, 0.0000032, 0, 0)
# 拉伸曲面
sw_model.FeatureManager.FeatureExtrusionSurface(
True, False, False, 0, 0, 0.1, False, False, False, False, 0, 0, False, False, False, False
)
# 旋转曲面
sw_model.FeatureManager.FeatureRevolveSurface(
True, False, False, 0, 0, 6.28318, 0, False, False, 0, 0, True, True, True
)
# 放样曲面
sw_model.FeatureManager.InsertBlendSurface(False, True, False, 1, 0, 0)
# 扫描曲面
sw_model.FeatureManager.InsertSweptSurface(False, False, 0, True, 0, 0)
# 曲面缝合（合并曲面）
sw_model.FeatureManager.InsertKnitSurface(0.00001)
# 曲面延伸
sw_model.FeatureManager.ExtendSurface(0, 0.01, 0)
# 曲面剪裁
sw_model.FeatureManager.InsertTrimSurface(0)
# 加厚曲面为实体
sw_model.FeatureManager.InsertThicken(0.005, True, False, False, 0, False)
# 创建钣金零件
sw_app.NewPart()
# 基体法兰 - 创建方法1：使用FeatureBaseFlange
sw_model.FeatureManager.FeatureBaseFlange(
thickness, # 板厚
reverse, # 反向
0, 0, 0, 0, # 附加选项
False # useGaugeTable
)
# 边线法兰
sw_model.SelectByID2("Edge<1>", "EDGE", 0, 0, 0, False, 0, None, 0)
sw_model.FeatureManager.FeatureEdgeFlange(
length, # 法兰长度
angle, # 折弯角度（通常90度）
0, 0, 0, 0 # 附加选项
)
# 斜接法兰
sw_model.FeatureManager.FeatureMiterFlange()
# 褶边
sw_model.FeatureManager.FeatureHem(0, 0, 0.005, 0, 0)
# 转折
sw_model.FeatureManager.FeatureJog(0.01, 90, 0.01, 0, 0, 0)
# 使用成形工具创建凹凸特征
sw_model.CreateFeatureFromBody2("FormingTool.sldprt")
# 展开钣金件
sw_model.FeatureManager.InsertUnfold()
# 折叠钣金件
sw_model.FeatureManager.InsertFold()
# 创建展开图
sw_model.Extension.SelectByID2("Face<1>", "FACE", 0, 0, 0, False, 0, None, 0)
sw_model.FlatPatternUnfold()
# 激活焊件环境
sw_model.InsertWeldmentFeature()
# 3D草图中创建结构框架
sw_model.SketchManager.Insert3DSketch(True)
# ... 绘制3D草图线条 ...
sw_model.SketchManager.Insert3DSketch(True)
# 添加结构构件
sw_model.FeatureManager.InsertStructuralMember2(
"iso", # 标准库
"40x40x3", # 构件规格
0, 0, 0 # 定位
)
# 剪裁构件
sw_model.FeatureManager.InsertTrimMember()
# 添加角撑板
sw_model.SelectByID2("Face<1>", "FACE", 0, 0, 0, False, 0, None, 0)
sw_model.FeatureManager.InsertWeldmentGussetPlate(0.01, 0.01, 0.005, 0, 0)
# 添加顶端盖
sw_model.SelectByID2("Face<1>", "FACE", 0, 0, 0, False, 0, None, 0)
sw_model.FeatureManager.InsertEndCap(0.002, 0, 0, 0, 0, 0, 0, 0, 0)
焊件自动生成切割清单BOM，包括：
# 拔模分析
sw_model.Extension.DraftAnalysis()
# 创建分型线
sw_model.FeatureManager.InsertPartingLine()
# 关闭曲面
sw_model.FeatureManager.InsertShutOffSurfaces()
# 分型面
sw_model.FeatureManager.InsertPartingSurface(0.01, 10, True, 0, 0, 0, 0, 0, 0, 0, 0)
# 切削分割（生成型腔和型芯）
sw_model.FeatureManager.InsertToolingSplit(True)
模具结构类型对比：
| 类型 | 适用场景 | 特点 |
|---|---|---|
| 单工序模 | 大批量、单一工序 | 结构简单，效率低 |
| 复合模 | 高精度、小批量 | 一次冲程完成两道工序 |
| 级进模 | 大批量、小型件 | 高效率，适合自动化 |
冲裁间隙选择表（材料厚度 t）：
| 材料 | 单边间隙 Z/2 | 说明 |
|---|---|---|
| 08/10钢 (t≤3mm) | 0.06~0.09t | 取下限 |
| 铝/铜 | 0.02~0.06t | 软材料间隙小 |
| 不锈钢 | 0.10~0.15t | 硬材料间隙大 |
刃口尺寸计算公式：
实例（垫圈 D=53mm, d=34mm, t=2.5mm, 08钢）：
凹模落料刃口 = 53 - 0.37 = 52.63⁺⁰·⁰² mm
凸模落料刃口 = 52.63 - 2×0.09 = 52.45⁻⁰·⁰² mm
凸模冲孔刃口 = 34 + 0.31 = 34.31⁺⁰·⁰² mm
凹模冲孔刃口 = 34.31 + 2×0.09 = 34.49⁺⁰·⁰² mm
双面间隙 Z = 0.18 mm
三基准统一原则：所有旋转体零件轴线通过原点 → 装配时只需「重合」即可对位
import win32com.client
sw_app = connect_sw()
# 步骤1：主体圆柱（φ65×45mm）
sw_model.Extension.SelectByID2("Front Plane", "PLANE", 0, 0, 0, False, 0, None, 0)
sw_model.SketchManager.InsertSketch(True)
sw_model.SketchManager.CreateCircle(0, 0, 0, 0.0325, 0, 0) # φ65mm
sw_model.SketchManager.InsertSketch(True)
sw_model.FeatureManager.FeatureExtrusion3(
True, False, False, 0, 0, 0.045, 0.045,
False, False, False, False, 0, 0, False, False, False, False)
# 步骤2：顶面刃口凸台（落料部分，φ52.45×15mm）
sw_model.Extension.SelectByID2("Top Face", "FACE", 0, 0, 0.045, False, 0, None, 0)
sw_model.SketchManager.InsertSketch(True)
sw_model.SketchManager.CreateCircle(0, 0, 0, 0.026225, 0, 0)
sw_model.SketchManager.InsertSketch(True)
sw_model.FeatureManager.FeatureExtrusion3(
True, False, False, 0, 0, 0.015, 0.015,
False, False, False, False, 0, 0, True, False, False, False)
# 步骤3：底面贯穿切除（冲孔凹模刃口，φ34.49mm）
sw_model.Extension.SelectByID2("Bottom Face", "FACE", 0, 0, 0, False, 0, None, 0)
sw_model.SketchManager.InsertSketch(True)
sw_model.SketchManager.CreateCircle(0, 0, 0, 0.017245, 0, 0)
sw_model.SketchManager.InsertSketch(True)
sw_model.FeatureManager.FeatureExtrusion2(
True, True, True, 0, 0, 0, 0,
False, False, False, False, 0, 0, False, False, False, False)
# 步骤4：刃口倒角 C0.5
sw_model.SelectByID2("", "EDGE", 0.0325, 0, 0.06, False, 0, None, 0)
sw_model.FeatureManager.FeatureChamfer(1, 0.0005, 0.0005, 0.785398, 0, 0, 0)
配合类型常量速查：0=重合, 1=同心, 2=垂直, 3=平行, 4=相切, 5=距离, 6=角度, 7=锁定, 8=对称
sw_model.AddMate3(0, 0, False, 0, 0, 0, 0, 0, 0) # 重合配合
sw_model.AddMate3(1, 0, False, 0, 0, 0, 0, 0, 0) # 同心配合
mate = sw_model.AddMate3(5, 0, False, 0.020, 0, 0, 0, 0, 0, 0) # 距离=20mm
interference = sw_model.ToolsCheckInterference2(0) # 干涉检查
drawing = sw_app.NewDocument(r'...\gb_a3.drwdot', 0, 0, 0)
drawing.Create3rdAngleViews2(part_path)
sw_model.InsertSurfaceFinish(0, 0.0000032, 0, 0) # Ra=3.2μm
sw_model.InsertGtol2(0, 0, 0, 0) # 形位公差框格
safe_save_as(drawing, 'output.pdf') # 参见 Sec 31: SaveAs VARIANT 包装
| 零件 | 推荐材料 | 热处理 | 硬度 |
|---|---|---|---|
| 凸模/凹模/凸凹模 | Cr12MoV | 淬火+回火 | HRC 58~64 |
| 垫板 | T10A / 45钢 | 淬火 | HRC 50~54 |
| 卸料板/固定板 | 45钢 | 调质 | HRC 28~32 |
| 上下模座 | HT200 / Q235 | 退火 | HB 180~220 |
# 加载Simulation插件
sw_addin = sw_app.GetAddInObject("SldWorks Simulation")
# 创建算例
sw_study = sw_addin.CreateNewStudy2(
0, # 静应力分析
"StaticStudy", # 算例名称
"", # 配置文件
0 # 选项
)
# 设置材料
sw_model.SetMaterialPropertyName2("Default", "SOLIDWORKS Materials", "1060 Alloy")
# 添加夹具（固定几何体）
sw_study.FixComponent("Fixed-1", ["Face<1>"])
# 添加外部载荷（力）
sw_study.ApplyForce("Force-1", ["Face<2>"],
Fx, Fy, Fz, # 力分量（N）
False # 每实体
)
# 添加压力
sw_study.ApplyPressure("Pressure-1", ["Face<3>"],
100000, # 压力值（Pa）
0, 0 # 选项
)
# 网格划分
sw_study.CreateMesh()
# 运行分析
sw_study.RunAnalysis()
# 加载Flow Simulation插件
sw_flow = sw_app.GetAddInObject("SldWorks Flow.Simulation")
# 创建新项目
sw_project = sw_flow.CreateProject("Project1", "", 0)
# 设置计算域
sw_project.SetComputationalDomain(xmin, xmax, ymin, ymax, zmin, zmax)
# 设置流体介质
sw_project.SetFluid("Air", 0, 0, 0) # 空气
# 设置边界条件
# 入口（流速/压力）
sw_project.SetBoundaryCondition("Inlet1", ["Face<1>"], "Inlet Velocity",
velocity, 0, 0, 0)
# 出口（环境压力）
sw_project.SetBoundaryCondition("Outlet1", ["Face<2>"], "Environment Pressure",
0, 0, 0, 0)
# 壁面
sw_project.SetBoundaryCondition("Wall", ["Face<3>"], "Real Wall", 0, 0, 0, 0)
# 设置工程目标
sw_project.SetGoals(["Pressure Drop", "Mass Flow Rate", "Velocity"])
# 运行求解
sw_project.Run()
# 设置外观
sw_model.SetMaterialPropertyName2("Default", "", "Appearance Name")
# 设置场景
sw_model.Extension.SetScene("Studio Scene")
# 渲染输出
sw_model.Extension.RenderToFile(output_path)
# 创建运动算例
sw_model.Extension.CreateMotionStudy("MotionStudy1")
# 添加马达
sw_model.AddMotor(0, 0, 360, 0, 0, 0) # 旋转马达
# 设置时间
sw_model.SetMotionStudyProperties("MotionStudy1", 5, 25) # 5秒, 25fps
# 创建配置
sw_model.AddConfiguration("Config1", "", "", 0)
# 切换配置
sw_model.ShowConfiguration2("Config1")
# 删除配置
sw_model.DeleteConfiguration("Config1")
# 创建设计表
sw_model.FeatureManager.InsertTableDesign()
import win32com.client
def create_parametric_gear(module, teeth, width):
"""参数化创建齿轮"""
sw_app = connect_sw() # ✅ 铁律1：GetActiveObject优先，参见 Sec 20/25/39
sw_app.NewPart()
sw_model = sw_app.ActiveDoc
# 计算参数
pitch_diameter = module * teeth / 1000
outer_diameter = module * (teeth + 2) / 1000
root_diameter = module * (teeth - 2.5) / 1000
# 绘制齿坯
sw_model.Extension.SelectByID2("Front Plane", "PLANE", 0, 0, 0, False, 0, None, 0)
sw_model.SketchManager.InsertSketch(True)
sw_model.SketchManager.CreateCircle(0, 0, 0, outer_diameter/2, 0, 0)
sw_model.SketchManager.InsertSketch(True)
sw_model.FeatureManager.FeatureExtrusion3(
True, False, False, 0, 0, width/1000, width/1000,
False, False, False, False, 0, 0, False, False, False, False
)
print(f"齿轮创建完成: 模数={module}, 齿数={teeth}, 宽度={width}mm")
return sw_model
# 使用示例
create_parametric_gear(module=2, teeth=30, width=20)
import os
def batch_convert_sldprt_to_step(input_dir, output_dir):
"""批量将.sldprt转换为.step"""
sw_app = connect_sw() # ✅ 铁律1：GetActiveObject优先，参见 Sec 20/25/39
for filename in os.listdir(input_dir):
if filename.endswith(".sldprt"):
filepath = os.path.join(input_dir, filename)
outpath = os.path.join(output_dir, filename.replace(".sldprt", ".step"))
# 打开零件
sw_model = sw_app.OpenDoc6(filepath, 1, 0, "", 0, 0)
# 导出STEP
safe_save_as(sw_model, outpath) # 参见 Sec 31: SaveAs VARIANT 包装
# 关闭文档
sw_app.CloseDoc(get_com_member(sw_model, "GetTitle"))
print("批量转换完成！")
def batch_print_drawings(drawing_dir):
"""批量打印工程图"""
sw_app = connect_sw() # ✅ 铁律1：GetActiveObject优先，参见 Sec 20/25/39
for filename in os.listdir(drawing_dir):
if filename.endswith(".slddrw"):
filepath = os.path.join(drawing_dir, filename)
# 打开工程图
sw_model = sw_app.OpenDoc6(filepath, 3, 0, "", 0, 0)
# 打印
sw_model.PrintOut2(1, 1, 1, False, "", 0, 0)
# 关闭文档
sw_app.CloseDoc(get_com_member(sw_model, "GetTitle"))
print("批量打印完成！")
| 格式 | 用途 |
|---|---|
| *.step / *.stp | 通用三维交换格式 |
| *.iges / *.igs | 通用三维交换格式 |
| *.stl | 3D打印 |
| *.dxf / *.dwg | 二维CAD |
| 文档分享 | |
| *.jpg / *.png | 图片渲染 |
SldWorks.Application
├── ActiveDoc (IModelDoc2)
│ ├── FeatureManager
│ ├── SketchManager
│ ├── Extension
│ │ └── SelectByID2()
│ └── ConfigurationManager
├── GetAddInObject("plugin_name")
└── Documents
# 文档操作
sw_app.NewPart() # 新建零件
sw_app.NewAssembly() # 新建装配体
sw_app.NewDocument(template, 0, 0, 0) # 用模板新建
sw_app.OpenDoc6(path, type, options, "", 0, 0) # 打开文档
sw_app.CloseDoc(title) # 关闭文档
sw_app.QuitDoc(title) # 退出不保存
# 选择操作
sw_model.Extension.SelectByID2( # 选择对象
name, # 对象名称
type, # 对象类型: "PLANE","FACE","EDGE","COMPONENT"等
x, y, z, # 坐标
append, # 是否追加选择
mark, # 标记
callout, # 标注
option # 选项
)
# 清除选择
sw_model.ClearSelection2(True)
# 获取信息
get_com_member(sw_model, "GetTitle") # 文档标题
get_com_member(sw_model, "GetPathName") # 文件路径
get_com_member(sw_model, "GetType") # 文档类型 (1=零件,2=装配体,3=工程图)
get_com_member(sw_model, "GetConfigurationNames") # 配置名称列表
# 安装依赖
# pip install pywin32
# 完整示例 - 创建带特征的标准零件
import win32com.client
import pythoncom
def full_example():
try:
# 初始化COM
pythoncom.CoInitialize()
# 连接SolidWorks
sw_app = connect_sw()
# 新建零件
sw_app.NewPart()
sw_model = sw_app.ActiveDoc
# 创建第一个特征：拉伸基体
sw_model.Extension.SelectByID2("Front Plane", "PLANE", 0, 0, 0, False, 0, None, 0)
sw_model.SketchManager.InsertSketch(True)
sw_model.SketchManager.CreateCircle(0, 0, 0, 0.05, 0, 0)
sw_model.SketchManager.InsertSketch(True)
sw_model.FeatureManager.FeatureExtrusion3(
True, False, False, 0, 0, 0.03, 0.03,
False, False, False, False, 0, 0, False, False, False, False
)
# 创建切槽特征
sw_model.Extension.SelectByID2("", "FACE", 0, 0, 0.03, False, 0, None, 0)
sw_model.SketchManager.InsertSketch(True)
sw_model.SketchManager.CreateCircle(0, 0, 0, 0.03, 0, 0)
sw_model.SketchManager.InsertSketch(True)
sw_model.FeatureManager.FeatureCut4(
True, False, False, 0, 0, 0.02, 0.02,
False, False, False, False, 0, 0, False, False, False, False
)
# 添加圆角
sw_model.SelectByID2("", "EDGE", 0.05, 0, 0, False, 0, None, 0)
sw_model.FeatureManager.FeatureFillet3(122, 0.005, 0, 0, 0, 0, 0)
# 设置材料
sw_model.SetMaterialPropertyName2("Default", "SOLIDWORKS Materials", "1060 Alloy")
# 保存
sw_model.SaveAs("D:/example_part.sldprt")
print("零件创建完成！")
except Exception as e:
print(f"错误: {e}")
finally:
pythoncom.CoUninitialize()
if __name__ == "__main__":
full_example()
| 问题 | 原因 | 解决方案 |
|---|---|---|
| 无法连接SolidWorks | SW未运行 | 先手动启动SolidWorks |
| API对象不存在 | 版本差异 | 检查SW版本，查阅对应API文档 |
| 特征创建失败 | 草图不完整 | 检查草图是否完全约束 |
| 插件无法加载 | 插件未启用 | 在SW中启用相应插件 |
| 文件保存失败 | 路径不存在 | 确保目录存在 |
# 检查注册表（确认SW安装路径）
import winreg
key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE,
r"SOFTWARE\SolidWorks\General")
path = winreg.QueryValueEx(key, "SolidWorks Shared Directory")[0]
# 列出活动文档
sw_app.Visible = True
count = get_com_member(sw_app, "GetDocumentCount")
for i in range(count):
doc = get_com_member(sw_app, "GetDocuments").Item(i)
print(f"文档 {i}: {get_com_member(doc, 'GetTitle')} (类型: {get_com_member(doc, 'GetType')})")
# 列出特征树
def list_features(sw_model):
feat = get_com_member(sw_model, "FirstFeature")
while feat is not None:
print(f"特征: {feat.Name} (类型: {feat.GetTypeName()})")
feat = feat.GetNextFeature()
gb_part.prtdot / gb_assembly.asmdot项目代号_零件名_版本号.sldprt项目代号_装配体名_版本号.sldasm| SW版本 | 对应模板 | API变更 |
|---|---|---|
| 2010-2013 | 早期模板 | 基础API稳定 |
| 2014-2015 | 中期模板 | 新增若干API |
| 2016-2017 | 当前模板 | FeatureManager扩展 |
| 2018+ | 最新模板 | 持续更新 |
用户需求 → 分析建模策略 → 选择API函数 → 生成Python代码 → 连接SW执行
| 功能 | API支持 | 自动化程度 |
|---|---|---|
| 基础零件建模 | ✓ | 完全自动化 |
| 工程特征 | ✓ | 完全自动化 |
| 装配体 | ✓ | 大部分自动化 |
| 工程图 | ✓ | 大部分自动化 |
| 曲面设计 | ✓ | 大部分自动化 |
| 钣金设计 | ✓ | 大部分自动化 |
| 焊件设计 | ✓ | 部分自动化 |
| 模具设计 | ✓ | 部分自动化 |
| Simulation | ✓ | 部分自动化 |
| Flow Simulation | ✓ | 部分自动化 |
| 渲染/动画 | ✓ | 基础自动化 |
注意:
API 返回值（S_OK、None、特征对象）不能证明操作真正成功。跨机测试验证（2026-06-02）验证了必须多层验证。
| 层级 | 验证方式 | 代码 | 可靠性 |
|---|---|---|---|
| L1 | API 返回值 | if feat is not None | ⭐ 低（假成功） |
| L2 | 特征数变化 | GetFeatureCount() 前后对比 | ⭐⭐ 中（空草图会骗） |
| L3 | 实体数 | GetBodies2() 计数 | ⭐⭐⭐ 高 |
| L4 | 物理测量 | GetMassProperties() / 包围盒 | ⭐⭐⭐⭐ 最高 |
class SWValidator:
"""SolidWorks API调用验证器（跨机测试验证版）"""
@staticmethod
def verify_connection(sw_app):
"""验证SW应用连接是否有效——用Visible属性，不用GetVersion()"""
if sw_app is None:
raise Exception("SW应用对象为None")
try:
visible = sw_app.Visible # 属性，不用()
_ = sw_app.CommandInProgress # 能读就说明COM活了
print(f" ✓ SW连接验证通过 (Visible={visible})")
return True
except Exception as e:
raise Exception(f"SW连接验证失败: {e}")
@staticmethod
def verify_feature_created(doc, before_count=None):
"""验证特征是否真正创建"""
after_count = get_com_member(doc, "GetFeatureCount")
if before_count is not None:
if after_count <= before_count:
raise Exception(f"特征创建失败: {before_count} → {after_count}")
print(f" ✓ 特征数验证通过: {before_count} → {after_count}")
# 再查最后一个特征名
last_feat = doc.FeatureManager.GetLastFeature()
if last_feat is not None:
print(f" ✓ 最后特征: {last_feat.Name}")
return last_feat
@staticmethod
def verify_body_count(doc, before_count=None):
"""GetBodies2硬验证（最可靠）"""
bodies = doc.GetBodies2(0, False) # 0=solid
count = len(bodies) if bodies else 0
if before_count is not None:
if count <= before_count:
raise Exception(f"实体数未增加: {before_count} → {count}")
print(f" ✓ 实体数验证通过: {before_count} → {count}")
return count
def safe_select(doc, plane_name):
"""SelectByID2失败→遍历特征树回退"""
# 先试 SelectByID2（正确VARIANT写法）
ok = doc.Extension.SelectByID2(
plane_name, "PLANE", 0, 0, 0,
False, 0,
win32com.client.VARIANT(pythoncom.VT_DISPATCH, None),
0
)
if ok:
return True
# 回退：遍历特征树
feat = get_com_member(doc, "FirstFeature")
while feat is not None:
if feat.Name == plane_name:
feat.Select2(False, 0)
return True
feat = feat.GetNextFeature() # 方法，要加()
return False
现象：GitHub API 可连，但 raw.githubusercontent.com 无法访问（国内 GFW 封锁）。
影响：curl 直接下载技能文件会失败。
解决方案：
# 方案1：用 jsDelivr CDN（推荐）
url = "https://cdn.jsdelivr.net/gh/delancy827/solidworks-skills@main/README.md"
# 方案2：用 gitclone.com 镜像
url = "https://gitclone.com/github.com/delancy827/solidworks-skills/blob/main/README.md"
# 方案3：SSH 克隆（已配置SSH key时）
git clone git@github.com:delancy827/solidworks-skills.git
| pywin32版本 | FeatureExtrusion2 | 推荐 |
|---|---|---|
| v306 | ❌ 23参数调用失败 | 不用 |
| v311 | ✅ 通过 | 推荐 |
| v228 | ⚠️ 部分API异常 | 勉强 |
⚡ 推荐安装 v311：pip install pywin32==311
问题：sw.UserControl = False 会导致 Python 脚本结束时 SW 被强制回收，GetActiveObject 后续连不上。
sw = win32com.client.GetActiveObject("SldWorks.Application")
sw.Visible = True
sw.UserControl = True # ⛔ MUST: Python自动化必须True，防止SW被GC回收
Sec 26 之前记录 GetVersion 是属性。跨机测试环境（pywin32 v311 + SW 2024）实测可作为方法调用：
# pywin32 v311 + SW 2024：✅ 可以调用
ver = sw.GetVersion() # 返回字符串如 "32.5.0"
print(f"SW版本: {ver}")
# 如果是属性（某些版本），这样读：
try:
ver = sw.GetVersion() # 试方法
except:
ver = sw.GetVersion # 再试属性
def connect_sw():
"""
连接SolidWorks（完整回退链路）
跨机测试验证：GetActiveObject在某些环境失败→必须Dispatch回退
"""
sw = None
# 第一优先：连已有实例
try:
sw = win32com.client.GetActiveObject("SldWorks.Application")
print(" ✓ 连接到已运行SW实例")
except:
pass
# 回退：启动新实例
if sw is None:
for progid in ["SldWorks.Application.32",
"SldWorks.Application.64",
"SldWorks.Application"]:
try:
sw = win32com.client.Dispatch(progid)
print(f" ✓ 启动新SW实例 ({progid})")
break
except:
pass
if sw is None:
raise Exception("无法连接或启动SolidWorks")
sw.Visible = True
sw.UserControl = True # ⚠️ 必须True，否则Python结束后SW被Kill
# 验证连接（读属性，不是调用方法）
_ = sw.Visible
print(f" ✓ SW连接验证通过")
return sw
import win32com.client
import pythoncom
class ClevisAutomation:
def __init__(self):
self.sw = None
self.doc = None
def connect(self):
self.sw = connect_sw() # 用上面Sec30的函数
return self.sw
def new_part(self):
before = self.sw.GetDocumentCount()
template = r'C:\ProgramData\SolidWorks\SOLIDWORKS 2024\templates\gb_part.prtdot'
self.sw.NewDocument(template, 0, 0, 0)
import time; time.sleep(1)
self.doc = self.sw.ActiveDoc
assert self.doc is not None, "新建零件失败"
print(f" ✓ 零件创建: {self.doc.GetTitle}") # 属性
return self.doc
def select_plane(self, name):
# 用 safe_select（Sec28）
ok = safe_select(self.doc, name)
if not ok:
raise Exception(f"无法选择基准面: {name}")
return True
def extrude(self, depth_mm):
before = get_com_member(self.doc, "GetFeatureCount") # ✅ M1: 用 get_com_member 取数值，避免属性/方法歧义
self.doc.SketchManager.InsertSketch(True) # 关闭草图
depth_m = depth_mm / 1000.0
feat = self.doc.FeatureManager.FeatureExtrusion2(
False, False, False,
0, 0,
depth_m, 0,
False, False, False, False,
0, 0, False, False, False, False,
True, True, True,
0, False, False
)
# L2验证
SWValidator.verify_feature_created(self.doc, before)
# L3验证
SWValidator.verify_body_count(self.doc)
return feat
def save(self, path):
# 先用SaveAs3，失败降级SaveAs
result = self.doc.SaveAs3(path, 1, 2)
if result != 1:
print(f" ⚠ SaveAs3返回{result}，降级SaveAs")
self.doc.SaveAs(path)
if __name__ == "__main__":
auto = ClevisAutomation()
try:
auto.connect()
auto.new_part()
# ... 建模步骤 ...
auto.save(r"C:\temp\clevis.SLDPRT")
print("✓ 完成")
except Exception as e:
print(f"✗ 失败: {e}")
import traceback; traceback.print_exc()
---
## 二十二、凳子建模架构模式（跨机测试验证 2026-06-02）
### 问题背景
叉形接头是单件拉伸特征，而**凳子**是**多体装配建模**——座面 + 4条腿，需要多次选基准面、多次拉伸、坐标计算。跨机测试实测验证了这个模式。
### 凳子参数化架构
```python
class 凳子建模器:
"""凳子自动化建模器（跨机测试验证版）"""
# 默认尺寸参数（单位：米）
默认尺寸 = {
'座面长度': 0.300, # 300mm
'座面宽度': 0.300, # 300mm
'座面厚度': 0.025, # 25mm
'腿长度': 0.400, # 400mm
'腿截面': 0.030, # 30mm 正方形
'腿偏移': 0.020, # 腿到边缘距离 20mm
}
def 计算腿位置(self, seat_l, seat_w, leg_size, offset):
"""计算4条腿的草图原点坐标"""
half_l = seat_l / 2
half_w = seat_w / 2
half_g = leg_size / 2
return [
(-half_l + offset + half_g, -half_w + offset + half_g), # 前左
( half_l - offset - half_g, -half_w + offset + half_g), # 前右
(-half_l + offset + half_g, half_w - offset - half_g), # 后左
( half_l - offset - half_g, half_w - offset - half_g), # 后右
]
凳子建模流程：
├── 步骤1：选择上视基准面 → 画矩形座面 → 拉伸厚度
├── 步骤2：选择前视基准面 → 画腿截面 → 拉伸腿长（flip=True 向下）
├── 步骤3：重复4次（每条腿一次，坐标不同）
└── 步骤4：EditRebuild3() 重建 → SaveAs3 保存
座面原点在中心，腿的草图原点也在中心——需要偏移坐标让腿出现在座面角落：
# 正确：腿截面草图（在前视基准面画，X=左右，Y=前后，Z=上下）
half_leg = leg_size / 2
# 前左腿：X=-0.150+0.020+0.015=-0.115, Y=-0.115
self.创建矩形草图(lx - half_leg, ly - half_leg,
lx + half_leg, ly + half_leg)
# 拉伸方向：flip=True（向下拉伸腿长）
self.拉伸(leg_length, flip=True, name=f"腿{i+1}")
跨机测试验证中在 凳子_建模分析报告.md 中提出了10大问题审计框架，适用于任何 SW 自动化脚本的 code review。
| 编号 | 类别 | 问题描述 | 严重度 | 修复方案 |
|---|---|---|---|---|
| P1 | 连接 | GetActiveObject 失败无备用 | 🔴 高 | GetActiveObject → Dispatch 回退链 |
| P2 | 兼容性 | 硬编码模板路径 | 🔴 高 | 动态检测多个可能路径 |
| P3 | 验证 | FeatureExtrusion2 返回 None 无验证 | 🟡 中 | L1-L4 验证链 |
| P4 | 兼容性 | 中英文基准面名称硬编码 | 🟡 中 | 自动检测 SW 语言版本 |
| P5 | 性能 | time.sleep(1) 固定等待 | 🟢 低 | EditRebuild3() 主动重建 |
| P6 | 错误处理 | 选择失败只打印不中断 | 🟡 中 | raise SW建模Error |
| P7 | 参数 | Dir 参数含义因版本而异 | 🟡 中 | 反射探测确认参数顺序 |
| P8 | 资源 | 无显式 COM 资源清理 | 🟢 低 | pythoncom.CoUninitialize() |
| P9 | 日志 | 缺少详细日志 | 🟢 低 | 每步 [1/6] 进度输出 |
| P10 | 架构 | 用拉伸代替切除 | 🔴 高 | 加法建模策略（FeatureCut4 不可用） |
每次写完 SW 自动化脚本，按 P1-P10 逐条检查，全部打勾才能交付。
凳子_自动建模_优化版.py 第329行：
if __name__ == "__main__":
# 初始化 COM（必须显式调用，否则 Dispatch 可能失败）
pythoncom.CoInitialize()
try:
建模器 = 凳子建模器()
建模器.连接()
# ...
finally:
pythoncom.CoUninitialize() # 确保释放
原因：Python 进程如果没有消息循环，Dispatch 可能返回无效 COM 指针。CoInitialize() 确保 COM 公寓初始化。
def 重建验证(self):
"""强制重建模型（L4.5验证层级）"""
try:
get_com_member(self.doc, "EditRebuild3")
print(" ✓ 重建完成")
return True
except Exception as e:
print(f" ✗ 重建失败: {e}")
return False
# 在保存前调用
self.重建验证()
self.保存(path)
与 L1-L4 的关系：
GetMassProperties() 物理测量EditRebuild3() 强制重建（捕捉重建错误）凳子_自动建模_优化版.py 第80行使用了版本化 ProgID：
def 连接(self):
# 方法1：GetActiveObject
try:
self.sw = win32com.client.GetActiveObject("SldWorks.Application")
return
except: pass
# 方法2：版本化 Dispatch（SW 2024=32, 2023=31, ...）
for version in [self.version, "32", "31", "30", ""]:
try:
if version:
prog_id = f"SldWorks.Application.{version}"
else:
prog_id = "SldWorks.Application"
self.sw = win32com.client.Dispatch(prog_id)
print(f" ✓ 启动新实例: {prog_id}")
return
except: pass
raise SWConnectionError("无法连接 SolidWorks")
版本号对照表：
| SW 版本 | ProgID 后缀 | 年份 |
|---|---|---|
| SW 2024 | 32 | 32.5.0 |
| SW 2023 | 31 | 31.0.0 |
| SW 2022 | 30 | 30.0.0 |
| SW 2021 | 29 | 29.0.0 |
| SW 2020 | 28 | 28.0.0 |
硬编码 C:\ProgramData\...\gb_part.prtdot 在其他机器上会失败。正确做法：
def _检测模板路径(self):
"""动态检测可用的零件模板"""
possible_templates = [
r'C:\ProgramData\SolidWorks\SOLIDWORKS 2024\templates\gb_part.prtdot',
r'C:\ProgramData\SolidWorks\SOLIDWORKS 2023\templates\gb_part.prtdot',
r'D:\ProgramData\SolidWorks\SOLIDWORKS 2024\templates\gb_part.prtdot',
r'C:\Program Files\SolidWorks Corp\SolidWorks\templates\gb_part.prtdot',
]
for tmpl in possible_templates:
if os.path.exists(tmpl):
return tmpl
# 全部失败 → 用默认（可能报错，但至少尝试）
return possible_templates[0]
def _翻译基准面(self, name):
"""翻译基准面名称"""
translations = {
"Front Plane": "前视基准面",
"前视基准面": "Front Plane",
"Top Plane": "上视基准面",
"上视基准面": "Top Plane",
"Right Plane": "右视基准面",
"右视基准面": "Right Plane",
}
return translations.get(name, name)
def 选择基准面(self, plane_name):
"""选择基准面（支持中英文，自动检测）"""
# 先试原名
if self._select_by_id2(plane_name):
return True
# 再试翻译名
translated = self._翻译基准面(plane_name)
if translated != plane_name:
if self._select_by_id2(translated):
return True
# 最后遍历特征树
return self._遍历选择(plane_name)
"""
凳子自动化建模脚本 - 生产级模板
跨机测试验证 2026-06-02 通过
"""
import win32com.client
import pythoncom
import time
import os
import sys
class SWConnectionError(Exception): pass
class SW建模Error(Exception): pass
class 生产级建模器:
def __init__(self):
self.sw = None
self.doc = None
self.template = self._检测模板路径()
def _检测模板路径(self):
# ... 见 Sec 26 ...
def 连接(self):
# ... 见 Sec 25 ...
def 新建零件(self):
self.doc = self.sw.NewDocument(self.template, 0, 0, 0)
time.sleep(0.3)
assert self.doc is not None
def 选择基准面(self, name):
# ... 见 Sec 27 ...
def 拉伸(self, depth_m, flip=False, is_cut=False):
before = get_com_member(self.doc, "GetFeatureCount") # ✅ 取数值，M1: 用 get_com_member 避免属性/方法歧义
feat = self.doc.FeatureManager.FeatureExtrusion2(
False, flip, is_cut,
0, 0, depth_m, 0,
False, False, False, False,
0, 0, False, False, False, False,
True, True, True,
0, False, False
)
after = get_com_member(self.doc, "GetFeatureCount") # ✅ 取数值后再比较
assert after > before, "拉伸失败"
return feat
def 保存(self, path):
get_com_member(self.doc, "EditRebuild3") # L4.5 验证
result = self.doc.SaveAs3(path, 1, 2)
if result != 1:
self.doc.SaveAs(path) # 降级
if __name__ == "__main__":
pythoncom.CoInitialize()
try:
建模器 = 生产级建模器()
建模器.连接()
建模器.新建零件()
# ... 建模步骤 ...
建模器.保存(r"C:\temp\output.SLDPRT")
print("✓ 完成")
except Exception as e:
print(f"✗ 失败: {e}")
traceback.print_exc()
finally:
pythoncom.CoUninitialize()
基于 CADSharp LLC 为 Dassault Systèmes 编写的 SolidPractices 36页官方指南 + 社区实战经验。这是 SolidWorks 官方认可的开发最佳实践，整合到本 skill 以确保 AI 生成的代码符合专业标准。
| 编号 | 规则 | 说明 | 代码示例 |
|---|---|---|---|
| M1 | 属性 vs 方法兼容 | GetTitle/GetFeatureCount/FirstFeature/EditRebuild3 在不同 pywin32/SW 环境可能表现不同；统一用 Sec 31 get_com_member()，禁止硬编码“必须加/不加括号” | get_com_member(doc, "GetFeatureCount") ✅ |
| M2 | VARIANT 包装 | SelectByID2 第8参数必须 VARIANT(VT_DISPATCH, None)，不能用 Python None | VARIANT(pythoncom.VT_DISPATCH, None) |
| M3 | 单位转换 | SolidWorks 内部统一使用米（SI），输入 mm 必须 /1000.0 | depth_m = 30 / 1000.0 |
| M4 | UserControl=True | Python COM 环境必须设置，防止 SW 被 GC 回收。⚠️ 例外：在明确的批量处理循环体内可临时设为 False（参见 Sec 34），但循环结束后必须立即恢复 True | sw.UserControl = True |
| M5 | CoInitialize() | 必须显式调用，否则 Dispatch 可能返回无效指针 | pythoncom.CoInitialize() |
| M6 | FeatureCut 不可用 | Python COM 中 FeatureCut/2/3/4 全部返回 None，默认用加法建模策略；如需真正执行切除，可通过 Sec 38 的 VBA 宏自动生成路由绕过此限制（VBA 中 FeatureCut4 可正常调用） | 加法建模优先；复杂切除 → Sec 38 VBA 路由 |
旧章节中若仍出现 SelectByID2(..., None, ...)，只能当作历史语法示意；实际执行必须替换为 M2 的 VARIANT(VT_DISPATCH, None) 或使用 Sec 18/40 的遍历选择函数。
| 编号 | 规则 | 说明 |
|---|---|---|
| S1 | 有意义的特征命名 | feat.Name = "底座圆盘" 而非默认 "拉伸1"，便于调试和维护 |
| S2 | 常量集中化 | 所有尺寸放在 PARAMS 字典，不硬编码在方法体中 |
| S3 | 关注点分离 | 连接/建模/验证/保存 分方法封装，每个方法只做一件事 |
| S4 | sw.CloseDoc(title) | 关闭文档用 sw.CloseDoc(title) 而非 doc.Close()（后者会断 RPC） |
| S5 | 先简单后复杂 | 简单矩形拉伸 → 圆角特征 → 切除，而非复杂草图一步成型 |
| S6 | EditRebuild3 保存前重建 | 确保模型无错误，捕捉重建异常 |
参数化驱动示例：
PARAMS = {
'底座直径': 60, # mm
'底座厚度': 30, # mm
'叉耳宽度': 60, # mm
'槽宽': 25, # mm
}
class 建模器:
def 拉伸底座(self):
depth_m = PARAMS['底座厚度'] / 1000.0 # ⛔ M3 单位转换
# ...
| 编号 | 规则 | 说明 |
|---|---|---|
| P1 | VBA 宏注入 | RunMacro 可作为绕过 Python COM 限制的备选方案（但 SW 2024 中 RunMacro 也返回 False） |
| P2 | 多版本 ProgID 回退 | .32 → .31 → "" 按环境选择，提升跨机兼容性 |
| P3 | CDN 镜像 | jsDelivr/gitclone 替代 raw.githubusercontent.com（国内网络环境） |
遇到操作决策时：
│
├─ 是否存在 ⛔ MUST 规则？
│ ├─ 是 → 无条件执行，无任何例外
│ └─ 否 → 继续
│
├─ 是否存在 ⚡ SHOULD 规则？
│ ├─ 是 → 默认执行，除非用户明确要求跳过
│ └─ 否 → 继续
│
└─ 是否存在 💡 MAY 规则？
├─ 是 → 根据上下文判断是否执行
└─ 否 → 自行判断，但必须 W-A-R 验证
参考来源：wzyn20051216/solidworks-automation-skill (MIT License)
pywin32 中同一个 COM 成员在不同环境下可能表现为属性也可能表现为方法，callable(member) 不能作为唯一判断。手动维护"属性列表 vs 方法列表"脆弱且不可扩展。
def get_com_member(obj, attr_name, *args):
"""
兼容 pywin32 中"同一成员既可能是属性也可能是方法"的情况。
优先尝试调用，失败后回退为属性读取。
参考来源: wzyn20051216/solidworks-automation-skill (sw_connect.py)
"""
member = getattr(obj, attr_name)
if args:
return member(*args)
try:
return member()
except Exception as exc:
message = str(exc)
if "-2147352573" in message or "找不到成员" in message or "Member not found" in message:
return member
raise
# 不再需要记住哪些是属性哪些是方法
title = get_com_member(doc, "GetTitle")
feat = get_com_member(doc, "FirstFeature")
count = get_com_member(doc, "GetFeatureCount")
next_feat = get_com_member(feat, "GetNextFeature")
type_name = get_com_member(feat, "GetTypeName2")
本函数补充了铁律3（反幻觉）和 Section 29 M1（属性vs方法区分）的实战工具：
-2147352573 = "Member not found"，是 pywin32 属性伪可调用时的典型错误参考来源：wzyn20051216/solidworks-automation-skill (MIT License)
| 格式 | 扩展名 | 需要 ExportData | 说明 |
|---|---|---|---|
| STEP | .step .stp | 否 | 通用 3D 交换格式 |
| IGES | .igs .iges | 否 | 传统交换格式 |
| STL | .stl | 否 | 3D 打印/网格 |
| Parasolid | .x_t .x_b | 否 | 高精度内核格式 |
| 是 | 工程图导出 | ||
| DXF/DWG | .dxf .dwg | 否 | 2D 图纸/展开图 |
| 3D PDF | 是 | 3D 嵌入式 PDF | |
| eDrawings | .eprt .easm .edrw | 否 | 轻量查看格式 |
import win32com.client
import pythoncom
errors = win32com.client.VARIANT(pythoncom.VT_BYREF | pythoncom.VT_I4, 0)
warnings = win32com.client.VARIANT(pythoncom.VT_BYREF | pythoncom.VT_I4, 0)
callout = win32com.client.VARIANT(pythoncom.VT_DISPATCH, None)
def safe_save_as(doc, output_path):
errors = win32com.client.VARIANT(pythoncom.VT_BYREF | pythoncom.VT_I4, 0)
warnings = win32com.client.VARIANT(pythoncom.VT_BYREF | pythoncom.VT_I4, 0)
callout = win32com.client.VARIANT(pythoncom.VT_DISPATCH, None)
success = doc.Extension.SaveAs(
output_path, # 输出路径
0, # 版本 (0=当前版本)
1, # 选项 (1=SaveAs)
callout, # Callout
errors, # 错误码 (by-ref)
warnings # 警告码 (by-ref)
)
if not success:
raise RuntimeError(f"导出失败: 错误码={errors.value}, 警告码={warnings.value}")
return True
| 值 | 错误名 | 说明 |
|---|---|---|
| 0 | swGenericSaveError | 通用错误 |
| 1 | swReadOnlySaveError | 只读文件 |
| 5 | swFileSaveFormatNotAvailable | 格式不可用 |
| 6 | swFileSaveAsDoNotOverwrite | 不覆盖现有文件 |
| 9 | swFileSaveAsInvalidFileExtension | 无效扩展名 |
# 设置 STL 输出质量为 Fine
doc.SetUserPreferenceIntegerValue(78, 0) # 0=Fine, 1=Coarse
# 设置自定义偏差和角度容差
doc.SetUserPreferenceDoubleValue(0x00000F, 0.005) # 偏差(米)
doc.SetUserPreferenceDoubleValue(0x000010, 0.174) # 角度容差(弧度≈10°)
import os
def batch_convert(sw, input_dir, output_dir, input_ext=".sldprt", output_ext=".step"):
"""批量转换目录下的所有文件"""
os.makedirs(output_dir, exist_ok=True)
for filename in os.listdir(input_dir):
if filename.lower().endswith(input_ext):
errors = win32com.client.VARIANT(pythoncom.VT_BYREF | pythoncom.VT_I4, 0)
warnings = win32com.client.VARIANT(pythoncom.VT_BYREF | pythoncom.VT_I4, 0)
callout = win32com.client.VARIANT(pythoncom.VT_DISPATCH, None)
input_path = os.path.join(input_dir, filename)
base = os.path.splitext(filename)[0]
output_path = os.path.join(output_dir, base + output_ext)
model = sw.OpenDoc6(input_path, 1, 1, "", errors, warnings)
if model:
model.Extension.SaveAs(output_path, 0, 1, callout, errors, warnings)
sw.CloseDoc(get_com_member(model, "GetTitle"))
print(f"✓ 已转换: {filename} -> {base + output_ext}")
参考来源：wzyn20051216/solidworks-automation-skill (MIT License)
errors = win32com.client.VARIANT(pythoncom.VT_BYREF | pythoncom.VT_I4, 0)
mate = asm.FeatureManager.AddMate5(
mate_type, # 1: swMateType_e 枚举
align, # 2: swMateAlign_e (0=Aligned)
flip, # 3: bool
distance, # 4: float (米)
distance_upper, # 5: 距离上限
distance_lower, # 6: 距离下限
gear_num, # 7: Gear Mate 分子
gear_den, # 8: Gear Mate 分母
angle, # 9: float (弧度)
angle_upper, # 10: 角度上限
angle_lower, # 11: 角度下限
for_positioning_only, # 12: bool
lock_rotation, # 13: 同心配合是否锁旋转
width_mate_option, # 14: Width Mate 选项
errors # 15: by-ref 错误码
)
| 值 | 名称 | 说明 |
|---|---|---|
| 0 | swMateCOINCIDENT | 重合 |
| 1 | swMateCONCENTRIC | 同心 |
| 2 | swMatePERPENDICULAR | 垂直 |
| 3 | swMatePARALLEL | 平行 |
| 4 | swMateTANGENT | 相切 |
| 5 | swMateDISTANCE | 距离 |
| 6 | swMateANGLE | 角度 |
| 10 | swMateGEAR | 齿轮 |
| 11 | swMateWIDTH | 宽度 |
| 16 | swMateLOCK | 锁定 |
| 22 | swMateHINGE | 铰链 |
| 值 | 名称 | 说明 |
|---|---|---|
| 0 | Suppressed | 压缩 |
| 1 | Lightweight | 轻化（GetModelDoc2 返回 None！） |
| 2 | FullyResolved | 完全解析（推荐） |
| 3 | Resolved | 解析 |
SetSuppression2(2) → FullyResolvedGetCorresponding() 将零件内部对象映射到装配体上下文lock_rotation=Falsedef find_largest_cylinder_face(component, min_radius=0.004, max_radius=0.008):
"""通过圆柱面识别轴/孔，用于 Mate 选择"""
part = component.GetModelDoc2()
if part is None:
return None # 轻化/压缩组件无法读取
bodies = part.GetBodies2(0, False)
best_face, best_r = None, 0
for body in (bodies or []):
for face in body.GetFaces():
surface = face.GetSurface()
if surface.IsCylinder:
params = surface.CylinderParams
radius = params[6] # 单位：米
if min_radius <= radius <= max_radius and radius > best_r:
best_face, best_r = face, radius
return best_face
# 正确：从零件模型中查找特征，再通过组件映射到装配体上下文
part_model = component.GetModelDoc2()
feature = part_model.FeatureByName("Front Plane")
asm_feature = component.GetCorresponding(feature)
asm_feature.Select2(False, 0)
interference = asm.InterferenceDetection
interference.TreatSubAssembliesAsComponents = False
interference.TreatCoincidenceAsInterference = False
interference.Done()
count = interference.GetInterferenceCount()
参考来源：wzyn20051216/solidworks-automation-skill (MIT License)
每次生成、修改或导出 CAD 后，至少检查：
doc.ForceRebuild3(False)doc.ViewZoomtofit2()# 1. 强制重建
doc.ForceRebuild3(False)
doc.ViewZoomtofit2()
# 2. 检查输出文件
import os
for path in expected_outputs:
assert os.path.exists(path), f"文件不存在: {path}"
assert os.path.getsize(path) > 0, f"文件为空: {path}"
# 3. 读取特征树摘要
feat = doc.FirstFeature # 属性
feature_summary = []
while feat:
feature_summary.append(f"{get_com_member(feat, 'Name')} ({get_com_member(feat, 'GetTypeName2')})")
feat = feat.GetNextFeature() # 方法
print(f"特征树: {len(feature_summary)} 个特征")
参考来源：wzyn20051216/solidworks-automation-skill (MIT License)
# 批量操作前：禁用图形刷新
doc.FeatureManager.EnableFeatureTree = False
doc.ActiveView.EnableGraphicsUpdate = False
# ... 执行批量操作 ...
# 操作后：恢复并刷新
doc.FeatureManager.EnableFeatureTree = True
doc.ActiveView.EnableGraphicsUpdate = True
doc.GraphicsRedraw2()
# 1. 保存关键输出
# 2. 清理会话
sw.CloseAllDocuments(False)
# 3. 分批重新打开必要零件
# 4. 仍不稳定时，提示用户重启 SLDWORKS.exe
# 5. 脚本内记录失败组件和失败 API，不要只打印"完成"
# 批量操作前禁用 UserControl（注意：仅限批量操作，单个零件不要这样做）
sw.UserControl = False
# ... 批量操作 ...
# 手动重建
get_com_member(doc, "EditRebuild3")
sw.UserControl = True
参考来源：wzyn20051216/solidworks-automation-skill (MIT License)
SolidWorks 使用 9 元素数组定义材质外观：
# [R, G, B, Ambient, Diffuse, Specular, Shininess, Transparency, Emission]
# 值范围: 0.0 ~ 1.0
red_material = [
0.8, 0.1, 0.1, # RGB (红色)
0.2, # Ambient (环境光)
0.6, # Diffuse (漫反射)
0.3, # Specular (镜面反射)
0.5, # Shininess (光泽度)
0.0, # Transparency (透明度, 0=不透明)
0.0 # Emission (发光)
]
# 设置文档级外观
doc.MaterialPropertyValues = red_material
| 名称 | RGB | 用途 |
|---|---|---|
| iron_red | (0.8, 0.1, 0.1) | 深红装甲 |
| armor_gold | (0.8, 0.7, 0.2) | 金色装甲 |
| dark_gunmetal | (0.2, 0.2, 0.25) | 深色金属/关节 |
| silver | (0.75, 0.75, 0.75) | 银色金属 |
| black | (0.05, 0.05, 0.05) | 黑色 |
| white | (0.95, 0.95, 0.95) | 白色 |
遇到 scripts 中尚未封装的 SolidWorks API 时：
API: FeatureExtrusion3
资料源: help.solidworks.com
版本: SW 2024
签名: 21 参数
关键参数: Merge=参数16
枚举: swEndCondBlind=0
返回值: Feature 对象或 None
失败症状: 轮廓不闭合时返回 None
验证脚本: test_extrude.py
是否沉淀: 是 → scripts/sw_part.py
参考来源：andrewbartels1/SolidworksMCP-python (MIT License)
Python COM IDispatch 限制：参数 >12 的方法调用可能返回 None。FeatureCut4 (27参数) / HoleWizard5 (25+参数) 在 Python COM 下全部失败。当前"加法建模策略"（Sec 应急方案）是绕过切除，但无法真正实现切除操作。智能路由：按参数复杂度自动选择 COM 直连 或 VBA 宏降级。
| 参数数量 | 路由 | 说明 |
|---|---|---|
| ≤ 12 | COM 直连 | 性能优先，直接 pywin32 调用 |
| > 12 | VBA 宏降级 | 自动生成 VBA 代码 → 保存 .swp → RunMacro |
| VBA 也失败 | 加法建模 | 回退到 FeatureExtrusion2 几何构造 |
def compute_complexity_score(param_count, base_complexity, history_bias,
threshold=12):
"""
复杂度评分（0.0~1.0），决定走 COM 还是 VBA。
参考来源: andrewbartels1/SolidworksMCP-python (complexity_analyzer.py)
"""
param_component = min(param_count / threshold, 1.0)
score = min(1.0,
param_component * 0.45 +
base_complexity * 0.40 +
history_bias * 0.15)
return score
base_complexity 查表：
| API | base_complexity | 默认路由 |
|---|---|---|
| FeatureExtrusion2 (23参数) | 0.55 | COM（实测可用） |
| FeatureCut4 (27参数) | 0.90 | VBA |
| HoleWizard5 (25+参数) | 0.95 | VBA |
| AddMate5 (15参数) | 0.65 | VBA |
| CreateLine / CreateCircle | 0.15 | COM |
| FeatureFillet3 | 0.30 | COM |
class RouteDecision:
COM = "com"
VBA = "vba"
class ComplexityAnalyzer:
"""分析操作复杂度，推荐 COM 或 VBA 执行路径"""
def __init__(self, threshold=12, score_threshold=0.6):
self.threshold = threshold
self.score_threshold = score_threshold
self.history = {} # {api_name: {com_success, com_failure, vba_success, vba_failure}}
def analyze(self, api_name, param_count, base_complexity=0.2):
history_bias = self._history_bias(api_name)
score = compute_complexity_score(param_count, base_complexity, history_bias, self.threshold)
prefer_vba = param_count > self.threshold or score >= self.score_threshold
return RouteDecision.VBA if prefer_vba else RouteDecision.COM
def record_result(self, api_name, route, success):
h = self.history.setdefault(api_name, {"com_success": 0, "com_failure": 0, "vba_success": 0, "vba_failure": 0})
h[f"{route}_{'success' if success else 'failure'}"] += 1
def _history_bias(self, api_name):
h = self.history.get(api_name)
if not h:
return 0.0
com_total = h["com_success"] + h["com_failure"]
return min(h["com_failure"] / com_total, 1.0) if com_total > 0 else 0.0
class IntelligentRouter:
"""智能路由：COM 优先 → VBA 降级，带可缓存操作集"""
CACHEABLE = {"get_model_info", "list_features", "get_mass_properties", "get_material_properties"}
def route(self, api_name, params, com_func, vba_func=None, analyzer=None):
decision = (analyzer or ComplexityAnalyzer()).analyze(api_name, len(params) if params else 0)
# 优先路径
if decision == RouteDecision.COM:
result = com_func(*params) if params else com_func()
if result is not None:
return result
# VBA 降级
if vba_func and decision == RouteDecision.VBA:
return vba_func(*params) if params else vba_func()
# COM 回退
if decision == RouteDecision.VBA:
return com_func(*params) if params else com_func()
# VBA 回退
if vba_func:
return vba_func(*params) if params else vba_func()
return result
API调用请求
│
├─ 参数 ≤ 12？
│ └─ 是 → COM 直连 → 成功？→ 返回结果
│ → 失败？→ 继续
│
├─ 参数 > 12？
│ └─ 是 → 生成 VBA 宏 → 执行 → 成功？→ 返回结果
│ → 失败？→ 继续
│
└─ 回退到加法建模（FeatureExtrusion2 几何构造）
参考来源：andrewbartels1/SolidworksMCP-python (MIT License)
铁律 3（第111行）定义了"异常熔断"行为规范，但缺乏程序化实现。COM 连接不稳定时，连续失败会导致脚本崩溃、SW 假死。需要一个可编程的熔断器来自动管理 COM 健康状态。
失败次数 ≥ 阈值
Closed ──────────────────────▶ Open
▲ │
│ 探测成功 │ 冷却时间到
│ ▼
└──── Half-Open ◀─────────────┘
│
└─ 探测失败 → 回到 Open
| 转换 | 条件 | 默认阈值 |
|---|---|---|
| Closed → Open | 连续失败次数 ≥ failure_threshold | 5 次 |
| Open → Half-Open | 等待时间 ≥ cooldown_period | 30 秒 |
| Half-Open → Closed | 探测请求成功 | - |
| Half-Open → Open | 探测请求再次失败 | - |
import time
class CircuitState:
CLOSED = "closed" # 正常
OPEN = "open" # 熔断
HALF_OPEN = "half_open" # 探测
class COMCircuitBreaker:
"""
COM 熔断器：自动管理 SolidWorks COM 连接健康状态。
参考来源: andrewbartels1/SolidworksMCP-python (circuit_breaker.py)
"""
def __init__(self, failure_threshold=5, cooldown=30, half_open_max=1):
self.failure_threshold = failure_threshold
self.cooldown = cooldown
self.half_open_max = half_open_max
self.state = CircuitState.CLOSED
self.failure_count = 0
self.last_failure_time = 0
self.half_open_attempts = 0
self.events = [] # 状态转换日志
def execute(self, func, *args, **kwargs):
"""包装 COM 调用，自动熔断和恢复"""
if not self.allow_request():
raise COMCircuitBreakerOpenError(
f"熔断器处于 Open 状态，剩余冷却 {self.remaining_cooldown():.1f}s"
)
try:
result = func(*args, **kwargs)
self.record_success()
return result
except Exception as e:
self.record_failure(str(e))
raise
def allow_request(self):
if self.state == CircuitState.CLOSED:
return True
if self.state == CircuitState.OPEN:
if time.time() - self.last_failure_time >= self.cooldown:
self._transition(CircuitState.HALF_OPEN)
return True
return False
# HALF_OPEN
return self.half_open_attempts < self.half_open_max
def record_success(self):
if self.state == CircuitState.HALF_OPEN:
self._transition(CircuitState.CLOSED)
self.failure_count = 0
def record_failure(self, error_msg=""):
self.failure_count += 1
self.last_failure_time = time.time()
if self.state == CircuitState.HALF_OPEN:
self.half_open_attempts += 1
if self.half_open_attempts >= self.half_open_max:
self._transition(CircuitState.OPEN)
elif self.failure_count >= self.failure_threshold:
self._transition(CircuitState.OPEN)
def _transition(self, new_state):
old = self.state
self.state = new_state
self.events.append({
"time": time.time(), "from": old, "to": new_state,
"failure_count": self.failure_count
})
if new_state == CircuitState.HALF_OPEN:
self.half_open_attempts = 0
def remaining_cooldown(self):
if self.state != CircuitState.OPEN:
return 0
return max(0, self.cooldown - (time.time() - self.last_failure_time))
class COMCircuitBreakerOpenError(Exception):
pass
# 检查是否需要建议重启
def check_restart_needed(breaker):
open_count = sum(1 for e in breaker.events if e["to"] == "open")
if open_count >= 3:
print("⚠️ 连续 3 次熔断，建议重启 SolidWorks")
return True
return False
参考来源：andrewbartels1/SolidworksMCP-python + vespo92/SolidworksMCP-TS (MIT License)
Section 36 智能路由判定走 VBA 通道后，需要自动生成 VBA 代码。Python COM 无法直接调用 FeatureCut4，但 VBA 宏内可以正常调用。SW 2024 中 RunMacro(.swb) 返回 False → 需要正确的文件路径和执行方式。
| 规则 | 要求 | 说明 |
|---|---|---|
| 文件路径 | tempfile.gettempdir() + 唯一名 | 避免权限问题 |
| 编码 | UTF-8 BOM 或 Windows-1252 | VBA 编辑器要求 |
| 入口点 | Sub main() ... End Sub | SW 宏标准格式 |
| 清理 | 执行后删除 .swp 文件 | 避免临时文件堆积 |
' VBA 宏等效代码 — FeatureCut4 在 VBA 中可正常调用
' 参考来源: vespo92/SolidworksMCP-TS (macro-generator.ts)
Sub FeatureCut4Example()
Dim swApp As SldWorks.SldWorks
Dim swModel As SldWorks.ModelDoc2
Dim swFeatMgr As SldWorks.FeatureManager
Dim swFeat As SldWorks.Feature
Set swApp = Application.SldWorks
Set swModel = swApp.ActiveDoc
Set swFeatMgr = swModel.FeatureManager
' FeatureCut4 — VBA 中 27 参数全部正常
Set swFeat = swFeatMgr.FeatureCut4(
True, False, False, ' Sd, Flip, Dir
0, 0, ' T1, T2
0.05, 0.05, ' D1, D2
False, False, False, ' Dchk1, Dchk2, Ddir1
False, 0, 0, ' Ddir2, Dang1, Dang2
False, False, ' Ofr, Ofc
False, False, ' Tf1, Tf2
True, ' Merge
False, False, ' UseFeatScope, UseAutoSelect
0, False, False, ' StartOffset, IsAutoStartOffset, FlipStartOffset
False, False, False, ' 额外参数
False ' 额外参数
)
If swFeat Is Nothing Then
Debug.Print "FeatureCut4 失败"
Else
Debug.Print "FeatureCut4 成功: " & swFeat.Name
End If
End Sub
import tempfile
import os
class VBAMacroGenerator:
"""根据 Python 参数自动生成等效 VBA 宏代码"""
def generate_feature_cut_vba(self, params_dict):
"""生成 FeatureCut4 VBA 代码"""
return f'''Sub main()
Dim swApp As SldWorks.SldWorks
Dim swModel As SldWorks.ModelDoc2
Set swApp = Application.SldWorks
Set swModel = swApp.ActiveDoc
Dim swFeat As SldWorks.Feature
Set swFeat = swModel.FeatureManager.FeatureCut4({params_dict['params_str']})
If Not swFeat Is Nothing Then
Debug.Print "OK"
End If
End Sub'''
def generate_feature_extrusion_vba(self, params_dict):
"""生成 FeatureExtrusion2 VBA 代码"""
return f'''Sub main()
Dim swApp As SldWorks.SldWorks
Set swApp = Application.SldWorks
Set swModel = swApp.ActiveDoc
Dim swFeat As SldWorks.Feature
Set swFeat = swModel.FeatureManager.FeatureExtrusion2({params_dict['params_str']})
End Sub'''
class VBAMacroExecutor:
"""保存并执行 VBA 宏文件"""
def __init__(self, sw_app):
self.sw_app = sw_app
self.history = [] # 执行历史记录
def save_macro(self, vba_code, macro_name="auto_macro"):
"""保存 VBA 代码到 .swp 文件"""
temp_dir = tempfile.gettempdir()
safe_name = "".join(c if c.isalnum() or c in ("_", "-") else "_" for c in macro_name)
swp_path = os.path.join(temp_dir, f"{safe_name}.swp")
# UTF-8 BOM 编码
with open(swp_path, "w", encoding="utf-8-sig") as f:
f.write(vba_code)
return swp_path
def execute_macro(self, swp_path, subroutine="main"):
"""执行 VBA 宏并记录结果"""
import time
start = time.time()
try:
result = self.sw_app.RunMacro2(swp_path, subroutine, 0)
duration = time.time() - start
self.history.append({
"path": swp_path, "result": result, "duration": duration
})
# 清理临时文件
if os.path.exists(swp_path):
os.remove(swp_path)
return result
except Exception as e:
self.history.append({"path": swp_path, "error": str(e)})
return False
# 检查宏执行成功率
def get_macro_success_rate(executor, api_name=None):
total = len(executor.history)
success = sum(1 for h in executor.history if h.get("result"))
rate = success / total if total > 0 else 0.0
if rate < 0.3 and total >= 3:
print(f"⚠️ 宏执行成功率仅 {rate:.0%}，建议切换到加法建模")
return rate
Sec 36 判定走 VBA
│
├─ 调用 VBAMacroGenerator 生成代码
├─ 调用 VBAMacroExecutor 保存并执行
├─ 执行成功 → 记录到路由历史（com_failure++ / vba_success++）
└─ 执行失败 → 回退到加法建模（Sec 应急方案）
参考来源：andrewbartels1/SolidworksMCP-python (MIT License)
Sec 20 提供了连接回退链路，Sec 25 提供了版本化 ProgID，但缺少：自动重连机制、COM 安全包装器、类型库信息缓存。长时间运行的脚本中，COM 连接可能因 SW 崩溃/超时断开。
import win32com.client
import pythoncom
import time
class SWPyWin32Adapter:
"""
pywin32 统一适配器：整合连接回退、自动重连、安全包装、类型库缓存。
参考来源: andrewbartels1/SolidworksMCP-python (pywin32_adapter.py)
"""
def __init__(self, prog_ids=None):
self.prog_ids = prog_ids or [
"SldWorks.Application", "SldWorks.Application.32", "SldWorks.Application.64"
]
self.sw = None
self.connected = False
self._type_cache = {} # API 签名缓存
def connect(self):
"""连接 SolidWorks（整合 Sec 20 回退链 + Sec 25 ProgID 策略）"""
# 第一优先：GetActiveObject
try:
self.sw = win32com.client.GetActiveObject("SldWorks.Application")
self._on_connected()
return self.sw
except Exception:
pass
# 回退：遍历 ProgID
for prog_id in self.prog_ids:
try:
self.sw = win32com.client.Dispatch(prog_id)
self._on_connected()
return self.sw
except Exception:
continue
raise ConnectionError("无法连接或启动 SolidWorks")
def _on_connected(self):
self.sw.Visible = True
self.sw.UserControl = True # ⛔ MUST
self.connected = True
self._type_cache.clear()
def auto_reconnect(self, max_retries=3, base_interval=5):
"""自动重连（指数退避 5s → 10s → 20s）"""
for attempt in range(max_retries):
try:
_ = self.sw.Visible # 探测连接
return True
except Exception:
self.connected = False
wait = base_interval * (2 ** attempt)
print(f"连接断开，{wait}s 后重试 ({attempt+1}/{max_retries})")
time.sleep(wait)
try:
pythoncom.CoUninitialize()
except Exception:
pass
pythoncom.CoInitialize()
try:
self.connect()
return True
except Exception:
continue
raise ConnectionError(f"重连失败：已重试 {max_retries} 次")
def safe_call(self, method_name, *args, circuit_breaker=None):
"""
安全包装 COM 调用：捕获异常、超时保护、熔断器集成。
"""
if circuit_breaker and not circuit_breaker.allow_request():
raise COMCircuitBreakerOpenError("熔断器 Open，拒绝执行")
try:
method = getattr(self.sw.ActiveDoc.FeatureManager, method_name)
result = method(*args)
if circuit_breaker:
circuit_breaker.record_success()
return result
except Exception as e:
if circuit_breaker:
circuit_breaker.record_failure(str(e))
raise COMSafeError(f"{method_name} 失败: {e}")
class COMSafeError(Exception):
pass
# 首次连接时缓存方法签名，避免重复 COM 元数据查询
def cache_type_info(sw_adapter):
"""缓存 SW 类型库信息"""
try:
type_info = sw_adapter.sw._oleobj_.GetTypeInfo()
type_attr = type_info.GetTypeAttr()
sw_adapter._type_cache["_type_attr"] = type_attr
print(f"类型库缓存: {type_attr.cFuncs} 个方法")
except Exception:
pass # 某些环境不支持
safe_call() 内部检查熔断器状态safe_call() 拒绝执行参考来源：vespo92/SolidworksMCP-TS (MIT License)
SelectByID2 存在多个已知问题：VARIANT 包装（Sec 29 M2）、中文名称不一致（Sec 27）、浮点误差。Sec 18 的 safe_select 提供了遍历回退，但只覆盖基准面。本 Section 提供系统化的特征树遍历框架。
class FeatureTreeTraversal:
"""
系统化特征树遍历框架，替代 SelectByID2。
参考来源: vespo92/SolidworksMCP-TS (feature-complexity-analyzer.ts)
"""
@staticmethod
def find_feature_by_name(doc, name):
"""按名称查找特征（正向遍历）"""
feat = doc.FirstFeature # 属性
while feat is not None:
feat_name = feat.Name # 属性
if feat_name == name:
return feat
feat = feat.GetNextFeature() # 方法
return None
@staticmethod
def find_feature_by_type(doc, type_name):
"""按类型查找特征（反向遍历，最新创建优先）"""
feat = doc.FeatureManager.GetLastFeature()
while feat is not None:
if feat.GetTypeName2() == type_name: # GetTypeName2 更精确
return feat
# 反向遍历需要手动实现（SW API 无 GetPreviousFeature）
break # 实际实现中需要完整遍历
# 回退：正向遍历查找
feat = doc.FirstFeature
result = None
while feat is not None:
if feat.GetTypeName2() == type_name:
result = feat
feat = feat.GetNextFeature()
return result
@staticmethod
def find_all_features_of_type(doc, type_name):
"""查找所有指定类型的特征"""
results = []
feat = doc.FirstFeature
while feat is not None:
if feat.GetTypeName2() == type_name:
results.append(feat)
feat = feat.GetNextFeature()
return results
@staticmethod
def find_sketch_for_feature(doc, feature_name):
"""查找特征关联的草图"""
feat = FeatureTreeTraversal.find_feature_by_name(doc, feature_name)
if feat is None:
return None
try:
definition = feat.GetDefinition()
if definition is not None:
return definition.GetSketch()
except Exception:
pass
return None
| GetTypeName2 返回值 | 特征类型 |
|---|---|
BaseBody | 基体 |
Extrusion | 拉伸 |
Cut | 切除 |
Fillet | 圆角 |
Chamfer | 倒角 |
Shell | 抽壳 |
RefPlane | 参考基准面 |
Sketch | 草图 |
ProfileFeature | 轮廓特征 |
def find_plane_by_name(doc, plane_name, translations=None):
"""
查找基准面（支持中英文双匹配）。
整合 Sec 27 翻译表 + Sec 18 遍历回退。
"""
if translations is None:
translations = {
"Front Plane": "前视基准面", "前视基准面": "Front Plane",
"Top Plane": "上视基准面", "上视基准面": "Top Plane",
"Right Plane": "右视基准面", "右视基准面": "Right Plane",
}
# 1. 正向遍历查找原名
feat = doc.FirstFeature
while feat is not None:
if feat.Name == plane_name:
feat.Select2(False, 0)
return feat
feat = feat.GetNextFeature()
# 2. 尝试翻译名
translated = translations.get(plane_name)
if translated:
feat = doc.FirstFeature
while feat is not None:
if feat.Name == translated:
feat.Select2(False, 0)
return feat
feat = feat.GetNextFeature()
return None
| 维度 | safe_select (Sec 18) | FeatureTreeTraversal (本 Sec) |
|---|---|---|
| 覆盖范围 | 仅基准面 | 所有特征类型 |
| 遍历方向 | FirstFeature → forward | 支持正向 + GetLastFeature |
| 类型检测 | Name 字符串匹配 | GetTypeName2 + Name 双重匹配 |
| 草图查找 | 不支持 | find_sketch_for_feature() |
| 中英文兼容 | 无 | 内置翻译表 |
参考来源：vespo92/SolidworksMCP-TS (MIT License)