cad-cam

## What I do - Create 3D geometric models using CAD software - Generate CNC toolpaths for manufacturing - Program CNC machines using G-code and CAM software - Design for additive manufacturing (3D printing) - Perform toolpath simulation and verification - Optimize machining parameters for efficiency - Convert CAD models to manufacturing formats - Verify tool collision and machine limits ## When to use me When creating 3D models, generating CNC toolpaths, programming CNC machines, or designing parts for additive manufacturing. ## Core Concepts - Solid modeling (CSG, B-rep) - Surface modeling and NURBS - Feature-based modeling - Toolpath strategies (contour, pocketing, drilling) - CNC programming (G-code, M-code) - Feed and speed calculations - Tool geometry and compensation - Additive manufacturing processes (FDM, SLA, SLS) - Build orientation and support generation - Post-processing for different machine controllers ## Code Examples ### G-Code Generation ```python from dataclasses import dataclass from typing import List, Tuple import math @dataclass class GCodeCommand: code: str x: float = None y: float = None z: float = None f: float = None s: float = None def rapid_move(x: float, y: float, z: float) -> str: """Generate G0 rapid move command.""" return f"G0 X{x:.4f} Y{y:.4f} Z{z:.4f}" def linear_move(x: float, y: float, z: float, f: float) -> str: """Generate G1 linear move command.""" return f"G1 X{x:.4f} Y{y:.4f} Z{z:.4f} F{f:.1f}" def circular_move( i: float, j: float, x: float, y: float, direction: str = "clockwise", f: float = 100 ) -> str: """Generate G2/G3 circular move.""" g_code = "G2" if direction == "clockwise" else "G3" return f"{g_code} X{x:.4f} Y{y:.4f} I{i:.4f} J{j:.4f} F{f:.1f}" def drill_cycle( x: float, y: float, z_start: float, z_depth: float, z_retract: float, f_plunge: float, f_rapid: float ) -> List[str]: """Generate G81 drilling cycle.""" return [ rapid_move(x, y, z_start), f"G81 R{z_retract} Z{z_depth} F{f_plunge}", f"G80", rapid_move(x, y, z_retract) ] def canned_cycle( cycle: str, x: float, y: float, r: float, z: float, q: float = None, f: float = 100 ) -> str: """Generate canned cycle command.""" if q: return f"{cycle} R{r} Z{z} Q{q} F{f}" return f"{cycle} R{r} Z{z} F{f}" # Example: Simple part program gcode = [ "G90 G21 G40", # Absolute, mm, cancel compensation "G54", # Work coordinate system 1 "M6 T1", # Tool change to tool 1 "M3 S3000", # Spindle on clockwise 3000 RPM rapid_move(0, 0, 5), linear_move(10, 0, -2, 100), linear_move(10, 10, -2, 100), linear_move(0, 10, -2, 100), linear_move(0, 0, -2, 100), "M5", # Spindle off "M30" # Program end ] for line in gcode[:5]: print(line) ``` ### Toolpath Generation ```python from typing import List, Tuple import numpy as np def offset_polygon( vertices: List[Tuple[float, float]], offset: float, corner_style: str = "round" ) -> List[Tuple[float, float]]: """Generate offset contour for tool radius compensation.""" offset_vertices = [] n = len(vertices) for i in range(n): p1 = vertices[i] p2 = vertices[(i + 1) % n] p0 = vertices[(i - 1) % n] v1 = np.array(p2) - np.array(p1) v0 = np.array(p1) - np.array(p0) angle1 = math.atan2(v1[1], v1[0]) angle0 = math.atan2(v0[1], v0[0]) if corner_style == "round": radius = offset center = np.array(p1) + np.array([ radius * math.cos((angle0 + angle1) / 2), radius * math.sin((angle0 + angle1) / 2) ]) # Generate arc points for t in np.linspace(0, 1, 9): angle = angle0 + (angle1 - angle0) * t offset_vertices.append(( center[0] + radius * math.cos(angle + math.pi/2), center[1] + radius * math.sin(angle + math.pi/2) )) else: # Miter join bisector = (angle0 + angle1) / 2 offset_vertices.append(( p1[0] + offset * math.cos(bisector + math.pi/2), p1[1] + offset * math.sin(bisector + math.pi/2) )) return offset_vertices def raster_toolpath( bbox: Tuple[float, float, float, float], stepover: float, direction: str = "x" ) -> List[Tuple[float, float]]: """Generate raster (zigzag) toolpath.""" xmin, xmax, ymin, ymax = bbox path = [] if direction == "x": for y in np.arange(ymin, ymax, stepover): if (y - ymin) / stepover % 2 == 0: path.extend([(xmin, y), (xmax, y)]) else: path.extend([(xmax, y), (xmin, y)]) else: for x in np.arange(xmin, xmax, stepover): if (x - xmin) / stepover % 2 == 0: path.extend([(x, ymin), (x, ymax)]) else: path.extend([(x, ymax), (x, ymin)]) return path def spiral_toolpath( center: Tuple[float, float], start_radius: float, end_radius: float, angle_per_step: float = 0.1, z_feed: float = 0.01 ) -> List[Tuple[float, float, float]]: """Generate spiral toolpath for drilling/milling.""" path = [] r = start_radius theta = 0 while r <= end_radius: x = center[0] + r * math.cos(theta) y = center[1] + r * math.sin(theta) z = -r / end_radius * 5 # Example z-depth path.append((x, y, z)) r += 0.05 theta += angle_per_step return path def trochoidal_milling( center: Tuple[float, float], radius: float, slot_width: float, stepdown: float, total_depth: float ) -> List[Tuple[float, float, float]]: """Generate trochoidal milling toolpath.""" path = [] current_depth = 0 while current_depth < total_depth: current_depth += stepdown if current_depth > total_depth: current_depth = total_depth angle = 0 while angle < 2 * math.pi: x = center[0] + (radius + slot_width/2 * math.cos(angle)) * math.cos(angle/2) y = center[1] + (radius + slot_width/2 * math.cos(angle)) * math.sin(angle/2) z = -current_depth path.append((x, y, z)) angle += 0.2 return path # Example: Raster toolpath bbox = (0, 100, 0, 50) path = raster_toolpath(bbox, 10, "x") print(f"Generated {len(path)} path points") ``` ### Feeds and Speeds ```python @dataclass class ToolParameters: diameter: float # mm num_flutes: int material: str hardness: float # HRC @dataclass class MaterialProperties: name: str hardness: float # HB or HRC tensile_strength: float # MPa machinability_rating: float def calculate_spindle_speed( cutting_speed: float, tool_diameter: float ) -> float: """Calculate spindle RPM.""" return (1000 * cutting_speed) / (math.pi * tool_diameter) def calculate_feed_rate( spindle_speed: float, feed_per_tooth: float, num_flutes: int ) -> float: """Calculate feed rate mm/min.""" return spindle_speed * feed_per_tooth * num_flutes def calculate_material_removal_rate( width: float, depth: float, feed_rate: float ) -> float: """Calculate MRR mm³/min.""" return width * depth * feed_rate def calculate_power_requirement( mrr: float, specific_energy: float ) -> float: """Calculate cutting power kW.""" return mrr * specific_energy / 60000 def estimate_feeds_speeds( material: str, tool_diameter: float, num_flutes: int, operation: str ) -> dict: """Estimate feeds and speeds based on material and operation.""" material_data = { "aluminum": {"vc": 200, "fz": 0.08, "se": 600}, "steel": {"vc": 100, "fz": 0.04, "se": 1500}, "stainless": {"vc": 70, "fz": 0.03, "se": 1800}, "titanium": {"vc": 50, "fz": 0.02, "se": 2500} } modifiers = { "roughing": {"vc_mult": 1.2, "fz_mult": 1.2}, "finishing": {"vc_mult": 1.5, "fz_mult": 0.5}, "slotting": {"vc_mult": 0.6, "fz_mult": 0.8} } m = material_data.get(material, material_data["steel"]) op_mod = modifiers.get(operation, {"vc_mult": 1.0, "fz_mult": 1.0}) vc = m["vc"] * op_mod["vc_mult"] fz = m["fz"] * op_mod["fz_mult"] n = calculate_spindle_speed(vc) vf, tool_diameter = calculate_feed_rate(n, fz, num_flutes) return { "spindle_speed_rpm": n, "feed_rate_mm_min": vf, "chip_load_mm_tooth": fz } # Example: Feeds and speeds settings = estimate_feeds_speeds("aluminum", 10, 4, "roughing") print(f"Spindle speed: {settings['spindle_speed_rpm']:.0f} RPM") print(f"Feed rate: {settings['feed_rate_mm_min']:.1f} mm/min") ``` ### Additive Manufacturing ```python @dataclass class AMBuildSettings: layer_height: float # mm infill_percentage: float infill_pattern: str build_temperature: float # C bed_temperature: float # C print_speed: float # mm/s support_type: str def estimate_build_time( num_layers: int, layer_area: float, print_speed: float, travel_speed: float = 150, layer_change_time: float = 5 ) -> float: """Estimate total build time in hours.""" print_time = (num_layers * layer_area) / print_speed / 60 travel_factor = 0.3 layer_time = num_layers * layer_change_time / 60 return (print_time * (1 + travel_factor) + layer_time) / 60 def calculate_material_usage( volume_mm3: float, infill_percentage: float = 20, support_percentage: float = 10 ) -> float: """Calculate required material in grams.""" density = 1.24 # PLA g/cm³ volume_cm3 = volume_mm3 / 1000 total_volume = volume_cm3 * (1 + infill_percentage/100) * (1 + support_percentage/100) return total_volume * density def optimize_build_orientation( surface_area: float, build_volume: Tuple[float, float, float], min_surface_roughness: bool = True, max_strength: bool = False ) -> Tuple[float, float, float]: """Optimize part orientation for 3D printing.""" x, y, z = build_volume if min_surface_roughness: return (x, y, 0.1) # Largest flat surface down elif max_strength: return (0.1, y, z) # Layer lines perpendicular to load return (x, y, z) def generate_support_structure( overhang_angle_threshold: float = 45, support_density: float = 0.2 ) -> List[dict]: """Generate support structure parameters.""" return [{ "angle_threshold": overhang_angle_threshold, "density": support_density, "style": "tree" if support_density < 0.15 else "grid"