Beispiel #1
0
    def __make_y_beams(self):
        x = self.parameters['beam_width']
        y = self.parameters['y']
        z = self.parameters['z']
        y_beam = t_slotted.Extrusion(x=x, y=y, z=z)
        y_beam_tx = self.parameters['x'] / 2 - self.parameters['beam_width'] / 2
        y_beam_ty = 0
        y_beam_tz = self.x_beam_tz

        bn = t_slotted.LBracket(x=-2, y=2, z=2, extrusion_axis=[0, 1, 0])
        bn_tx = -self.parameters['beam_width'] / 2
        b_ty = self.wc_parameters['rail_rail_distance'] / 2 - 1
        b_tz = -self.parameters['z'] / 2
        bsn = po.LinearArray(bn, x=bn_tx, y=[-b_ty, b_ty], z=b_tz)

        bp = t_slotted.LBracket(x=2, y=2, z=2, extrusion_axis=[0, 1, 0])
        bp_tx = self.parameters['beam_width'] / 2
        bsp = po.LinearArray(bp, x=bp_tx, y=[-b_ty, b_ty], z=b_tz)
        y_beam |= [bsn, bsp]

        y_beams = po.LinearArray(y_beam,
                                 x=[-y_beam_tx, y_beam_tx],
                                 y=y_beam_ty,
                                 z=y_beam_tz)
        y_beams.set_color(self.parameters['color'], recursive=True)
        self.add_obj(y_beams)
Beispiel #2
0
    def __make_laser_sensor_and_mount(self):
        # Add laser sensor mount beam
        lsmb_x = 2
        lsmb_y = 1
        lsmb_z = self.parameters['sensor_mount_beam_length']
        lsmb = t_slotted.Extrusion(x=lsmb_x, y=lsmb_y, z=lsmb_z)
        lsmb_tx = self.parameters['laser_sensor_tx']
        lsmb_ty = self.parameters['beam_width'] / 2 + lsmb_y / 2
        lsmb_tz = self.x_beam_tz - lsmb_z / 2 + self.parameters['z'] / 2
        lsmb.set_color(self.parameters['color'], recursive=True)
        lsmb.translate([lsmb_tx, lsmb_ty, lsmb_tz])

        ls = laser_sensor_short_range.LaserSensorShortRange()
        ls.rotate(angle=math.pi, axis=[1, 0, 0])
        self.ls_parameters = ls.get_parameters()
        lsmp = laser_sensor_short_range_mount_plate.LaserSensorShortRangeMountPlate(
        )
        lsmp.rotate(angle=math.pi / 2, axis=[1, 0, 0])
        self.lsmp_parameters = lsmp.get_parameters()
        ls_tx = self.lsmp_parameters['lssr_tx']
        ls_ty = -self.ls_parameters['z'] / 2 - self.lsmp_parameters['z'] / 2
        ls_tz = self.lsmp_parameters['lssr_ty']
        ls.translate([ls_tx, ls_ty, ls_tz])
        ls_and_mp = ls | lsmp
        ls_and_mp_tx = lsmb_tx - self.lsmp_parameters['mount_hole_tx']
        ls_and_mp_ty = lsmb_ty - lsmb_y / 2 - self.lsmp_parameters['z'] / 2
        ls_and_mp_tz = lsmb_tz - lsmb_z / 2 + self.lsmp_parameters[
            'y'] / 2 - 0.25
        ls_and_mp.translate([ls_and_mp_tx, ls_and_mp_ty, ls_and_mp_tz])

        ls_and_mount = lsmb | ls_and_mp
        self.add_obj(ls_and_mount)

        # Add brackets
        b_x = 1
        b_y = 1
        b_z = 2

        b_tx = lsmb_x / 2
        b_ty = self.parameters['beam_width'] / 2
        b_tz = 0
        b1 = t_slotted.LBracket(x=b_x, y=b_y, z=b_z, extrusion_axis=[0, 0, 1])
        b1.translate([b_tx, b_ty, b_tz])
        b4 = t_slotted.LBracket(x=-b_x, y=b_y, z=b_z, extrusion_axis=[0, 0, 1])
        b4.translate([-b_tx, b_ty, b_tz])
        bs = b1 | b4
        bs.translate([lsmb_tx, 0, self.x_beam_tz])
        bs.set_color(self.parameters['color'], recursive=True)
        self.add_obj(bs)
Beispiel #3
0
    def __make_pillowblocks_and_plates(self):
        pb = pillowblock.PillowBlock()
        self.pb_parameters = pb.get_parameters()
        pmp = pillowblock_mount_plate.PillowblockMountPlate()
        self.pmp_parameters = pillowblock_mount_plate.get_parameters()

        self.pb_tx = self.parameters['x']/2 - self.pmp_parameters['y']/2
        pb_ax = [-self.pb_tx,self.pb_tx]
        self.wc_parameters = water_channel.get_parameters()
        pb_ty = self.wc_parameters['rail_rail_distance']/2
        pb_ay = [-pb_ty,pb_ty]
        pb_az = [0]

        self.pmp_tz = self.pb_parameters['y']/2 + self.pmp_parameters['z']/2
        pmp.translate([0,0,self.pmp_tz])
        pb_and_pmp = pb | pmp

        pbs_and_pmps = po.LinearArray(pb_and_pmp,x=pb_ax,y=pb_ay,z=pb_az)
        self.add_obj(pbs_and_pmps)

        # Add sled-sled connection brackets and beams
        bracket = t_slotted.LBracket(x=1,y=2,z=1,extrusion_axis=[0,1,0])
        bracket2 = po.LinearArray(bracket,x=0,y=[-1,1],z=0)
        beam = t_slotted.Extrusion(x=1,y=5,z=1)
        beam.translate([-0.5,0,0.5])
        b2b = bracket2 | beam
        b2bs_ax = [-self.pb_tx - 4]
        b2bs_ay = [-pb_ty, pb_ty]
        b2bs_az = [self.pmp_tz + self.pmp_parameters['z']/2]
        b2bs = po.LinearArray(b2b,b2bs_ax,b2bs_ay,b2bs_az)
        b2bs.set_color(self.parameters['color'],recursive=True)
        self.add_obj(b2bs)
Beispiel #4
0
 def __make_brackets(self):
     b = t_slotted.LBracket(x=-1, y=2, z=1, extrusion_axis=[0, 1, 0])
     b_x = self.parameters['x'] / 2 + 2
     b_y = self.wc_parameters['rail_rail_distance'] / 2 + 1
     b_z = self.x_beam_tz - self.parameters['z'] / 2
     bs = po.LinearArray(b, x=b_x, y=[-b_y, b_y], z=b_z)
     bs.set_color(self.parameters['color'], recursive=True)
     self.add_obj(bs)
Beispiel #5
0
    def __make_x_beam(self):
        beam_width = self.parameters['beam_width']
        x = self.parameters['x'] - beam_width * 2
        y = beam_width
        z = self.parameters['z']
        x_beam = t_slotted.Extrusion(x=x, y=y, z=z)
        # self.x_beam_ty = -0.375/2
        self.x_beam_ty = 0
        self.x_beam_tz = self.pmp_tz + self.pmp_parameters['z'] / 2 + z / 2

        b1 = t_slotted.LBracket(x=2, y=2, z=2, extrusion_axis=[0, 0, 1])
        b1.translate([-x / 2, beam_width / 2, 0])
        b2 = t_slotted.LBracket(x=-2, y=2, z=2, extrusion_axis=[0, 0, 1])
        b2.translate([x / 2, beam_width / 2, 0])
        b3 = t_slotted.LBracket(x=2, y=-2, z=2, extrusion_axis=[0, 0, 1])
        b3.translate([-x / 2, -beam_width / 2, 0])
        b4 = t_slotted.LBracket(x=-2, y=-2, z=2, extrusion_axis=[0, 0, 1])
        b4.translate([x / 2, -beam_width / 2, 0])
        x_beam |= [b1, b2, b3, b4]

        x_beam.translate([0, self.x_beam_ty, self.x_beam_tz])
        x_beam.set_color(self.parameters['color'], recursive=True)
        self.add_obj(x_beam)
Beispiel #6
0
    def __make_force_sensor_mount_beams(self):
        self.lcmp_parameters = loadcell_mount_plate.get_parameters()
        fsmb_x = 2
        fsmb_y = 1
        fsmb_z = self.parameters['sensor_mount_beam_length']
        fsmb = t_slotted.Extrusion(x=fsmb_x, y=fsmb_y, z=fsmb_z)
        fsmb_tx = self.aba.lcmpu_tx - self.lcmp_parameters[
            'z'] / 2 - fsmb_x / 2 - 1
        fsmb_ty = self.parameters['beam_width'] / 2 + fsmb_y / 2
        fsmb_tz = self.x_beam_tz - fsmb_z / 2 + self.parameters['z'] / 2
        fsmbs = po.LinearArray(fsmb,
                               x=fsmb_tx,
                               y=[-fsmb_ty, fsmb_ty],
                               z=fsmb_tz)
        fsmbs.set_color(self.parameters['color'], recursive=True)
        self.add_obj(fsmbs)

        # Add brackets
        b_x = 1
        b_y = 1
        b_z = 2

        b_tx = fsmb_x / 2
        b_ty = self.parameters['beam_width'] / 2
        b_tz = 0
        b1 = t_slotted.LBracket(x=b_x, y=b_y, z=b_z, extrusion_axis=[0, 0, 1])
        b1.translate([b_tx, b_ty, b_tz])
        b2 = t_slotted.LBracket(x=b_x, y=-b_y, z=b_z, extrusion_axis=[0, 0, 1])
        b2.translate([b_tx, -b_ty, b_tz])
        b3 = t_slotted.LBracket(x=-b_x,
                                y=-b_y,
                                z=b_z,
                                extrusion_axis=[0, 0, 1])
        b3.translate([-b_tx, -b_ty, b_tz])
        b4 = t_slotted.LBracket(x=-b_x, y=b_y, z=b_z, extrusion_axis=[0, 0, 1])
        b4.translate([-b_tx, b_ty, b_tz])
        bs = b1 | [b2, b3, b4]
        bs.translate([fsmb_tx, 0, self.x_beam_tz])
        bs.set_color(self.parameters['color'], recursive=True)
        self.add_obj(bs)

        # Add cross beam
        cb_x = 1
        cb_y = fsmb_ty * 2 + fsmb_y
        cb_z = 1
        cb = t_slotted.Extrusion(x=cb_x, y=cb_y, z=cb_z)
        cb_tx = fsmb_tx + fsmb_x / 2 + cb_x / 2
        cb_ty = 0
        # cb_tz = fsmb_tz - fsmb_z/2 + cb_z/2
        cb_tz = self.aba.lcmpu_tz - 0.125
        cb.translate([cb_tx, cb_ty, cb_tz])
        cb.set_color(self.parameters['color'])
        self.add_obj(cb)

        # Add first set of cross beam brackets
        b = t_slotted.LBracket(x=1, y=1, z=1, extrusion_axis=[0, 1, 0])
        b_tx = 0
        b_ty = cb_y / 2 - 0.5
        b_tz = 0
        bs = po.LinearArray(b, x=b_tx, y=[-b_ty, b_ty], z=b_tz)
        bs_tx = cb_tx - 0.5
        bs_ty = cb_ty
        bs_tz = cb_tz + 0.5
        bs.translate([bs_tx, bs_ty, bs_tz])
        bs.set_color(self.parameters['color'], recursive=True)
        self.add_obj(bs)

        # Add second set of cross beam brackets
        b_tx = bs_tx
        b_ty = b_ty - 0.5
        b_tz = bs_tz - 0.5
        b1 = t_slotted.LBracket(x=-1, y=-1, z=1, extrusion_axis=[0, 0, 1])
        b1.translate([b_tx, b_ty, b_tz])
        b1.set_color(self.parameters['color'], recursive=True)
        b2 = t_slotted.LBracket(x=-1, y=1, z=1, extrusion_axis=[0, 0, 1])
        b2.translate([b_tx, -b_ty, b_tz])
        b2.set_color(self.parameters['color'], recursive=True)
        self.add_obj([b1, b2])
Beispiel #7
0
    def __make_brackets(self):
        # Front and back sets
        bracket_tx = 0
        bracket_ty = self.ab_parameters['slide_width']/2 - 1
        bracket_tz = (self.parameters['y_beam_separation'] - 1)/2
        bracket1 = t_slotted.LBracket(x=1,y=1,z=1,extrusion_axis=[1,0,0])
        bracket1.translate([bracket_tx,-bracket_ty,-bracket_tz])
        bracket2 = t_slotted.LBracket(x=1,y=-1,z=1,extrusion_axis=[1,0,0])
        bracket2.translate([bracket_tx,bracket_ty,-bracket_tz])
        bracket3 = t_slotted.LBracket(x=1,y=-1,z=-1,extrusion_axis=[1,0,0])
        bracket3.translate([bracket_tx,bracket_ty,bracket_tz])
        bracket4 = t_slotted.LBracket(x=1,y=1,z=-1,extrusion_axis=[1,0,0])
        bracket4.translate([bracket_tx,-bracket_ty,bracket_tz])
        brackets = bracket1 | [bracket2,bracket3,bracket4]
        brackets_tx = self.slider_holes_tx
        brackets_ty = 0
        brackets_tz = self.z_beam_tz
        brackets = po.LinearArray(brackets,x=[-brackets_tx,brackets_tx],y=brackets_ty,z=brackets_tz)
        brackets.set_color(self.parameters['color'],recursive=True)
        self.add_obj(brackets)

        # Left and right sets
        bracket_tx = (self.slider_holes_tx*2 - 1)/2
        bracket_ty = 0
        bracket_tz = (self.parameters['y_beam_separation'] - 2)/2
        bracket1 = t_slotted.LBracket(x=1,y=1,z=1,extrusion_axis=[0,1,0])
        bracket1.translate([-bracket_tx,bracket_ty,-bracket_tz])
        bracket2 = t_slotted.LBracket(x=1,y=1,z=-1,extrusion_axis=[0,1,0])
        bracket2.translate([-bracket_tx,bracket_ty,bracket_tz])
        bracket3 = t_slotted.LBracket(x=-1,y=1,z=-1,extrusion_axis=[0,1,0])
        bracket3.translate([bracket_tx,bracket_ty,bracket_tz])
        bracket4 = t_slotted.LBracket(x=-1,y=1,z=1,extrusion_axis=[0,1,0])
        bracket4.translate([bracket_tx,bracket_ty,-bracket_tz])
        brackets = bracket1 | [bracket2,bracket3,bracket4]
        brackets_tx = 0
        brackets_ty = self.ab_parameters['slide_width']/2 - 0.5
        brackets_tz = self.z_beam_tz - 0.5
        brackets = po.LinearArray(brackets,x=brackets_tx,y=[-brackets_ty,brackets_ty],z=brackets_tz)
        brackets.set_color(self.parameters['color'],recursive=True)
        self.add_obj(brackets)

        # Bottom set
        bracket_tx = (self.slider_holes_tx*2 - 1)/2
        bracket_ty = self.ab_parameters['slide_width']/2 - 1
        bracket_tz = 0
        bracket1 = t_slotted.LBracket(x=1,y=1,z=1,extrusion_axis=[0,0,1])
        bracket1.translate([-bracket_tx,-bracket_ty,bracket_tz])
        bracket2 = t_slotted.LBracket(x=1,y=-1,z=1,extrusion_axis=[0,0,1])
        bracket2.translate([-bracket_tx,bracket_ty,bracket_tz])
        bracket3 = t_slotted.LBracket(x=-1,y=-1,z=1,extrusion_axis=[0,0,1])
        bracket3.translate([bracket_tx,bracket_ty,bracket_tz])
        bracket4 = t_slotted.LBracket(x=-1,y=1,z=1,extrusion_axis=[0,0,1])
        bracket4.translate([bracket_tx,-bracket_ty,bracket_tz])
        brackets = bracket1 | [bracket2,bracket3,bracket4]
        brackets_tx = 0
        brackets_ty = 0
        brackets_tz = self.x_beam_tz
        brackets.translate([brackets_tx,brackets_ty,brackets_tz])
        brackets.set_color(self.parameters['color'],recursive=True)
        self.add_obj(brackets)

        # Submersible mount beam brackets
        bracket_tx = 0.5
        bracket_ty = 0
        bracket_tz = (self.parameters['y_beam_separation'] - 2)/2
        bracket1 = t_slotted.LBracket(x=1,y=1,z=1,extrusion_axis=[0,1,0])
        bracket1.translate([bracket_tx,bracket_ty,-bracket_tz])
        bracket2 = t_slotted.LBracket(x=1,y=1,z=-1,extrusion_axis=[0,1,0])
        bracket2.translate([bracket_tx,bracket_ty,bracket_tz])
        bracket3 = t_slotted.LBracket(x=-1,y=1,z=-1,extrusion_axis=[0,1,0])
        bracket3.translate([-bracket_tx,bracket_ty,bracket_tz])
        bracket4 = t_slotted.LBracket(x=-1,y=1,z=1,extrusion_axis=[0,1,0])
        bracket4.translate([-bracket_tx,bracket_ty,-bracket_tz])
        brackets = bracket1 | [bracket2,bracket3,bracket4]
        brackets_tx = 0
        brackets_ty = self.ab_parameters['slide_width']/2 - 0.5
        brackets_tz = self.z_beam_tz - 0.5
        brackets = po.LinearArray(brackets,x=brackets_tx,y=[-brackets_ty,brackets_ty],z=brackets_tz)
        brackets.translate([self.smb_tx,0,0])
        brackets.set_color(self.parameters['color'],recursive=True)
        self.add_obj(brackets)