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')