好友
阅读权限10
听众
最后登录1970-1-1
|
本帖最后由 myuniversity 于 2022-11-12 08:52 编辑
水平传动时，丝杆电机选型，用Java实现。大致思路是将丝杆、电机、工况作为对象，然后提供一个计算校验服务，以及一个测试demo。修改参数只需在测试demo中修改，其他的不需要变动。
这个是丝杆对象代码。
BallScrew.java
[Java] 纯文本查看 复制代码 package test.test;
public class BallScrew {
private final double d;
private final double d1;
private final double Ph;
private final double ls;
private final double la;
private final double lb;
private final double md;
private final double C0a;
private final double F0;
//单例模式
private volatile static BallScrew ballScrew;
/**
* [url=home.php?mod=space&uid=952169]@Param[/url] d 丝杠公称直径 mm
* @param d1 丝杠螺纹小径 mm
* @param ph 丝杠导程 mm
* @param ls 行程长度 mm
* @param la 丝杠安装间距 mm
* @param lb 丝杠总长 mm
* @param md 丝杠单位长度质量 kg/m
* @param c0a 丝杠基本额定动载荷 KN
* @param f0 丝杠预压力 N
*/
private BallScrew(double d, double d1, double ph, double ls, double la, double lb, double md, double c0a,
double f0) {
super();
this.d = d;
this.d1 = d1;
this.Ph = ph;
this.ls = ls;
this.la = la;
this.lb = lb;
this.md = md;
this.C0a = c0a;
this.F0 = f0;
}
public static BallScrew getBallScrew(double d, double d1, double ph, double ls, double la, double lb, double md,
double c0a, double f0) {
if (ballScrew == null) {
synchronized (BallScrew.class) {
if (ballScrew == null) {
ballScrew = new BallScrew(d, d1, ph, ls, la, lb, md, c0a, f0);
}
}
}
return ballScrew;
}
public double getD() {
return d;
}
public double getD1() {
return d1;
}
public double getPh() {
return Ph;
}
public double getLs() {
return ls;
}
public double getLa() {
return la;
}
public double getLb() {
return lb;
}
public double getMd() {
return md;
}
public double getC0a() {
return C0a;
}
public double getF0() {
return F0;
}
@Override
public String toString() {
return "***丝杠***：直径d=" + d + "mm, 螺纹底径d1=" + d1 + "mm, 导程Ph=" + Ph + "mm, 行程ls=" + ls + "mm, 轴承座间距la=" + la
+ "mm, 总长lb=" + lb + "mm, 单位长度质量md=" + md + "kg/m, 基本额定动载荷C0a=" + C0a + "KN, 预压力F0=" + F0 + "N";
}
}
这个是电机对象代码。
Motor.java
[Java] 纯文本查看 复制代码 package test.test;
public class Motor {
private final double Jm;
private final double Te;
private final double Tf;
private final double glm;
private volatile static Motor motor;
/**
* @param jm 电机转子惯量 kg*m平方
* @param te 电机额定转矩 N*m
* @param tf 电机峰值转矩 N*m
* @param glm 容许负载转动惯量的倍率
*/
private Motor(double jm, double te, double tf, double glm) {
super();
this.Jm = jm;
this.Te = te;
this.Tf = tf;
this.glm = glm;
}
public static Motor getMotor(double jm, double te, double tf, double glm) {
if (motor == null) {
synchronized (Motor.class) {
if (motor == null) {
motor = new Motor(jm, te, tf, glm);
}
}
}
return motor;
}
public double getJm() {
return Jm;
}
public double getTe() {
return Te;
}
public double getTf() {
return Tf;
}
public double getGlm() {
return glm;
}
@Override
public String toString() {
return "***电机***：转子惯量Jm=" + Jm + "kg*m平方, 额定转矩Te=" + Te + "N*m, 峰值转矩Tf=" + Tf + "N*m, 容许负载转动惯量的倍率glm=" + glm
+ "]";
}
}
这个是工况对象代码。
GongKuang.java
[Java] 纯文本查看 复制代码 package test.test;
public class GongKuang {
private final double miu;
private final double Vmax;
private final double t1;
private final double m;
private final double f;
private final double eta;
private final double eta2;
private final double lambda2;
// 单例模式
private volatile static GongKuang gongKuang;
/**
* @param miu 导向面摩擦系数
* @param vmax 工作台最大运行速度 m/s
* @param t1 加减速时间 s
* @param m 单轴运送质量含螺母和滑块 kg
* @param f 导向面阻力 N
* @param eta 丝杠机械效率
* @param eta2 计算挫曲载荷时，与安装方法相关的系数
* @param lambda2 计算危险转速时，与安装方法相关的系数
*/
private GongKuang(double miu, double vmax, double t1, double m, double f, double eta, double eta2, double lambda2) {
super();
this.miu = miu;
this.Vmax = vmax;
this.t1 = t1;
this.m = m;
this.f = f;
this.eta = eta;
this.eta2 = eta2;
this.lambda2 = lambda2;
}
public static GongKuang getGongKuang(double miu, double vmax, double t1, double m, double f, double eta,
double eta2, double lambda2) {
if (gongKuang == null) {
synchronized (GongKuang.class) {
if (gongKuang == null) {
gongKuang = new GongKuang(miu, vmax, t1, m, f, eta, eta2, lambda2);
}
}
}
return gongKuang;
}
public double getMiu() {
return miu;
}
public double getVmax() {
return Vmax;
}
public double getT1() {
return t1;
}
public double getM() {
return m;
}
public double getF() {
return f;
}
public double getEta() {
return eta;
}
public double getEta2() {
return eta2;
}
public double getLambda2() {
return lambda2;
}
@Override
public String toString() {
return "***工况***：导向面摩擦系数miu=" + miu + ", 工作台最大运行速度Vmax=" + Vmax + "m/s, 加减速时间t1=" + t1 + "s,单轴运送质量含螺母和滑块 m=" + m
+ "kg, 导向面阻力f=" + f + "N, 丝杠机械效率eta=" + eta + ", 计算挫曲载荷时，与安装方法相关的系数eta2=" + eta2
+ ", 计算危险转速时，与安装方法相关的系数lambda2=" + lambda2 + "]";
}
}
这个是计算服务代码。
SgServer.java
[Java] 纯文本查看 复制代码 package test.test;
public final class SgServer {
// 常数项
final static double g = 9.8;
final static double E = 2.06 * (Math.pow(10, 5));
static double F;
static double Lh;
static double L10;
static double P1;
static double P2;
static double N1;
static double Nmax;
static double Famax;
static double T;
static double J;
public static double niuju(BallScrew ballScrew, Motor motor, GongKuang gongKuang) {
// 丝杠所需扭矩
System.out.println("单轴总负载: " + gongKuang.getM() + "kg");
// 克服摩擦匀速运动所需扭矩
double T1 = (gongKuang.getM() * (g * gongKuang.getMiu() + (gongKuang.getVmax() / gongKuang.getT1()))
+ ballScrew.getF0()) * ballScrew.getPh() / (2 * Math.PI * gongKuang.getEta() * 1000);
System.out.println("克服摩擦所需扭矩: " + T1 + "N*m");
if (motor.getTe() > T1) {
System.out.println("额定扭矩要求满足 ");
} else {
System.out.println("***警告***：额定扭矩要求不满足，请重新选择额定扭矩更大的电机 ");
}
double J1 = ballScrew.getMd() * (ballScrew.getLb() / 1000) * Math.pow(ballScrew.getD(), 2)
/ (8 * Math.pow(10, 6));
System.out.println("丝杠本身的的转动惯量: " + J1 + "kg/m平方");
double J2 = gongKuang.getM() * Math.pow((ballScrew.getPh() / (2 * Math.PI)), 2) * Math.pow(10, -6);
System.out.println("负载折算到丝杠转动惯量: " + J2 + "kg/m平方");
J = J1 + J2;
System.out.println("传递到电机端的转动惯量: " + J + "kg/m平方");
if (J < motor.getGlm() * motor.getJm()) {
System.out.println("惯量要求满足 ");
System.out.println("实际负载惯量是转子惯量的倍数为： " + (J / motor.getJm()));
} else {
System.out.println("***警告***：惯量要求不满足，请重新选择惯量更大的电机；电机惯量倍率为 " + motor.getGlm());
System.out.println("***警告***：实际负载惯量是转子惯量的倍数为： " + (J / motor.getJm()));
}
// wj 角加速度 rad/s平方
double wj = 2 * Math.PI * Nmax / (60 * gongKuang.getT1());
// 加速运动，不考虑摩擦时的扭矩
double T2 = (J + motor.getJm()) * wj;
System.out.println(" 加速运动，不考虑摩擦时的扭矩: " + T2 + "N*m");
// 丝杠所需的总扭矩
T = T1 + T2;
System.out.println("丝杠所需的总扭矩: " + T + "N*m");
if (motor.getTf() > T) {
System.out.println("峰值扭矩要求满足 ");
} else {
System.out.println("***警告***：峰值扭矩要求不满足，请重新选择峰值扭矩更大的电机 ");
}
return T;
}
public static double zhouxianggangxingbianxingliang(BallScrew ballScrew, double L) {
// 固定支持方式安装时，丝杠轴向刚性变形量delta um
// k 刚性值 N/um
double k = Math.PI * (Math.pow(ballScrew.getD1(), 2)) * E / (4 * 1000 * L);
// System.out.println("丝杠刚性值K:" + k);
double delta = F / k;
// System.out.println("丝杠轴向刚性变形量delta:" + delta);
return delta;
}
public static double shuipingzhouxiangzaihe(BallScrew ballScrew, GongKuang gongKuang) {
// "============实际轴向载荷: " + F + "N"
P1 = (Math.pow(10, 4)) * gongKuang.getEta2() * (Math.pow(ballScrew.getD1(), 4))
/ (Math.pow(ballScrew.getLa(), 2));
System.out.println("挫曲载荷: " + P1 + "N");
P2 = 116 * Math.pow(ballScrew.getD1(), 2);
System.out.println("容许拉伸压缩载荷: " + P2 + "N");
F = gongKuang.getMiu() * gongKuang.getM() * g + gongKuang.getF()
+ gongKuang.getM() * (gongKuang.getVmax() / gongKuang.getT1());
System.out.println("实际轴向载荷: " + F + "N");
Famax = ballScrew.getC0a() / 3.5;
System.out.println("容许轴向载荷: " + Famax + "KN");
if (F > Famax * 1000 || F > P1 || F > P2) {
System.out.println("***警告***：实际轴向载荷大于容许轴向载荷，请重新进行丝杠选型计算");
} else {
System.out.println("====合格===轴向载荷满足要求");
}
return F;
}
public static double edingshouming(BallScrew ballScrew, GongKuang gongKuang) {
Nmax = (Math.pow(10, 3)) * gongKuang.getVmax() * 60 / ballScrew.getPh();
System.out.println("所需最高转速: " + Nmax + "转每分钟");
// "============可能共振的危险转速: " + N1 + "转每分钟"
N1 = (Math.pow(10, 7)) * gongKuang.getLambda2() * ballScrew.getD1() / (Math.pow(ballScrew.getLa(), 2));
System.out.println("可能共振的危险转速: " + N1 + "转每分钟");
System.out.println("可能共振的线速度: " + N1 * ballScrew.getPh() / 60 + "mm/s");
if (N1 < Nmax) {
System.out.println("警告：危险速度小于所需最高转速，请加大丝杠直径或导程");
} else {
System.out.println("====合格===最大转速满足要求");
}
if (F != 0 && Nmax != 0) {
L10 = (Math.pow(10, 6)) * (Math.pow(((1 / 1.5) * ballScrew.getC0a() * 1000 / F), 3));
System.out.println("额定寿命: " + L10 + "转");
Lh = L10 / (60 * Nmax);
System.out.println("工作寿命时间: " + Lh + "小时");
System.out.println("工作寿命天数（8小时每天）: " + Lh / 8 + "天");
System.out.println("工作寿命（8小时每天一年365天）: " + Lh / (8 * 365) + "年");
}
return L10;
}
}
这个是测试demo代码，修改此处参数即可。相关参数需要查询丝杆和电机厂商给的手册，这里是随便写的数字。
Tdemo.java
[Java] 纯文本查看 复制代码 package test.test;
/**
* 滚珠丝杠传动：丝杠和电机选型测试
*
*/
public class Tdemo {
// 根据目标和工况预先定义的参数项
// 工况参数相关
/**
* @param miu 导向面摩擦系数
* @param Vmax 工作台最大运行速度 m/s
* @param t1 加减速时间 s
* @param m 单轴运送质量含螺母和滑块 kg
* @param f 导向面阻力 N
* @param eta 丝杠机械效率
* @param eta2 计算挫曲载荷时，与安装方法相关的系数
* @param lambda2 计算危险转速时，与安装方法相关的系数
*/
final static double miu = 0.1;
final static double Vmax = 0.5;
final static double t1 = 0.2;
final static double m = 50;
final static double f = 50;
final static double eta = 0.9;
final static double eta2 = 10.0;
final static double lambda2 = 15.1;
// 丝杠参数相关
/**
* @param d 丝杠公称直径 mm
* @param d1 丝杠螺纹小径 mm
* @param ph 丝杠导程 mm
* @param ls 行程长度 mm
* @param la 丝杠安装间距 mm
* @param lb 丝杠总长 mm
* @param md 丝杠单位长度质量 kg/m
* @param c0a 丝杠基本额定动载荷 KN
* @param f0 丝杠预压力 N
*/
final static double d = 20;
final static double d1 = 17.5;
final static double Ph = 25;
final static double ls = 600;
final static double la = 700;
final static double lb = 800;
final static double md = 3;
final static double C0a = 10.5;
final static double F0 = 15;
// 电机参数相关
/**
* @param Jm 电机转子惯量 kg*m平方
* @param Te 电机额定转矩 N*m
* @param Tf 电机峰值转矩 N*m
* @param glm 容许负载转动惯量的倍率
*/
final static double Jm = 0.5 * Math.pow(10, -4);
final static double Te = 2;
final static double Tf = 6;
final static double glm = 10;
public static void main(String[] args) throws Exception {
/**
* @param d 丝杠公称直径 mm
* @param d1 丝杠螺纹小径 mm
* @param ph 丝杠导程 mm
* @param ls 行程长度 mm
* @param la 丝杠安装间距 mm
* @param lb 丝杠总长 mm
* @param md 丝杠单位长度质量 kg/m
* @param c0a 丝杠基本额定动载荷 KN
* @param f0 丝杠预压力 N
*/
BallScrew ballScrew = BallScrew.getBallScrew(d, d1, Ph, ls, la, lb, md, C0a, F0);
System.out.println(ballScrew.toString());
/**
* @param Jm 电机转子惯量 kg*m平方
* @param Te 电机额定转矩 N*m
* @param Tf 电机峰值转矩 N*m
* @param glm 容许负载转动惯量的倍率
*/
Motor motor = Motor.getMotor(Jm, Te, Tf, glm);
System.out.println(motor.toString());
/**
* @param miu 导向面摩擦系数
* @param Vmax 工作台最大运行速度 m/s
* @param t1 加减速时间 s
* @param m 单轴运送质量含螺母和滑块 kg
* @param f 导向面阻力 N
* @param eta 丝杠机械效率
* @param eta2 计算挫曲载荷时，与安装方法相关的系数
* @param lambda2 计算危险转速时，与安装方法相关的系数
*/
GongKuang gongKuang = GongKuang.getGongKuang(miu, Vmax, t1, m, f, eta, eta2, lambda2);
System.out.println(gongKuang.toString());
System.out.println("============双轴丝杠计算选型==========");
SgServer.shuipingzhouxiangzaihe(ballScrew, gongKuang);
SgServer.edingshouming(ballScrew, gongKuang);
System.out.println("丝杠轴向刚性变形量" + (SgServer.zhouxianggangxingbianxingliang(ballScrew, la)
- SgServer.zhouxianggangxingbianxingliang(ballScrew, 100)) + "um");
System.out.println("============伺服电机计算选型==========");
SgServer.niuju(ballScrew, motor, gongKuang);
}
}
有什么建议欢迎学习交流{:1_918:} |
免费评分
-
查看全部评分
|
[复制链接]
发表于 2022-11-12 08:49
|
发表于 2022-11-12 15:14
