def CheckEngineWithMoments(engine, e_out, J_out, i0, xi):
Km = 0.5
Storage().put(Km=Km) # учитывает инерционность редуктора
# приведенная к валу динамическая нагрузка
M_d_pr = e_out * i0 * ((1 + Km) * engine['Jr'] + J_out / (i0**2)) * 10**3
Storage().put(M_d_pr=M_d_pr)
if engine['Mn'] > M_d_pr * xi:
return (True, M_d_pr, engine['Mn'])
else:
return (False, M_d_pr, engine['Mn'])
def CalculateGearRatios(i0):
n = int(round((3 + 1.85) / 2 * log10(i0), 0)); Storage().put(gears_n=n)
i_avr = i0 ** (1. / n); Storage().put(i_avr=i_avr)
assert n >= 5
i = [0] * n
i[0] = (2 * i_avr) ** (1. / 4)
i[1] = sqrt(i_avr)
i[-1] = i_avr ** 2 / i[0]
i[-2] = i_avr ** 2 / i[1]
for j in range(2, len(i) - 2):
i[j] = i_avr
return list(map(lambda v: round(v, 2), i))
def calcMinDiameter(M, d1, d2, shaft):
F_circ1, F_circ2 = M / (d1 / 2), M / (d2 / 2)
F_r1, F_r2 = F_circ1 * math.tan(math.radians(20)), F_circ2 * math.tan(
math.radians(20))
R_B_y = (shaft['g2'] * F_r2 - shaft['g1'] * F_r1) / shaft['L']
R_A_y = F_r2 - F_r1 - R_B_y
R_B_x = (shaft['g2'] * F_circ2 + shaft['g1'] * F_circ1) / shaft['L']
R_A_x = F_circ1 + F_circ2 - R_B_x
Mkx, Mky = 91.36, 24.3
Msum_izg = math.sqrt(Mkx**2 + Mky**2)
M_pr = math.sqrt(Msum_izg**2 + 0.75 * M**2)
d_min = (M_pr / (0.1 * 0.1 * shaft['material']['sigma_b']))**(1.0 / 3)
d_min_round = int(d_min + 1)
n = 218
F_r_A = math.sqrt(R_A_x**2 + R_A_y**2)
F_r_B = math.sqrt(R_B_x**2 + R_B_y**2)
F_R = max(F_r_A, F_r_B)
P = 1 * 1.2 * 1 * F_R
Cp = 0.01 * P * (60 * n * 3000)**(1.0 / 3)
tmpl = 'shaft.%s'
damp = locals()
Storage().put(**dict(
(tmpl % name, damp[name])
for name in ('M', 'F_circ1', 'F_circ2', 'F_r1', 'F_r2', 'R_B_x',
'R_B_y', 'R_A_x', 'R_A_y', 'Mkx', 'Mky', 'Msum_izg',
'M_pr', 'd_min', 'd_min_round', 'P', 'F_R', 'F_r_A',
'F_r_B', 'n', 'Cp')))
def LoshSpringCalculation(Wh):
Sp = Wh['spring']
phi = radians(360 * Wh['n'] / Wh['z']) # угол поворота одной половины колеса относительно другой
A1 = Wh['A'] * cos(phi / 2) - Sp['L'] / 2 * sin(phi / 2) # новое плечо действия пружины
P2 = Wh['xi'] * Wh['M'] / (2 * A1) # рабочее усилие пружины
P3 = P2 / (1 - Wh['d']) # максимальное усилие пружины
L1 = Sp['L']*cos(phi/2) + 2*Wh['A']*sin(phi/2) # длина пружины в растянутом состоянии
F2 = L1 - Sp['L'] # удлинение пружины, мм
z = P2/F2 # жёсткость пружины
n = round(Sp['z1']/z) # число витков пружины
n1 = n # число витков с зацепами
H0 = (n1 + 1) * Sp['d'] # длина пружины в свободном состоянии
L_dash = H0 + 2*Sp['D'] # полная длина пружины
# TODO: в примере от Жуковой есть проверочный расчёт на d
alpha = atan((Sp['d']+0.3)/(3.14*Sp['D'])) # угол подьема витков в свободом состояни
L = 3.14*Sp['D']*n/cos(alpha) + 3.14*Sp['D'] # полная длина проволоки
Lapp = 3.2*n*Sp['D']
tmpl = 'loft.%s'
print(locals()['phi'])
damp = locals()
Storage().put(**dict((tmpl % name, damp[name]) for name in (
'phi', 'A1', 'P2', 'P3', 'L1', 'F2', 'z', 'n', 'n1', 'H0', 'L_dash', 'L', 'Lapp'
)))
return P3, L_dash, H0
def CalculateContactStrength(gears, materials, M):
sigma_H = materials['wheel']['sigma_H']
K = 1.2 # коэффициент расчётной нагрузки
zk = 0.9 # для прямозубых передач
for i in range(len(gears)):
z1, z2 = gears[i]['d'][0]['z'], gears[i]['d'][1]['z']
m, i0, b = gears[i]['m'], gears[i]['i'], gears[i]['b']
m = 0.4
a_w = (z1 + z2) * m / 2
sigma_n = 108.5 * zk / (a_w * i0) * sqrt(
(i0 + 1) ** 3 * K * M[i] / b
)
tmpl = 'cs.{0}.%s'.format(i+1)
Storage().put(**{
tmpl % 'aw': a_w,
tmpl % 'sigma_n': sigma_n,
tmpl % 'i': i0,
tmpl % 'b': b,
})
if sigma_n < sigma_H:
print("Колесная пара %d: проверка на прочность пройдена: sigma_n=%d, [sigma_H]=%d" % (i, sigma_n, sigma_H))
else:
print(
"Колесная пара %d: проверка на прочность НЕ пройдена: sigma_n=%d, [sigma_H]=%d" % (i, sigma_n, sigma_H))
return False
print("\033[32mРедуктор прошел проверку на прочность\033[0m")
return True
def CalculateKpdMoments(gG_, Min_, kpdOp):
preM = Min_
eps = 1.5
f = 0.15
buildStruct = lambda M, kpd: {'M': round(M, 2), 'Kpd': round(kpd, 2)}
newM = [buildStruct(preM, 1)]
for i in range(len(gG_) - 1, -1, -1):
pair = gG_[i]
g1, g2 = pair['d'][0], pair['d'][1]
F = 2 * preM / (max(g1['d'], g2['d']))
c = (F + 2.87) / (F + 0.17)
kpd = 1 - 3.14 * c * eps * f * (1 / g1['z'] + 1 / g2['z'])
preM = preM / (pair['i'] * kpd * kpdOp)
newM.append(buildStruct(preM, kpd))
tmpl = 'kpd.{0}.%s'.format(i+1)
Storage().put(**{
tmpl % 'F': F,
tmpl % 'c': c,
tmpl % 'kpd': kpd,
tmpl % 'newM': preM
})
return newM[::-1]
def calcAccurance(wheels):
j_n_max = [11, 11, 13, 16, 19]
s = 0
I_mul = [1] * len(wheels)
for i in range(len(wheels)):
for j in range(i, len(wheels)):
I_mul[i] *= wheels[j]['i']
Storage().put(**{
"acc.I_mul.%d" % i: I_mul[i],
})
pair = wheels[i]
m, z = pair['m'], pair['d'][0]['z']
phi_L = 7.4 * j_n_max[i] / (m * z)
s += phi_L / I_mul[i]
Storage().put(**{
"acc.%d.phi_L" % i: phi_L,
})
Storage().put(**{
"acc.phi_L": s,
})
F_f = [9] * 8 + [10] * 2
F_p = [22, 24, 22, 24, 22, 30, 22, 35, 26, 42]
Phi = []
for i in range(len(wheels)):
pair = wheels[i]
m, z = pair['m'], pair['d'][0]['z']
for j in range(2):
phi = 4.8 * (F_f[2 * i + j] + F_p[2 * i + j]) / (m * z)
Phi.append(phi)
Storage().put(**{
"acc.%d.phi_i" % (2 * i + j + 1): phi,
})
phi_summ = Phi[0] / I_mul[0] + (Phi[1] + Phi[2]) / I_mul[1] + (
Phi[3] + Phi[4]) / I_mul[2] + (Phi[5] + Phi[6]) / I_mul[3] + (
Phi[7] + Phi[8]) / I_mul[4] + Phi[9]
Storage().put(**{
"acc.Phi": phi_summ,
"acc.Sum": phi_summ + s,
})
def CalculateModule(Z, M, material, K, Ybm):
YF = lambda x: 3.6 if (
x > 80) else 6.39598364 - 0.22982 * x + 0.0082 * x ** 2 - 0.000155222 * x ** 3 + 1.5935909197769 * 10 ** (
-6) * x ** 4 - 8.2802228698844 * 10 ** (-9) * x ** 5 + 1.6784912618852 * 10 ** (-11) * x ** 6
m = []
for i in range(len(M) - 1):
z_gear = min(Z[2 * i], Z[2 * i + 1])
z_wheel = max(Z[2 * i], Z[2 * i + 1])
a = YF(z_gear) / material['gear']['sigma_f']; Storage().put(**{'YF_gear%d'%(i+1): a})
b = YF(z_wheel) / material['wheel']['sigma_f']; Storage().put(**{'YF_wheel%d'%(i+1): a})
Storage().put(**{
'gear.yf.%d' % (i+1): YF(z_gear),
'wheel.yf.%d' % (i+1): YF(z_wheel),
'gear./.%d' % (i+1): a,
'wheel./.%d' % (i+1): b,
})
if a > b:
yf = YF(YF(z_gear))
sigma = material['gear']['sigma_f']
z = z_gear
ind = i
print("Прочность по шестерне: Z=", z_gear); Storage().put(**{'YF_choose%d'%(i+1): 'шестерне'})
else:
yf = YF(YF(z_wheel))
sigma = material['wheel']['sigma_f']
z = z_wheel
ind = i+1
print("Прочность по колесу: Z=", z_wheel); Storage().put(**{'YF_choose%d'%(i+1): 'колесу'})
Storage().put(**{'sigma%d'%(i+1): sigma})
Storage().put(**{'yf.%d'%(i+1): yf})
Storage().put(**{'z.%d'%(i+1): z})
m_ = 1.4 * (
M[ind] * K * Yf / (Ybm * z * sigma)
) ** (1. / 3)
Storage().put(**{'gear.%d.minm' % (i+1): m_-0.05}) # чтобы не перерисовывать это гавно заново
m.append(round(m_, eps_module))
Storage().put(**{'m%d'%(i+1): m[-1]})
print("Max module: %.2f" % max(m))
return m
from latex_storage import Storage
def dump_data(storage, filename):
storage.put(M_load='valueA', N_min='valueB')
storage.put(**dict(
('engine.%s' % key, value) for key, value in engine.items()))
storage.export(filename)
dump_data(Storage(), 'latex/work.json')