def Prisma_hueco(): # generamos una caja de 100x100x100 como base de este ejemplo shp_caja = fcfun.shp_box_dir_xtr(100, 100, 100, fc_axis_h=VZ, fc_axis_d=VY, fc_axis_w=V0, cw=0, cd=0, ch=0, pos=V0) # generamos una segunda forma que será una segunda caja de 100x80x80 shp_caja_2 = fcfun.shp_box_dir_xtr(100, 80, 80, fc_axis_h=VZ, fc_axis_d=VY, fc_axis_w=V0, cw=0, cd=0, ch=0, pos=V0 + FreeCAD.Vector(0, 10, 10)) # restamos a shp_caja shp_caja_2 para realizar un prisma hueco por una cara shp_caja = shp_caja.cut(shp_caja_2) # PRUEBA DE LA GENERACIÓN DEL SHAPE POR FASES # form1 = FreeCAD.ActiveDocument.addObject("Part::Feature","Prisma hueco 1") # form1.Shape = shp_caja # generamos una tercera forma que será una tercera caja de 80x100x80 shp_caja_3 = fcfun.shp_box_dir_xtr(80, 100, 80, fc_axis_h=VZ, fc_axis_d=VY, fc_axis_w=V0, cw=0, cd=0, ch=0, pos=V0 + FreeCAD.Vector(10, 0, 10)) # restamos a shp_form shp_caja_3 para realizar un prisma hueco por dos caras shp_caja = shp_caja.cut(shp_caja_3) # PRUEBA DE LA GENERACIÓN DEL SHAPE POR FASES # form2 = FreeCAD.ActiveDocument.addObject("Part::Feature","Prisma hueco 2") # form2.Shape = shp_caja # generamos una cuarta forma que será una cuarta caja de 80x80x100 shp_caja_4 = fcfun.shp_box_dir_xtr(80, 80, 100, fc_axis_h=VZ, fc_axis_d=VY, fc_axis_w=V0, cw=0, cd=0, ch=0, pos=V0 + FreeCAD.Vector(10, 10, 0)) # restamos a shp_form shp_caja_4 para realizar un prisma hueco por dos caras shp_caja = shp_caja.cut(shp_caja_4) form = FreeCAD.ActiveDocument.addObject("Part::Feature", "Prisma hueco") form.Shape = shp_caja.removeSplitter()
def __init__(self, w, d, h, pos): shp_clss.Obj3D.__init__(self, axis_d=VY, axis_w=V0, axis_h=VZ) self.shp_placa = fcfun.shp_box_dir_xtr(box_w=w, box_d=d, box_h=h, fc_axis_h=VZ, fc_axis_d=VY, fc_axis_w=V0, cw=0, cd=0, ch=0, pos=pos)
def silla_fun(): # vamos a generar una silla sencilla con primas # Primero hacemos el asiento shp_silla = fcfun.shp_box_dir_xtr(box_w=450, box_d=450, box_h=25, fc_axis_h=VZ, fc_axis_d=VY, fc_axis_w=V0, cw=0, cd=0, ch=0, pos=V0) # hacemos el respaldo shp_respaldo = fcfun.shp_box_dir_xtr(box_w=450, box_d=25, box_h=600, fc_axis_h=VZ, fc_axis_d=VY, fc_axis_w=V0, cw=0, cd=0, ch=0, pos=V0 + FreeCAD.Vector(0, 425, 0)) shp_silla = shp_silla.fuse(shp_respaldo) shp_pata_1 = fcfun.shp_box_dir_xtr(box_w=25, box_d=25, box_h=400, fc_axis_h=VZ, fc_axis_d=VY, fc_axis_w=V0, cw=0, cd=0, ch=0, pos=V0 + FreeCAD.Vector(0, 425, -400)) shp_silla = shp_silla.fuse(shp_pata_1) shp_pata_2 = fcfun.shp_box_dir_xtr(box_w=25, box_d=25, box_h=400, fc_axis_h=VZ, fc_axis_d=VY, fc_axis_w=V0, cw=0, cd=0, ch=0, pos=V0 + FreeCAD.Vector(425, 425, -400)) shp_silla = shp_silla.fuse(shp_pata_2) shp_pata_3 = fcfun.shp_box_dir_xtr(box_w=25, box_d=25, box_h=400, fc_axis_h=VZ, fc_axis_d=VY, fc_axis_w=V0, cw=0, cd=0, ch=0, pos=V0 + FreeCAD.Vector(425, 0, -400)) shp_silla = shp_silla.fuse(shp_pata_3) shp_pata_4 = fcfun.shp_box_dir_xtr(box_w=25, box_d=25, box_h=400, fc_axis_h=VZ, fc_axis_d=VY, fc_axis_w=V0, cw=0, cd=0, ch=0, pos=V0 + FreeCAD.Vector(0, 0, -400)) shp_silla = shp_silla.fuse(shp_pata_4) silla = FreeCAD.ActiveDocument.addObject("Part::Feature", "Silla") silla.Shape = shp_silla.removeSplitter()
def __init__(self, w, d, h, pos): shp_clss.Obj3D.__init__(self, axis_d=VY, axis_w=V0, axis_h=VZ) self.shp_asiento = fcfun.shp_box_dir_xtr(box_w=w, box_d=d, box_h=h, fc_axis_h=VZ, fc_axis_d=VY, fc_axis_w=V0, cw=0, cd=0, ch=0, pos=pos) self.shp_asiento.h_0 = pos self.shp_asiento.h_1 = pos + h / 2 self.shp_asiento.h_2 = pos + h self.shp_asiento.w_0 = pos self.shp_asiento.w_1 = pos + w / 2 self.shp_asiento.w_2 = pos + w self.shp_asiento.d_0 = pos self.shp_asiento.d_1 = pos + d / 2 self.shp_asiento.d_2 = pos + d
def __init__( self, filter_l=60., filter_w=25., filter_t=2.5, base_h=6., hold_d=10., filt_supp_in=2., filt_rim=3., filt_cen_d=0, fillet_r=1., # linear guides SEBLV16 y SEBS15, y MGN12H: boltcol1_dist=20 / 2., boltcol2_dist=12.5, #thorlabs breadboard distance boltcol3_dist=25, boltrow1_h=0, boltrow1_2_dist=12.5, # linear guide MGN12H boltrow1_3_dist=20., # linear guide SEBLV16 and SEBS15 boltrow1_4_dist=25., bolt_cen_mtr=4, bolt_linguide_mtr=3, # linear guide bolts beltclamp_t=3., #2.8, beltclamp_l=12., beltclamp_h=8., clamp_post_dist=4., sm_beltpost_r=1., tol=kcomp.TOL, axis_d=VX, axis_w=VY, axis_h=VZ, pos_d=0, pos_w=0, pos_h=0, pos=V0): shp_clss.Obj3D.__init__(self, axis_d, axis_w, axis_h) # save the arguments as attributes: frame = inspect.currentframe() args, _, _, values = inspect.getargvalues(frame) for i in args: if not hasattr(self, i): setattr(self, i, values[i]) # normal axes to print without support self.prnt_ax = self.axis_h # calculation of the dimensions: # hole for the filter, including tolerances: # Note that now the dimensions width and length are changed. # to depth and width # they are relative to the holder, not to the filter # no need to have the tolerances here: self.filt_hole_d = filter_w # + tol # depth self.filt_hole_w = filter_l # + tol # width in holder axis self.filt_hole_h = filter_t # + tol/2. # 0.5 tolerance for height # The hole under the filter to let the light go through # and big enough to hold the filter # we could take filter_hole dimensions or filter dimensiones # just the tolerance difference self.filt_supp_d = self.filt_hole_d - 2 * filt_supp_in self.filt_supp_w = self.filt_hole_w - 2 * filt_supp_in # look for the largest bolt head in the first row: # dictionary of the center bolt and 2nd and 3rd column self.bolt_cen_dict = kcomp.D912[bolt_cen_mtr] self.bolt_cen_head_r_tol = self.bolt_cen_dict['head_r_tol'] self.bolt_cen_r_tol = self.bolt_cen_dict['shank_r_tol'] self.bolt_cen_head_l_tol = self.bolt_cen_dict['head_l_tol'] # dictionary of the 1st column bolts (for the linear guide) self.bolt_linguide_dict = kcomp.D912[bolt_linguide_mtr] self.bolt_linguide_head_r_tol = self.bolt_linguide_dict['head_r_tol'] self.bolt_linguide_r_tol = self.bolt_linguide_dict['shank_r_tol'] self.bolt_linguide_head_l_tol = self.bolt_linguide_dict['head_l_tol'] max_row1_head_r_tol = max(self.bolt_linguide_head_r_tol, self.bolt_cen_head_r_tol) if boltrow1_h == 0: self.boltrow1_h = 2 * max_row1_head_r_tol elif boltrow1_h < 2 * max_row1_head_r_tol: self.boltrow1_h = 2 * max_row1_head_r_tol msg1 = 'boltrow1_h smaller than bolt head diameter' msg2 = 'boltrow1_h will be bolt head diameter' logger.warning(msg1 + msg2 + str(self.boltrow1_h)) # else # it will be as it is self.hold_h = (base_h + self.boltrow1_h + boltrow1_4_dist + 2 * self.bolt_linguide_head_r_tol) self.tot_h = self.hold_h + beltclamp_h self.beltclamp_blk_t = (hold_d - beltclamp_t) / 2. #self.clamp2cenpost = clamp_post_dist + s_beltclamp_r_sm # the large radius of the belt post self.lr_beltpost_r = (hold_d - 3) / 2. min_filt_cen_d = hold_d + filt_rim + filter_w / 2. if filt_cen_d == 0: filt_cen_d = hold_d + filt_rim + filter_w / 2. elif filt_cen_d < min_filt_cen_d: filt_cen_d = hold_d + filt_rim + filter_w / 2. msg = 'filt_cen_d is smaller than needed, taking: ' logger.warning(msg + str(filt_cen_d)) self.filt_cen_d = filt_cen_d self.tot_d = self.filt_cen_d + filter_w / 2. + filt_rim # find out if the max width if given by the filter or the holder base_w = filter_l + 2 * filt_rim hold_w = 2 * boltcol3_dist + 4 * self.bolt_cen_head_r_tol self.tot_w = max(base_w, hold_w) self.beltpost_l = (3 * self.lr_beltpost_r) + sm_beltpost_r self.clamp_lrbeltpostcen_dist = (self.beltpost_l - self.lr_beltpost_r + self.clamp_post_dist) self.d0_cen = 0 self.w0_cen = 1 # symmetrical self.h0_cen = 0 self.d_o[0] = V0 self.d_o[1] = self.vec_d(self.beltclamp_blk_t) self.d_o[2] = self.vec_d(hold_d / 2.) self.d_o[3] = self.vec_d(hold_d - self.beltclamp_blk_t) # at the beginning of the bolt head hole for the central bolt self.d_o[4] = self.vec_d(hold_d - self.bolt_cen_head_l_tol) self.d_o[5] = self.vec_d(hold_d - self.bolt_linguide_head_l_tol) self.d_o[6] = self.vec_d(hold_d) # at the beginning of the hole of the porta (no tolerance): self.d_o[7] = self.vec_d(self.filt_cen_d - filter_w / 2.) # inner side of porta thruhole self.d_o[8] = self.d_o[7] + self.vec_d(filt_supp_in) # at the center of the porta: self.d_o[9] = self.vec_d(self.filt_cen_d) # outer side of porta thruhole self.d_o[10] = self.vec_d(self.filt_cen_d + filter_w / 2. - filt_supp_in) # at the end of the hole of the porta (no tolerance): self.d_o[11] = self.vec_d(self.filt_cen_d + filter_w / 2.) self.d_o[12] = self.vec_d(self.tot_d) # these are negative because actually the pos_w indicates a negative # position along axis_w self.w_o[0] = V0 #1: at the first bolt column self.w_o[1] = self.vec_w(-boltcol1_dist) #2: at the second bolt column self.w_o[2] = self.vec_w(-boltcol2_dist) #3: at the third bolt column self.w_o[3] = self.vec_w(-boltcol3_dist) #7: at the end of the piece self.w_o[7] = self.vec_w(-self.tot_w / 2.) #6: at the inner side of the clamp rails # add belt_clamp because w_o are negative self.w_o[6] = self.w_o[7] + self.vec_w(beltclamp_l) #5: at the outer side of the clamp post (smaller circle) self.w_o[5] = self.w_o[6] + self.vec_w(clamp_post_dist) #4: at the inner side of the clamp post (larger circle) self.w_o[4] = self.w_o[5] + self.vec_w(self.beltpost_l) #0: at the bottom (base) self.h_o[0] = V0 #1: at the base for the porta self.h_o[1] = self.vec_h(base_h - self.filt_hole_h) #2: at the top of the base self.h_o[2] = self.vec_h(base_h) #3: first row of bolts self.h_o[3] = self.vec_h(base_h + self.boltrow1_h) #4: second row of bolts self.h_o[4] = self.h_o[3] + self.vec_h(boltrow1_2_dist) #5: third row of bolts, taking self.h_o[3] self.h_o[5] = self.h_o[3] + self.vec_h(boltrow1_3_dist) #6: 4th row of bolts self.h_o[6] = self.h_o[3] + self.vec_h(boltrow1_4_dist) #7: at the base of the belt clamp self.h_o[7] = self.vec_h(self.hold_h) #8: at the middle of the belt clamp self.h_o[8] = self.vec_h(self.hold_h + self.beltclamp_h / 2.) #9: at the top of the piece self.h_o[9] = self.vec_h(self.tot_h) # calculates the position of the origin, and keeps it in attribute pos_o self.set_pos_o() # -------- building of the piece # the base shp_base = fcfun.shp_box_dir(box_w=self.tot_w, box_d=self.tot_d, box_h=base_h, fc_axis_w=self.axis_w, fc_axis_d=self.axis_d, fc_axis_h=self.axis_h, cw=1, cd=0, ch=0, pos=self.pos_o) shp_base = fcfun.shp_filletchamfer_dir(shp_base, self.axis_h, fillet=1, radius=fillet_r) shp_base = shp_base.removeSplitter() # the holder to attach to a linear guide shp_holder = fcfun.shp_boxdir_fillchmfplane( box_w=self.tot_w, box_d=hold_d, box_h=self.hold_h, axis_d=self.axis_d, axis_h=self.axis_h, cw=1, cd=0, ch=0, fillet=1, radius=fillet_r, plane_fill=self.axis_d.negative(), both_planes=0, edge_dir=self.axis_h, pos=self.pos_o) #shp_holder = fcfun.shp_box_dir (box_w = self.tot_w, #box_d = hold_d, #box_h = self.hold_h, #fc_axis_w = self.axis_w, #fc_axis_d = self.axis_d, #fc_axis_h = self.axis_h, #cw = 1, cd = 0, ch = 1, #pos = self.pos_o) #shp_base = fcfun.shp_filletchamfer_dir (shp_base, self.axis_h, #fillet = 1, radius = fillet_r) shp_base = shp_base.removeSplitter() shp_l = shp_base.fuse(shp_holder) shp_l = shp_l.removeSplitter() # pos (6,0,2): position at the corner of the L shp_l = fcfun.shp_filletchamfer_dirpt(shp_l, fc_axis=self.axis_w, fc_pt=self.get_pos_dwh(6, 0, 2), fillet=0, radius=fillet_r) shp_l = shp_l.removeSplitter() # now we have the L shape with its chamfers and fillets # ------------------- Holes for the filter # include tolerances, along nh: only half of it, along h= 1 to make # the cut # pos (9,0,1) position at the center of the porta, at its bottom shp_filter_hole = fcfun.shp_box_dir_xtr(box_w=self.filt_hole_w, box_d=self.filt_hole_d, box_h=self.filt_hole_h, fc_axis_h=self.axis_h, fc_axis_d=self.axis_d, cw=1, cd=1, ch=0, xtr_h=1, xtr_nh=tol / 2., xtr_d=tol, xtr_nd=tol, xtr_w=tol, xtr_nw=tol, pos=self.get_pos_dwh(9, 0, 1)) # pos (9,0,0) position at the center of the porta, at the bottom of the # piece # no extra on top because it will be fused with shp_filter_hole shp_filter_thruhole = fcfun.shp_box_dir_xtr(box_w=self.filt_supp_w, box_d=self.filt_supp_d, box_h=base_h, fc_axis_h=self.axis_h, fc_axis_d=self.axis_d, cw=1, cd=1, ch=0, xtr_h=0, xtr_nh=1, xtr_d=tol, xtr_nd=tol, xtr_w=tol, xtr_nw=tol, pos=self.get_pos_dwh( 9, 0, 0)) shp_fuse_filter_hole = shp_filter_hole.fuse(shp_filter_thruhole) shp_l = shp_l.cut(shp_fuse_filter_hole) shp_l = shp_l.removeSplitter() # the L with the hole in the base is done # ---------------- Holes for the bolts bolt_list = [] shp_cen_bolt = fcfun.shp_bolt_dir( r_shank=self.bolt_cen_r_tol, l_bolt=hold_d, r_head=self.bolt_cen_head_r_tol, l_head=self.bolt_cen_head_l_tol, xtr_head=1, xtr_shank=1, support=0, #not at printing directi fc_normal=self.axis_d.negative(), pos_n=2, pos=self.get_pos_dwh(0, 0, 3)) bolt_list.append(shp_cen_bolt) # the rest of the bolts come in pairs: for w_side in [-1, 1]: # the wider bolts (although can be smaller) for cen_col, cen_row in zip([2, 3], [4, 3]): boltpos = self.get_pos_dwh(0, w_side * cen_col, cen_row) shp_cen_bolt = fcfun.shp_bolt_dir( r_shank=self.bolt_cen_r_tol, l_bolt=hold_d, r_head=self.bolt_cen_head_r_tol, l_head=self.bolt_cen_head_l_tol, xtr_head=1, xtr_shank=1, support=0, #not at printing directi fc_normal=self.axis_d.negative(), pos_n=2, pos=boltpos) bolt_list.append(shp_cen_bolt) # the smaller bolts (although can be larger). Linear guide # first row: boltpos = self.get_pos_dwh(0, w_side * 1, 3) shp_lin_bolt = fcfun.shp_bolt_dir( r_shank=self.bolt_linguide_r_tol, l_bolt=hold_d, r_head=self.bolt_linguide_head_r_tol, l_head=self.bolt_linguide_head_l_tol, xtr_head=1, xtr_shank=1, support=0, #not at printing directi fc_normal=self.axis_d.negative(), pos_n=2, pos=boltpos) bolt_list.append(shp_lin_bolt) # 3rd and 4th row. Just 2 shanks and a stadium per side for linrow in [5, 6]: boltpos = self.get_pos_dwh(0, w_side * 1, linrow) shp_lin_shank = fcfun.shp_cylcenxtr( r=self.bolt_linguide_r_tol, h=hold_d, normal=self.axis_d, ch=0, xtr_top=0, #no need: stadium xtr_bot=1, pos=boltpos) bolt_list.append(shp_lin_shank) # the stadium for both bolts head (they are too close) stadpos = self.get_pos_dwh(6, w_side * 1, 5) shp_stad = fcfun.shp_stadium_dir( length=boltrow1_4_dist - boltrow1_3_dist, radius=self.bolt_linguide_head_r_tol, height=self.bolt_linguide_head_l_tol, fc_axis_h=self.axis_d.negative(), fc_axis_l=self.axis_h, ref_l=2, ref_h=2, xtr_h=0, xtr_nh=1, pos=stadpos) bolt_list.append(shp_stad) shp_bolts = fcfun.fuseshplist(bolt_list) shp_l = shp_l.cut(shp_bolts) # ---------------- Belt clamps # at both sides clamp_list = [] for w_side in [-1, 1]: clamp_pos = self.get_pos_dwh(0, w_side * 7, 7) if w_side == 1: clamp_axis_w = self.axis_w.negative() else: clamp_axis_w = self.axis_w shp_clamp = fcfun.shp_box_dir_xtr(box_w=beltclamp_l, box_d=self.beltclamp_blk_t, box_h=beltclamp_h, fc_axis_h=self.axis_h, fc_axis_d=self.axis_d, fc_axis_w=clamp_axis_w, cw=0, cd=0, ch=0, xtr_nh=1, pos=clamp_pos) # fillet the corner shp_clamp = fcfun.shp_filletchamfer_dirpt(shp_clamp, self.axis_h, fc_pt=clamp_pos, fillet=1, radius=fillet_r) shp_clamp = shp_clamp.removeSplitter() clamp_list.append(shp_clamp) # the other clamp, with no fillet clamp_pos = self.get_pos_dwh(6, w_side * 7, 7) shp_clamp = fcfun.shp_box_dir_xtr(box_w=beltclamp_l, box_d=self.beltclamp_blk_t, box_h=beltclamp_h, fc_axis_h=self.axis_h, fc_axis_d=self.axis_d.negative(), fc_axis_w=clamp_axis_w, cw=0, cd=0, ch=0, xtr_nh=1, pos=clamp_pos) clamp_list.append(shp_clamp) # the belt post beltpost_pos = self.get_pos_dwh(2, w_side * 5, 7) shp_beltpost = fcfun.shp_belt_dir(center_sep=2 * self.lr_beltpost_r, rad1=sm_beltpost_r, rad2=self.lr_beltpost_r, height=beltclamp_h, fc_axis_h=self.axis_h, fc_axis_l=clamp_axis_w, ref_l=3, ref_h=2, xtr_h=0, xtr_nh=1, pos=beltpost_pos) clamp_list.append(shp_beltpost) shp_filterholder = shp_l.multiFuse(clamp_list) shp_filterholder = shp_filterholder.removeSplitter() #Part.show (shp_filterholder) self.shp = shp_filterholder
def __init__(self, d, w, conn_d, conn_sep=2, conmut_d=2, conmut_r=4, conmut_sep=2, thick_d=1, corner_r=0.5, axis_d=VY, axis_w=VX, pos_d=0, pos_w=0, pos=V0): shp_clss.Obj3D.__init__(self, axis_d, axis_w) # save the arguments as attributes: frame = inspect.currentframe() args, _, _, values = inspect.getargvalues(frame) for i in args: if not hasattr(self, i): setattr(self, i, values[i]) self.d0_cen = 0 self.w0_cen = 1 # symmetrical self.tot_d = d + conn_d + conmut_d self.tot_w = max(conmut_d, w) self.cable_d = d + conn_d # distances from the pos_o to pos_d self.d_o[0] = V0 self.d_o[1] = self.vec_d(conmut_d) self.d_o[2] = self.d_o[1] + self.vec_d(conn_d) self.d_o[3] = self.d_o[2] + self.vec_d(d / 2.) self.d_o[4] = self.d_o[2] + self.vec_d(d) # these are negative because actually the pos_w indicates a negative # position along axis_w self.w_o[0] = V0 self.w_o[1] = self.vec_w(-conn_sep / 2.) self.w_o[2] = self.vec_w(-conmut_r) self.w_o[3] = self.vec_w(-w / 2.) # calculates the position of the origin, and keeps it in attribute pos_o self.set_pos_o() shp_cable = fcfun.shp_cableturn(d=d, w=w, thick_d=thick_d, corner_r=corner_r, conn_d=conn_d, xtr_conn_d=1, conn_sep=conn_sep, closed=0, axis_d=self.axis_d, axis_w=self.axis_w, pos_d=0, pos_w=0, pos=self.get_o_to_d(1)) shp_cyl_conmut = fcfun.shp_cylcenxtr(r=conmut_r, h=conmut_d, normal=self.axis_d, ch=0, pos=self.pos_o) #left cut the conmutator shp_conmut_divide_l = fcfun.shp_box_dir_xtr( box_w=conmut_sep, box_d=conmut_d, box_h=2 * conmut_r, fc_axis_h=self.axis_d.cross(self.axis_w), fc_axis_d=self.axis_d, fc_axis_w=self.axis_w, cw=1, cd=0, ch=1, xtr_h=1, xtr_nh=1, xtr_d=1, xtr_nd=1, xtr_w=0, xtr_nw=conmut_r, pos=self.pos_o) #right cut the conmutator shp_conmut_divide_r = fcfun.shp_box_dir_xtr( box_w=conmut_sep, box_d=conmut_d, box_h=2 * conmut_r, fc_axis_h=self.axis_d.cross(self.axis_w), fc_axis_d=self.axis_d, fc_axis_w=self.axis_w, cw=1, cd=0, ch=1, xtr_h=1, xtr_nh=1, xtr_d=1, xtr_nd=1, xtr_w=conmut_r, xtr_nw=0, pos=self.pos_o) shp_conmut_l = shp_cyl_conmut.cut(shp_conmut_divide_r) shp_conmut_r = shp_cyl_conmut.cut(shp_conmut_divide_l) self.shp_conmut_l = shp_conmut_l self.shp_conmut_r = shp_conmut_r self.shp_cable = shp_cable
#axis_w = FreeCAD.Vector(1,0,1), #axis_w = FreeCAD.Vector(1,0,0), pos_d=0, pos_w=0, pos=V0) # the brushes: shp_brush_l = fcfun.shp_box_dir_xtr(box_w=2 * turn.conmut_r, box_d=turn.conmut_d, box_h=turn.conmut_sep * 0.9, fc_axis_h=VZ, fc_axis_d=VY, fc_axis_w=VXN, cw=0, cd=0, ch=1, xtr_h=0, xtr_nh=0, xtr_d=0, xtr_nd=0, xtr_w=0, xtr_nw=0, pos=turn.pos_o) shp_cyl_conmut = fcfun.shp_cylcenxtr(r=turn.conmut_r, h=turn.conmut_d, normal=turn.axis_d, ch=0, pos=turn.pos_o) shp_brush_l = shp_brush_l.cut(shp_cyl_conmut)
def __init__(self, nema_size=17, base_motor_d=6., base_d=4., base_h=16., wall_thick=4., motor_thick=4., reinf_thick=4., motor_min_h=10., motor_max_h=20., motor_xtr_space=2., bolt_wall_d=4., bolt1_wall_d=5., bolt_wall_sep=30., rail=1, chmf_r=1., axis_h=VZ, axis_d=VX, axis_w=None, pos_h=1, pos_d=3, pos_w=0, pos=V0, name=''): if axis_w is None or axis_w == V0: axis_w = axis_h.cross(axis_d) #vector product default_name = 'NemaMotorHolder' self.set_name(name, default_name, change=0) Obj3D.__init__(self, axis_d, axis_w, axis_h, self.name) self.pos = FreeCAD.Vector(0, 0, 0) self.position = pos # save the arguments as attributes frame = inspect.currentframe() args, _, _, values = inspect.getargvalues(frame) for i in args: if not hasattr(self, i): setattr(self, i, values[i]) # normal axes to print without support self.prnt_ax = self.axis_h self.motor_w = kcomp.NEMA_W[nema_size] self.motor_bolt_sep = kcomp.NEMA_BOLT_SEP[nema_size] self.motor_bolt_d = kcomp.NEMA_BOLT_D[nema_size] # calculation of the bolt wall d self.boltwallshank_r_tol = kcomp.D912[bolt_wall_d]['shank_r_tol'] self.boltwallhead_l = kcomp.D912[bolt_wall_d]['head_l'] self.boltwallhead_r = kcomp.D912[bolt_wall_d]['head_r'] self.washer_thick = kcomp.WASH_D125_T[bolt_wall_d] # calculation of the bolt wall separation self.max_bolt_wall_sep = self.motor_w - 2 * self.boltwallhead_r self.min_bolt_wall_sep = 4 * self.boltwallhead_r if bolt_wall_sep == 0: self.bolt_wall_sep = self.max_bolt_wall_sep elif bolt_wall_sep > self.max_bolt_wall_sep: logger.debug('bolt separation too large:' + str(bolt_wall_sep)) self.bolt_wall_sep = self.max_bolt_wall_sep logger.debug('taking largest value:' + str(self.bolt_wall_sep)) elif bolt_wall_sep < self.min_bolt_wall_sep: #elif bolt_wall_sep < 4 * self.boltwallhead_r: logger.debug('bolt separation too short:' + str(bolt_wall_sep)) #self.bolt_wall_sep = self.self.max_bolt_wall_sep self.bolt_wall_sep = self.min_bolt_wall_sep logger.debug('taking smallest value:' + str(self.bolt_wall_sep)) # distance from the motor to the inner wall (in axis_d) self.motor_inwall_space = motor_xtr_space + self.boltwallhead_l + self.washer_thick # making the big box that will contain everything and will be cut self.tot_h = motor_thick + motor_max_h + 2 * bolt_wall_d self.tot_w = 2 * reinf_thick + self.motor_w + 2 * motor_xtr_space self.tot_d = wall_thick + self.motor_w + self.motor_inwall_space # distance from the motor axis to the wall (in axis_d) self.motax2wall = wall_thick + self.motor_inwall_space + self.motor_w / 2. # definition of which axis is symmetrical self.h0_cen = 0 self.w0_cen = 1 # symmetrical self.d0_cen = 0 # vectors from the origin to the points along axis_h self.h_o[0] = V0 self.h_o[1] = self.vec_h(motor_thick) self.h_o[2] = self.vec_h(motor_thick + motor_min_h) self.h_o[3] = self.vec_h(motor_thick + motor_max_h) self.h_o[4] = self.vec_h(self.tot_h) # position along axis_d self.d_o[0] = V0 self.d_o[1] = self.vec_d(wall_thick) self.d_o[2] = self.vec_d(self.motax2wall - self.motor_bolt_sep / 2.) self.d_o[3] = self.vec_d(self.motax2wall) self.d_o[4] = self.vec_d(self.motax2wall + self.motor_bolt_sep / 2.) self.d_o[5] = self.vec_d(self.tot_d) # vectors from the origin to the points along axis_w self.w_o[0] = V0 self.w_o[1] = self.vec_w(-self.bolt_wall_sep / 2.) self.w_o[2] = self.vec_w(-self.motor_bolt_sep / 2.) self.w_o[3] = self.vec_w(-self.tot_w / 2.) # calculates the position of the origin, and keeps it in attribute pos_o self.set_pos_o() # make the whole box, extra height and depth to cut all the way back and down shp_box1 = fcfun.shp_box_dir(box_w=self.tot_w, box_d=self.tot_d, box_h=self.tot_h, fc_axis_h=self.axis_h, fc_axis_d=self.axis_d, cw=1, cd=0, ch=0, pos=self.pos_o) # little chamfer at the corners, if fillet there are some problems shp_box2 = fcfun.shp_filletchamfer_dir(shp_box1, self.axis_h, fillet=0, radius=chmf_r) # chamfer of the box to make a 'triangular' reinforcement chmf_reinf_r = min(self.tot_d - wall_thick, self.tot_h - motor_thick) shp_box3 = fcfun.shp_filletchamfer_dirpt(shp_box2, self.axis_w, fc_pt=self.get_pos_dwh( 5, 0, 4), fillet=0, radius=chmf_reinf_r) super().add_child(shp_box3, 1, 'shp_box3') # holes # the space for the motor shp_motor = fcfun.shp_box_dir(box_w=self.motor_w + 2 * motor_xtr_space, box_d=self.tot_d + chmf_r, box_h=self.tot_h, fc_axis_h=self.axis_h, fc_axis_d=self.axis_d, cw=1, cd=0, ch=0, pos=self.get_pos_dwh(1, 0, 1)) shp_motor = fcfun.shp_filletchamfer_dir(shp_motor, self.axis_h, fillet=0, radius=chmf_r) super().add_child(shp_motor, 0, 'shp_motor') # central circle of the motor shp_hole1 = fcfun.shp_cylcenxtr( r=(self.motor_bolt_sep - self.motor_bolt_d) / 2., h=motor_thick, normal=self.axis_h, ch=0, xtr_top=1, xtr_bot=1, pos=self.get_pos_d(3)) super().add_child(shp_hole1, 0, 'shp_hole1') # motor bolt holes shp_hole2 = fcfun.shp_cylcenxtr(r=self.motor_bolt_d / 2. + TOL, h=motor_thick, normal=self.axis_h, ch=0, xtr_top=1, xtr_bot=1, pos=self.get_pos_dwh(2, -2, 0)) super().add_child(shp_hole2, 0, 'shp_hole2') shp_hole3 = fcfun.shp_cylcenxtr(r=self.motor_bolt_d / 2. + TOL, h=motor_thick, normal=self.axis_h, ch=0, xtr_top=1, xtr_bot=1, pos=self.get_pos_dwh(2, 2, 0)) super().add_child(shp_hole3, 0, 'shp_hole3') shp_hole4 = fcfun.shp_cylcenxtr(r=self.motor_bolt_d / 2. + TOL, h=motor_thick, normal=self.axis_h, ch=0, xtr_top=1, xtr_bot=1, pos=self.get_pos_dwh(4, -2, 0)) super().add_child(shp_hole4, 0, 'shp_hole4') shp_hole5 = fcfun.shp_cylcenxtr(r=self.motor_bolt_d / 2. + TOL, h=motor_thick, normal=self.axis_h, ch=0, xtr_top=1, xtr_bot=1, pos=self.get_pos_dwh(4, 2, 0)) super().add_child(shp_hole5, 0, 'shp_hole5') # rail holes if rail == 1: shp_hole6 = fcfun.shp_box_dir_xtr(box_w=2 * self.boltwallshank_r_tol, box_d=wall_thick, box_h=motor_max_h - motor_min_h, fc_axis_h=self.axis_h, fc_axis_d=self.axis_d, cw=1, cd=0, ch=0, xtr_d=1, xtr_nd=1, pos=self.get_pos_dwh(0, -1, 2)) super().add_child(shp_hole6, 0, 'shp_hole6') shp_hole7 = fcfun.shp_box_dir_xtr(box_w=2 * self.boltwallshank_r_tol, box_d=wall_thick, box_h=motor_max_h - motor_min_h, fc_axis_h=self.axis_h, fc_axis_d=self.axis_d, cw=1, cd=0, ch=0, xtr_d=1, xtr_nd=1, pos=self.get_pos_dwh(0, 1, 2)) super().add_child(shp_hole7, 0, 'shp_hole7') # hole for the ending of the rails (4 semicircles) shp_hole8 = fcfun.shp_cylcenxtr(r=self.boltwallshank_r_tol, h=wall_thick, normal=self.axis_d, ch=0, xtr_top=1, xtr_bot=1, pos=self.get_pos_dwh(0, -1, 2)) super().add_child(shp_hole8, 0, 'shp_hole8') shp_hole9 = fcfun.shp_cylcenxtr(r=self.boltwallshank_r_tol, h=wall_thick, normal=self.axis_d, ch=0, xtr_top=1, xtr_bot=1, pos=self.get_pos_dwh(0, 1, 2)) super().add_child(shp_hole9, 0, 'shp_hole9') shp_hole10 = fcfun.shp_cylcenxtr(r=self.boltwallshank_r_tol, h=wall_thick, normal=self.axis_d, ch=0, xtr_top=1, xtr_bot=1, pos=self.get_pos_dwh(0, -1, 3)) super().add_child(shp_hole10, 0, 'shp_hole10') shp_hole11 = fcfun.shp_cylcenxtr(r=self.boltwallshank_r_tol, h=wall_thick, normal=self.axis_d, ch=0, xtr_top=1, xtr_bot=1, pos=self.get_pos_dwh(0, 1, 3)) super().add_child(shp_hole11, 0, 'shp_hole11') super().make_parent(name) # Then the Part super().create_fco(name) self.fco.Placement.Base = FreeCAD.Vector(0, 0, 0) self.fco.Placement.Base = self.position
shp_brida = fcfun.shp_cylhole_bolthole (r_out = brida_r_out , r_in = 0, h=brida_h, n_bolt = 4, d_bolt = brida_d_bolt, r_bolt2cen = brida_r_bolt2cen, axis_h = axis_brida, axis_ra = axis_punta, axis_rb = None, bolt_axis_ra = 0, pos_h = 1, pos_ra = 3, pos_rb = 0, xtr_top=0, xtr_bot=0, xtr_r_out=0, xtr_r_in=0, pos = V0) union_l.append(shp_brida) shp_base_brida = fcfun.shp_box_dir_xtr( box_w = 2*brida_r_bolt2cen-2, box_d = brida_h, box_h = brida_r_out - brida_r_bolt2cen +1.8, fc_axis_h = axis_punta, fc_axis_d = axis_brida, fc_axis_w = axis_lateral, cw= 1, cd=0, ch=0, pos=V0) union_l.append(shp_base_brida) #r_rotu_in = 11. #r_rotu_out = 14. #h_rotu_in = 100. #rotu_sep = 50. #shp_cylrotu = fcfun.shp_cylholedir (r_out = r_rotu_out, # r_in = r_rotu_in, # h = h_rotu_in,
def __init__ (self, nema_size = 17, wall_thick = 4., motorside_thick = 4., reinf_thick = 4., motor_min_h =10., motor_max_h =20., rail = 1, # if there is a rail or not at the profile side motor_xtr_space = 2., # counting on one side bolt_wall_d = 4., # Metric of the wall bolts bolt_wall_sep = 0, # optional chmf_r = 1., axis_h = VZ, axis_d = VX, axis_w = None, pos_h = 1, # 1: inner wall of the motor side pos_d = 3, # 3: motor axis pos_w = 0, # 0: center of symmetry pos = V0, model_type = 3, #to be printed name = None): self.pos = FreeCAD.Vector(0,0,0) self.position = pos if name == None: name = 'nema' + str(nema_size) + '_motorholder' if axis_w is None or axis_w == V0: axis_w = axis_h.cross(axis_d) NuevaClase.Obj3D.__init__(self, axis_d, axis_w, axis_h, name) # save the arguments as attributes: frame = inspect.currentframe() args, _, _, values = inspect.getargvalues(frame) for i in args: if not hasattr(self,i): setattr(self, i, values[i]) # normal axes to print without support self.prnt_ax = self.axis_h self.motor_w = kcomp.NEMA_W[nema_size] self.motor_bolt_sep = kcomp.NEMA_BOLT_SEP[nema_size] self.motor_bolt_d = kcomp.NEMA_BOLT_D[nema_size] self.boltwallshank_r_tol = kcomp.D912[bolt_wall_d]['shank_r_tol'] self.boltwallhead_l = kcomp.D912[bolt_wall_d]['head_l'] self.boltwallhead_r = kcomp.D912[bolt_wall_d]['head_r'] self.washer_thick = kcomp.WASH_D125_T[bolt_wall_d] # calculation of the bolt wall separation self.max_bolt_wall_sep = self.motor_w - 2 * self.boltwallhead_r if bolt_wall_sep == 0: self.bolt_wall_sep = self.max_bolt_wall_sep elif bolt_wall_sep > self.max_bolt_wall_sep: logger.debug('bolt wall separtion too large: ' + str(bolt_wall_sep)) self.bolt_wall_sep = self.max_bolt_wall_sep logger.debug('taking larges value: ' + str(self.bolt_wall_sep)) elif bolt_wall_sep < 4 * self.boltwallhead_r: logger.debug('bolt wall separtion too short: ' + str(bolt_wall_sep)) self.bolt_wall_sep = self.max_bolt_wall_sep logger.debug('taking larges value: ' + str(self.bolt_wall_sep)) # else: the given separation is good # distance from the motor to the inner wall (in axis_d) self.motor_inwall_space = ( motor_xtr_space + self.boltwallhead_l + self.washer_thick) # making the big box that will contain everything and will be cut self.tot_h = motorside_thick + motor_max_h + 2 * bolt_wall_d self.tot_w = 2* reinf_thick + self.motor_w + 2 * motor_xtr_space self.tot_d = ( wall_thick + self.motor_w + self.motor_inwall_space) # distance from the motor axis to the wall (in axis_d) self.motax2wall = wall_thick + self.motor_inwall_space + self.motor_w/2. # definition of which axis is symmetrical self.h0_cen = 0 self.d0_cen = 0 self.w0_cen = 1 # symmetrical # vectors from the origin to the points along axis_h: self.h_o[0] = V0 self.h_o[1] = self.vec_h(motorside_thick) self.h_o[2] = self.vec_h(motorside_thick + motor_min_h) self.h_o[3] = self.vec_h(motorside_thick + motor_max_h) self.h_o[4] = self.vec_h(self.tot_h) # position along axis_d self.d_o[0] = V0 self.d_o[1] = self.vec_d(wall_thick) # inner wall # distance to the inner bolts of the motor self.d_o[2] = self.vec_d(self.motax2wall - self.motor_bolt_sep/2.) self.d_o[3] = self.vec_d(self.motax2wall) # motor axis self.d_o[4] = self.vec_d(self.motax2wall + self.motor_bolt_sep/2.) self.d_o[5] = self.vec_d(self.tot_d) # vectors from the origin to the points along axis_w: # these are negative because actually the pos_w indicates a negative # position along axis_w (this happens when it is symmetrical) self.w_o[0] = V0 self.w_o[1] = self.vec_w(-self.bolt_wall_sep/2.) self.w_o[2] = self.vec_w(-self.motor_bolt_sep/2.) self.w_o[3] = self.vec_w(-self.tot_w/2.) # calculates the position of the origin, and keeps it in attribute pos_o self.set_pos_o() # make the whole box, extra height and depth to cut all the way # back and down: shp_box = fcfun.shp_box_dir (box_w = self.tot_w, box_d = self.tot_d, box_h = self.tot_h, fc_axis_h = self.axis_h, fc_axis_d = self.axis_d, cw=1, cd=0, ch=0, pos = self.pos_o) # little chamfer at the corners, if fillet there are some problems shp_box = fcfun.shp_filletchamfer_dir(shp_box, self.axis_h, fillet=0, radius = chmf_r) shp_box = shp_box.removeSplitter() # chamfer of the box to make a 'triangular' reinforcement chmf_reinf_r = min(self.tot_d- wall_thick, self.tot_h-motorside_thick) # chamfer at the lower point (h=4), and the other end of d (d=5) shp_box = fcfun.shp_filletchamfer_dirpt(shp_box, self.axis_w, fc_pt =self.get_pos_dwh(5,0,4), fillet=0, radius = chmf_reinf_r) shp_box = shp_box.removeSplitter() # holes: holes = [] # the space for the motor shp_motor = fcfun.shp_box_dir ( box_w = self.motor_w + 2 * motor_xtr_space, box_d = self.tot_d + chmf_r, box_h = self.tot_h, fc_axis_h = self.axis_h, fc_axis_d = self.axis_d, cw=1, cd=0, ch=0, # at the inner walls pos = self.get_pos_dwh(1,0,1)) shp_motor = fcfun.shp_filletchamfer_dir(shp_motor, fc_axis=self.axis_h, fillet=0, radius=chmf_r) holes.append(shp_motor) # central circle of the motor shp_hole = fcfun.shp_cylcenxtr( r=(self.motor_bolt_sep - self.motor_bolt_d)/2., h = motorside_thick, normal = self.axis_h, ch = 0, xtr_top = 1, xtr_bot = 1, # position of the motor axis, at the top pos = self.get_pos_d(3)) holes.append(shp_hole) # motor bolt holes for pt_d in (2,4): # points of the motor holes along axis d for pt_w in (-2,2): # points of the motor holes along axis_w shp_hole = fcfun.shp_cylcenxtr( r = self.motor_bolt_d/2.+TOL, h = motorside_thick, normal = self.axis_h, ch = 0, xtr_top = 1, xtr_bot = 1, pos = self.get_pos_dwh(pt_d,pt_w,0)) holes.append(shp_hole) # rail holes. To mount the motor holder to a profile or whatever for pt_w in (-1,1): # points of the holes to attach the holder # hole for the rails if rail == 1: shp_hole = fcfun.shp_box_dir_xtr( box_w = self.boltwallshank_r_tol * 2., box_d = wall_thick, box_h = motor_max_h - motor_min_h, fc_axis_h = self.axis_h, fc_axis_d = self.axis_d, cw=1, cd=0, ch=0, xtr_d =1, xtr_nd=1, #to cut # h:2 the position on top of the rail pos = self.get_pos_dwh(0,pt_w,2)) holes.append(shp_hole) # hole for the ending of the rails (4 semicircles) for pt_h in (2,3) : # both ends of the rail (along axis_h) shp_hole = fcfun.shp_cylcenxtr( r = self.boltwallshank_r_tol, h = wall_thick, normal = self.axis_d, ch = 0, xtr_top = 1, xtr_bot = 1, pos = self.get_pos_dwh(0,pt_w,pt_h)) holes.append(shp_hole) shp_holes = fcfun.fuseshplist(holes) shp_motorholder = shp_box.cut(shp_holes) shp_bracket =shp_motorholder.removeSplitter() self.shp = shp_bracket super().create_fco() # Need to set first in (0,0,0) and after that set the real placement. # This enable to do rotations without any issue self.fco.Placement.Base = FreeCAD.Vector(0,0,0) self.fco.Placement.Base = self.position
def __init__(self, size, fc_axis_h = VZ, fc_axis_d = VX, fc_axis_w = V0, pos_h = 1, pos_w = 1, pos_d = 1, pillow = 0, #make it the same height of a pillow block pos = V0, wfco = 1, tol = 0.3, name= "shaft_holder"): self.size = size self.wfco = wfco self.name = name self.pos = FreeCAD.Vector(0,0,0) self.position = pos self.tol = tol self.pos_h = pos_h self.pos_w = pos_w self.pos_d = pos_d doc = FreeCAD.ActiveDocument if pillow == 0: skdict = kcomp.SK.get(size) else: skdict = kcomp.PILLOW_SK.get(size) if skdict == None: logger.error("Sk size %d not supported", size) # normalize de axis axis_h = DraftVecUtils.scaleTo(fc_axis_h,1) axis_d = DraftVecUtils.scaleTo(fc_axis_d,1) if fc_axis_w == V0: axis_w = axis_h.cross(axis_d) else: axis_w = DraftVecUtils.scaleTo(fc_axis_w,1) axis_h_n = axis_h.negative() axis_d_n = axis_d.negative() axis_w_n = axis_w.negative() NuevaClase.Obj3D.__init__(self, axis_d, axis_w, axis_h, name = name) # Total height: sk_h = skdict['H'] self.tot_h = sk_h # Total width (Y): sk_w = skdict['W'] self.tot_w = sk_w # Total depth (x): sk_d = skdict['L'] self.tot_d = sk_d # Base height sk_base_h = skdict['g'] # center width sk_center_w = skdict['I'] # Axis height: sk_axis_h = skdict['h'] # self.axis_h = sk_axis_h # Mounting bolts separation sk_mbolt_sep = skdict['B'] # tightening bolt with added tolerances: tbolt_d = skdict['tbolt'] # Bolt's head radius tbolt_head_r = (self.holtol * kcomp.D912_HEAD_D[skdict['tbolt']])/2.0 # Bolt's head lenght tbolt_head_l = (self.holtol * kcomp.D912_HEAD_L[skdict['tbolt']] ) # Mounting bolt radius with added tolerance mbolt_r = self.holtol * skdict['mbolt']/2. self.d0_cen = 0 self.w0_cen = 1 # symmetric self.h0_cen = 0 # vectors from the origin to the points along axis_d: self.d_o[0] = V0 # origin self.d_o[1] = self.vec_d(sk_d/2.) self.d_o[2] = self.vec_d(sk_d) # vectors from the origin to the points along axis_w: self.w_o[0] = V0 self.w_o[1] = self.vec_w(sk_mbolt_sep/2) self.w_o[2] = self.vec_w(sk_w/2) # vectors from the origin to the points along axis_h: self.h_o[0] = V0 self.h_o[1] = self.vec_h(sk_axis_h) # calculates the position of the origin, and keeps it in attribute pos_o self.set_pos_o() # TODO: See how to change this reference points if pos_h == 1: # distance vectors on axis_h ref2rod_h = V0 # h_o[0] ref2base_h = DraftVecUtils.scale(axis_h, -sk_axis_h) # h_o[1] else: ref2rod_h = DraftVecUtils.scale(axis_h, sk_axis_h) # h_o[1] ref2base_h = V0 # h_o[0] if pos_w == 0: # distance vectors on axis_w ref2cen_w = V0 # w_o[0] ref2bolt_w = DraftVecUtils.scale(axis_w, -sk_mbolt_sep/2.) # w_o[-1] ref2end_w = DraftVecUtils.scale(axis_w, -sk_w/2.) # w_o[2] elif pos_w == 1: ref2cen_w = DraftVecUtils.scale(axis_w, sk_mbolt_sep/2.) # w_o[1] ref2bolt_w = V0 # w_o[0] ref2end_w = DraftVecUtils.scale(axis_w, -(sk_w-sk_mbolt_sep)/2.) # w_o[] else: # w_o == -1 at the end on the width dimension ref2cen_w = DraftVecUtils.scale(axis_w, sk_w/2.) # w_o[2] ref2bolt_w = DraftVecUtils.scale(axis_w, (sk_w-sk_mbolt_sep)/2.) # w_o[] if pos_d == 1: # distance vectors on axis_d ref2cen_d = V0 # d_o[0] ref2end_d = DraftVecUtils.scale(axis_d, -sk_d/2.) # d_o[1] else: ref2cen_d = DraftVecUtils.scale(axis_d, sk_d/2.) # d_o[1] ref2end_d = V0 # d_o[0] # TODO: Use the newe method: # super().get_pos_dwh(pos_d,pos_w,pos_h) basecen_pos = self.pos + ref2base_h + ref2cen_w + ref2cen_d # Making the tall box: shp_tall = fcfun.shp_box_dir (box_w = sk_center_w, box_d = sk_d, box_h = sk_h, fc_axis_w = axis_w, fc_axis_h = axis_h, fc_axis_d = axis_d, cw = 1, cd= 1, ch=0, pos = basecen_pos) # Making the wide box: shp_wide = fcfun.shp_box_dir (box_w = sk_w, box_d = sk_d, box_h = sk_base_h, fc_axis_w = axis_w, fc_axis_h = axis_h, fc_axis_d = axis_d, cw = 1, cd= 1, ch=0, pos = basecen_pos) shp_sk = shp_tall.fuse(shp_wide) doc.recompute() shp_sk = shp_sk.removeSplitter() holes = [] # Shaft hole, rodcen_pos = self.pos + ref2rod_h + ref2cen_w + ref2cen_d rod_hole = fcfun.shp_cylcenxtr(r= size/2. +self.tol, h = sk_d, normal = axis_d, ch = 1, xtr_top = 1, xtr_bot = 1, pos = rodcen_pos) holes.append(rod_hole) # the upper sepparation shp_topopen = fcfun.shp_box_dir_xtr ( box_w = self.up_sep_dist, box_d = sk_d, box_h = sk_h-sk_axis_h, fc_axis_w = axis_w, fc_axis_h = axis_h, fc_axis_d = axis_d, cw = 1, cd= 1, ch=0, xtr_h = 1, xtr_d = 1, xtr_nd = 1, pos = rodcen_pos) holes.append(shp_topopen) # Tightening bolt hole # tbolt_d is the diameter of the bolt: (M..) M4, ... # tbolt_head_r: is the radius of the tightening bolt's head # (including tolerance), which its bottom either #- is at the middle point between # - A: the total height :sk_h # - B: the top of the shaft hole: axis_h + size/2. # - so the result will be (A + B)/2 # tot_h - (axis_h + size/2.) # _______..A........................ # | ___ |.B.......+ rodtop2top_dist = sk_h - (axis_h + size/2.) # | / \ |.......+ size/2. # | \___/ | : # __| |__ + axis_h # |_____________|....: rodtop2top_dist = sk_h - (sk_axis_h + size/2.) tbolt_pos = ( rodcen_pos + DraftVecUtils.scale(axis_w, sk_center_w/2.) + DraftVecUtils.scale(axis_h, size/2.) + DraftVecUtils.scale(axis_h, rodtop2top_dist/2.)) shp_tbolt = fcfun.shp_bolt_dir(r_shank= tbolt_d/2., l_bolt = sk_center_w, r_head = tbolt_head_r, l_head = tbolt_head_l, hex_head = 0, xtr_head = 1, xtr_shank = 1, support = 0, fc_normal = axis_w_n, fc_verx1 = axis_h, pos = tbolt_pos) holes.append(shp_tbolt) #Mounting bolts cen2mbolt_w = DraftVecUtils.scale(axis_w, sk_mbolt_sep/2.) for w_pos in [cen2mbolt_w.negative(), cen2mbolt_w]: mbolt_pos = basecen_pos + w_pos mbolt_hole = fcfun.shp_cylcenxtr(r= mbolt_r, h = sk_d, normal = axis_h, ch = 0, xtr_top = 1, xtr_bot = 1, pos = mbolt_pos) holes.append(mbolt_hole) shp_holes = fcfun.fuseshplist(holes) shp_sk = shp_sk.cut(shp_holes) self.shp = shp_sk if wfco == 1: super().create_fco() # Need to set first in (0,0,0) and after that set the real placement. # This enable to do rotations without any issue self.fco.Placement.Base = FreeCAD.Vector(0,0,0) self.fco.Placement.Base = self.position
def __init__(self, nema_size = 17, wall_thick = 4., motor_thick = 4., reinf_thick = 4., motor_min_h = 10., motor_max_h = 20., motor_xtr_space = 2., xtr_diam_cir = 8., diam_cir = 28.,bolt_wall_d = 3., bolt_wall_d_rail = 4., bolt_wall_sep = 30., rail = 1, chmf_r = 1., angle = 45., axis_h = VZ, axis_d = VX, axis_w = None, pos_h = 1, pos_d = 3, pos_w = 0, pos = V0, name = ''): if axis_w is None or axis_w == V0: axis_w = axis_h.cross(axis_d) #vector product default_name = 'NemaMotorHolder' self.set_name(name, default_name, change = 0) Obj3D.__init__(self, axis_d, axis_w, axis_h, self.name) shp_clss.Obj3D.__init__(self, axis_d, axis_w, axis_h) # save the arguments as attributes frame = inspect.currentframe() args, _, _, values = inspect.getargvalues(frame) for i in args: if not hasattr(self,i): setattr(self, i, values[i]) self.pos = FreeCAD.Vector(0, 0, 0) self.position = pos # normal axes to print without support self.prnt_ax = self.axis_h self.motor_w = kcomp.NEMA_W[nema_size] self.motor_bolt_sep = kcomp.NEMA_BOLT_SEP[nema_size] self.motor_bolt_d = kcomp.NEMA_BOLT_D[nema_size] # calculation of the bolt wall d self.boltwallshank_r_tol = kcomp.D912[bolt_wall_d]['shank_r_tol'] self.boltwallhead_l = kcomp.D912[bolt_wall_d]['head_l'] self.boltwallhead_r_tol = kcomp.D912[bolt_wall_d]['head_r_tol'] self.boltwallhead_r = kcomp.D912[bolt_wall_d]['head_r'] self.washer_thick = kcomp.WASH_D125_T[bolt_wall_d] # calculation of the bolt wall d rail self.boltwallshank_r_tol_rail = kcomp.D912[bolt_wall_d_rail]['shank_r_tol'] self.boltwallhead_l_rail = kcomp.D912[bolt_wall_d_rail]['head_l'] self.boltwallhead_r_rail = kcomp.D912[bolt_wall_d_rail]['head_r'] self.washer_thick_rail = kcomp.WASH_D125_T[bolt_wall_d_rail] # calculation of the bolt wall separation self.max_bolt_wall_sep = self.motor_w - 2 * self.boltwallhead_r if bolt_wall_sep == 0: self.bolt_wall_sep = self.max_bolt_wall_sep elif bolt_wall_sep > self.max_bolt_wall_sep: logger.debug('bolt separation too large:' + str(bolt_wall_sep)) self.bolt_wall_sep = self.max_bolt_wall_sep logger.debug('taking largest value:' + str(self.bolt_wall_sep)) elif bolt_wall_sep < 4 * self.boltwallhead_r: logger.debug('bolt separation too short:' + str(bolt_wall_sep)) self.bolt_wall_sep = self.self.max_bolt_wall_sep logger.debug('taking smallest value:' + str(self.bolt_wall_sep)) # distance from the motor to the inner wall (in axis_d) self.motor_inwall_space = motor_xtr_space + self.boltwallhead_l + self.washer_thick # making the big box that will contain everything and will be cut self.tot_h = motor_thick + motor_max_h + 2 * bolt_wall_d self.tot_w = 2 * reinf_thick + self.motor_w + 2 * motor_xtr_space self.tot_d = wall_thick + self.motor_w + self.motor_inwall_space # distance from the motor axis to the wall (in axis_d) self.motax2wall = wall_thick + self.motor_inwall_space + self.motor_w/2. # self.d_circle = math.sin(math.radians(angle))*(diam_cir/2.) self.w_circle = math.cos(math.radians(angle))*(diam_cir/2.) # definition of which axis is symmetrical self.h0_cen = 0 self.w0_cen = 1 # symmetrical self.d0_cen = 0 # vectors from the origin to the points along axis_h self.h_o[0] = V0 self.h_o[1] = self.vec_h(motor_thick) self.h_o[2] = self.vec_h(motor_thick + motor_min_h) self.h_o[3] = self.vec_h(motor_thick + motor_max_h) self.h_o[4] = self.vec_h(self.tot_h) # position along axis_d self.d_o[0] = V0 self.d_o[1] = self.vec_d(wall_thick) self.d_o[2] = self.vec_d(self.motax2wall - self.d_circle) self.d_o[3] = self.vec_d(self.motax2wall) self.d_o[4] = self.vec_d(self.motax2wall + self.d_circle) self.d_o[5] = self.vec_d(self.tot_d) # vectors from the origin to the points along axis_w self.w_o[0] = V0 self.w_o[1] = self.vec_w(-self.bolt_wall_sep/2.) self.w_o[2] = self.vec_w(self.w_circle + TOL) self.w_o[3] = self.vec_w(-self.tot_w/2.) # calculates the position of the origin, and keeps it in attribute pos_o self.set_pos_o() # make the whole box, extra height and depth to cut all the way back and down shp_box = fcfun.shp_box_dir(box_w = self.tot_w, box_d = self.tot_d, box_h = self.tot_h, fc_axis_h = self.axis_h, fc_axis_d = self.axis_d, cw = 1, cd = 0, ch = 0, pos = self.pos_o) # little chamfer at the corners, if fillet there are some problems shp_box = fcfun.shp_filletchamfer_dir(shp_box, self.axis_h, fillet = 0, radius = chmf_r) shp_box = shp_box.removeSplitter() # chamfer of the box to make a 'triangular' reinforcement chmf_reinf_r = min(self.tot_d - wall_thick, self.tot_h - motor_thick) shp_box = fcfun.shp_filletchamfer_dirpt(shp_box, self.axis_w, fc_pt = self.get_pos_dwh(5, 0, 4), fillet = 0, radius = chmf_reinf_r) shp_box = shp_box.removeSplitter() # holes holes = [] # the space for the motor shp_motor = fcfun.shp_box_dir(box_w = self.motor_w + 2 * motor_xtr_space, box_d = self.tot_d + chmf_r, box_h = self.tot_h, fc_axis_h = self.axis_h, fc_axis_d = self.axis_d, cw = 1, cd = 0, ch = 0, pos = self.get_pos_dwh(1, 0, 1)) shp_motor = fcfun.shp_filletchamfer_dir(shp_motor, self.axis_h, fillet = 0, radius = chmf_r) holes.append(shp_motor) # central circle of the motor shp_hole = fcfun.shp_cylcenxtr(r = (self.motor_bolt_sep - self.motor_bolt_d - xtr_diam_cir + TOL)/2., h = motor_thick, normal = self.axis_h, ch = 0, xtr_top = 1, xtr_bot = 1, pos = self.get_pos_d(3)) holes.append(shp_hole) # motor bolt holes for pt_d in (2, 4): for pt_w in (-2, 2): shp_hole = fcfun.shp_bolt_dir(r_shank = self.boltwallshank_r_tol, l_bolt = motor_thick, r_head = self.boltwallhead_r + TOL/3., l_head = 2, xtr_head = 1, xtr_shank = 1, fc_normal = self.axis_h, pos_n = 0, pos = self.get_pos_dwh(pt_d, pt_w, 0)) #shp_hole = fcfun.shp_cylcenxtr(r = self.boltwallshank_r_tol, h = motor_thick, normal = self.axis_h, ch = 0, xtr_top = 1, xtr_bot = 1, pos = self.get_pos_dwh(pt_d, pt_w, 0)) holes.append(shp_hole) # rail holes for pt_w in (-1, 1): if rail == 1: shp_hole = fcfun.shp_box_dir_xtr(box_w = 2 * self.boltwallshank_r_tol_rail, box_d = wall_thick, box_h = motor_max_h - motor_min_h, fc_axis_h = self.axis_h, fc_axis_d = self.axis_d, cw = 1, cd = 0, ch = 0, xtr_d = 1, xtr_nd = 1, pos = self.get_pos_dwh(0, pt_w, 2)) holes.append(shp_hole) # hole for the ending of the rails (4 semicircles) for pt_h in (2, 3): shp_hole = fcfun.shp_cylcenxtr(r = self.boltwallshank_r_tol_rail, h = wall_thick, normal = self.axis_d, ch = 0, xtr_top = 1, xtr_bot =1, pos = self.get_pos_dwh(0, pt_w, pt_h)) holes.append(shp_hole) shp_holes = fcfun.fuseshplist(holes) shp_motorholder = shp_box.cut(shp_holes) shp_bracket = shp_motorholder.removeSplitter() self.shp = shp_bracket # Then the Part super().create_fco(name) self.fco.Placement.Base = FreeCAD.Vector(0, 0, 0) self.fco.Placement.Base = self.position
def __init__(self, n_bolt=1, bra_w_1=22., bra_w_2=17., bra_d_1=21., bra_d_2=51., bra_h_1=21., bra_h_2=51., bolt=5., rail=1, d_rail=10., reinf_thick_1=3., reinf_thick_2=5., wall_thick=6., chmf_r=1., dist_bet_nuts=17., dist_hole=5., axis_h=VZ, axis_d=VX, axis_w=None, pos_h=1, pos_d=3, pos_w=0, pos=V0, name=''): if axis_w is None or axis_w == V0: axis_w = axis_h.cross(axis_d) #vector product default_name = 'alu_bracket' self.set_name(name, default_name, change=0) Obj3D.__init__(self, axis_d, axis_w, axis_h, self.name) # save the arguments as attributes: frame = inspect.currentframe() args, _, _, values = inspect.getargvalues(frame) for i in args: if not hasattr(self, i): setattr(self, i, values[i]) self.pos = FreeCAD.Vector(0, 0, 0) self.position = pos # normal axes to print without support self.prnt_ax = self.axis_h # calculation of the bolt to hold the bottom coverplate to the wood self.boltshank_r_tol = kcomp.D912[bolt]['shank_r_tol'] self.bolthead_r = kcomp.D912[bolt]['head_l'] self.bolthead_r_tol = kcomp.D912[bolt]['head_r'] self.bolthead_l = kcomp.D912[bolt]['head_l'] # making the big box that will contain everything and will be cut if n_bolt == 1: self.tot_d = bra_d_1 + wall_thick self.tot_w = bra_w_1 + 2 * reinf_thick_1 self.tot_h = bra_h_1 + wall_thick else: self.tot_d = bra_d_2 + wall_thick self.tot_w = bra_w_2 + 2 * reinf_thick_2 self.tot_h = bra_h_2 + wall_thick # definition of which axis is symmetrical if n_bolt == 1: self.h0_cen = 0 self.w0_cen = 1 # symmetrical self.d0_cen = 0 else: self.h0_cen = 0 self.w0_cen = 0 self.d0_cen = 0 if n_bolt == 1: # vectors from the origin to the points along axis_h self.h_o[0] = V0 self.h_o[1] = self.vec_h(wall_thick) self.h_o[2] = self.vec_h(wall_thick + dist_hole) self.h_o[3] = self.vec_h(wall_thick + bra_h_1 / 2.) self.h_o[4] = self.vec_h(wall_thick + dist_hole + d_rail) self.h_o[5] = self.vec_h(self.tot_h) # position along axis_d self.d_o[0] = V0 self.d_o[1] = self.vec_d(dist_hole) self.d_o[2] = self.vec_d(dist_hole + d_rail) self.d_o[3] = self.vec_d(bra_d_1 / 2.) self.d_o[4] = self.vec_d(bra_d_1) self.d_o[5] = self.vec_d(self.tot_d) # position along axis_w self.w_o[0] = V0 self.w_o[1] = self.vec_w(-self.boltshank_r_tol) self.w_o[2] = self.vec_w(-bra_w_1 / 2.) self.w_o[3] = self.vec_w(-self.tot_w / 2.) else: # vectors from the origin to the points along axis_h self.h_o[0] = V0 self.h_o[1] = self.vec_h(wall_thick) self.h_o[2] = self.vec_h(wall_thick + dist_hole) self.h_o[3] = self.vec_h(wall_thick + dist_hole + d_rail / 2.) self.h_o[4] = self.vec_h(wall_thick + dist_hole + d_rail) self.h_o[5] = self.vec_h(wall_thick + dist_hole + d_rail + dist_bet_nuts) self.h_o[6] = self.vec_h(wall_thick + dist_hole + d_rail + dist_bet_nuts + d_rail / 2.) self.h_o[7] = self.vec_h(wall_thick + dist_hole + d_rail + dist_bet_nuts + d_rail) self.h_o[8] = self.vec_h(self.tot_h) # position along axis_d self.d_o[0] = V0 self.d_o[1] = self.vec_d(dist_hole) self.d_o[2] = self.vec_d(dist_hole + d_rail / 2.) self.d_o[3] = self.vec_d(dist_hole + d_rail) self.d_o[4] = self.vec_d(dist_hole + d_rail + dist_bet_nuts) self.d_o[5] = self.vec_d(dist_hole + d_rail + dist_bet_nuts + d_rail / 2.) self.d_o[6] = self.vec_d(dist_hole + d_rail + dist_bet_nuts + d_rail) self.d_o[7] = self.vec_d(bra_d_2) self.d_o[8] = self.vec_d(self.tot_d) # position along axis_w self.w_o[0] = V0 self.w_o[1] = self.vec_w(-reinf_thick_2) self.w_o[2] = self.vec_w(-(reinf_thick_2 + dist_hole)) self.w_o[3] = self.vec_w(-(reinf_thick_2 + dist_hole + self.boltshank_r_tol)) self.w_o[4] = self.vec_w(-(reinf_thick_2 + dist_hole + 2 * self.boltshank_r_tol)) self.w_o[5] = self.vec_w(-(reinf_thick_2 + bra_w_2)) self.w_o[6] = self.vec_w(-self.tot_w) # calculates the position of the origin, and keeps it in attribute pos_o self.set_pos_o() # make the whole box if n_bolt == 1: shp_box = fcfun.shp_box_dir(box_w=self.tot_w, box_d=self.tot_d, box_h=self.tot_h, fc_axis_h=axis_h, fc_axis_d=axis_d, cw=1, cd=0, ch=0, pos=self.pos_o) cut = [] shp_box_int = fcfun.shp_box_dir(box_w=bra_w_1, box_d=bra_d_1, box_h=bra_h_1, fc_axis_h=axis_h, fc_axis_d=axis_d, cw=1, cd=0, ch=0, pos=self.get_pos_dwh(0, 0, 1)) cut.append(shp_box_int) if rail == 0: shp_hole1 = fcfun.shp_cylcenxtr(r=self.boltshank_r_tol, h=wall_thick, normal=self.axis_h, ch=0, xtr_top=1, xtr_bot=1, pos=self.get_pos_dwh(3, 0, 0)) cut.append(shp_hole1) shp_hole2 = fcfun.shp_cylcenxtr(r=self.boltshank_r_tol, h=wall_thick, normal=self.axis_d, ch=0, xtr_top=1, xtr_bot=1, pos=self.get_pos_dwh(4, 0, 3)) cut.append(shp_hole2) else: shp_hole1 = fcfun.shp_box_dir_xtr( box_w=2 * self.boltshank_r_tol, box_d=d_rail, box_h=wall_thick, fc_axis_h=self.axis_h, fc_axis_d=self.axis_d, cw=1, cd=0, ch=0, xtr_d=0, xtr_nd=0, pos=self.get_pos_dwh(1, 0, 0)) cut.append(shp_hole1) shp_hole2 = fcfun.shp_box_dir_xtr( box_w=2 * self.boltshank_r_tol, box_d=wall_thick, box_h=d_rail, fc_axis_h=self.axis_h, fc_axis_d=self.axis_d, cw=1, cd=0, ch=0, xtr_d=0, xtr_nd=0, pos=self.get_pos_dwh(4, 0, 2)) cut.append(shp_hole2) shp_cut = fcfun.fuseshplist(cut) shp_final = shp_box.cut(shp_cut) chmf_reinf_r = min(bra_d_1, bra_h_1) for pt_w in (-3, 3): shp_final = fcfun.shp_filletchamfer_dirpt( shp_final, self.axis_w, fc_pt=self.get_pos_dwh(0, pt_w, 5), fillet=0, radius=chmf_reinf_r) shp_final = fcfun.shp_filletchamfer_dirpt(shp_final, self.axis_w, fc_pt=self.get_pos_dwh( 0, 0, 0), fillet=0, radius=chmf_r) shp_final = fcfun.shp_filletchamfer_dirpt(shp_final, self.axis_w, fc_pt=self.get_pos_dwh( 4, 0, 1), fillet=1, radius=chmf_r) for pt_h in (0, 5): shp_final = fcfun.shp_filletchamfer_dirpt( shp_final, self.axis_w, fc_pt=self.get_pos_dwh(5, 0, pt_h), fillet=0, radius=chmf_r) if rail == 1: for pt_w in (-1, 1): for pt_d in (1, 2): shp_final = fcfun.shp_filletchamfer_dirpt( shp_final, self.axis_h, fc_pt=self.get_pos_dwh(pt_d, pt_w, 0), fillet=1, radius=chmf_r) for pt_h in (2, 4): shp_final = fcfun.shp_filletchamfer_dirpt( shp_final, self.axis_d, fc_pt=self.get_pos_dwh(4, pt_w, pt_h), fillet=1, radius=chmf_r) else: shp_box = fcfun.shp_box_dir(box_w=self.tot_w, box_d=self.tot_d, box_h=self.tot_h, fc_axis_h=axis_h, fc_axis_d=axis_d, cw=0, cd=0, ch=0, pos=self.pos_o) cut = [] shp_box_int = fcfun.shp_box_dir(box_w=bra_w_2 + reinf_thick_2, box_d=bra_d_2, box_h=bra_h_2, fc_axis_h=axis_h, fc_axis_d=axis_d, cw=0, cd=0, ch=0, pos=self.get_pos_dwh(0, 1, 1)) cut.append(shp_box_int) if rail == 0: for pt_d in (2, 5): shp_hole1 = fcfun.shp_cylcenxtr(r=self.boltshank_r_tol, h=wall_thick, normal=self.axis_h, ch=0, xtr_top=1, xtr_bot=1, pos=self.get_pos_dwh( pt_d, 3, 0)) cut.append(shp_hole1) for pt_h in (3, 6): shp_hole2 = fcfun.shp_cylcenxtr(r=self.boltshank_r_tol, h=wall_thick, normal=self.axis_d, ch=0, xtr_top=1, xtr_bot=1, pos=self.get_pos_dwh( 7, 3, pt_h)) cut.append(shp_hole2) else: for pt_d in (1, 4): shp_hole1 = fcfun.shp_box_dir_xtr( box_w=2 * self.boltshank_r_tol, box_d=d_rail, box_h=wall_thick, fc_axis_h=self.axis_h, fc_axis_d=self.axis_d, cw=1, cd=0, ch=0, xtr_d=0, xtr_nd=0, pos=self.get_pos_dwh(pt_d, 3, 0)) cut.append(shp_hole1) for pt_h in (2, 5): shp_hole2 = fcfun.shp_box_dir_xtr( box_w=2 * self.boltshank_r_tol, box_d=wall_thick, box_h=d_rail, fc_axis_h=self.axis_h, fc_axis_d=self.axis_d, cw=1, cd=0, ch=0, xtr_d=0, xtr_nd=0, pos=self.get_pos_dwh(7, 3, pt_h)) cut.append(shp_hole2) shp_cut = fcfun.fuseshplist(cut) shp_final = shp_box.cut(shp_cut) chmf_reinf_r = min(bra_d_2, bra_h_2) shp_final = fcfun.shp_filletchamfer_dirpt(shp_final, self.axis_w, fc_pt=self.get_pos_dwh( 0, 1, 8), fillet=0, radius=chmf_reinf_r) shp_final = fcfun.shp_filletchamfer_dirpt(shp_final, self.axis_w, fc_pt=self.get_pos_dwh( 0, 0, 0), fillet=0, radius=chmf_r) shp_final = fcfun.shp_filletchamfer_dirpt(shp_final, self.axis_w, fc_pt=self.get_pos_dwh( 7, 0, 1), fillet=1, radius=chmf_r) for pt_h in (0, 8): shp_final = fcfun.shp_filletchamfer_dirpt( shp_final, self.axis_w, fc_pt=self.get_pos_dwh(8, 0, pt_h), fillet=0, radius=chmf_r) if rail == 1: for pt_w in (2, 4): for pt_d in (1, 3, 4, 6): shp_final = fcfun.shp_filletchamfer_dirpt( shp_final, self.axis_h, fc_pt=self.get_pos_dwh(pt_d, pt_w, 0), fillet=1, radius=chmf_r) for pt_h in (2, 4, 5, 7): shp_final = fcfun.shp_filletchamfer_dirpt( shp_final, self.axis_d, fc_pt=self.get_pos_dwh(7, pt_w, pt_h), fillet=1, radius=chmf_r) shp_final = shp_final.removeSplitter() self.shp = shp_final # Then the Part super().create_fco(name) self.fco.Placement.Base = FreeCAD.Vector(0, 0, 0) self.fco.Placement.Base = self.position