def create_tabcut_program(params, remove=False, pos_nums=None, contour=False):
prog = gcode_cmd.GCodeProg()
prog.add(gcode_cmd.GenericStart())
prog.add(gcode_cmd.Space())
prog.add(gcode_cmd.FeedRate(params['finishing']['feedrate']))
safe_z = params['safe_z']
tabcut_data = get_tabcut_data(params,
remove=remove,
pos_nums=pos_nums,
contour=contour)
for data in tabcut_data:
tabcut_params = {
'centerX': data['x'],
'centerY': data['y'],
'radius': data['radius'],
'depth': data['depth'],
'startZ': data['start_z'],
'angles': data['angles'],
'safeZ': params['safe_z'],
'maxCutDepth': params['finishing']['step_size'],
'toolDiam': params['finishing']['diam_tool'],
'startDwell': params['start_dwell'],
}
arc = ArcRoutine(tabcut_params)
prog.add(arc)
prog.add(gcode_cmd.Space())
prog.add(gcode_cmd.End(), comment=True)
return prog
def create_alignment_drill(params):
prog = gcode_cmd.GCodeProg()
prog.add(gcode_cmd.GenericStart())
prog.add(gcode_cmd.Space())
prog.add(gcode_cmd.FeedRate(params['stockcut']['feedrate']))
thickness = params['stockcut']['thickness']
overcut = params['stockcut']['overcut']
drill_step = params['stockcut']['drill_step']
start_dwell = params['start_dwell']
safe_z = params['safe_z']
start_z = 0.0
param = {
'centerX': 0.0,
'centerY': 0.0,
'startZ': start_z,
'stopZ': start_z - (thickness + 2 * overcut),
'safeZ': safe_z,
'stepZ': drill_step,
'startDwell': start_dwell,
}
drill = cnc_drill.PeckDrill(param)
prog.add(drill)
prog.add(gcode_cmd.Space())
prog.add(gcode_cmd.End(), comment=True)
return prog
def createNGCFile(display=False):
standoffParam = param['standoffPocket']
motorPocketParam = param['motorPocket']
motorHoleParam = param['motorHole']
boundaryParam = param['boundaryCut']
prog = gcode_cmd.GCodeProg()
prog.add(gcode_cmd.GenericStart())
prog.add(gcode_cmd.Space())
for x0, y0 in param['partPos']:
# Standoff pockets
prog.add(gcode_cmd.Comment('-' * 60))
prog.add(
gcode_cmd.Comment('Standoff pocket, partPos = ({0}, {1})'.format(
x0, y0)))
prog.add(gcode_cmd.Comment('-' * 60))
prog.add(gcode_cmd.FeedRate(standoffParam['feedRate']))
for i in (-1, 1):
for j in (-1, 1):
x = x0 + i * 0.5 * standoffParam['holeSpacing']
y = y0 + j * 0.5 * standoffParam['holeSpacing']
pocketDict = {
'centerX': x,
'centerY': y,
'radius': 0.5 * standoffParam['holeDiam'],
'depth': standoffParam['depth'],
'startZ': standoffParam['startZ'],
'safeZ': standoffParam['safeZ'],
'overlap': standoffParam['overlap'],
'overlapFinish': standoffParam['overlapFinish'],
'maxCutDepth': standoffParam['maxCutDepth'],
'toolDiam': standoffParam['toolDiam'],
'direction': standoffParam['direction'],
'startDwell': standoffParam['startDwell'],
}
pocket = cnc_pocket.CircPocketXY(pocketDict)
prog.add(pocket)
prog.add(gcode_cmd.Space())
prog.add(gcode_cmd.End(), comment=True)
baseName, ext = os.path.splitext(__file__)
fileName = '{0}.ngc'.format(baseName)
if display:
print(prog)
else:
print('creating: {0}'.format(fileName))
prog.write(fileName)
def create_stockcut_drill(params):
prog = gcode_cmd.GCodeProg()
prog.add(gcode_cmd.GenericStart())
prog.add(gcode_cmd.Space())
prog.add(gcode_cmd.FeedRate(params['stockcut']['feedrate']))
thickness = params['stockcut']['thickness']
overcut = params['stockcut']['overcut']
diam_tool = params['stockcut']['diam_tool']
step_size = params['stockcut']['step_size']
start_dwell = params['start_dwell']
drill_step = params['stockcut']['drill_step']
drill_inset = params['stockcut']['drill_inset']
safe_z = params['safe_z']
start_z = 0.0
pocket_data = get_stockcut_pocket_data(params)
for data in pocket_data:
for i in (-1, 1):
for j in (-1, 1):
cx = data['x'] + 0.5 * data['w'] + i * (0.5 * data['w'] -
drill_inset)
cy = data['y'] + 0.5 * data['h'] + j * (0.5 * data['h'] -
drill_inset)
param = {
'centerX': cx,
'centerY': cy,
'startZ': start_z,
'stopZ': start_z - (thickness + overcut),
'safeZ': safe_z,
'stepZ': drill_step,
'startDwell': start_dwell,
}
drill = cnc_drill.PeckDrill(param)
prog.add(drill)
prog.add(gcode_cmd.Space())
prog.add(gcode_cmd.End(), comment=True)
return prog
def create_jigcut_program(params):
prog = gcode_cmd.GCodeProg()
prog.add(gcode_cmd.GenericStart())
prog.add(gcode_cmd.Space())
prog.add(gcode_cmd.FeedRate(params['stockcut']['feedrate']))
margin = params['jigcut']['margin']
depth = params['jigcut']['depth']
safe_z = params['safe_z']
step_size = params['jigcut']['step_size']
diam_tool = params['jigcut']['diam_tool']
start_dwell = params['start_dwell']
dx = params['stockcut']['cut_sheet_x'] + margin
dy = params['stockcut']['cut_sheet_y'] + margin
cx = 0.5 * dx
cy = 0.5 * dy
param = {
'centerX': cx,
'centerY': cy,
'width': dx,
'height': dy,
'depth': depth,
'startZ': 0.0,
'safeZ': safe_z,
'overlap': 0.5,
'overlapFinish': 0.5,
'maxCutDepth': step_size,
'toolDiam': diam_tool,
'cornerCut': True,
'direction': 'ccw',
'startDwell': start_dwell,
}
pocket = cnc_pocket.RectPocketXY(param)
prog.add(pocket)
prog.add(gcode_cmd.Space())
prog.add(gcode_cmd.End(), comment=True)
return prog
def create_stockcut_program(params):
prog = gcode_cmd.GCodeProg()
prog.add(gcode_cmd.GenericStart())
prog.add(gcode_cmd.Space())
prog.add(gcode_cmd.FeedRate(params['stockcut']['feedrate']))
thickness = params['stockcut']['thickness']
overcut = params['stockcut']['overcut']
diam_tool = params['stockcut']['diam_tool']
step_size = params['stockcut']['step_size']
start_dwell = params['start_dwell']
start_z = 0.0
safe_z = params['safe_z']
pocket_data = get_stockcut_pocket_data(params)
for data in pocket_data:
param = {
'centerX': data['x'] + 0.5 * data['w'],
'centerY': data['y'] + 0.5 * data['h'],
'width': data['w'],
'height': data['h'],
'depth': thickness + overcut,
'radius': None,
'startZ': start_z,
'safeZ': safe_z,
'toolDiam': diam_tool,
'cutterComp': 'outside',
'direction': 'ccw',
'maxCutDepth': step_size,
'startDwell': start_dwell,
}
boundary = cnc_boundary.RectBoundaryXY(param)
prog.add(boundary)
prog.add(gcode_cmd.Space())
prog.add(gcode_cmd.End(), comment=True)
return prog
def createNGCFile(display=False):
motorParam = param['motorDrill']
prog = gcode_cmd.GCodeProg()
prog.add(gcode_cmd.GenericStart())
prog.add(gcode_cmd.Space())
# Motor mount holes
for x0, y0 in param['partPos']:
prog.add(gcode_cmd.Comment('-' * 60))
prog.add(
gcode_cmd.Comment('Motor mount holes, partPos = ({0},{1})'.format(
x0, y0)))
prog.add(gcode_cmd.Comment('-' * 60))
prog.add(gcode_cmd.FeedRate(motorParam['feedRate']))
for i in (-1, 1):
x = x0 + i * 0.5 * motorParam['holeSpacing']
drillDict = {
'centerX': x,
'centerY': y0,
'startZ': motorParam['startZ'],
'stopZ': motorParam['stopZThru'],
'safeZ': motorParam['safeZ'],
'stepZ': motorParam['stepZ'],
'startDwell': motorParam['startDwell'],
}
drill = cnc_drill.PeckDrill(drillDict)
prog.add(drill)
prog.add(gcode_cmd.Space())
prog.add(gcode_cmd.End(), comment=True)
baseName, ext = os.path.splitext(__file__)
fileName = '{0}.ngc'.format(baseName)
if display:
print(prog)
else:
print('creating: {0}'.format(fileName))
prog.write(fileName)
def createNGCFile(display=False):
surfaceParam = param['surface']
prog = gcode_cmd.GCodeProg()
prog.add(gcode_cmd.GenericStart())
prog.add(gcode_cmd.Space())
# Standoff holes
prog.add(gcode_cmd.Comment('-' * 60))
prog.add(gcode_cmd.Comment("Surface"))
prog.add(gcode_cmd.Comment('-' * 60))
prog.add(gcode_cmd.FeedRate(surfaceParam['feedRate']))
pocket = cnc_pocket.RectPocketXY(surfaceParam)
prog.add(pocket)
prog.add(gcode_cmd.End(), comment=True)
baseName, ext = os.path.splitext(__file__)
fileName = '{0}.ngc'.format(baseName)
if display:
print(prog)
else:
print('creating: {0}'.format(fileName))
prog.write(fileName)
def create_finishing_program(params):
prog = gcode_cmd.GCodeProg()
prog.add(gcode_cmd.GenericStart())
prog.add(gcode_cmd.Space())
prog.add(gcode_cmd.FeedRate(params['finishing']['feedrate']))
pos_list = pocket_centers(params)
toolpath_params = {
'diam_sphere': params['diam_sphere'],
'diam_tool': params['finishing']['diam_tool'],
'margin': params['finishing']['margin'],
'step_size': params['finishing']['step_size'],
'tab_thickness': params['tab_thickness'],
'center_z': params['center_z'],
}
toolpath_annulus_data = ball_endmill.get_toolpath_annulus_data(
toolpath_params)
for pos in pos_list:
start_z = toolpath_annulus_data[0]['step_z'] + params['roughing'][
'margin']
routine_params = {
'centerX': pos['x'],
'centerY': pos['y'],
'startZ': start_z,
'safeZ': params['safe_z'],
'startDwell': params['start_dwell'],
'toolpathData': toolpath_annulus_data,
'direction': 'ccw',
}
routine = SphereFinishingRoutine(routine_params)
prog.add(routine)
prog.add(gcode_cmd.Space())
prog.add(gcode_cmd.End(), comment=True)
return prog
def createNGCFile(display=False):
standoffParam = param['standoffDrill']
prog = gcode_cmd.GCodeProg()
prog.add(gcode_cmd.GenericStart())
prog.add(gcode_cmd.Space())
# Standoff holes
prog.add(gcode_cmd.Comment("Standoff holes"))
prog.add(gcode_cmd.FeedRate(standoffParam['feedRate']))
for x0, y0 in param['partPos']:
for i in (-1, 1):
for j in (-1, 1):
x = x0 + i * 0.5 * standoffParam['holeSpacing']
y = y0 + j * 0.5 * standoffParam['holeSpacing']
drillDict = {
'centerX': x,
'centerY': y,
'startZ': standoffParam['startZ'],
'stopZ': standoffParam['stopZThru'],
'safeZ': standoffParam['safeZ'],
'stepZ': standoffParam['stepZ'],
'startDwell': standoffParam['startDwell'],
}
drill = cnc_drill.PeckDrill(drillDict)
prog.add(drill)
prog.add(gcode_cmd.Space())
prog.add(gcode_cmd.End(), comment=True)
baseName, ext = os.path.splitext(__file__)
fileName = '{0}.ngc'.format(baseName)
if display:
print(prog)
else:
print('creating: {0}'.format(fileName))
prog.write(fileName)
feedrate = 150.0
fileName = 'bottom_in.dxf'
finishDepth = 0.56
roughDepth = 0.5
startZ = 0.0
safeZ = 0.5
maxCutDepth = 0.05
toolDiam = 0.5
direction = 'ccw'
cutterComp = 'outside'
startDwell = 1.0
startCond = 'minX'
prog = gcode_cmd.GCodeProg()
prog.add(gcode_cmd.GenericStart())
prog.add(gcode_cmd.Space())
prog.add(gcode_cmd.FeedRate(feedrate))
prog.add(gcode_cmd.PathBlendMode(P=0.01))
roughParam = {
'fileName': fileName,
'layers': ['rough_boundary'],
'depth': roughDepth,
'startZ': startZ,
'safeZ': safeZ,
'toolDiam': toolDiam,
'direction': direction,
'cutterComp': cutterComp,
'maxCutDepth': maxCutDepth,
def create_roughing_program(params):
prog = gcode_cmd.GCodeProg()
prog.add(gcode_cmd.GenericStart())
prog.add(gcode_cmd.Space())
prog.add(gcode_cmd.FeedRate(params['roughing']['feedrate']))
pos_list = pocket_centers(params)
toolpath_params = {
'diam_sphere': params['diam_sphere'],
'diam_tool': params['roughing']['diam_tool'],
'margin': params['roughing']['margin'],
'step_size': params['roughing']['step_size'],
'tab_thickness': params['tab_thickness'],
'center_z': params['center_z'],
}
toolpath_annulus_data = flat_endmill.get_toolpath_annulus_data(
toolpath_params)
toolpath_radii = [data['radius'] for data in toolpath_annulus_data]
max_radius = max(toolpath_radii) + 0.5 * params['roughing']['diam_tool']
first_step_z = toolpath_annulus_data[0]['step_z']
for pos in pos_list:
# Remove material down to first step
annulus_params = {
'centerX': pos['x'],
'centerY': pos['y'],
'radius': max_radius,
'thickness': max_radius,
'depth': abs(first_step_z),
'startZ': 0.0,
'safeZ': params['safe_z'],
'overlap': 0.5,
'overlapFinish': 0.5,
'maxCutDepth': params['roughing']['step_size'],
'toolDiam': params['roughing']['diam_tool'],
'direction': 'ccw',
'startDwell': params['start_dwell'],
}
pocket = cnc_pocket.CircAnnulusPocketXY(annulus_params)
prog.add(pocket)
# Rough out half sphere pocket
last_step_z = first_step_z
for data in toolpath_annulus_data:
thickness = min(
max_radius, max_radius -
(data['radius'] - 0.5 * params['roughing']['diam_tool']))
if abs(thickness - params['roughing']['diam_tool']) < 1.0e-9:
thickness = params['roughing']['diam_tool']
annulus_params = {
'centerX': pos['x'],
'centerY': pos['y'],
'radius': max_radius,
'thickness': thickness,
'depth': abs(data['step_z']) - abs(last_step_z),
'startZ': last_step_z,
'safeZ': params['safe_z'],
'overlap': 0.5,
'overlapFinish': 0.5,
'maxCutDepth': params['roughing']['step_size'],
'toolDiam': params['roughing']['diam_tool'],
'direction': 'ccw',
'startDwell': params['start_dwell'],
}
pocket = cnc_pocket.CircAnnulusPocketXY(annulus_params)
prog.add(pocket)
last_step_z = data['step_z']
# Final cut at sphere boundary to remove chamfer
thickness = params['roughing']['diam_tool']
radius = 0.5 * params['diam_sphere'] + thickness
start_z = toolpath_annulus_data[-2]['step_z']
stop_z = toolpath_annulus_data[-1]['step_z']
annulus_params = {
'centerX': pos['x'],
'centerY': pos['y'],
'radius': radius,
'thickness': thickness,
'depth': abs(stop_z - start_z),
'startZ': start_z,
'safeZ': params['safe_z'],
'overlap': 0.5,
'overlapFinish': 0.5,
'maxCutDepth': params['roughing']['step_size'],
'toolDiam': params['roughing']['diam_tool'],
'direction': 'ccw',
'startDwell': params['start_dwell'],
}
pocket = cnc_pocket.CircAnnulusPocketXY(annulus_params)
prog.add(pocket)
prog.add(gcode_cmd.Space())
prog.add(gcode_cmd.End(), comment=True)
return prog
def createNGCFile(display=False):
standoffParam = param['standoffPocket']
motorPocketParam = param['motorPocket']
motorHoleParam = param['motorHole']
boundaryParam = param['boundaryCut']
prog = gcode_cmd.GCodeProg()
prog.add(gcode_cmd.GenericStart())
prog.add(gcode_cmd.Space())
for x0, y0 in param['partPos']:
# Motor pocket
prog.add(gcode_cmd.Comment('-'*60))
prog.add(gcode_cmd.Comment('Motor pocket, partPos = ({0}, {1})'.format(x0,y0)))
prog.add(gcode_cmd.Comment('-'*60))
prog.add(gcode_cmd.FeedRate(motorPocketParam['feedRate']))
pocketDict = dict(motorPocketParam)
pocketDict['centerX'] = x0
pocketDict['centerY'] = y0
pocket = cnc_pocket.CircPocketXY(pocketDict)
prog.add(pocket)
# Motor hole
prog.add(gcode_cmd.FeedRate(motorHoleParam['feedRate']))
prog.add(gcode_cmd.Comment('-'*60))
prog.add(gcode_cmd.Comment('Motor hole, partPos = ({0}, {1})'.format(x0,y0)))
prog.add(gcode_cmd.Comment('-'*60))
holeDict = dict(motorHoleParam)
holeDict['centerX'] = x0
holeDict['centerY'] = y0
pocket = cnc_pocket.CircPocketXY(holeDict)
prog.add(pocket)
# Boundary cut
prog.add(gcode_cmd.FeedRate(boundaryParam['feedRate']))
prog.add(gcode_cmd.Comment('-'*60))
prog.add(gcode_cmd.Comment('Boundary cut norm, partPos = ({0}, {1})'.format(x0,y0)))
prog.add(gcode_cmd.Comment('-'*60))
boundaryDict = dict(boundaryParam)
boundaryDict['centerX'] = x0
boundaryDict['centerY'] = y0
boundaryDict['depth'] = boundaryParam['normDepth']
boundaryDict['maxCutDepth'] = boundaryParam['normMaxCutDepth']
boundaryDict['startZ'] = boundaryParam['normStartZ']
pocket = cnc_pocket.RectAnnulusPocketXY(boundaryDict)
prog.add(pocket)
prog.add(gcode_cmd.Comment('-'*60))
prog.add(gcode_cmd.Comment('Boundary cut sep, partPos = ({0}, {1})'.format(x0,y0)))
prog.add(gcode_cmd.Comment('-'*60))
boundaryDict = dict(boundaryParam)
boundaryDict['centerX'] = x0
boundaryDict['centerY'] = y0
boundaryDict['depth'] = boundaryParam['sepDepth'] - boundaryParam['normDepth']
boundaryDict['maxCutDepth'] = boundaryParam['sepMaxCutDepth']
boundaryDict['startZ'] = -boundaryParam['normDepth']
pocket = cnc_pocket.RectAnnulusPocketXY(boundaryDict)
prog.add(pocket)
prog.add(gcode_cmd.End(),comment=True)
baseName, ext = os.path.splitext(__file__)
fileName = '{0}.ngc'.format(baseName)
if display:
print(prog)
else:
print('creating: {0}'.format(fileName))
prog.write(fileName)
y0 = -0.1
y1 = 1.7
z0 = 0
z1 = -0.3
step = 0.03
retDist = 0.1
startDwell = 2.0
coordSystem = 1
feedrate = 20.0
prog = gcode_cmd.GCodeProg()
prog.add(gcode_cmd.GenericStart(coord=coordSystem, feedrate=feedrate))
for x, sgn in zip(xList, sgnList):
if sgn == '+':
xCut = x - 0.5 * endMillDiam
xRet = x - 0.5 * endMillDiam - retDist
y0Mod, y1Mod = y1, y0
else:
xCut = x + 0.5 * endMillDiam
xRet = x + 0.5 * endMillDiam + retDist
y0Mod, y1Mod = y0, y1
print(xCut)
prog.add(gcode_cmd.Space())
