From 0d2eff8804685cc6d6aaf0a903b2e39fb0088735 Mon Sep 17 00:00:00 2001 From: Kelvin Ly Date: Thu, 5 Dec 2024 22:53:39 -0500 Subject: [PATCH] Adjust some stuff; almost have the z axis ballscrew where I want it to be; TODO move it further up, figure out spacer and mount situation --- gantry.py | 391 +++++++++++++++++++++++++++++++++++++++++------------- 1 file changed, 301 insertions(+), 90 deletions(-) diff --git a/gantry.py b/gantry.py index 5253b0c..6854420 100644 --- a/gantry.py +++ b/gantry.py @@ -6,15 +6,26 @@ import localselectors tube_w = inch(2.0) tube_h = inch(1.5) -tube_wall = inch(0.075) # 1.519 #inch(0.062) -column_spacing = 500 +tube_wall = inch(0.075) # 1.519 #inch(0.062) +column_spacing = 560 column_h = 400 plate_z = 2.54 plate_z2 = 10 +x_mount_z = 5 + +ballscrew_x_offset = 4 + +ballscrew_len = 500 +column_spacing = ( + ballscrew_len - 15 - 39 + 25 - 10 + 7 / 2 + 20 / 2 + 2 * x_mount_z + tube_w +) +print("column_spacing = ", column_spacing) + x_rail_spacing = 240 x_carriage_spacing = 120 + class Gantry: def __init__(self, w): self.left = tubing( @@ -22,20 +33,26 @@ class Gantry: tube_w, tube_h, tube_wall, - w.transformed(offset=(-0.5*column_spacing, 0, 0))) + w.transformed(offset=(-0.5 * column_spacing, 0, 0)), + ) self.right = tubing( column_h, tube_w, tube_h, tube_wall, - w.transformed(offset=(0.5*column_spacing, 0, 0))) - upper_center = column_h - 0.5*tube_w + w.transformed(offset=(0.5 * column_spacing, 0, 0)), + ) + upper_center = column_h - 0.5 * tube_w self.upper = tubing( column_spacing - tube_w, tube_h, tube_w, tube_wall, - w.transformed(offset=(-0.5*column_spacing+0.5*tube_w, 0, upper_center), rotate=(90, 90, 0))) + w.transformed( + offset=(-0.5 * column_spacing + 0.5 * tube_w, 0, upper_center), + rotate=(90, 90, 0), + ), + ) lower_center = upper_center - x_rail_spacing self.lower = tubing( column_spacing - tube_w, @@ -43,39 +60,68 @@ class Gantry: tube_w, tube_wall, w.transformed( - offset=( - -0.5*column_spacing+0.5*tube_w, - 0, - lower_center), rotate=(90, 90, 0))) + offset=(-0.5 * column_spacing + 0.5 * tube_w, 0, lower_center), + rotate=(90, 90, 0), + ), + ) self.upper_rail = HGR20( w.transformed( - offset=(0, 0.5*tube_h + plate_z, upper_center), - rotate=(-90, 0, 0) - ), column_spacing + tube_w) + offset=(0, 0.5 * tube_h + plate_z, upper_center), rotate=(-90, 0, 0) + ), + column_spacing + tube_w, + ) self.lower_rail = HGR20( w.transformed( - offset=(0, 0.5*tube_h + plate_z, lower_center), - rotate=(-90, 0, 0) - ), column_spacing + tube_w) + offset=(0, 0.5 * tube_h + plate_z, lower_center), rotate=(-90, 0, 0) + ), + column_spacing + tube_w, + ) self.upper_front_plate = ( - w.transformed(offset=(0, tube_h/2, upper_center), rotate=(-90, 0, 0)) - .rect(column_spacing + tube_w, tube_w) - .extrude(plate_z) + w.transformed(offset=(0, tube_h / 2, upper_center), rotate=(-90, 0, 0)) + .rect(column_spacing + tube_w, tube_w) + .extrude(plate_z) ) self.lower_front_plate = ( - w.transformed(offset=(0, tube_h/2, lower_center), rotate=(-90, 0, 0)) - .rect(column_spacing + tube_w, tube_w) - .extrude(plate_z) + w.transformed(offset=(0, tube_h / 2, lower_center), rotate=(-90, 0, 0)) + .rect(column_spacing + tube_w, tube_w) + .extrude(plate_z) ) self.upper_back_plate = ( - w.transformed(offset=(0, -tube_h/2, upper_center), rotate=(90, 0, 0)) - .rect(column_spacing + tube_w, tube_w) - .extrude(plate_z) + w.transformed(offset=(0, -tube_h / 2, upper_center), rotate=(90, 0, 0)) + .rect(column_spacing + tube_w, tube_w) + .extrude(plate_z) ) self.lower_back_plate = ( - w.transformed(offset=(0, -tube_h/2, lower_center), rotate=(90, 0, 0)) - .rect(column_spacing + tube_w, tube_w) - .extrude(plate_z) + w.transformed(offset=(0, -tube_h / 2, lower_center), rotate=(90, 0, 0)) + .rect(column_spacing + tube_w, tube_w) + .extrude(plate_z) + ) + self.ball_screw_w = w.transformed( + offset=( + ballscrew_len / 2 - (-15 - 39 + 25 + 10 - 7 / 2 - 20 / 2) / 2, + ballscrew_x_offset, + (upper_center + lower_center) / 2, + ), + rotate=(0, 0, 90), + ).transformed(rotate=(0, 90, 0)) + self.ball_screw_model = SFU1204(self.ball_screw_w, ballscrew_len) + self.floating_mount_w = self.ball_screw_w.transformed( + offset=(0, ballscrew_len + (-10 + 7 / 2 + 20 / 2), 0), rotate=(-90, 0, 0) + ) + + self.ball_screw = self.ball_screw_model.ballscrew() + self.fixed_bearing = self.ball_screw_model.fixedBearing() + self.floating_bearing = self.ball_screw_model.floatingBearing() + + self.left = self.ball_screw_model.floatingBearingHoles(self.left) + self.right = self.ball_screw_model.fixedBearingHoles(self.right) + self.right = ( + self.right + # holes for the ball screw + .copyWorkplane(self.ball_screw_w.transformed(rotate=(90, 0, 0))) + .hole(20) + .copyWorkplane(self.ball_screw_w.transformed(rotate=(-90, 0, 0))) + .hole(20) ) self.upper_front_plate = self.upper_rail.holes(self.upper_front_plate) @@ -84,66 +130,118 @@ class Gantry: self.lower_front_plate = self.lower_rail.holes(self.lower_front_plate) self.lower_back_plate = self.lower_rail.holes(self.lower_back_plate) - def assembly(self): - return (cq.Assembly(name="gantry") - .add(self.left, name="left column") - .add(self.right, name="right column") - .add(self.upper, name="upper platform") - .add(self.lower, name="lower platform") - .add(self.upper_rail.rail(), name="upper rail") - .add(self.lower_rail.rail(), name="lower rail") - .add(self.upper_front_plate, name="upper front plate") - .add(self.lower_front_plate, name="lower front plate") - .add(self.upper_back_plate, name="upper back plate") - .add(self.lower_back_plate, name="lower back plate") + right_bearing_base = ( + self.ball_screw_w.transformed(offset=(0, 0, -ballscrew_x_offset)) + .transformed(rotate=(-90, 0, 0)) + .transformed(offset=(0, 0, 15 + 39 - 25 - x_mount_z)) + .transformed(rotate=(0, 0, 90)) ) - #assembly.test = 7 -z_rail_spacing = 120 + self.right_bearing_mount = ( + w.copyWorkplane(right_bearing_base) + .rect(tube_h, x_rail_spacing - tube_w) + .extrude(x_mount_z) + .copyWorkplane(right_bearing_base) + .center(-4, 0) + .rect(35, 35) + .extrude(20, combine="s") + ) + self.right_bearing_mount = self.ball_screw_model.fixedBearingHoles( + self.right_bearing_mount + ) + self.left_bearing_mount = ( + w.copyWorkplane(self.floating_mount_w) + .transformed(offset=(0, ballscrew_x_offset, 0), rotate=(0, 0, 90)) + .rect(tube_h, x_rail_spacing - tube_w) + .extrude(x_mount_z) + ) + + def assembly(self): + return ( + cq.Assembly(name="gantry") + .add(self.left, name="left column") + .add(self.right, name="right column") + .add(self.upper, name="upper platform") + .add(self.lower, name="lower platform") + .add(self.upper_rail.rail(), name="upper rail") + .add(self.lower_rail.rail(), name="lower rail") + .add(self.upper_front_plate, name="upper front plate") + .add(self.lower_front_plate, name="lower front plate") + .add(self.upper_back_plate, name="upper back plate") + .add(self.lower_back_plate, name="lower back plate") + .add(self.ball_screw, name="ball screw") + .add(self.fixed_bearing, name="fixed bearing") + .add(self.floating_bearing, name="floating bearing") + .add(self.right_bearing_mount, name="fixed bearing mount") + .add(self.left_bearing_mount, name="floating bearing mount") + ) + + +z_rail_spacing = 110 z_carriage_spacing = 100 -z_rail_len = 450 +z_rail_len = 400 carriage_w = 250 carriage_h = 300 bolster_w = 30 bolster_z = 25 + +z_spacer_z = 10 +z_spacer_w = 40 + +z_ballscrew_len = 400 +z_ballscrew_offset = 0 + + class Carriage: def __init__(self, gantry, x=0, z=0): + self.z = z + self.bul = gantry.upper_rail.carriage(x) - self.bur = gantry.upper_rail.carriage(x+x_carriage_spacing) + self.bur = gantry.upper_rail.carriage(x + x_carriage_spacing) self.bll = gantry.lower_rail.carriage(x) - self.blr = gantry.lower_rail.carriage(x+x_carriage_spacing) - back = cq.Workplane("XZ").copyWorkplane(self.bul.workplaneFromTagged("mountingholes")) + self.blr = gantry.lower_rail.carriage(x + x_carriage_spacing) + back = cq.Workplane("XZ").copyWorkplane( + self.bul.workplaneFromTagged("mountingholes") + ) # why doesn't this track the carriage without me adding x to it? - self.plate = (back.center(-x-HGR20.L-x_carriage_spacing/2, -x_rail_spacing/2) - #.rect(HGR20.L+x_carriage_spacing, HGR20.W+x_rail_spacing) - .rect(carriage_w, carriage_h) - .extrude(plate_z2) - .faces(">z") # localselectors plugin - .workplane() - .tag("carriage_plate") - ) + self.plate = ( + cq.Workplane() + .copyWorkplane(back) + .center(-x - HGR20.L - x_carriage_spacing / 2, -x_rail_spacing / 2) + # .rect(HGR20.L+x_carriage_spacing, HGR20.W+x_rail_spacing) + .rect(carriage_w, carriage_h) + .extrude(plate_z2) + .faces(">z") # localselectors plugin + .workplane() + .tag("carriage_plate") + ) self.plate = gantry.upper_rail.carriageHoles(self.plate, x) - self.plate = gantry.upper_rail.carriageHoles(self.plate, x+x_carriage_spacing) + self.plate = gantry.upper_rail.carriageHoles(self.plate, x + x_carriage_spacing) self.plate = gantry.lower_rail.carriageHoles(self.plate, x) - self.plate = gantry.lower_rail.carriageHoles(self.plate, x+x_carriage_spacing) - + self.plate = gantry.lower_rail.carriageHoles(self.plate, x + x_carriage_spacing) + # creating the workplane the rails of the spindle carrier # mount to, because HGR works from that plane forward - self.carrier_plane = (cq.Workplane() + self.carrier_plane = ( + cq.Workplane() .copyWorkplane(self.plate.workplaneFromTagged("carriage_plate")) .transformed(offset=(0, 0, HGR20.H), rotate=(180, 0, 0)) - ) - - self.left_rail = HGR20( - self.carrier_plane. - transformed(offset=(z_rail_spacing/2, z, 0), rotate=(0, 0, 90)), - z_rail_len) - self.right_rail = HGR20( - self.carrier_plane. - transformed(offset=(-z_rail_spacing/2, z, 0), rotate=(0, 0, 90)), - z_rail_len) + ) - u_zcarriage_pos = z_rail_len/2 - HGR20.L/2 -z - z_carriage_spacing/2 + self.left_rail = HGR20( + self.carrier_plane.transformed( + offset=(z_rail_spacing / 2, z, 0), rotate=(0, 0, 90) + ), + z_rail_len, + ) + self.right_rail = HGR20( + self.carrier_plane.transformed( + offset=(-z_rail_spacing / 2, z, 0), rotate=(0, 0, 90) + ), + z_rail_len, + ) + + u_zcarriage_pos = z_rail_len / 2 - HGR20.L / 2 - z - z_carriage_spacing / 2 l_zcarriage_pos = u_zcarriage_pos + z_carriage_spacing self.ful = self.left_rail.carriage(u_zcarriage_pos) self.fll = self.left_rail.carriage(l_zcarriage_pos) @@ -154,28 +252,46 @@ class Carriage: self.plate = self.left_rail.carriageHoles(self.plate, l_zcarriage_pos) self.plate = self.right_rail.carriageHoles(self.plate, u_zcarriage_pos) self.plate = self.right_rail.carriageHoles(self.plate, l_zcarriage_pos) - - self.lbolster = (cq.Workplane() + + self.ball_nut = gantry.ball_screw_model.nut(x + carriage_w / 2) + + self.lbolster = ( + cq.Workplane() .copyWorkplane(self.plate.workplaneFromTagged("carriage_plate")) - .transformed(offset=(-(carriage_w - bolster_w)/2, 0, 0)) + .transformed(offset=(-(carriage_w - bolster_w) / 2, 0, 0)) .rect(bolster_w, carriage_h) .extrude(bolster_z) ) - self.rbolster = (cq.Workplane() + self.rbolster = ( + cq.Workplane() .copyWorkplane(self.plate.workplaneFromTagged("carriage_plate")) - .transformed(offset=((carriage_w - bolster_w)/2, 0, 0)) + .transformed(offset=((carriage_w - bolster_w) / 2, 0, 0)) .rect(bolster_w, carriage_h) .extrude(bolster_z) ) # TODO add bolster mounting holes - self.wp_carrier = (cq.Workplane() + self.wp_carrier = ( + cq.Workplane() .copyWorkplane(self.plate.workplaneFromTagged("carriage_plate")) .transformed(offset=(0, -z, HGR20.H), rotate=(0, 0, 0)) - ) - + ) + self.x_nut_mount = ( + cq.Workplane() + .copyWorkplane(back) + .center(-x - HGR20.L - x_carriage_spacing / 2, -x_rail_spacing / 2) + .transformed(rotate=(180, 0, 0)) + .rect(60, 60) + .extrude(64) + ) + + # these are filled in by the carrier + self.z_nut_mount = None + self.z_nut = None + def assembly(self): - return (cq.Assembly(name="x carriage") + assmbly = ( + cq.Assembly(name="x carriage") .add(self.bul, name="back ul carriage") .add(self.bur, name="back ur carriage") .add(self.bll, name="back ll carriage") @@ -188,35 +304,130 @@ class Carriage: .add(self.fll, name="front ll carriage") .add(self.flr, name="front lr carriage") .add(self.lbolster, name="left bolster") - .add(self.lbolster, name="right bolster") + .add(self.rbolster, name="right bolster") + .add(self.ball_nut, name="ball nut") + .add(self.x_nut_mount, name="x nut mount") ) + if self.z_nut_mount is not None: + assmbly = assmbly.add(self.z_nut_mount, name="z nut mount") + if self.z_nut is not None: + assmbly = assmbly.add(self.z_nut, name="z nut") + return assmbly + class Carrier: def __init__(self, carriage): self.plane = carriage.wp_carrier - self.plate = (cq.Workplane() + self.left_spacer = ( + cq.Workplane() .copyWorkplane(self.plane) + .transformed(offset=(z_rail_spacing / 2, 0, 0)) + .rect(z_spacer_w, z_rail_len) + .extrude(z_spacer_z) + ) + self.right_spacer = ( + cq.Workplane() + .copyWorkplane(self.plane) + .transformed(offset=(-z_rail_spacing / 2, 0, 0)) + .rect(z_spacer_w, z_rail_len) + .extrude(z_spacer_z) + ) + + self.plate = ( + cq.Workplane() + .copyWorkplane(self.plane) + .transformed(offset=(0, 0, z_spacer_z)) .rect(200, z_rail_len) - .extrude(10)) + .extrude(10) + ) self.plate = carriage.left_rail.holes(self.plate) self.plate = carriage.right_rail.holes(self.plate) - + self.left_spacer = carriage.left_rail.holes(self.left_spacer) + self.right_spacer = carriage.right_rail.holes(self.right_spacer) + + self.ballscrew_model = SFU1204( + self.plane.transformed( + offset=( + 0, + z_ballscrew_len / 2, + # 25, + z_spacer_z - 25 + 5, # offset into the spindle plate 5mm + ), # -(HGR20.H - z_spacer_z) / 2 - 1.2), + rotate=(180, 0, 0), + ), + z_ballscrew_len, + ) + self.ballscrew = self.ballscrew_model.ballscrew() + self.fixed_bearing = self.ballscrew_model.fixedBearing() + self.floating_bearing = self.ballscrew_model.floatingBearing() + + carriage.z_nut = self.ballscrew_model.nut(z_ballscrew_len / 2 + carriage.z) + # TODO add carriage nut mount to carriage + def assembly(self): - return (cq.Assembly(name="z carrier") - .add(self.plate, name="z plate")) + return ( + cq.Assembly(name="z carrier") + .add(self.left_spacer, name="left spacer") + .add(self.right_spacer, name="right spacer") + .add(self.plate, name="z plate") + .add(self.ballscrew, name="z ballscrew") + .add(self.fixed_bearing, name="z fixed bearing") + .add(self.floating_bearing, name="z floating bearing") + ) + + +class SpindleMount: + def __init__(self, carrier, z_offset=0): + self.plane = ( + carrier.plane.transformed(offset=(0, z_offset, z_spacer_z + 10)) + .transformed(rotate=(-90, 0, 0)) + .transformed(rotate=(0, 0, 180)) + ) + self.spindleaxis = cq.Workplane().copyWorkplane(self.plane).center(0, 54) + self.mount = ( + cq.Workplane() + .copyWorkplane(self.plane) + .hLineTo(184 / 2) + .vLineTo(17) + .hLineTo(113 / 2) + .vLineTo(82) + .hLineTo(-113 / 2) + .vLineTo(17) + .hLineTo(-184 / 2) + .vLineTo(0) + .close() + .extrude(78) + .copyWorkplane(self.spindleaxis) + .cylinder(78, 104 / 2, angle=180, centered=[True, True, False]) + .copyWorkplane(self.spindleaxis) + .cylinder(78, 80 / 2, centered=[True, True, False], combine="s") + ) + + def mounting_holes(self, w): + # TODO + pass + + def assembly(self): + return cq.Assembly(name="spindle motor mount").add(self.mount, name="mount") + + g = Gantry(cq.Workplane()) -c = Carriage(g, 150, 0) +c = Carriage(g, 150, -50) ca = Carrier(c) +m = SpindleMount(ca, -200) # TODO add ball screws and associated assembly -full_assmbly = (cq.Assembly() +full_assembly = ( + cq.Assembly() .add(g.assembly(), name="gantry") .add(c.assembly(), name="carriage") .add(ca.assembly(), name="carrier") + .add(m.assembly(), name="spindle mount") ) -show_object(full_assmbly) -#show_object(ca.assembly()) -#show_object(c.assembly()) -#show_object(g.assembly()) \ No newline at end of file +show_object(full_assembly) +# show_object(ca.assembly()) +# show_object(c.assembly()) +# show_object(g.assembly()) +