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
