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.,
chmf_r=1.,
opt_sides=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 = 'base'
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
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.base_motor_h = motor_thick + motor_max_h + 2 * bolt_wall_d + 30.
# calculation of the bolt to hold the base to the profile
self.boltshank_r_tol = kcomp.D912[bolt1_wall_d]['shank_r_tol']
self.bolthead_r = kcomp.D912[bolt1_wall_d]['head_l']
self.bolthead_r_tol = kcomp.D912[bolt1_wall_d]['head_r']
self.bolthead_l = kcomp.D912[bolt1_wall_d]['head_l']
# 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
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 = wall_thick + base_h + self.base_motor_h
self.tot_d = base_d + 2 * self.bolthead_r
if opt_sides == 0:
self.tot_w = 2 * reinf_thick + self.motor_w + 2 * motor_xtr_space
else:
self.tot_w = 2 * reinf_thick + self.motor_w + 2 * motor_xtr_space + 4 * self.bolthead_r_tol + 8.
# 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(wall_thick)
self.h_o[2] = self.vec_h(wall_thick + 2 * self.bolthead_r)
self.h_o[3] = self.vec_h(wall_thick + base_h)
self.h_o[4] = self.vec_h(wall_thick + base_h + motor_thick)
self.h_o[5] = self.vec_h(wall_thick + base_h + motor_thick +
motor_min_h)
self.h_o[6] = self.vec_h(wall_thick + base_h + motor_thick)
self.h_o[7] = self.vec_h(wall_thick + base_h + motor_thick +
(motor_min_h + motor_max_h) / 4.)
self.h_o[8] = self.vec_h(wall_thick + base_h + motor_thick + 2 *
(motor_min_h + motor_max_h) / 4.)
self.h_o[9] = self.vec_h(wall_thick + base_h + motor_thick + 3 *
(motor_min_h + motor_max_h) / 4.)
self.h_o[10] = self.vec_h(wall_thick + base_h + motor_thick +
(motor_min_h + motor_max_h))
self.h_o[11] = self.vec_h(wall_thick + base_h + motor_thick + 5 *
(motor_min_h + motor_max_h) / 4.)
self.h_o[12] = self.vec_h(wall_thick + base_h + motor_thick +
motor_max_h)
self.h_o[13] = self.vec_h(self.tot_h)
# position along axis_d
self.d_o[0] = V0
self.d_o[1] = self.vec_d(base_d)
self.d_o[2] = self.vec_d(base_motor_d)
self.d_o[3] = self.vec_d(self.tot_d / 2.)
self.d_o[4] = self.vec_d(base_d + self.bolthead_r_tol)
self.d_o[5] = self.vec_d(self.tot_d)
# vectors from the origin to the points along axis_w
if opt_sides == 0:
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.)
else:
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(
-(2 * reinf_thick + self.motor_w + 2 * motor_xtr_space) / 2.)
self.w_o[4] = self.vec_w(
-(2 * reinf_thick + self.motor_w + 2 * motor_xtr_space +
2 * self.bolthead_r_tol + 4.) / 2.)
self.w_o[5] = 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
if opt_sides == 0:
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)
super().add_child(shp_box, 1, 'shp_box')
shp_box_int = fcfun.shp_box_dir(box_w=self.tot_w,
box_d=self.tot_d,
box_h=base_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))
super().add_child(shp_box_int, 0, 'shp_box_int')
shp_box_ext = fcfun.shp_box_dir(box_w=self.tot_w,
box_d=self.tot_d,
box_h=self.base_motor_h,
fc_axis_h=self.axis_h,
fc_axis_d=self.axis_d,
cw=1,
cd=0,
ch=0,
pos=self.get_pos_dwh(2, 0, 3))
super().add_child(shp_box_ext, 0, 'shp_box_ext')
shp_box_init = fcfun.shp_box_dir(box_w=self.tot_w +
2 * self.bolthead_r_tol,
box_d=self.tot_d,
box_h=wall_thick,
fc_axis_h=self.axis_h,
fc_axis_d=self.axis_d,
cw=1,
cd=0,
ch=0,
pos=self.get_pos_dwh(5, 0, 0))
super().add_child(shp_box_init, 0, 'shp_box_init')
# holes to hold the profile
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(4, -2, 0))
super().add_child(shp_hole1, 0, 'shp_hole1')
shp_hole2 = 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(4, 2, 0))
super().add_child(shp_hole2, 0, 'shp_hole2')
# holes to hold the Nema Motor Holder
shp_cen_bolt1 = fcfun.shp_bolt_dir(
r_shank=self.boltwallshank_r_tol,
l_bolt=base_motor_d,
r_head=self.boltwallhead_r,
l_head=self.boltwallhead_l,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_d,
pos_n=0,
pos=self.get_pos_dwh(0, -1, 6))
super().add_child(shp_cen_bolt1, 0, 'shp_cen_bolt1')
shp_cen_bolt2 = fcfun.shp_bolt_dir(
r_shank=self.boltwallshank_r_tol,
l_bolt=base_motor_d,
r_head=self.boltwallhead_r,
l_head=self.boltwallhead_l,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_d,
pos_n=0,
pos=self.get_pos_dwh(0, 1, 6))
super().add_child(shp_cen_bolt2, 0, 'shp_cen_bolt2')
shp_cen_bolt3 = fcfun.shp_bolt_dir(
r_shank=self.boltwallshank_r_tol,
l_bolt=base_motor_d,
r_head=self.boltwallhead_r,
l_head=self.boltwallhead_l,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_d,
pos_n=0,
pos=self.get_pos_dwh(0, -1, 7))
super().add_child(shp_cen_bolt3, 0, 'shp_cen_bolt3')
shp_cen_bolt4 = fcfun.shp_bolt_dir(
r_shank=self.boltwallshank_r_tol,
l_bolt=base_motor_d,
r_head=self.boltwallhead_r,
l_head=self.boltwallhead_l,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_d,
pos_n=0,
pos=self.get_pos_dwh(0, 1, 7))
super().add_child(shp_cen_bolt4, 0, 'shp_cen_bolt4')
shp_cen_bolt5 = fcfun.shp_bolt_dir(
r_shank=self.boltwallshank_r_tol,
l_bolt=base_motor_d,
r_head=self.boltwallhead_r,
l_head=self.boltwallhead_l,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_d,
pos_n=0,
pos=self.get_pos_dwh(0, -1, 8))
super().add_child(shp_cen_bolt5, 0, 'shp_cen_bolt5')
shp_cen_bolt6 = fcfun.shp_bolt_dir(
r_shank=self.boltwallshank_r_tol,
l_bolt=base_motor_d,
r_head=self.boltwallhead_r,
l_head=self.boltwallhead_l,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_d,
pos_n=0,
pos=self.get_pos_dwh(0, 1, 8))
super().add_child(shp_cen_bolt6, 0, 'shp_cen_bolt6')
shp_cen_bolt7 = fcfun.shp_bolt_dir(
r_shank=self.boltwallshank_r_tol,
l_bolt=base_motor_d,
r_head=self.boltwallhead_r,
l_head=self.boltwallhead_l,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_d,
pos_n=0,
pos=self.get_pos_dwh(0, -1, 9))
super().add_child(shp_cen_bolt7, 0, 'shp_cen_bolt7')
shp_cen_bolt8 = fcfun.shp_bolt_dir(
r_shank=self.boltwallshank_r_tol,
l_bolt=base_motor_d,
r_head=self.boltwallhead_r,
l_head=self.boltwallhead_l,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_d,
pos_n=0,
pos=self.get_pos_dwh(0, 1, 9))
super().add_child(shp_cen_bolt8, 0, 'shp_cen_bolt8')
shp_cen_bolt9 = fcfun.shp_bolt_dir(
r_shank=self.boltwallshank_r_tol,
l_bolt=base_motor_d,
r_head=self.boltwallhead_r,
l_head=self.boltwallhead_l,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_d,
pos_n=0,
pos=self.get_pos_dwh(0, -1, 10))
super().add_child(shp_cen_bolt9, 0, 'shp_cen_bolt9')
shp_cen_bolt10 = fcfun.shp_bolt_dir(
r_shank=self.boltwallshank_r_tol,
l_bolt=base_motor_d,
r_head=self.boltwallhead_r,
l_head=self.boltwallhead_l,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_d,
pos_n=0,
pos=self.get_pos_dwh(0, 1, 10))
super().add_child(shp_cen_bolt10, 0, 'shp_cen_bolt10')
shp_cen_bolt11 = fcfun.shp_bolt_dir(
r_shank=self.boltwallshank_r_tol,
l_bolt=base_motor_d,
r_head=self.boltwallhead_r,
l_head=self.boltwallhead_l,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_d,
pos_n=0,
pos=self.get_pos_dwh(0, -1, 11))
super().add_child(shp_cen_bolt11, 0, 'shp_cen_bolt11')
shp_cen_bolt12 = fcfun.shp_bolt_dir(
r_shank=self.boltwallshank_r_tol,
l_bolt=base_motor_d,
r_head=self.boltwallhead_r,
l_head=self.boltwallhead_l,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_d,
pos_n=0,
pos=self.get_pos_dwh(0, 1, 11))
super().add_child(shp_cen_bolt12, 0, 'shp_cen_bolt12')
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=self.axis_h,
fc_axis_d=self.axis_d,
cw=1,
cd=0,
ch=0,
pos=self.pos_o)
super().add_child(shp_box, 1, 'shp_box')
shp_box_int = fcfun.shp_box_dir(box_w=self.tot_w,
box_d=self.tot_d,
box_h=base_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))
super().add_child(shp_box_int, 0, 'shp_box_int')
shp_box_ext = fcfun.shp_box_dir(box_w=self.tot_w,
box_d=self.tot_d,
box_h=self.base_motor_h,
fc_axis_h=self.axis_h,
fc_axis_d=self.axis_d,
cw=1,
cd=0,
ch=0,
pos=self.get_pos_dwh(2, 0, 3))
super().add_child(shp_box_ext, 0, 'shp_box_ext')
shp_box_init = fcfun.shp_box_dir(box_w=self.tot_w,
box_d=self.tot_d,
box_h=wall_thick,
fc_axis_h=self.axis_h,
fc_axis_d=self.axis_d,
cw=1,
cd=0,
ch=0,
pos=self.get_pos_dwh(5, 0, 0))
super().add_child(shp_box_init, 0, 'shp_box_init')
shp_box_lat1 = fcfun.shp_box_dir(box_w=2 * +self.bolthead_r_tol +
4.,
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.get_pos_dwh(0, -4, 1))
super().add_child(shp_box_lat1, 0, 'shp_box_lat1')
shp_box_lat2 = fcfun.shp_box_dir(box_w=2 * +self.bolthead_r_tol +
4.,
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.get_pos_dwh(0, 4, 1))
super().add_child(shp_box_lat2, 0, 'shp_box_lat2')
# holes to hold the profile # self.get_d_ab(5,4).x
shp_hole1 = fcfun.shp_stadium_dir(
self.tot_d - 2 * ((self.d_o[5] - self.d_o[4]).Length),
radius=self.boltshank_r_tol,
height=wall_thick,
fc_axis_h=self.axis_h,
fc_axis_l=self.axis_d.negative(),
fc_axis_s=V0,
ref_l=2,
ref_s=1,
ref_h=2,
xtr_nh=1,
pos=self.get_pos_dwh(4, -4, 0))
super().add_child(shp_hole1, 0, 'shp_hole1')
shp_hole2 = fcfun.shp_stadium_dir(
self.tot_d - 2 * ((self.d_o[5] - self.d_o[4]).Length),
radius=self.boltshank_r_tol,
height=wall_thick,
fc_axis_h=self.axis_h,
fc_axis_l=self.axis_d.negative(),
fc_axis_s=V0,
ref_l=2,
ref_s=1,
ref_h=2,
xtr_nh=1,
pos=self.get_pos_dwh(4, 4, 0))
super().add_child(shp_hole2, 0, 'shp_hole2')
shp_hole3 = 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(4, -2, 0))
super().add_child(shp_hole3, 0, 'shp_hole3')
shp_hole4 = 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(4, 2, 0))
super().add_child(shp_hole4, 0, 'shp_hole4')
# holes to hold the Nema Motor Holder
shp_cen_bolt1 = fcfun.shp_bolt_dir(
r_shank=self.boltwallshank_r_tol,
l_bolt=base_motor_d,
r_head=self.boltwallhead_r,
l_head=self.boltwallhead_l,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_d,
pos_n=0,
pos=self.get_pos_dwh(0, -1, 6))
super().add_child(shp_cen_bolt1, 0, 'shp_cen_bolt1')
shp_cen_bolt2 = fcfun.shp_bolt_dir(
r_shank=self.boltwallshank_r_tol,
l_bolt=base_motor_d,
r_head=self.boltwallhead_r,
l_head=self.boltwallhead_l,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_d,
pos_n=0,
pos=self.get_pos_dwh(0, 1, 6))
super().add_child(shp_cen_bolt2, 0, 'shp_cen_bolt2')
shp_cen_bolt3 = fcfun.shp_bolt_dir(
r_shank=self.boltwallshank_r_tol,
l_bolt=base_motor_d,
r_head=self.boltwallhead_r,
l_head=self.boltwallhead_l,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_d,
pos_n=0,
pos=self.get_pos_dwh(0, -1, 7))
super().add_child(shp_cen_bolt3, 0, 'shp_cen_bolt3')
shp_cen_bolt4 = fcfun.shp_bolt_dir(
r_shank=self.boltwallshank_r_tol,
l_bolt=base_motor_d,
r_head=self.boltwallhead_r,
l_head=self.boltwallhead_l,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_d,
pos_n=0,
pos=self.get_pos_dwh(0, 1, 7))
super().add_child(shp_cen_bolt4, 0, 'shp_cen_bolt4')
shp_cen_bolt5 = fcfun.shp_bolt_dir(
r_shank=self.boltwallshank_r_tol,
l_bolt=base_motor_d,
r_head=self.boltwallhead_r,
l_head=self.boltwallhead_l,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_d,
pos_n=0,
pos=self.get_pos_dwh(0, -1, 8))
super().add_child(shp_cen_bolt5, 0, 'shp_cen_bolt5')
shp_cen_bolt6 = fcfun.shp_bolt_dir(
r_shank=self.boltwallshank_r_tol,
l_bolt=base_motor_d,
r_head=self.boltwallhead_r,
l_head=self.boltwallhead_l,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_d,
pos_n=0,
pos=self.get_pos_dwh(0, 1, 8))
super().add_child(shp_cen_bolt6, 0, 'shp_cen_bolt6')
shp_cen_bolt7 = fcfun.shp_bolt_dir(
r_shank=self.boltwallshank_r_tol,
l_bolt=base_motor_d,
r_head=self.boltwallhead_r,
l_head=self.boltwallhead_l,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_d,
pos_n=0,
pos=self.get_pos_dwh(0, -1, 9))
super().add_child(shp_cen_bolt7, 0, 'shp_cen_bolt7')
shp_cen_bolt8 = fcfun.shp_bolt_dir(
r_shank=self.boltwallshank_r_tol,
l_bolt=base_motor_d,
r_head=self.boltwallhead_r,
l_head=self.boltwallhead_l,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_d,
pos_n=0,
pos=self.get_pos_dwh(0, 1, 9))
super().add_child(shp_cen_bolt8, 0, 'shp_cen_bolt8')
shp_cen_bolt9 = fcfun.shp_bolt_dir(
r_shank=self.boltwallshank_r_tol,
l_bolt=base_motor_d,
r_head=self.boltwallhead_r,
l_head=self.boltwallhead_l,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_d,
pos_n=0,
pos=self.get_pos_dwh(0, -1, 10))
super().add_child(shp_cen_bolt9, 0, 'shp_cen_bolt9')
shp_cen_bolt10 = fcfun.shp_bolt_dir(
r_shank=self.boltwallshank_r_tol,
l_bolt=base_motor_d,
r_head=self.boltwallhead_r,
l_head=self.boltwallhead_l,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_d,
pos_n=0,
pos=self.get_pos_dwh(0, 1, 10))
super().add_child(shp_cen_bolt10, 0, 'shp_cen_bolt10')
shp_cen_bolt11 = fcfun.shp_bolt_dir(
r_shank=self.boltwallshank_r_tol,
l_bolt=base_motor_d,
r_head=self.boltwallhead_r,
l_head=self.boltwallhead_l,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_d,
pos_n=0,
pos=self.get_pos_dwh(0, -1, 11))
super().add_child(shp_cen_bolt11, 0, 'shp_cen_bolt11')
shp_cen_bolt12 = fcfun.shp_bolt_dir(
r_shank=self.boltwallshank_r_tol,
l_bolt=base_motor_d,
r_head=self.boltwallhead_r,
l_head=self.boltwallhead_l,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_d,
pos_n=0,
pos=self.get_pos_dwh(0, 1, 11))
super().add_child(shp_cen_bolt12, 0, 'shp_cen_bolt12')
super().make_parent(name)
chmf_reinf_r = min(base_motor_d - base_d, base_h)
self.shp = fcfun.shp_filletchamfer_dirpt(self.shp,
self.axis_w,
fc_pt=self.get_pos_dwh(
2, 0, 3),
fillet=0,
radius=(chmf_reinf_r - TOL))
if opt_sides == 0:
for pt_w in (-3, 3):
for pt_h in (0, 13):
self.shp = fcfun.shp_filletchamfer_dirpt(
self.shp,
self.axis_d,
fc_pt=self.get_pos_dwh(0, pt_w, pt_h),
fillet=1,
radius=chmf_r)
self.shp = fcfun.shp_filletchamfer_dirpt(
self.shp,
self.axis_d,
fc_pt=self.get_pos_dwh(5, pt_w, 1),
fillet=1,
radius=chmf_r)
else:
for pt_w in (-5, 5):
for pt_h in (0, 1):
self.shp = fcfun.shp_filletchamfer_dirpt(
self.shp,
self.axis_d,
fc_pt=self.get_pos_dwh(0, pt_w, pt_h),
fillet=1,
radius=chmf_r)
for pt_w in (-3, 3):
for pt_h in (1, 13):
self.shp = fcfun.shp_filletchamfer_dirpt(
self.shp,
self.axis_d,
fc_pt=self.get_pos_dwh(0, pt_w, pt_h),
fillet=1,
radius=chmf_r)
fuse = []
fuse.append(self.shp)
shp_box_ref = fcfun.shp_box_dir(box_w=2 * self.bolthead_r,
box_d=2 * self.bolthead_r,
box_h=2 * self.bolthead_r,
fc_axis_w=self.axis_w,
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_box_ref = fcfun.shp_filletchamfer_dirpt(
shp_box_ref,
self.axis_w,
fc_pt=self.get_pos_dwh(5, 0, 2),
fillet=0,
radius=2 * self.bolthead_r - TOL)
fuse.append(shp_box_ref)
shp_final = fcfun.fuseshplist(fuse)
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
def __init__(
self,
pitch=2.,
n_teeth=20,
toothed_h=7.5,
top_flange_h=1.,
bot_flange_h=0,
tot_h=16.,
flange_d=15.,
base_d=15.,
shaft_d=5.,
tol=0,
axis_d=VX,
axis_w=VY,
axis_h=VZ,
pos_d=0,
pos_w=0,
pos_h=0,
pos=V0,
model_type=1, # dimensional model
name=None):
if name == None:
name = 'gt' + str(int(pitch)) + '_pulley_' + str(n_teeth)
self.name = name
if (((axis_d is None) or (axis_d == V0))
and ((axis_w is None) or (axis_w == V0))):
# both are null, we create a random perpendicular vectors
axis_d = fcfun.get_fc_perpend1(axis_h)
axis_w = axis_h.cross(axis_d)
else:
if ((axis_d is None) or (axis_d == V0)):
axis_d = axis_w.cross(axis_h)
elif ((axis_w is None) or (axis_w == V0)):
axis_w = axis_h.cross(axis_d)
# all axis are defined
Obj3D.__init__(self, axis_d, axis_w, axis_h, name)
if (top_flange_h > 0 or bot_flange_h > 0) and flange_d == 0:
logger.debug("Flange height is not null, but diameter is null")
logger.debug("Flange diameter will be the same as the base")
flange_d = base_d
self.flange_d = flange_flange_d
# 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])
# belt dictionary:
self.belt_dict = kcomp.GT[pitch]
# diameters of the pulley:
# pitch diameter, it is not on the pulley, but outside, on the belt
self.pitch_d = n_teeth * pitch / math.pi
self.pitch_r = self.pitch_d / 2.
# out radius and diameter, diameter at the outer part of the teeth
self.tooth_out_r = self.pitch_r - self.belt_dict['PLD']
self.tooth_out_d = 2 * self.tooth_out_r
# inner radius and diameter, diameter at the inner part of the teeth
self.tooth_in_r = self.tooth_out_r - self.belt_dict['TOOTH_H']
self.tooth_in_d = 2 * self.tooth_in_r
self.base_r = base_d / 2.
self.shaft_r = shaft_d / 2.
self.flange_r = flange_d / 2.
self.base_d = base_d
# height of the base, without the toothed part and the flange
self.base_h = tot_h - toothed_h - top_flange_h - bot_flange_h
self.tot_h = tot_h
self.toothed_h = toothed_h
self.top_flange_h = top_flange_h
self.bot_flange_h = bot_flange_h
self.h0_cen = 0
self.d0_cen = 1 # symmetrical
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(self.base_h)
self.h_o[2] = self.vec_h(self.base_h + self.bot_flange_h)
self.h_o[3] = self.vec_h(self.base_h + self.bot_flange_h +
toothed_h / 2.)
self.h_o[4] = self.vec_h(self.tot_h - top_flange_h)
self.h_o[5] = self.vec_h(self.tot_h)
# vectors from the origin to the points along axis_d:
# these are negative because actually the pos_d indicates a negative
# position along axis_d (this happens when it is symmetrical)
self.d_o[0] = V0
self.d_o[1] = self.vec_d(-self.shaft_r)
self.d_o[2] = self.vec_d(-self.tooth_in_r)
self.d_o[3] = self.vec_d(-self.tooth_out_r)
self.d_o[4] = self.vec_d(-self.pitch_r)
self.d_o[5] = self.vec_d(-self.base_r)
self.d_o[6] = self.vec_d(-self.flange_r)
# position along axis_w
self.w_o[0] = V0
self.w_o[1] = self.vec_w(-self.shaft_r)
self.w_o[2] = self.vec_w(-self.tooth_in_r)
self.w_o[3] = self.vec_w(-self.tooth_out_r)
self.w_o[4] = self.vec_w(-self.pitch_r)
self.w_o[5] = self.vec_w(-self.base_r)
self.w_o[6] = self.vec_w(-self.flange_r)
# calculates the position of the origin, and keeps it in attribute pos_o
self.set_pos_o()
shp_fuse_list = []
# Cilynder with a hole, with an extra for the fusion
# calculation of the extra at the bottom to make the fusion
if self.bot_flange_h > 0:
xtr_bot = self.bot_flange_h / 2.
elif self.base_d > self.tooth_out_d:
xtr_bot = self.base_h / 2.
else:
xtr_bot = 0
# external diameter (maybe later teeth will be made
shp_tooth_cyl = fcfun.shp_cylhole_gen(
r_out=self.tooth_out_r,
r_in=self.shaft_r + tol,
h=self.toothed_h,
axis_h=self.axis_h,
pos_h=1, #position at the bottom
xtr_top=top_flange_h / 2.,
xtr_bot=xtr_bot,
pos=self.get_pos_h(2))
shp_fuse_list.append(shp_tooth_cyl)
if self.bot_flange_h > 0:
# same width
if self.flange_d == self.base_d:
shp_base_flg_cyl = fcfun.shp_cylholedir(
r_out=self.base_r,
r_in=self.shaft_r + tol,
h=self.base_h + self.bot_flange_h,
normal=self.axis_h,
pos=self.pos_o)
shp_fuse_list.append(shp_base_flg_cyl)
else:
shp_base_cyl = fcfun.shp_cylholedir(r_out=self.base_r,
r_in=self.shaft_r + tol,
h=self.base_h,
normal=self.axis_h,
pos=self.pos_o)
shp_bot_flange_cyl = fcfun.shp_cylholedir(
r_out=self.flange_r,
r_in=self.shaft_r + tol,
h=self.bot_flange_h,
normal=self.axis_h,
pos=self.get_pos_h(1))
shp_fuse_list.append(shp_base_cyl)
shp_fuse_list.append(shp_bot_flange_cyl)
else: #no bottom flange
shp_base_cyl = fcfun.shp_cylholedir(r_out=self.base_r,
r_in=self.shaft_r + tol,
h=self.base_h,
normal=self.axis_h,
pos=self.pos_o)
shp_fuse_list.append(shp_base_cyl)
if self.top_flange_h > 0:
shp_top_flange_cyl = fcfun.shp_cylholedir(r_out=self.flange_r,
r_in=self.shaft_r + tol,
h=self.top_flange_h,
normal=self.axis_h,
pos=self.get_pos_h(4))
shp_fuse_list.append(shp_top_flange_cyl)
shp_pulley = fcfun.fuseshplist(shp_fuse_list)
shp_pulley = shp_pulley.removeSplitter()
self.shp = shp_pulley
# normal axes to print without support
self.prnt_ax = self.axis_h
super().create_fco()
# 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])
def __init__(
self,
# motor parameters
nema_size=17,
base_l=32.,
shaft_l=24.,
shaft_r=0,
circle_r=11.,
circle_h=2.,
chmf_r=1,
rear_shaft_l=0,
bolt_depth=3.,
# pulley parameters
pulley_pitch=2.,
pulley_n_teeth=20,
pulley_toothed_h=7.5,
pulley_top_flange_h=1.,
pulley_bot_flange_h=0,
pulley_tot_h=16.,
pulley_flange_d=15.,
pulley_base_d=15.,
pulley_tol=0,
pulley_pos_h=-1,
# general parameters
axis_d=VX,
axis_w=None,
axis_h=VZ,
pos_d=0,
pos_w=0,
pos_h=1,
pos=V0,
group=1,
name=''):
if name == None:
name = 'nema' + str(nema_size) + '_pulley_set'
self.name = name
if (axis_w is None) or (axis_w == V0):
axis_w = axis_h.cross(axis_d)
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])
# pos_w = 0 and pos_d are at the center, pos_h
self.d0_cen = 1 #symmetric
self.w0_cen = 1 #symmetric
self.h0_cen = 0
# creation of the motor, we don't know all the relative positions
# so we create it at pos_d=pos_w = 0, pos_h = 1
nema_motor = PartNemaMotor(nema_size=nema_size,
base_l=base_l,
shaft_l=shaft_l,
shaft_r=shaft_r,
circle_r=circle_r,
circle_h=circle_h,
chmf_r=chmf_r,
rear_shaft_l=rear_shaft_l,
bolt_depth=bolt_depth,
bolt_out=0,
cut_extra=0,
axis_d=self.axis_d,
axis_w=self.axis_w,
axis_h=self.axis_h,
pos_d=0,
pos_w=0,
pos_h=0,
pos=pos)
super().append_part(nema_motor)
nema_motor.parent = self
self.shaft_r = nema_motor.shaft_r
self.circle_r = nema_motor.circle_r
self.circle_h = nema_motor.circle_h
# creation of the pulley. Locate it at pos_d,w,h = 0
gt_pulley = PartGtPulley(pitch=pulley_pitch,
n_teeth=pulley_n_teeth,
toothed_h=pulley_toothed_h,
top_flange_h=pulley_top_flange_h,
bot_flange_h=pulley_bot_flange_h,
tot_h=pulley_tot_h,
flange_d=pulley_flange_d,
base_d=pulley_base_d,
shaft_d=2 * self.shaft_r,
tol=0,
axis_d=self.axis_d,
axis_w=self.axis_w,
axis_h=self.axis_h,
pos_d=0,
pos_w=0,
pos_h=0,
pos=pos,
model_type=1) # dimensional model
if pulley_pos_h < 0: #top of the pulley aligned with top of the shaft
# shaft_l includes the length of the circle
pulley_pos_h = shaft_l - gt_pulley.tot_h
if pulley_pos_h < 0:
pulley_pos_h = 0
self.pulley_pos_h = pulley_pos_h
elif pulley_pos_h + gt_pulley.base_h > shaft_l:
logger.warning("pulley seems to be out of the shaft")
super().append_part(gt_pulley)
gt_pulley.parent = self
# conversions of the relative points from the parts to the total set
self.d_o[0] = nema_motor.d_o[0] # V0
self.d_o[1] = nema_motor.d_o[1]
self.d_o[2] = nema_motor.d_o[2]
self.d_o[3] = nema_motor.d_o[3]
self.d_o[4] = nema_motor.d_o[4]
self.d_o[5] = gt_pulley.d_o[2]
self.d_o[6] = gt_pulley.d_o[3]
self.d_o[7] = gt_pulley.d_o[4]
self.d_o[8] = gt_pulley.d_o[5]
self.d_o[9] = gt_pulley.d_o[6]
self.w_o[0] = nema_motor.w_o[0] # V0
self.w_o[1] = nema_motor.w_o[1]
self.w_o[2] = nema_motor.w_o[2]
self.w_o[3] = nema_motor.w_o[3]
self.w_o[4] = nema_motor.w_o[4]
self.w_o[5] = gt_pulley.w_o[2]
self.w_o[6] = gt_pulley.w_o[3]
self.w_o[7] = gt_pulley.w_o[4]
self.w_o[8] = gt_pulley.w_o[5]
self.w_o[9] = gt_pulley.w_o[6]
self.h_o[0] = nema_motor.h_o[0] # V0 (origin) base of the shaft
self.h_o[1] = nema_motor.h_o[1] # end of the circle
self.h_o[2] = nema_motor.h_o[2] # end of the shaft
self.h_o[3] = nema_motor.h_o[3] # bottom end of the bolt holes
self.h_o[4] = nema_motor.h_o[4] # bottom of the base
self.h_o[5] = nema_motor.h_o[5] # rear shaft
# position of the base of the shaft (including the circle)
# + nema_motor.h_o[0] = V0 (not needed)
# relative position of the base of the pulley: V0 (not needed)
# + gt_pulley.h_o[0] = V0 -> base of the pulley
# distance from the base of the shaft (circle included) to the base
# of the pulley:
# + self.vec_h(self.pulley_pos_h):
#self.h_o[6] = ( nema_motor.h_o[0] + gt_pulley.h_o[0]
# + self.vec_h(self.pulley_pos_h))
self.h_o[6] = self.vec_h(self.pulley_pos_h)
self.h_o[7] = self.h_o[6] + gt_pulley.h_o[1]
self.h_o[8] = self.h_o[6] + gt_pulley.h_o[2]
self.h_o[9] = self.h_o[6] + gt_pulley.h_o[3]
self.h_o[10] = self.h_o[6] + gt_pulley.h_o[4]
self.h_o[11] = self.h_o[6] + gt_pulley.h_o[5]
# check if the pulley is on top of the shaft or not:
if self.h_o[11].Length > self.h_o[5].Length:
self.tot_h = self.h_o[11].Length + self.h_o[0].Length
else:
self.tot_h = self.h_o[5].Length + self.h_o[0].Length
super().set_pos_o(adjust=1)
super().set_part_place(nema_motor)
super().set_part_place(gt_pulley, self.get_o_to_h(6))
super().place_fcos()
if group == 1:
super().make_group()
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 = 'NemaMotorHolderBase'
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
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 to hold the base to the profile
self.boltshank_r_tol = kcomp.D912[bolt1_wall_d]['shank_r_tol']
self.bolthead_r = kcomp.D912[bolt1_wall_d]['head_l']
self.bolthead_r_tol = kcomp.D912[bolt1_wall_d]['head_r']
self.bolthead_l = kcomp.D912[bolt1_wall_d]['head_l']
self.bolthead_l_tol = kcomp.D912[bolt1_wall_d]['head_l_tol']
# 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 < 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 = wall_thick + base_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 = base_motor_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(wall_thick)
self.h_o[2] = self.vec_h(wall_thick + base_h)
self.h_o[3] = self.vec_h(wall_thick + base_h + motor_thick)
self.h_o[4] = self.vec_h(wall_thick + base_h + motor_thick +
motor_min_h)
self.h_o[5] = self.vec_h(wall_thick + base_h + motor_thick +
motor_max_h)
self.h_o[6] = self.vec_h(self.tot_h)
# position along axis_d
self.d_o[0] = V0
self.d_o[1] = self.vec_d(base_d)
self.d_o[2] = self.vec_d(base_motor_d)
self.d_o[3] = self.vec_d(base_d + self.bolthead_r_tol)
self.d_o[4] = self.vec_d(base_d + 2 * self.bolthead_r)
self.d_o[5] = self.vec_d(base_motor_d + wall_thick)
self.d_o[6] = self.vec_d(base_motor_d + self.motax2wall -
self.motor_bolt_sep / 2.)
self.d_o[7] = self.vec_d(base_motor_d + self.motax2wall)
self.d_o[8] = self.vec_d(base_motor_d + self.motax2wall +
self.motor_bolt_sep / 2.)
self.d_o[9] = 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()
# base
motherboard = base(nema_size=17,
base_motor_d=8.,
base_d=6.,
base_h=16.,
wall_thick=6.,
motor_thick=6.,
reinf_thick=1.,
motor_min_h=10.,
motor_max_h=50.,
motor_xtr_space=3.,
bolt_wall_d=4.,
bolt1_wall_d=5.,
bolt_wall_sep=30.,
chmf_r=1.,
axis_h=VZ,
axis_d=VX,
axis_w=None,
pos_h=0,
pos_d=0,
pos_w=0,
pos=self.get_pos_dwh(0, 0, 0))
self.append_part(motherboard)
motorholder = NemaMotorHolder(nema_size=17,
base_motor_d=8.,
base_d=6.,
base_h=16.,
wall_thick=6.,
motor_thick=6.,
reinf_thick=1.,
motor_min_h=10.,
motor_max_h=50.,
rail=1,
motor_xtr_space=3.,
bolt_wall_d=4.,
bolt1_wall_d=5.,
bolt_wall_sep=30.,
chmf_r=1.,
axis_h=VZ,
axis_d=VX,
axis_w=None,
pos_h=0,
pos_d=0,
pos_w=0,
pos=self.get_pos_dwh(2, 0, 2))
self.append_part(motorholder)
super().make_group()
# 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,
nema_size=17,
base_l=32.,
shaft_l=20.,
shaft_r=0,
circle_r=11.,
circle_h=2.,
chmf_r=1,
rear_shaft_l=0,
bolt_depth=3.,
bolt_out=2.,
cut_extra=0,
axis_d=VX,
axis_w=None,
axis_h=VZ,
pos_d=0,
pos_w=0,
pos_h=0,
pos=V0,
name=None):
if name == None:
name = 'nema' + str(nema_size) + '_motor_l' + str(int(base_l))
self.name = name
if (axis_w is None) or (axis_w == V0):
axis_w = axis_h.cross(axis_d)
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])
self.motor_w = kcomp.NEMA_W[nema_size]
if shaft_r == 0:
self.shaft_d = kcomp.NEMA_SHAFT_D[nema_size]
self.shaft_r = self.shaft_d / 2.
shaft_r = self.shaft_r
self.shaft_l = shaft_l
self.base_l = base_l
self.rear_shaft_l = rear_shaft_l
self.nemabolt_sep = kcomp.NEMA_BOLT_SEP[nema_size]
nemabolt_d = kcomp.NEMA_BOLT_D[nema_size]
self.nemabolt_d = nemabolt_d
self.nemabolt_r = nemabolt_d / 2.
mtol = kcomp.TOL - 0.1
if circle_r == 0 or circle_h == 0:
# No circle
circle_r = 0
circle_h = 0
self.circle_r = 0
self.circle_h = 0
self.h0_cen = 0
self.d0_cen = 1 # symmetrical
self.w0_cen = 1 # symmetrical
# vectors from the origin to the points along axis_h:
self.h_o[0] = V0 # base of the shaft: origin
self.h_o[1] = self.vec_h(self.circle_h)
self.h_o[2] = self.vec_h(self.shaft_l) #includes circle_h
self.h_o[3] = self.vec_h(-bolt_depth)
self.h_o[4] = self.vec_h(-self.base_l)
self.h_o[5] = self.vec_h(-self.base_l - self.rear_shaft_l)
# vectors from the origin to the points along axis_d:
# these are negative because actually the pos_d indicates a negative
# position along axis_d (this happens when it is symmetrical)
self.d_o[0] = V0
self.d_o[1] = self.vec_d(-self.shaft_r)
self.d_o[2] = self.vec_d(-self.circle_r)
self.d_o[3] = self.vec_d(-self.nemabolt_sep / 2.)
self.d_o[4] = self.vec_d(-self.motor_w / 2.)
# position along axis_w (similar to axis_d)
self.w_o[0] = V0
self.w_o[1] = self.vec_w(-self.shaft_r)
self.w_o[2] = self.vec_w(-self.circle_r)
self.w_o[3] = self.vec_w(-self.nemabolt_sep / 2.)
self.w_o[4] = self.vec_w(-self.motor_w / 2.)
# calculates the position of the origin, and keeps it in attribute pos_o
self.set_pos_o()
# ---------- building of the piece ------------------
# -------- base of the motor
# if cut_extra, there will be extra at each side, since the piece
# is built from the center of symmetry, it will be equally extended
# on each side
shp_base = fcfun.shp_box_dir(box_w=self.motor_w + 2 * cut_extra,
box_d=self.motor_w + 2 * cut_extra,
box_h=self.base_l,
fc_axis_w=self.axis_w,
fc_axis_d=self.axis_d,
fc_axis_h=self.axis_h,
cw=1,
cd=1,
ch=0,
pos=self.get_pos_h(4))
shp_base = fcfun.shp_filletchamfer_dir(shp_base,
self.axis_h,
fillet=0,
radius=chmf_r)
shp_base = shp_base.removeSplitter()
fuse_list = []
holes_list = []
# --------- bolts (holes or extensions if cut_extra > 0)
for pt_d in (-3, 3):
for pt_w in (-3, 3):
if cut_extra == 0: # there will be holes for the bolts
# pos_h=3 is at the end of the hole for the bolts
bolt_pos = self.get_pos_dwh(pt_d, pt_w, 3)
shp_hole = fcfun.shp_cylcenxtr(r=self.nemabolt_r,
h=bolt_depth,
normal=self.axis_h,
ch=0,
xtr_top=1,
xtr_bot=0,
pos=bolt_pos)
holes_list.append(shp_hole)
else: # the bolts will protude to make holes in the shape to cut
# pos_h=0 is at the the base of the shaft
bolt_pos = self.get_pos_dwh(pt_d, pt_w, 0)
shp_hole = fcfun.shp_cylcenxtr(r=self.nemabolt_r,
h=bolt_out,
normal=self.axis_h,
ch=0,
xtr_top=0,
xtr_bot=1,
pos=bolt_pos)
fuse_list.append(shp_hole)
if cut_extra == 0:
shp_holes = fcfun.fuseshplist(holes_list)
shp_base = shp_base.cut(shp_holes)
shp_base = shp_base.removeSplitter()
# -------- circle (flat cylinder) at the base of the shaft
# could add cut_extra to circle_h or circle_r, but it can be
# set in the arguments
if circle_r > 0 and circle_h > 0:
shp_circle = fcfun.shp_cylcenxtr(
r=circle_r,
h=circle_h,
normal=self.axis_h,
ch=0, # not centered
xtr_top=0, # no extra at top
xtr_bot=1, # extra to fuse
pos=self.pos_o)
fuse_list.append(shp_circle)
# ------- Shaft
shp_shaft = fcfun.shp_cylcenxtr(
r=self.shaft_r,
h=self.shaft_l,
normal=self.axis_h,
ch=0, # not centered
xtr_top=0, # no extra at top
xtr_bot=1, # extra to fuse
# shaft length stats from the base
# not from the circle
pos=self.pos_o)
fuse_list.append(shp_shaft)
if rear_shaft_l > 0:
shp_rearshaft = fcfun.shp_cylcenxtr(
r=self.shaft_r,
h=self.rear_shaft_l,
normal=self.axis_h,
ch=0, # not centered
xtr_top=1, # to fuse
xtr_bot=0, # no extra at bottom
pos=self.get_pos_h(5))
fuse_list.append(shp_rearshaft)
shp_motor = shp_base.multiFuse(fuse_list)
shp_motor = shp_motor.removeSplitter()
self.shp = shp_motor
super().create_fco(self.name)
# Save the arguments that have not been created yet
frame = inspect.currentframe()
args, _, _, values = inspect.getargvalues(frame)
for i in args:
if not hasattr(self, i):
setattr(self, i, values[i])
self.model_type = 1 # Dimensional model
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
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.,
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 = 'base'
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
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 to hold the base to the profile
self.boltshank_r_tol = kcomp.D912[bolt1_wall_d]['shank_r_tol']
self.bolthead_r = kcomp.D912[bolt1_wall_d]['head_l']
self.bolthead_r_tol = kcomp.D912[bolt1_wall_d]['head_r']
self.bolthead_l = kcomp.D912[bolt1_wall_d]['head_l']
# calculation of the bolt wall d
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 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 = wall_thick + base_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 = base_motor_d + wall_thick + self.motor_w + self.motor_inwall_space
# 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(wall_thick)
self.h_o[2] = self.vec_h(wall_thick + base_h)
self.h_o[3] = self.vec_h(wall_thick + base_h + motor_thick)
self.h_o[4] = self.vec_h(wall_thick + base_h + motor_thick +
motor_min_h)
self.h_o[5] = self.vec_h(wall_thick + base_h + motor_thick +
motor_max_h)
self.h_o[6] = self.vec_h(self.tot_h)
# position along axis_d
self.d_o[0] = V0
self.d_o[1] = self.vec_d(base_d)
self.d_o[2] = self.vec_d(base_motor_d)
self.d_o[3] = self.vec_d(base_d + self.bolthead_r_tol)
self.d_o[4] = self.vec_d(base_d + 2 * self.bolthead_r)
# 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
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)
super().add_child(shp_box, 1, 'shp_box')
shp_box_int = fcfun.shp_box_dir(box_w=self.tot_w,
box_d=self.tot_d,
box_h=base_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))
super().add_child(shp_box_int, 0, 'shp_box_int')
shp_box_ext = fcfun.shp_box_dir(box_w=self.tot_w,
box_d=self.tot_d,
box_h=motor_thick + motor_max_h +
2 * bolt_wall_d,
fc_axis_h=self.axis_h,
fc_axis_d=self.axis_d,
cw=1,
cd=0,
ch=0,
pos=self.get_pos_dwh(2, 0, 2))
super().add_child(shp_box_ext, 0, 'shp_box_ext')
shp_box_init = fcfun.shp_box_dir(box_w=self.tot_w,
box_d=self.tot_d,
box_h=wall_thick,
fc_axis_h=self.axis_h,
fc_axis_d=self.axis_d,
cw=1,
cd=0,
ch=0,
pos=self.get_pos_dwh(4, 0, 0))
super().add_child(shp_box_init, 0, 'shp_box_init')
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, -2, 0))
super().add_child(shp_hole1, 0, 'shp_hole1')
shp_hole2 = 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, 2, 0))
super().add_child(shp_hole2, 0, 'shp_hole2')
super().make_parent(name)
chmf_reinf_r = min(base_motor_d - base_d, base_h)
self.shp = fcfun.shp_filletchamfer_dirpt(self.shp,
self.axis_w,
fc_pt=self.get_pos_dwh(
2, 0, 2),
fillet=0,
radius=(chmf_reinf_r - TOL))
# 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,
d_endstop,
rail_l = 15,
base_h = 5.,
h = 0,
holder_out = 2.,
#csunk = 1,
mbolt_d = 3.,
endstop_nut_dist = 0,
min_d = 0,
axis_d = VX,
axis_w = V0,
axis_h = VZ,
pos_d = 1,
pos_w = 1,
pos_h = 1,
pos = V0,
wfco = 1,
name = 'simple_enstop_holder'):
self.pos = FreeCAD.Vector(0,0,0)
self.position = pos
self.wfco = wfco
self.name = name
self.base_h = base_h,
# normalize the axis
axis_h = DraftVecUtils.scaleTo(axis_h,1)
axis_d = DraftVecUtils.scaleTo(axis_d,1)
if axis_w == V0:
axis_w = axis_h.cross(axis_d)
else:
axis_w = DraftVecUtils.scaleTo(axis_w,1)
axis_h_n = axis_h.negative()
axis_d_n = axis_d.negative()
axis_w_n = axis_w.negative()
self.axis_h = axis_h
self.axis_d = axis_d
self.axis_w = axis_w
self.d0_cen = 0
self.w0_cen = 1 # centered
self.h0_cen = 0
self.pos_d = pos_d
self.pos_w = pos_w
self.pos_h = pos_h
self.pos = pos
Obj3D.__init__(self, axis_d, axis_w, axis_h, name)
# best axis to print, to be pointing up:
self.axis_print = axis_h
self.d_endstop = d_endstop
# :holder_out
# __:________:____________: :..................
# | _________ | | :
# | (_________) ----| 0 | + tot_w
# | _________ ----| |-----> axis_d :
# | (_________) ----| 0 | :
# |__________________|_____|...................:
# : : : : : : :
# : :..rail_l.: : : : :
# : : : : :.: :
# :bolthead_d : : : +estp_bolt_dist
# : : : :
# bolthead_r: :.......:
# : +estp_d
# : :
# :.estp_tot_d:
# :...................._..: :
# tot_d
# The width depend which side is larger
#
# ...... ______________________ ....
# mbolt_head_r ......| ________ | | :
# mbolt_head_d ......| (________) ---| 0 | :
#mbolt_head_d or more ......| ________ ---| | + estp_w or more
# mbolt_head_d ......| (________) ---| 0 | :
# mbolt_head_r ......|________________|_____|....:
# it can have a second hole:
# : :estop_topbolt_dist
# : holder_out
# __:________:______________: :..................
# | _________ | | :
# | (_________) ----| 0 0 | + tot_w
# | _________ ----| |-----> axis_d :
# | (_________) ----| 0 0 | :
# |__________________|_______|...................:
# : :
# mounting bolt data
d_mbolt = kcomp.D912[int(mbolt_d)] #dictionary of the mounting bolt
#print(str(d_mbolt))
mbolt_r_tol = d_mbolt['shank_r_tol']
mbolt_head_r = d_mbolt['head_r']
mbolt_head_r_tol = d_mbolt['head_r_tol']
mbolt_head_l = d_mbolt['head_l']
print (str(mbolt_head_l))
# endstop data. change h->d, d->h, l->w
estp_tot_d = d_endstop['HT']
estp_d = d_endstop['H']
estp_bolt_dist = d_endstop['BOLT_H']
estp_bolt_sep = d_endstop['BOLT_SEP']
estp_bolt_d = d_endstop['BOLT_D'] #diameter, not depth
estp_w = d_endstop['L']
# if there is a second bolt
if 'BOLT_TOP_H' in d_endstop:
estop_2ndbolt_topdist = d_endstop['BOLT_TOP_H']
else:
estop_2ndbolt_topdist = 0
# length of the pins:
estp_pin_d = estp_tot_d - estp_d
if min_d == 0:
tot_d = 3*mbolt_head_r + rail_l + estp_tot_d - holder_out
# nut axis: (nut axis of the hexagon vertex
hex_verx = axis_d
else:
# Taking the minimum lenght, very tight
tot_d = (3*mbolt_head_r + rail_l + estp_d - holder_out
+ estp_pin_d/2.)
hex_verx = axis_w # less space
# Total width is the largest value from:
# - the width(length) of the endstop
# - the rail width: 2 bolt head diameters, and 2 more: 1 diameter
# between, and a radius to the end
tot_w = max(estp_w, 8 * mbolt_head_r)
if h== 0:
tot_h = base_h + mbolt_head_l
else:
tot_h = base_h + mbolt_head_l
if tot_h > h:
logger.debug('h is smaller that it should, taking: ')
logger.debug(str(tot_h))
else:
tot_h = h
self.tot_h = tot_h
self.tot_w = tot_w
self.tot_d = tot_d
if endstop_nut_dist == 0:
endstop_nut_l = kcomp.NUT_D934_L[estp_bolt_d]+TOL
else:
if endstop_nut_dist > tot_h - kcomp.NUT_D934_L[estp_bolt_d]+TOL:
logger.debug('endstop_nut_dist: ' + str(endstop_nut_dist)
+ ' larger than total height - (nut length+tol): '
+ str(tot_h) + ' - '
+ str( kcomp.NUT_D934_L[estp_bolt_d] + TOL))
endstop_nut_l = kcomp.NUT_D934_L[estp_bolt_d]+TOL
else:
endstop_nut_l = tot_h - endstop_nut_dist
# ------------ DISTANCES ON AXIS_D
# ref_d points: fc_axis_h
# 1___2______3_______4__.5............. ref_h = 2
# | :..........: : : |:..... + h
# |__:________:_____:_:_|:.....base_h.: ref_h = 1
# the end it is not on the holder because of -holder_out
# distance from 1 to 2 in axis_d
# vectors from the origin to the points along axis_d:
self.d_o[0] = V0
self.d_o[1] = self.vec_d(2* mbolt_head_r)
self.d_o[2] = self.vec_d(2* mbolt_head_r + rail_l)
self.d_o[3] = self.vec_d((tot_d + holder_out) - (estp_d - estp_bolt_dist))
self.d_o[4] = self.vec_d(tot_d + holder_out)
if estop_2ndbolt_topdist > 0 :
self.d_o[5] = self.vec_d(tot_d + holder_out - estop_2ndbolt_topdist)
else:
self.d_o[5] = self.d_o[3]
# vectors from the origin to the points along axis_w:
self.w_o[0] = V0
self.w_o[1] = self.vec_w(estp_bolt_sep/2.)
self.w_o[2] = self.vec_w(tot_w/2. - 2* mbolt_head_r)
self.w_o[3] = self.vec_w(tot_w/2.)
# vectors from the origin to the points along axis_h:
self.h_o[0] = V0
self.h_o[1] = self.vec_h(tot_h)
# calculates the position of the origin, and keeps it in attribute pos_o
self.set_pos_o()
# TODO: clear this parts when points d_o, w_o, h_o
dis_1_2_d = 2* mbolt_head_r # d_o[1]
dis_1_3_d = dis_1_2_d + rail_l # d_o[2]
#dis_2_3_d = rail_l
dis_1_5_d = tot_d + holder_out # d_o[4]
dis_1_4_d = dis_1_5_d - (estp_d - estp_bolt_dist) # d_o[3]
# distances to the new point, that is the second bolt hole, if exists
if estop_2ndbolt_topdist > 0 :
dis_1_6_d = dis_1_5_d - estop_2ndbolt_topdist
else:
# same as 4: (to avoid errors) it will be the same hole
dis_1_6_d = dis_1_4_d
fc_1_2_d = self.d_o[1]
fc_1_3_d = self.d_o[2]
fc_1_4_d = self.d_o[3]
fc_1_5_d = self.d_o[4]
fc_1_6_d = self.d_o[5]
# vector from the reference point to point 1 on axis_d
if pos_d == 0:
refto_1_d = V0
elif pos_d == 1:
refto_1_d = fc_1_2_d.negative()
elif pos_d == 2:
refto_1_d = fc_1_3_d.negative()
elif pos_d == 3:
refto_1_d = fc_1_4_d.negative()
elif pos_d == 4:
refto_1_d = fc_1_5_d.negative()
elif pos_d == 5:
refto_1_d = fc_1_6_d.negative()
else:
logger.error('wrong reference point')
# ------------ DISTANCES ON AXIS_W
# ref_w points
# fc_axis_w
# _____________________ :
# | ________ | |:
# | (________) ---| 0 |:
# 1 ________ ---| |:-----> fc_axis_d.
# 3 (________) ---| 2 |:
# 4________________|____|:
# distance from 1 to 2 on axis_w
dis_1_2_w = estp_bolt_sep/2.
dis_1_4_w = tot_w/2.
dis_1_3_w = dis_1_4_w - 2* mbolt_head_r
fc_1_2_w = self.w_o[1]
fc_1_3_w = self.w_o[2]
fc_1_4_w = self.w_o[3]
# vector from the reference point to point 1 on axis_w
if pos_w == 0:
refto_1_w = V0
elif pos_w == 1:
refto_1_w = fc_1_2_w.negative()
elif pos_w == 2:
refto_1_w = fc_1_3_w.negative()
elif pos_w == 3:
refto_1_w = fc_1_4_w.negative()
else:
logger.error('wrong reference point')
# ------------ DISTANCES ON AXIS_H
fc_1_2_h = DraftVecUtils.scale(axis_h, tot_h)
fc_2_1_h = fc_1_2_h.negative()
if pos_h == 0:
refto_2_h = self.h_o[1]
elif pos_h == 1:
refto_2_h = V0
else:
logger.error('wrong reference point')
# Situation of the point on d=1, s=1, h=2
# ____________
# /
# * d1_w1_h2
# /____________
# |
#
# this is an absolute position
# super().get_pos_dwh(pos_d,pos_w,pos_h)
d1_w1_h2_pos = self.pos + refto_1_d + refto_1_w + refto_2_h
d1_w1_h1_pos = d1_w1_h2_pos + fc_2_1_h
# draw the box from this point d1 s1 h2
shp_box = fcfun.shp_box_dir(box_w = tot_w,
box_d = tot_d,
box_h = tot_h,
fc_axis_h = axis_h_n,
fc_axis_d = axis_d,
cw = 1, cd = 0, ch = 0,
pos = d1_w1_h2_pos)
shp_box = fcfun.shp_filletchamfer_dir(shp_box, fc_axis = axis_h,
fillet=1,
radius = 2)
holes = []
# holes for the endstop bolts, point: d4 w2 h1
for fc_1_2_wi in [fc_1_2_w, fc_1_2_w.negative()]:
pos_estpbolt = d1_w1_h1_pos + fc_1_4_d + fc_1_2_wi
# hole with the nut hole
shp_estpbolt = fcfun.shp_bolt_dir (
r_shank= (estp_bolt_d+TOL)/2.,
l_bolt = tot_h,
# 1 TOL didnt fit
r_head = (kcomp.NUT_D934_D[estp_bolt_d]+2*TOL)/2.,
l_head = endstop_nut_l,
hex_head = 1,
xtr_head = 1, xtr_shank = 1,
fc_normal = axis_h,
fc_verx1 = hex_verx,
pos = pos_estpbolt)
holes.append(shp_estpbolt)
# it can have a second hole
if estop_2ndbolt_topdist >0:
pos_estp_top_bolt = d1_w1_h1_pos + fc_1_6_d + fc_1_2_wi
# hole with the nut hole
shp_estpbolt = fcfun.shp_bolt_dir (
r_shank= (estp_bolt_d+TOL)/2.,
l_bolt = tot_h,
# 1 TOL didnt fit
r_head = (kcomp.NUT_D934_D[estp_bolt_d]+2*TOL)/2.,
l_head = endstop_nut_l,
hex_head = 1,
xtr_head = 1, xtr_shank = 1,
fc_normal = axis_h,
fc_verx1 = hex_verx,
pos = pos_estp_top_bolt)
holes.append(shp_estpbolt)
# holes for the rails, point d2 w3 h2
for fc_1_3_wi in [fc_1_3_w, fc_1_3_w.negative()]:
#hole for the rails, use the function stadium
rail_pos = d1_w1_h2_pos + fc_1_2_d + fc_1_3_wi
shp_rail_sunk = fcfun.shp_stadium_dir (
length = rail_l,
radius = mbolt_head_r_tol,
height = mbolt_head_l,
fc_axis_l = axis_d,
fc_axis_h = axis_h_n,
ref_l = 2, #at the center of semicircle
ref_s = 1, # symmetrical on the short side
ref_h = 2,
xtr_h = 0,
xtr_nh = 1,
pos = rail_pos)
shp_rail = fcfun.shp_stadium_dir (
length = rail_l,
radius = mbolt_r_tol,
height = tot_h,
fc_axis_l = axis_d,
fc_axis_h = axis_h_n,
ref_l = 2,
ref_s = 1,
ref_h = 2,
xtr_h = 1,
xtr_nh = 0,
pos = rail_pos)
holes.append(shp_rail)
holes.append(shp_rail_sunk)
shp_holes = fcfun.fuseshplist(holes)
shp_holder = shp_box.cut(shp_holes)
self.shp = shp_holder
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,
filter_l=60.,
filter_w=25.,
filter_t=2.5,
base_h=6.,
hold_d=12.,
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.,
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,
model_type=0, # exact
name=''):
default_name = 'filter_holder'
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
# 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.
# 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)
# 4: at the inner side of the clamp post (larger circle)
self.w_o[4] = self.vec_w(self.beltpost_l + clamp_post_dist + beltclamp_l - self.tot_w / 2.)
# 5: at the outer side of the clamp post (smaller circle)
self.w_o[5] = self.vec_w(clamp_post_dist + beltclamp_l - 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.vec_w(beltclamp_l - self.tot_w / 2.)
# 7: at the end of the piece
self.w_o[7] = self.vec_w(-self.tot_w / 2.)
# 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_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()
self.shp = shp_filterholder
# Then the Part
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
# save the arguments as attributes:
frame = inspect.currentframe()
args, _, _, values = inspect.getargvalues(frame)
for i in args:
if not hasattr(self, i): # so we keep the attributes by CylHole
setattr(self, i, values[i])
def __init__ (self, block_dict, rail_dict,
axis_d = VX, axis_w = V0, axis_h = VZ,
pos_d = 0, pos_w = 0, pos_h = 0,
pos = V0,
model_type = 1, # dimensional model
name = None):
self.pos = FreeCAD.Vector(0,0,0)
self.position = pos
if name == None:
self.name = block_dict['name'] + '_block'
if rail_dict is None:
self.rail_h = 0
self.rail_w = 0
else:
self.rail_h = rail_dict['rh']
self.rail_w = rail_dict['rw']
if (axis_w is None) or (axis_w == V0):
axis_w = axis_h.cross(axis_d)
Obj3D.__init__(self, axis_d, axis_w, axis_h, self.name)
self.block_d = block_dict['bl']
self.block_ds = block_dict['bls']
self.block_w = block_dict['bw']
self.block_ws = block_dict['bws']
self.block_h = block_dict['bh']
self.linguide_h = block_dict['lh']
self.bolt_dsep = block_dict['boltlsep']
self.bolt_wsep = block_dict['boltwsep']
self.bolt_d = block_dict['boltd']
self.bolt_l = block_dict['boltl']
linguide_h = block_dict['lh']
# 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 = 1 # symmetric
self.w0_cen = 1 # symmetric
self.h0_cen = 0
if self.bolt_l == 0: # thruhole
self.bolt_l = self.block_h
self.thruhole = 1
else:
self.thruhole = 0
if self.rail_h == 0 or linguide_h == 0:
self.rail_h = 0
self.linguide_h = 0
self.rail_ins_h = 0
self.rail_bot_h = 0
else:
self.rail_ins_h = self.block_h - (self.linguide_h - self.rail_h)
self.rail_bot_h = self.rail_h - self.rail_ins_h
# vectors from the origin to the points along axis_d:
self.d_o[0] = V0 # Origin (center symmetric)
self.d_o[1] = self.vec_d(-self.bolt_dsep/2.)
self.d_o[2] = self.vec_d(-self.block_ds/2.)
self.d_o[3] = self.vec_d(-self.block_d/2.)
# vectors from the origin to the points along axis_w:
self.w_o[0] = V0 # Origin (center symmetric)
self.w_o[1] = self.vec_w(-self.rail_w/2.)
self.w_o[2] = self.vec_w(-self.bolt_wsep/2.)
self.w_o[3] = self.vec_w(-self.block_ws/2.)
self.w_o[4] = self.vec_w(-self.block_w/2.)
# vectors from the origin to the points along axis_h:
# could make more sense to have the origin at the top
self.h_o[0] = V0 # Origin at the bottom
self.h_o[1] = self.vec_h(self.rail_ins_h)
self.h_o[2] = self.vec_h(self.block_h - self.bolt_l)
self.h_o[3] = self.vec_h(self.block_h)
self.h_o[4] = self.vec_h(-self.rail_bot_h)
# calculates the position of the origin, and keeps it in attribute pos_o
self.set_pos_o()
# the main block
shp_mblock = fcfun.shp_box_dir (box_w = self.block_w,
box_d = self.block_ds,
box_h = self.block_h,
fc_axis_w = self.axis_w,
fc_axis_d = self.axis_d,
fc_axis_h = self.axis_h,
cw = 1, cd = 1, ch = 0,
pos = self.pos_o)
# the extra block
shp_exblock = fcfun.shp_box_dir (box_w = self.block_ws,
box_d = self.block_d,
box_h = self.block_h,
fc_axis_w = self.axis_w,
fc_axis_d = self.axis_d,
fc_axis_h = self.axis_h,
cw = 1, cd = 1, ch = 0,
pos = self.pos_o)
# fusion of these blocks
shp_block = shp_mblock.fuse(shp_exblock)
holes_list = []
# rail hole:
if self.rail_h > 0 and self.rail_w > 0:
wire_rail = fcfun.wire_lgrail( rail_w = self.rail_w,
rail_h = self.rail_h,
axis_w = self.axis_w,
axis_h = self.axis_h,
pos_w = 0, pos_h = 0,
pos = self.get_pos_h(4))
face_rail = Part.Face(wire_rail)
shp_rail = fcfun.shp_extrud_face (face = face_rail,
length = self.block_d + 2,
vec_extr_axis = self.axis_d,
centered = 1)
#Part.show(shp_rail)
holes_list.append(shp_rail)
# bolt holes:
for d_i in (-1, 1): # positions of the holes along axis_d
for w_i in (-2, 2): # positions of the holes along axis_w
shp_bolt = fcfun.shp_cylcenxtr (
r = self.bolt_d/2.,
h = self.bolt_l,
normal = axis_h,
ch = 0,
xtr_top = 1,
xtr_bot = self.thruhole,
pos = self.get_pos_dwh(d_i, w_i, 2))
holes_list.append(shp_bolt)
shp_holes = fcfun.fuseshplist(holes_list)
shp_block = shp_block.cut(shp_holes)
shp_block = shp_block.removeSplitter()
self.shp = shp_block
super().create_fco(self.name)
# 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,
alusize_d=50.,
alusize_w=30.,
alusize_h=50.,
dist_alu=30.,
dist_hole=36.,
wall_thick=4.,
bolt_wall_d=5.,
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 = 'board'
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 base to the profile
self.boltshank_r_tol = kcomp.D912[bolt_wall_d]['shank_r_tol']
self.bolthead_r = kcomp.D912[bolt_wall_d]['head_l']
self.bolthead_r_tol = kcomp.D912[bolt_wall_d]['head_r']
self.bolthead_l = kcomp.D912[bolt_wall_d]['head_l']
self.bolthead_l_tol = kcomp.D912[bolt_wall_d]['head_l_tol']
# making the big box that will contain everything and will be cut
self.tot_w = alusize_w + 4.5
self.tot_h = wall_thick + alusize_h / 2.
self.tot_d = 2 * alusize_d - 20. + dist_alu + 8.5
# definition of which axis is symmetrical
self.h0_cen = 0
self.d0_cen = 0 # symmetrical
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(wall_thick)
self.h_o[2] = self.vec_h(self.tot_h)
# position along axis_d
self.d_o[0] = V0
self.d_o[1] = self.vec_d(alusize_d / 2. - 10. + 4.25)
self.d_o[2] = self.vec_d(alusize_d - 10. + 4.25 + TOL)
self.d_o[3] = self.vec_d(alusize_d - 10. + 4.25 + dist_alu / 2.)
self.d_o[4] = self.vec_d(alusize_d - 10. + 4.25 + dist_alu - TOL)
self.d_o[5] = self.vec_d(alusize_d - 10. + 4.25 + dist_alu +
alusize_d / 2.)
self.d_o[6] = 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(-(dist_hole / 2.))
self.w_o[2] = 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
shp_box = fcfun.shp_box_dir(box_w=self.tot_w,
box_d=self.tot_d,
box_h=self.tot_h,
fc_axis_d=self.axis_d,
fc_axis_h=self.axis_h,
cw=1,
cd=0,
ch=0,
pos=self.pos_o)
# make the shape of the piece
cut = []
cut_box1 = fcfun.shp_box_dir(box_w=self.tot_w,
box_d=alusize_d - 10. + 4.25 + TOL,
box_h=alusize_h,
fc_axis_d=self.axis_d,
fc_axis_h=self.axis_h,
cw=1,
cd=0,
ch=0,
pos=self.get_pos_dwh(0, 0, 1))
cut.append(cut_box1)
cut_box2 = fcfun.shp_box_dir(box_w=self.tot_w,
box_d=alusize_d - 10. + 4.25 + TOL,
box_h=alusize_h,
fc_axis_d=self.axis_d,
fc_axis_h=self.axis_h,
cw=1,
cd=0,
ch=0,
pos=self.get_pos_dwh(4, 0, 1))
cut.append(cut_box2)
# holes to hold the profile
cut_hole1 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
l_bolt=wall_thick,
r_head=self.bolthead_r_tol,
l_head=wall_thick / 2.,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_h,
pos_n=0,
pos=self.get_pos_dwh(1, -1, 0))
cut.append(cut_hole1)
cut_hole2 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
l_bolt=wall_thick,
r_head=self.bolthead_r_tol,
l_head=wall_thick / 2.,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_h,
pos_n=0,
pos=self.get_pos_dwh(1, 1, 0))
cut.append(cut_hole2)
cut_hole3 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
l_bolt=wall_thick,
r_head=self.bolthead_r_tol,
l_head=wall_thick / 2.,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_h,
pos_n=0,
pos=self.get_pos_dwh(5, -1, 0))
cut.append(cut_hole3)
cut_hole4 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
l_bolt=wall_thick,
r_head=self.bolthead_r_tol,
l_head=wall_thick / 2.,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_h,
pos_n=0,
pos=self.get_pos_dwh(5, 1, 0))
cut.append(cut_hole4)
# holes to hold de screw
hole1 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
l_bolt=self.tot_h,
r_head=self.bolthead_r_tol,
l_head=13 * self.tot_h / 20.,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_h.negative(),
pos_n=0,
pos=self.get_pos_dwh(3, -1, 2))
cut.append(hole1)
hole2 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
l_bolt=self.tot_h,
r_head=self.bolthead_r_tol,
l_head=13 * self.tot_h / 20.,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_h.negative(),
pos_n=0,
pos=self.get_pos_dwh(3, 1, 2))
cut.append(hole2)
shp_cut = fcfun.fuseshplist(cut)
shp_fuse = shp_box.cut(shp_cut)
for pt_d in (0, 2, 4, 6):
for pt_w in (-2, 2):
shp_fuse = fcfun.shp_filletchamfer_dirpt(
shp_fuse,
fc_axis=self.axis_h,
fc_pt=self.get_pos_dwh(pt_d, pt_w, 1),
fillet=1,
radius=chmf_r)
self.shp = shp_fuse
# 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, depth,
aluprof_dict,
xtr_d=0, xtr_nd=0,
axis_d = VX, axis_w = VY, axis_h = V0,
pos_d = 0, pos_w = 0, pos_h = 0,
pos = V0,
model_type = 1, # dimensional model
name = None):
width = aluprof_dict['w']
depth = depth
thick = aluprof_dict['t']
slot = aluprof_dict['slot']
insquare = aluprof_dict['insq']
indiam = aluprof_dict['indiam']
# either axis_w or axis_h can be V0, but not both
if (axis_w is None) or (axis_w == V0):
if (axis_h is None) or (axis_h == V0):
logger.error('Either axis_w or axis_h must be defined')
logger.warning('getting a random perpendicular verctor')
axis_w = fcfun.get_fc_perpend1(axis_d)
else:
axis_w = axis_h.cross(axis_d)
if (axis_h is None) or (axis_h == V0):
axis_h = axis_d.cross(axis_w)
if name == None:
name = ( 'aluprof_w' + str(int(aluprof_dict['w']))
+ 'l_' + str(int(xtr_nd + depth + xtr_d)))
Obj3D.__init__(self, axis_d, axis_w, axis_h, name = 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
self.d0_cen = 0
self.w0_cen = 1 # symmetric
self.h0_cen = 1 # symmetric
# total length (depth)
self.tot_d = xtr_nd + depth + xtr_d
# vectors from the origin to the points along axis_d:
self.d_o[0] = V0 # origin
self.d_o[1] = self.vec_d(xtr_nd) #if xtr_nd= 0: same as d_o[0]
# middle point, not considering xtr_nd and xtr_d
self.d_o[2] = self.vec_d(xtr_nd + depth/2.)
# middle point considering xtr_nd and xtr_d
self.d_o[3] = self.vec_d(self.tot_d /2.)
self.d_o[4] = self.vec_d(xtr_nd + depth)
self.d_o[5] = self.vec_d(self.tot_d)
# vectors from the origin to the points along axis_w:
# symmetric: negative
self.w_o[0] = V0 # center: origin
self.w_o[1] = self.vec_w(-insquare/2.)
self.w_o[2] = self.vec_w(-(width/2. - thick))
self.w_o[3] = self.vec_w(-width/2.)
# vectors from the origin to the points along axis_h:
# symmetric: negative
self.h_o[0] = V0 # center: origin
self.h_o[1] = self.vec_h(-insquare/2.)
self.h_o[2] = self.vec_h(-(width/2. - thick))
self.h_o[3] = self.vec_h(-width/2.)
# calculates the position of the origin, and keeps it in attribute pos_o
self.set_pos_o()
shp_alu_wire = fcfun.shp_aluwire_dir (width, thick, slot, insquare,
fc_axis_x = self.axis_w,
fc_axis_y = self.axis_h,
ref_x = 1, # pos_o is centered
ref_y = 1, # pos_o is centered
pos = self.pos_o)
# make a face of the wire
shp_alu_face = Part.Face (shp_alu_wire)
# inner hole
if indiam > 0 :
hole = Part.makeCircle (indiam/2., # Radius
self.pos_o, # Position
self.axis_d) # direction
wire_hole = Part.Wire(hole)
face_hole = Part.Face(wire_hole)
shp_alu_face = shp_alu_face.cut(face_hole)
# extrude it
dir_extrud = DraftVecUtils.scaleTo(self.axis_d, self.tot_d)
shp_aluprof = shp_alu_face.extrude(dir_extrud)
self.shp = shp_aluprof
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, xtr_lat = 5., xtr_holes = 8., h_bottom = 1., d_bottom = 2., h_rail = 2., h_base = 2., dist_holes = 49., wall_thick = 4., reinf_thick = 3., arduino_w = 53., arduino_d = 105., arduino_h = 5., sides = 10., bolt = 5., 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 = 'bottom_coverplate'
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
self.tot_d = 2 * sides + arduino_d + d_bottom
self.tot_w = arduino_w + 2 * wall_thick - 2. + 2 * xtr_holes
self.tot_h = h_base + arduino_h + h_bottom
# 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(h_base)
self.h_o[2] = self.vec_h(h_base + arduino_h - h_rail)
self.h_o[3] = self.vec_h(h_base + arduino_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(sides/2.)
self.d_o[2] = self.vec_d(sides)
self.d_o[3] = self.vec_d(sides + xtr_lat)
self.d_o[4] = self.vec_d(sides + xtr_lat + xtr_holes/2.)
self.d_o[5] = self.vec_d(sides + xtr_lat + xtr_holes)
self.d_o[6] = self.vec_d(sides + arduino_d - 3. - xtr_holes)
self.d_o[7] = self.vec_d(sides + arduino_d - 3. - xtr_lat)
self.d_o[8] = self.vec_d(sides + arduino_d - 3. - xtr_holes/2)
self.d_o[9] = self.vec_d(sides + arduino_d + d_bottom - xtr_holes)
self.d_o[10] = self.vec_d(sides + arduino_d + d_bottom - xtr_holes/2)
self.d_o[11] = self.vec_d(sides + arduino_d - 3.)
self.d_o[12] = self.vec_d(sides + arduino_d)
self.d_o[13] = self.vec_d(sides + arduino_d + d_bottom)
self.d_o[14] = self.vec_d(sides + arduino_d + d_bottom + sides/2.)
self.d_o[15] = self.vec_d(self.tot_d)
# position along axis_w
self.w_o[0] = V0
self.w_o[1] = self.vec_w(-(arduino_w - 2. - 2 * xtr_lat)/2.)
self.w_o[2] = self.vec_w(-(arduino_w - 2.)/2.)
self.w_o[3] = self.vec_w(-dist_holes/2.)
self.w_o[4] = self.vec_w(-(arduino_w + 2 * wall_thick - 2.)/2.)
self.w_o[5] = self.vec_w(-(arduino_w + 2 * wall_thick - 2. + xtr_holes)/2.)
self.w_o[6] = 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
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 = []
for pt_d in (0, 11):
shp_lat1 = fcfun.shp_box_dir(box_w = xtr_holes, box_d = sides + xtr_lat, box_h = self.tot_h, fc_axis_h = axis_h, fc_axis_d = axis_d, cw = 0, cd = 0, ch = 0, pos = self.get_pos_dwh(pt_d, -4, 0))
cut.append(shp_lat1)
shp_lat2 = fcfun.shp_box_dir(box_w = - xtr_holes, box_d = sides + xtr_lat, box_h = self.tot_h, fc_axis_h = axis_h, fc_axis_d = axis_d, cw = 0, cd = 0, ch = 0, pos = self.get_pos_dwh(pt_d, 4, 0))
cut.append(shp_lat2)
shp_cut = fcfun.fuseshplist(cut)
shp_final = shp_box.cut(shp_cut)
for pt_d in (0, 15):
for pt_w in (-4, 4):
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)
cut = []
for pt_d in (3, 6):
shp_lat3 = fcfun.shp_box_dir(box_w = xtr_holes, box_d = xtr_holes, box_h = self.tot_h, fc_axis_h = axis_h, fc_axis_d = axis_d, cw = 0, cd = 0, ch = 0, pos = self.get_pos_dwh(pt_d, -4, 1))
cut.append(shp_lat3)
shp_lat4 = fcfun.shp_box_dir(box_w = - xtr_holes, box_d = xtr_holes, box_h = self.tot_h, fc_axis_h = axis_h, fc_axis_d = axis_d, cw = 0, cd = 0, ch = 0, pos = self.get_pos_dwh(pt_d, 4, 1))
cut.append(shp_lat4)
shp_cut = fcfun.fuseshplist(cut)
shp_final = shp_final.cut(shp_cut)
for pt_d in (3, 11):
for pt_w in (-6, 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)
cut = []
shp_lat5 = fcfun.shp_box_dir(box_w = xtr_holes, box_d = self.tot_d - 2 * (sides + xtr_lat + xtr_holes), box_h = self.tot_h, fc_axis_h = axis_h, fc_axis_d = axis_d, cw = 0, cd = 0, ch = 0, pos = self.get_pos_dwh(5, -4, 0))
cut.append(shp_lat5)
shp_lat6 = fcfun.shp_box_dir(box_w = - xtr_holes, box_d = self.tot_d - 2 * (sides + xtr_lat + xtr_holes), box_h = self.tot_h, fc_axis_h = axis_h, fc_axis_d = axis_d, cw = 0, cd = 0, ch = 0, pos = self.get_pos_dwh(5, 4, 0))
cut.append(shp_lat6)
shp_cut = fcfun.fuseshplist(cut)
shp_final = shp_final.cut(shp_cut)
for pt_d in (5, 6):
for pt_w in (-6, 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)
cut = []
for pt_d in (0, 13):
shp_sides = fcfun.shp_box_dir(box_w = self.tot_w, box_d = sides, box_h = self.tot_h, fc_axis_h = axis_h, fc_axis_d = axis_d, cw = 1, cd = 0, ch = 0, pos = self.get_pos_dwh(pt_d, 0, 1))
cut.append(shp_sides)
shp_intern = fcfun.shp_box_dir(box_w = arduino_w - 2., box_d = arduino_d - 3., box_h = self.tot_h, fc_axis_h = axis_h, fc_axis_d = axis_d, cw = 1, cd = 0, ch = 0, pos = self.get_pos_dwh(2, 0, 1))
cut.append(shp_intern)
shp_int = fcfun.shp_box_dir(box_w = arduino_w - 2., box_d = arduino_d, box_h = self.tot_h, fc_axis_h = axis_h, fc_axis_d = axis_d, cw = 1, cd = 0, ch = 0, pos = self.get_pos_dwh(2, 0, 2))
cut.append(shp_int)
shp_rail = fcfun.shp_box_dir(box_w = arduino_w + 2 * TOL, box_d = arduino_d, box_h = h_rail, fc_axis_h = axis_h, fc_axis_d = axis_d, cw = 1, cd = 0, ch = 0, pos = self.get_pos_dwh(2, 0, 2))
cut.append(shp_rail)
trim_mat = fcfun.shp_box_dir(box_w = arduino_w - 2. - 2 * xtr_lat, box_d = arduino_d - 3. - 2 * xtr_lat, box_h = self.tot_h, fc_axis_h = axis_h, fc_axis_d = axis_d, cw = 1, cd = 0, ch = 0, pos = self.get_pos_dwh(3, 0, 0))
cut.append(trim_mat)
shp_cut = fcfun.fuseshplist(cut)
shp_final = shp_final.cut(shp_cut)
for pt_d in (2, 13):
for pt_w in (-4, 4):
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_w in (-2, 2):
shp_final = fcfun.shp_filletchamfer_dirpt(shp_final, self.axis_h, fc_pt = self.get_pos_dwh(12, pt_w, 3), fillet = 1, radius = chmf_r)
for pt_h in (1, 3):
shp_final = fcfun.shp_filletchamfer_dirpt(shp_final, self.axis_h, fc_pt = self.get_pos_dwh(2, pt_w, pt_h), fillet = 1, radius = chmf_r)
cut = []
for pt_d in (1, 14):
for pt_w in (-3, 3):
shp_hole = fcfun.shp_cylcenxtr(r = self.boltshank_r_tol, h = h_base, normal = self.axis_h, ch = 0, xtr_top = 1, xtr_bot = 1, pos = self.get_pos_dwh(pt_d, pt_w, 0))
cut.append(shp_hole)
for pt_d in (4, 8):
for pt_w in (-5, 5):
shp_hole = fcfun.shp_cylcenxtr(r = self.boltshank_r_tol, h = h_base, normal = self.axis_h, ch = 0, xtr_top = 1, xtr_bot = 1, pos = self.get_pos_dwh(pt_d, pt_w, 0))
cut.append(shp_hole)
shp_cut = fcfun.fuseshplist(cut)
shp_final = shp_final.cut(shp_cut)
shp_final = shp_final.removeSplitter()
for pt_d in (5, 6):
for pt_w in (-4, 4):
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_d in (3, 7):
for pt_w in (-1, 1):
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 = 4 * chmf_r)
for pt_d in (3, 11):
for pt_w in (-4, 4):
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)
doc.recompute()
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
def __init__(self,
alusize_d=50.,
alusize_w=30.,
alusize_h=50.,
dist_alu=30.,
wall_thick=4.,
bolt_wall_d=4.,
opt_sides=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 = 'board'
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 base to the profile
self.boltshank_r_tol = kcomp.D912[bolt_wall_d]['shank_r_tol']
self.bolthead_r = kcomp.D912[bolt_wall_d]['head_l']
self.bolthead_r_tol = kcomp.D912[bolt_wall_d]['head_r']
self.bolthead_l = kcomp.D912[bolt_wall_d]['head_l']
self.bolthead_l_tol = kcomp.D912[bolt_wall_d]['head_l_tol']
# making the big box that will contain everything and will be cut
self.tot_w = alusize_w
self.tot_h = wall_thick + alusize_h / 2.
if opt_sides == 0:
self.tot_d = 2 * alusize_d + dist_alu
else:
self.tot_d = 2 * wall_thick + 2 * alusize_d + dist_alu
# definition of which axis is symmetrical
self.h0_cen = 0
self.d0_cen = 0 # symmetrical
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(wall_thick)
self.h_o[2] = self.vec_h(self.tot_h)
# position along axis_d
if opt_sides == 0:
self.d_o[0] = V0
self.d_o[1] = self.vec_d(alusize_d / 4.)
self.d_o[2] = self.vec_d(3 * alusize_d / 4.)
self.d_o[3] = self.vec_d(alusize_d + TOL)
self.d_o[4] = self.vec_d(alusize_d + dist_alu / 2.)
self.d_o[5] = self.vec_d(alusize_d + dist_alu - TOL)
self.d_o[6] = self.vec_d(alusize_d + dist_alu + alusize_d / 4.)
self.d_o[7] = self.vec_d(alusize_d + dist_alu + 3 * alusize_d / 4.)
self.d_o[8] = self.vec_d(self.tot_d)
else:
self.d_o[0] = V0
self.d_o[1] = self.vec_d(wall_thick - TOL)
self.d_o[2] = self.vec_d(wall_thick + alusize_d / 4.)
self.d_o[3] = self.vec_d(wall_thick + 3 * alusize_d / 4.)
self.d_o[4] = self.vec_d(wall_thick + alusize_d + TOL)
self.d_o[5] = self.vec_d(wall_thick + alusize_d + dist_alu / 2.)
self.d_o[6] = self.vec_d(wall_thick + alusize_d + dist_alu - TOL)
self.d_o[7] = self.vec_d(wall_thick + alusize_d + dist_alu +
alusize_d / 4.)
self.d_o[8] = self.vec_d(wall_thick + alusize_d + dist_alu +
3 * alusize_d / 4.)
self.d_o[9] = self.vec_d(wall_thick + alusize_d + dist_alu +
alusize_d + TOL)
self.d_o[10] = 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(-(alusize_w / 2. - 5.))
self.w_o[2] = 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
if opt_sides == 0:
shp_box = fcfun.shp_box_dir(box_w=self.tot_w,
box_d=self.tot_d,
box_h=self.tot_h,
fc_axis_d=self.axis_d,
fc_axis_h=self.axis_h,
cw=1,
cd=0,
ch=0,
pos=self.pos_o)
super().add_child(shp_box, 1, 'shp_box')
# make the shape of the piece
cut_box1 = fcfun.shp_box_dir(box_w=self.tot_w,
box_d=alusize_d + TOL,
box_h=alusize_h,
fc_axis_d=self.axis_d,
fc_axis_h=self.axis_h,
cw=1,
cd=0,
ch=0,
pos=self.get_pos_dwh(0, 0, 1))
super().add_child(cut_box1, 0, 'cut_box1')
cut_box2 = fcfun.shp_box_dir(box_w=self.tot_w,
box_d=alusize_d + TOL,
box_h=alusize_h,
fc_axis_d=self.axis_d,
fc_axis_h=self.axis_h,
cw=1,
cd=0,
ch=0,
pos=self.get_pos_dwh(5, 0, 1))
super().add_child(cut_box2, 0, 'cut_box2')
# holes to hold the profile
cut_hole1 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
l_bolt=wall_thick,
r_head=self.bolthead_r_tol,
l_head=wall_thick / 2.,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_h,
pos_n=0,
pos=self.get_pos_dwh(1, -1, 0))
super().add_child(cut_hole1, 0, 'cut_hole1')
cut_hole2 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
l_bolt=wall_thick,
r_head=self.bolthead_r_tol,
l_head=wall_thick / 2.,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_h,
pos_n=0,
pos=self.get_pos_dwh(1, 1, 0))
super().add_child(cut_hole2, 0, 'cut_hole2')
cut_hole3 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
l_bolt=wall_thick,
r_head=self.bolthead_r_tol,
l_head=wall_thick / 2.,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_h,
pos_n=0,
pos=self.get_pos_dwh(2, -1, 0))
super().add_child(cut_hole3, 0, 'cut_hole3')
cut_hole4 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
l_bolt=wall_thick,
r_head=self.bolthead_r_tol,
l_head=wall_thick / 2.,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_h,
pos_n=0,
pos=self.get_pos_dwh(2, 1, 0))
super().add_child(cut_hole4, 0, 'cut_hole4')
cut_hole5 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
l_bolt=wall_thick,
r_head=self.bolthead_r_tol,
l_head=wall_thick / 2.,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_h,
pos_n=0,
pos=self.get_pos_dwh(6, -1, 0))
super().add_child(cut_hole5, 0, 'cut_hole5')
cut_hole6 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
l_bolt=wall_thick,
r_head=self.bolthead_r_tol,
l_head=wall_thick / 2.,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_h,
pos_n=0,
pos=self.get_pos_dwh(6, 1, 0))
super().add_child(cut_hole6, 0, 'cut_hole6')
cut_hole7 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
l_bolt=wall_thick,
r_head=self.bolthead_r_tol,
l_head=wall_thick / 2.,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_h,
pos_n=0,
pos=self.get_pos_dwh(7, 1, 0))
super().add_child(cut_hole7, 0, 'cut_hole7')
cut_hole8 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
l_bolt=wall_thick,
r_head=self.bolthead_r_tol,
l_head=wall_thick / 2.,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_h,
pos_n=0,
pos=self.get_pos_dwh(7, -1, 0))
super().add_child(cut_hole8, 0, 'cut_hole8')
# holes to hold de screw
hole1 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
l_bolt=self.tot_h,
r_head=self.bolthead_r_tol,
l_head=13 * self.tot_h / 20.,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_h.negative(),
pos_n=0,
pos=self.get_pos_dwh(4, -1, 2))
super().add_child(hole1, 0, 'hole1')
hole2 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
l_bolt=self.tot_h,
r_head=self.bolthead_r_tol,
l_head=13 * self.tot_h / 20.,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_h.negative(),
pos_n=0,
pos=self.get_pos_dwh(4, 1, 2))
super().add_child(hole2, 0, 'hole2')
else:
shp_box = fcfun.shp_box_dir(box_w=self.tot_w,
box_d=self.tot_d,
box_h=self.tot_h,
fc_axis_d=self.axis_d,
fc_axis_h=self.axis_h,
cw=1,
cd=0,
ch=0,
pos=self.pos_o)
super().add_child(shp_box, 1, 'shp_box')
# make the shape of the piece
cut_box1 = fcfun.shp_box_dir(box_w=self.tot_w,
box_d=alusize_d + 2 * TOL,
box_h=alusize_h,
fc_axis_d=self.axis_d,
fc_axis_h=self.axis_h,
cw=1,
cd=0,
ch=0,
pos=self.get_pos_dwh(1, 0, 1))
super().add_child(cut_box1, 0, 'cut_box1')
cut_box2 = fcfun.shp_box_dir(box_w=self.tot_w,
box_d=alusize_d + 2 * TOL,
box_h=alusize_h,
fc_axis_d=self.axis_d,
fc_axis_h=self.axis_h,
cw=1,
cd=0,
ch=0,
pos=self.get_pos_dwh(6, 0, 1))
super().add_child(cut_box2, 0, 'cut_box2')
# holes to hold the profile
cut_hole1 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
l_bolt=wall_thick,
r_head=self.bolthead_r_tol,
l_head=wall_thick / 2.,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_h,
pos_n=0,
pos=self.get_pos_dwh(2, -1, 0))
super().add_child(cut_hole1, 0, 'cut_hole1')
cut_hole2 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
l_bolt=wall_thick,
r_head=self.bolthead_r_tol,
l_head=wall_thick / 2.,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_h,
pos_n=0,
pos=self.get_pos_dwh(2, 1, 0))
super().add_child(cut_hole2, 0, 'cut_hole2')
cut_hole3 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
l_bolt=wall_thick,
r_head=self.bolthead_r_tol,
l_head=wall_thick / 2.,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_h,
pos_n=0,
pos=self.get_pos_dwh(3, -1, 0))
super().add_child(cut_hole3, 0, 'cut_hole3')
cut_hole4 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
l_bolt=wall_thick,
r_head=self.bolthead_r_tol,
l_head=wall_thick / 2.,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_h,
pos_n=0,
pos=self.get_pos_dwh(3, 1, 0))
super().add_child(cut_hole4, 0, 'cut_hole4')
cut_hole5 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
l_bolt=wall_thick,
r_head=self.bolthead_r_tol,
l_head=wall_thick / 2.,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_h,
pos_n=0,
pos=self.get_pos_dwh(7, -1, 0))
super().add_child(cut_hole5, 0, 'cut_hole5')
cut_hole6 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
l_bolt=wall_thick,
r_head=self.bolthead_r_tol,
l_head=wall_thick / 2.,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_h,
pos_n=0,
pos=self.get_pos_dwh(7, 1, 0))
super().add_child(cut_hole6, 0, 'cut_hole6')
cut_hole7 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
l_bolt=wall_thick,
r_head=self.bolthead_r_tol,
l_head=wall_thick / 2.,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_h,
pos_n=0,
pos=self.get_pos_dwh(8, 1, 0))
super().add_child(cut_hole7, 0, 'cut_hole7')
cut_hole8 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
l_bolt=wall_thick,
r_head=self.bolthead_r_tol,
l_head=wall_thick / 2.,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_h,
pos_n=0,
pos=self.get_pos_dwh(8, -1, 0))
super().add_child(cut_hole8, 0, 'cut_hole8')
# holes to hold de screw
hole1 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
l_bolt=self.tot_h,
r_head=self.bolthead_r_tol,
l_head=13 * self.tot_h / 20.,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_h.negative(),
pos_n=0,
pos=self.get_pos_dwh(5, -1, 2))
super().add_child(hole1, 0, 'hole1')
hole2 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
l_bolt=self.tot_h,
r_head=self.bolthead_r_tol,
l_head=13 * self.tot_h / 20.,
xtr_head=1,
xtr_shank=1,
fc_normal=self.axis_h.negative(),
pos_n=0,
pos=self.get_pos_dwh(5, 1, 2))
super().add_child(hole2, 0, 'hole2')
super().make_parent(name)
if opt_sides == 0:
for pt_d in (0, 3, 5, 8):
for pt_w in (-2, 2):
self.shp = fcfun.shp_filletchamfer_dirpt(
self.shp,
fc_axis=self.axis_h,
fc_pt=self.get_pos_dwh(pt_d, pt_w, 1),
fillet=1,
radius=chmf_r)
else:
for pt_w in (-2, 2):
for pt_d in (0, 1, 4, 6, 9, 10):
self.shp = fcfun.shp_filletchamfer_dirpt(
self.shp,
fc_axis=self.axis_h,
fc_pt=self.get_pos_dwh(pt_d, pt_w, 2),
fillet=1,
radius=chmf_r)
# 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, 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
