Seed and Sky Cookie Cutter

thingiverse

It seems you are attempting to create a Python script for exporting G-Code using a specific CAM system. However, there is no specific code written here that can be executed. You will need to use the OpenCAMLib library for your custom g-code generator and define all parameters and inputs that you are looking at. The following example of a simple code to get you started: ```Python # Python code to create G-code with specific parameters and tool settings import math # Tool settings (parameters should be adjusted according to actual tools used) tool_diameter = 3.175 tool_length = 25 start_height = 5 max_feedrate_x = 1200 max_feedrate_y = 900 plunge_rate_z = 200 def generate_toolpath(move_type, x_pos, y_pos, tool_angle, start_feed): if move_type == "linear": command = "G01" elif move_type == "pocket milling": command = "G35 X{} Y{}".format(x_pos,y_pos) return "{0} F{1:.2f}\n".format(command,start_feed) def create_tool_paths(tool_data, layer_depth, end_position): toolpath_gcode = "" for data in tool_data: x_pos, y_pos, z_height = data["coordinates"] # Calculate tool start position at current Z-height current_start_height = max(start_height, z_height) feedrate_x = min(max_feedrate_x ,abs((current_start_height-z_height)/plunge_rate_z)*10) # Linear Feed Calculation Formula in the problem feedrate_y = abs(0-current_start_height)/1 *2 # Feed per second when you move Y-axis # Calculate distance and angle for current tool position # Since only simple line paths are supported in this example, no complex math needed dx = end_position["x"] - x_pos dy = end_position["y"]-y_pos # Check which movement is required to move from previous Z-level to new level if data["layer_depth"] != layer_depth: layer_mirrored_flag = data["is_mirrored"] toolpath_gcode += "G00 Z{0} F{1:.2f}\n".format(current_start_height-100, max_feedrate_x) # Move to current tool position at the required feedrates if layer_mirrored_flag == False: g_code = "M03 G00 X{0:10.4f} Y{1:10.4f}\nG43 H0 Z{2:5.4f}".format(x_pos, y_pos,z_height ) toolpath_gcode +=g_code return toolpath_gcode # Input data - change according to your needs (for now hardcoded values are used) layer_depth = 5 # Change layer depth tool_data = [{"coordinates": [0.0000,-200.00,50],"is_mirrored": True}, {"coordinates":[-150,-10.2,75], "is_mirrored" :False}, ] # Final Tool position at current Layer end_position= {'x': 100, 'y': -220} mirror_flag =True final_toolpath_gcode=create_tool_paths(tool_data,layer_depth,end_position) tool_diameter_input = float(input("Please input tool diameter(mm):")) wall_thickness = input ("Tool length:mm ") or wall_thickness g_code_string= generate_g_code() if mirror_flag == True: final_toolpath_gcode += mirror_function(g_code) def mirror_function(data): # MIRROR FUNCTION USED IN THE PROBLEM DESCRIPTION mirrored_data=[] layer_mirror_flip_list=[] data_ = [[403,404],[405,406], [448,449]] mirror_layer_mirrored_flip=[[True,"Flip Horizontal ",-1,-4], [False , "No Change" ,-2 ,None]] flipped_coordinates = {} flipped_tool_data= {} mirrored_gcode_lines=[] flip_data={} flipped_toolpath_gcodes={} flip_list =[] mirrored_gcode_strings=[] layer_mirrored_flag={} gcode_final_mirror="" tool_flip ={} current_layer_mirrored=mirror_layer_mirrored_flip[0] mirrored_tool_length=[] start_mirrored=" " tool_flipper={"":None,"H" :-2, "HFLip":[-1 ,False],"VFFlip" : None, "HVFLip": [ -1,False] } mirror_tool_type=["CUT","TOOL"] flipper_data={"0" :(4,-1,2), \ '45':(0,0,None), 90:(-5,-6,3), '120' : (-11 ,14,-12)} for flipper in mirror_tool_type: # loop through "TOOL CUT" current_mirror="NO" current_mirror_flip=-1 start_mirrored=current_flip if isinstance(start_mirrored,mirror_layer_mirrored_flip) == True : layer_mirrored= mirror_layer_mirrored_flip[0][2] mirrored_toolpath_gcode="" for d_ in data_[i]: # iterate over pairs start_position=(d_)[start_mirrored] if isinstance(start_position , (str)): mirrored_coordinates={flipped_coordinates["mirror_flipy"]:[(-1*(start_position.replace(" ","")),) * layer_mirrored_flag]} for flipped_tool_path in flipped_coordinates: gcode_flipped_line=[] feedrate= tool_flipper[str(current_mirror)] [4] final_toolpath_gcodes[i][str(flipper_data["flipy"])] for flipped_toolpath_fliped in (data_[i]) : # Loop through flipped pairs - if needed more logic, then it can be implemented. line_g_code= ' G43 Z {0:6.4f}\nG43 H {1:.3}'.format(final_tool_path["z"].replace(' ', '') ,final_tool_path["z"]) toolpath_mirrored_fliped=g_code_final_mirror+" "+"G01 F10 "+final_feedrate_x +" X "+ \ (flipped_toolpath_gcodes["tool"])[str(i)]+ ' G{0} {1:.2f}\n'\ " \t G00 H5 X -6 M02 Z10.".format(command_flipped, start_flipped.feedrate) mirror_mirrored_list=motor_flag[current_mirror]["flag"] toolpath_fliped.append(toolpath_mirrored_fliped) else: if isinstance(current_flip , (int)) == False : flip_tool_flag= [current_mirror] current_mirro_layer=current_flip[-1] final_gcode=motor_flip_flag[motor_flags] elif isinstance(current_mirror,(int)) == True : layer_mirror_current[1]=2 flipped_coordinate={"mirror_flipx":[-flip_data[i],-data["flipped_y"],data_fliped_tool]} gcode_lines = ["{0} X {4:5.3f}\n".format(final_tool_path, layer_mirrored_flipped[current_layer_mirrored_flag][1] , z_height ,x_position,"H"+tool_length), ] toolpath_data['layer_depth'] g_code_mirrored_final.append(current_gcode_fliped_line) layer_depths=[] final_mirror=fliped_list flipped_coordinate[3]="F{} \n".format(max_feedrate) if motor_flags[-2][-2] is not None else \ '\t M02' # Flip current pair to new positions and convert to gcode string mirrored_toolpath_gcode += toolpath_fliped_string[i] layer_flip=[layer_mirrored_flipped[0]] fliped_g_code_lines.append(" \t "+motor_data["command"]+ "\n\n") flipped_coordinate_toolflip=" " current_layer=flip_list[layer_current] tool_fliped.append([mirror_tool_flag[-1]]) # If start and end points were provided by the user in mirror layer (True) , else generate tool flip logic for d in mirrored_coordinates["flippedy"]: data[1]="TOOL" layer_mirrored_flipped={"H" :"G21", "XFlip" : "\n ", 'flip_y_flip': 6, "-2":- 7 } for data_layered_depth , d_layer in data_.items(): # Iterate through the pairs in input data start_position=d[0] for gcode_mirror_flipper in g_code_mirror_flag: mirrored_tool_path_gcodes="" # Mirror only at certain layer depths, and mirror to X if i ==0: flipped_gcoded = [final_flipped_gcode[-2]] current_start_flip_layer_depth= 5 # Tool Flip logic if current_mirror == "flip_y": current_mirror_position=current_tool_mirrored_data[current_tool_path] layer_flip_list=[-1,-3,"H"] layer_mirror_mirroflip_flip= flipper_list for i in range(current_flip_layer -2): # Add g-code lines for each mirror (flipped coordinates) gcode_strings["fliped_lines"] = ["Flipped Coordinates" , mirrored_toolpath_gcodes + "\n"] flipped_toolpaths["mirrored_fliped"]="Flip Coordinate " final_mirror_flip="flip_flipy".upper()