diff --git a/.gitignore b/.gitignore
index 9fa210a..774dd57 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,7 +1,11 @@
.vscode
-*tmp.gcode
-*tmp.nc
+
+# 3D files
+*.gcode
+*.nc
*.stl
+*.dmp
+*.f3d
# Byte-compiled / optimized / DLL files
__pycache__/
diff --git a/ASMBL.manifest b/ASMBL.manifest
new file mode 100644
index 0000000..a9681a1
--- /dev/null
+++ b/ASMBL.manifest
@@ -0,0 +1,13 @@
+{
+ "autodeskProduct": "Fusion360",
+ "type": "addin",
+ "id": "c48d4cde-3023-49c1-95f7-3515aba13ecd",
+ "author": "AndyEveritt",
+ "description": {
+ "": "Additive and Subtractive Manufacturing By Layer"
+ },
+ "version": "1.0.2",
+ "runOnStartup": false,
+ "supportedOS": "windows|mac",
+ "editEnabled": true
+}
\ No newline at end of file
diff --git a/ASMBL.py b/ASMBL.py
new file mode 100644
index 0000000..7f80b62
--- /dev/null
+++ b/ASMBL.py
@@ -0,0 +1,149 @@
+import adsk.core
+import adsk.fusion
+import traceback
+
+from .fusion_api import Handlers
+from .fusion_api.Handlers import handlers
+
+
+def create_tab(workspace, tab_name):
+ # Get all the tabs for the workspace:
+ allTabs = workspace.toolbarTabs
+ tabId = tab_name + 'TabId'
+
+ # check if tab exists
+ newTab = allTabs.itemById(tabId)
+
+ if not newTab:
+ # Add a new tab to the workspace:
+ newTab = allTabs.add(tabId, tab_name)
+ return newTab
+
+
+def create_panel(workspace, tab, panel_name):
+ # Get all of the toolbar panels for the NewCam tab:
+ allTabPanels = tab.toolbarPanels
+
+ # Activate the Cam Workspace before activating the newly added Tab
+ workspace.activate()
+
+ panel = None
+ panel = allTabPanels.itemById(panel_name + 'PanelId')
+ if panel is None:
+ # Add setup panel
+ panel = allTabPanels.add(panel_name + 'PanelId', panel_name)
+ return panel
+
+
+def create_button(workspace, tab, panel, button_name, CreatedEventHandler, tooltip=None, resources=''):
+ # We want this panel to be visible:
+ workspace.activate()
+ panel.isVisible = True
+
+ app = adsk.core.Application.get()
+ ui = app.userInterface
+ cmdDefinitions = ui.commandDefinitions
+
+ # Check if Setup Button exists
+ buttonId = button_name.replace(' ', '') + 'Id'
+ button = cmdDefinitions.itemById(buttonId)
+ if not tooltip:
+ tooltip = button_name
+
+ if not button:
+ # Create a button command definition.
+ button = cmdDefinitions.addButtonDefinition(
+ buttonId, button_name, tooltip, resources)
+
+ # Connect to the command created event.
+ newcommandCreated = CreatedEventHandler()
+ button.commandCreated.add(newcommandCreated)
+ handlers.append(newcommandCreated)
+
+ # Add setup button to ASMBL setup panel
+ panelControls = panel.controls
+ buttonControl = panelControls.itemById(buttonId)
+ if not buttonControl:
+ buttonControl = panelControls.addCommand(button)
+ return buttonControl
+
+
+def remove_pannel(tab, panel_name):
+ # Get all the tabs for the workspace:
+ panelId = panel_name + 'PanelId'
+
+ # check if tab exists
+ panel = tab.toolbarPanels.itemById(panelId)
+
+ # Remove the controls we added to our panel
+ for control in panel.controls:
+ if control.isValid:
+ control.deleteMe()
+
+ # Remove our panel
+ panel.deleteMe()
+
+
+def run(context):
+ ui = None
+ try:
+ app = adsk.core.Application.get()
+ ui = app.userInterface
+
+ cmdDefinitions = ui.commandDefinitions
+
+ # Get all workspaces:
+ allWorkspaces = ui.workspaces
+
+ # Get the CAM workspace:
+ camWorkspace = allWorkspaces.itemById('CAMEnvironment')
+
+ AsmblTab = create_tab(camWorkspace, 'Asmbl')
+ # asmblSetupPanel = create_panel(camWorkspace, AsmblTab, 'Setup')
+
+ asmblActionsPanel = create_panel(camWorkspace, AsmblTab, 'Actions')
+ asmblPostProcessControl = create_button(camWorkspace, AsmblTab, asmblActionsPanel,
+ 'Post Process', Handlers.PostProcessCreatedEventHandler,
+ tooltip='Generate combined gcode file for ASMBL',
+ resources='./resources/PostProcess')
+ asmblPostProcessControl.isPromotedByDefault = True
+ asmblPostProcessControl.isPromoted = True
+ asmblPostProcessControl.commandDefinition.tooltipDescription = '\
+
Requires an FFF setup and a milling setup\
+
Will not work if there are any more/fewer setups'
+ asmblPostProcessControl.commandDefinition.toolClipFilename = 'resources/GenerateAsmbl/tooltip.png'
+
+
+ pass
+
+ except:
+ if ui:
+ ui.messageBox('Failed:\n{}'.format(traceback.format_exc()))
+
+
+# When the addin stops we need to clean up the ui
+def stop(context):
+ app = adsk.core.Application.get()
+ ui = app.userInterface
+
+ try:
+ # Get all workspaces:
+ allWorkspaces = ui.workspaces
+
+ # Get the CAM workspace:
+ camWorkspace = allWorkspaces.itemById('CAMEnvironment')
+
+ allTabs = camWorkspace.toolbarTabs
+
+ # check if tab exists
+ tab = allTabs.itemById('AsmblTabId')
+
+ # remove_pannel(tab, 'Setup')
+ remove_pannel(tab, 'Actions')
+
+ # Remove our render tab from the UI
+ if tab.isValid:
+ tab.deleteMe()
+ except:
+ if ui:
+ ui.messageBox('Failed:\n{}'.format(traceback.format_exc()))
diff --git a/ASMBL_parser.py b/ASMBL_parser.py
index e53966e..b945b10 100644
--- a/ASMBL_parser.py
+++ b/ASMBL_parser.py
@@ -1,16 +1,19 @@
+import sys
+import os
+venv_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'env', 'Lib', 'site-packages')
+if venv_path not in sys.path:
+ sys.path.append(venv_path) # add venv to python path
+
+from scipy.signal import find_peaks
from math import (
inf,
ceil,
)
-
-from scipy.signal import find_peaks
-
-import re
-import os
import numpy as np
+import re
-class Simplify3DGcodeLayer:
+class AdditiveGcodeLayer:
""" Stores a complete layer of gcode produced in Simplify3d """
def __init__(self, gcode, name=None, layer_height=None):
@@ -28,15 +31,45 @@ def get_name(self, gcode):
return gcode.split(',')[0][2:]
def get_layer_height(self, gcode):
- return float(gcode.split('\n')[0].split('Z = ')[-1])
+ height = None
+ lines = gcode.split('\n')
+
+ # Check for Simplify3D end of file code
+ if lines[0] == '; layer end':
+ height = inf
+
+ else:
+ line_heights = []
+ for line in lines:
+ if line == '':
+ continue
+ if line[0] == ';':
+ continue
+ line_segments = line.split('Z')
+ if len(line_segments) > 1:
+ line_height = float(line_segments[1].split(' ')[0])
+ line_heights.append(line_height)
+
+ height = min(line_heights)
+
+ return height
+
+ def comment_all_gcode(self):
+ commented_gcode = ''
+ lines = self.gcode.split('\n')
+ for line in lines:
+ if line != '':
+ if line[0] != ';':
+ line = '; ' + line
+ commented_gcode += line + '\n'
+ self.gcode = commented_gcode
class CamGcodeLine:
""" Stores a single line of fusion360 CAM gcode. """
- def __init__(self, gcode, offset, name=None):
+ def __init__(self, gcode, offset):
self.gcode = self.offset_gcode(gcode, offset)
- self.name = name
self.layer_height = self.get_layer_height(self.gcode)
def offset_gcode(self, gcode, offset):
@@ -70,10 +103,15 @@ def get_layer_height(self, gcode):
class CamGcodeLayer:
""" Stores all the CAM operations in a specific layer. """
- def __init__(self, height, operations):
+ def __init__(self, operations, name=None, tool=None, height=None):
self.height = height
self.operations = operations
- self.gcode = self.parse_gcode(self.operations)
+ self.name = name
+ self.tool = tool
+
+ if self.operations:
+ self.gcode = self.parse_gcode(self.operations)
+
self.layer_height = None # height to print to before running the operation
def parse_gcode(self, operations):
@@ -85,24 +123,72 @@ def parse_gcode(self, operations):
return gcode
+ def set_min_z_height(self):
+ op_height = min(
+ [line.layer_height for line in self.operations])
+ self.height = op_height
+
+ def set_max_z_height(self):
+ lines = []
+ # Filter out retracts, only care about max Z height of cutting ops
+ for line in self.operations:
+ if len(line.gcode.split('F')) > 1:
+ lines.append(line)
+
+ op_height = max(
+ [line.layer_height for line in lines])
+ self.height = op_height
+
class Parser:
""" Main parsing class. """
- def __init__(self, config):
+ def __init__(self, config, progress=None):
self.config = config
+ self.progress = progress # progress bar for Fusion add-in
self.offset = (config['Printer']['bed_centre_x'],
config['Printer']['bed_centre_y'],
- config['PrintSettings']['raft_height'] -
- config['PrintSettings']['layer_height']*config['CamSettings']['layer_intersect']
+ config['PrintSettings']['raft_height'] - config['CamSettings']['layer_dropdown']
)
- self.last_process_tool = None
+ self.last_additive_tool = None
+ self.last_subtractive_tool = None
+
+ self.main()
+
+ def main(self):
+ progress = self.progress
+ if progress:
+ progress.message = 'Opening files'
+ progress.progressValue += 1
self.open_files(self.config)
- self.split_additive_layers(self.gcode_add)
- self.split_cam_operations(self.gcode_sub)
+
+ if progress:
+ progress.message = 'Spliting additive gcode layers'
+ progress.progressValue += 1
+ self.gcode_add_layers = self.split_additive_layers(self.gcode_add)
+
+ if progress:
+ progress.message = 'Spliting subtractive gcode layers'
+ progress.progressValue += 1
+ operations = self.split_cam_operations(self.gcode_sub)
+
+ if progress:
+ progress.message = 'Ordering subtractive gcode layers'
+ progress.progressValue += 1
+ self.cam_operations = self.order_cam_operations_by_layer(operations)
+
+ if progress:
+ progress.message = 'Merging gcode layers'
+ progress.progressValue += 1
+ self.merged_gcode = self.merge_gcode_layers(self.gcode_add_layers, self.cam_operations)
+
+ if progress:
+ progress.message = 'Creating gcode script'
+ progress.progressValue += 1
+ self.create_gcode_script(self.merged_gcode)
def open_files(self, config):
gcode_add_file = open(config['InputFiles']['additive_gcode'], 'r')
@@ -116,129 +202,162 @@ def split_additive_layers(self, gcode_add):
tmp_list = re.split('(; layer)', gcode_add)
gcode_add_layers = []
- gcode_add_layers.append(Simplify3DGcodeLayer(
- tmp_list[0],
+ initialise_layer = AdditiveGcodeLayer(
+ tmp_list.pop(0),
name="initialise",
layer_height=0,
- )) # slicer settings & initialise
+ ) # slicer settings & initialise
+ self.set_last_additive_tool(initialise_layer)
+ # initialise_layer.comment_all_gcode()
+ gcode_add_layers.append(initialise_layer)
for i in range(ceil(len(tmp_list)/2)):
- if i == 0:
- continue
- layer = tmp_list[2*i-1] + tmp_list[2*i]
+ layer = tmp_list[2*i] + tmp_list[2*i+1]
name = layer.split(',')[0][2:]
if 2*i == len(tmp_list) - 1:
- gcode_add_layers.append(Simplify3DGcodeLayer(
+ gcode_add_layers.append(AdditiveGcodeLayer(
layer, 'end', inf))
continue
- gcode_add_layers.append(Simplify3DGcodeLayer(layer))
+ gcode_add_layers.append(AdditiveGcodeLayer(layer))
- self.gcode_add_layers = gcode_add_layers
+ return gcode_add_layers
def split_cam_operations(self, gcode_sub):
""" Takes fusion360 CAM gcode and splits the operations by execution height """
tmp_operation_list = gcode_sub.split('\n\n')
- operations = [None]
+ operations = []
for i, operation in enumerate(tmp_operation_list):
- if i == 0: # ignore setup gcode
- continue
lines = operation.split('\n')
name = lines.pop(0)
+ tool = lines.pop(0)
lines = [line for line in lines if line != '']
operations.append([])
# extract information from string
- lines = [CamGcodeLine(line, self.offset, name) for line in lines]
+ lines = [CamGcodeLine(line, self.offset) for line in lines]
line_heights = np.array([line.layer_height for line in lines])
local_peaks = find_peaks(line_heights)[0]
if len(local_peaks) > 0:
- operations[i].append(lines[0: local_peaks[0]+1])
+ op_lines = lines[0: local_peaks[0]+1]
+ operations[i].append(CamGcodeLayer(op_lines, name, tool))
for index, peak in enumerate(local_peaks[:-1]):
- operations[i].append(lines[local_peaks[index]: local_peaks[index+1]+1])
+ op_lines = lines[local_peaks[index]: local_peaks[index+1]+1]
+ operations[i].append(CamGcodeLayer(op_lines, name, tool))
- operations[i].append(lines[local_peaks[-1]:])
+ op_lines = lines[local_peaks[-1]:]
+ operations[i].append(CamGcodeLayer(op_lines, name, tool))
else:
- operations[i].append(lines)
+ operations[i].append(CamGcodeLayer(lines, name, tool))
- self.order_cam_operations_by_layer(operations)
+ return operations
def order_cam_operations_by_layer(self, operations):
""" Takes a list of cam operations and calculates the layer that they should be executed """
- ordered_operations = []
+ unordered_ops = []
for operation in operations:
if operation:
for op_instance in operation:
- op_height = min(
- [height.layer_height for height in op_instance])
- ordered_operations.append(
- CamGcodeLayer(op_height, op_instance))
+ # if op_instance.name.startswith('(Radial'):
+ # op_instance.set_max_z_height()
+ # else:
+ op_instance.set_min_z_height()
+ unordered_ops.append(op_instance)
+
+ ordered_operations = sorted(unordered_ops, key=lambda x: x.height)
+ layer_overlap = self.config['CamSettings']['layer_overlap']
- ordered_operations.sort(key=lambda x: x.height)
for i, operation in enumerate(ordered_operations):
- later_ops = [
- op for op in ordered_operations if op.height > operation.height]
- try:
- operation.layer_height = min(
- [op.height for op in later_ops]) + self.config['PrintSettings']['layer_height'] * self.config['CamSettings']['layer_dropdown']
- except ValueError:
- operation.layer_height = operation.height + \
- self.config['PrintSettings']['layer_height'] * self.config['CamSettings']['layer_dropdown']
-
- self.cam_operations = ordered_operations
- self.merged_gcode = self.merge_gcode_layers(
- self.gcode_add_layers, self.cam_operations)
+ later_ops = [op for op in ordered_operations if op.height > operation.height]
+ if len(later_ops) > 0:
+ next_op_height = min([op.height for op in later_ops])
+ later_additive = [layer for layer in self.gcode_add_layers if layer.layer_height > next_op_height]
+
+ if layer_overlap == 0:
+ operation.layer_height = next_op_height
+
+ elif len(later_additive) == 0:
+ operation.layer_height = next_op_height
+
+ elif len(later_additive) >= layer_overlap:
+ operation.layer_height = later_additive[layer_overlap - 1].layer_height
+
+ else:
+ operation.layer_height = later_additive[-1].layer_height
+
+ else: # no later ops
+ later_additive = [layer for layer in self.gcode_add_layers if layer.layer_height > operation.height]
+
+ if len(later_additive) >= layer_overlap:
+ operation.layer_height = later_additive[layer_overlap - 1].layer_height
+
+ elif len(later_additive) == 0: # no further printing
+ # add 10 since it is unlikely that the printed layer height will exceed 10 mm
+ # but still want to place cutting after a print at the same height
+ operation.layer_height = operation.height + 10
+
+ else:
+ operation.layer_height = later_additive[-1].layer_height
+
+ return ordered_operations
def merge_gcode_layers(self, gcode_add, cam_operations):
""" Takes the individual CAM instructions and merges them into the additive file from Simplify3D """
merged_gcode = gcode_add + cam_operations
merged_gcode.sort(key=lambda x: x.layer_height)
- self.create_gcode_script(merged_gcode)
-
return merged_gcode
def create_gcode_script(self, gcode):
self.merged_gcode_script = ''
prev_layer = gcode[0]
for layer in gcode:
- self.set_last_process_tool(prev_layer)
+ self.set_last_additive_tool(prev_layer)
self.tool_change(layer, prev_layer)
prev_layer = layer
self.merged_gcode_script += layer.gcode
- def set_last_process_tool(self, layer):
- if isinstance(layer, Simplify3DGcodeLayer):
+ def set_last_additive_tool(self, layer):
+ if isinstance(layer, AdditiveGcodeLayer):
process_list = layer.gcode.split('\nT')
if len(process_list) > 1:
- self.last_process_tool = 'T' + process_list[-1].split('\n')[0]
+ self.last_additive_tool = 'T' + process_list[-1].split('\n')[0]
def tool_change(self, layer, prev_layer):
- if type(layer) != type(prev_layer):
- if type(layer) == Simplify3DGcodeLayer:
- first_gcode = layer.gcode.split('\n')[1]
- if first_gcode[0] is not 'T':
- self.merged_gcode_script += self.last_process_tool + '\n'
- elif type(layer == CamGcodeLayer):
- self.merged_gcode_script += self.config['Printer']['cam_tool'] + '\n'
-
- def create_output_file(self, gcode):
+ if type(layer) == AdditiveGcodeLayer:
+ if layer.name == 'initialise' or prev_layer.name == 'initialise':
+ return # no need to add a tool change
+ first_gcode = layer.gcode.split('\n')[1]
+ if first_gcode[0] is not 'T':
+ self.merged_gcode_script += self.last_additive_tool + '\n'
+ elif type(layer) == CamGcodeLayer:
+ self.merged_gcode_script += layer.tool + '\n'
+
+ def create_output_file(self, gcode, folder_path="output/", relative_path=True):
""" Saves the file to the output folder """
- file_path = "output/" + self.config['OutputSettings']['filename'] + ".gcode"
+ file_path = folder_path + self.config['OutputSettings']['filename'] + ".gcode"
+ file_path = os.path.expanduser(file_path)
os.makedirs(os.path.dirname(file_path), exist_ok=True)
with open(file_path, "w") as f:
f.write(gcode)
+
+ f.close()
+
+ try:
+ os.startfile(file_path)
+ except FileNotFoundError:
+ pass
if __name__ == "__main__":
diff --git a/CAD/Box.stl b/CAD/Box.stl
deleted file mode 100644
index 04bdf71..0000000
Binary files a/CAD/Box.stl and /dev/null differ
diff --git a/CAD/Box_bore.stl b/CAD/Box_bore.stl
deleted file mode 100644
index 869d8d0..0000000
Binary files a/CAD/Box_bore.stl and /dev/null differ
diff --git a/README.md b/README.md
index c9aba9d..c1ef8ef 100644
--- a/README.md
+++ b/README.md
@@ -2,57 +2,177 @@
This code is designed to create a gcode file suitable for Additive & Subtractive Manufacturing By Layer (ASMBL).
-It takes 2 input files:
-* An additive`.gcode` file from Simplify3D using the `ASMBL.factory` file to get the appropriate settings.
-* A subtractive `.nc` file from Fusion360.
+There are 2 main ways this repo can be used.
+* As a standalone program that takes 2 input files
+ * An additive`.gcode` file from Simplify3D using the `ASMBL.factory` file to get the appropriate settings.
+ * A subtractive `.gcode` file from Fusion360.
+ * These files require specific setup for this program to work
+* As a **Fusion 360 add-in** where the **ENTIRE** workflow from designing the part to getting the merged gcode is in Fusion 360
+ * This means no handling dirty STL files!!!
+
+The Fusion 360 add-in is the recommended option however the slicer is new and not widely adopted yet. Therefore, support for Simplify3D is present. The 2 slicers create mostly compatible gcode files. Until further notice, support for both programs will exist.
+
+
+
+For the standalone program, download the latest release for the `ASMBL.exe`, an example `config.json`, and the Simplify3D factory file.
+
+# Contents
+
+- [Overview](#overview)
+- [Contents](#contents)
+- [Installation](#installation)
+ - [Fusion 360 Add-in](#fusion-360-add-in)
+ - [Fusion360 Design Workspace](#fusion360-design-workspace)
+ - [Setting up the code for standalone use (Simplify3D)](#setting-up-the-code-for-standalone-use-simplify3d)
+- [Usage](#usage)
+ - [Material Choice](#material-choice)
+ - [Additive Setup](#additive-setup)
+ - [Fusion360](#fusion360)
+ - [Standalone (Simplify3D, Other Slicers)](#standalone-simplify3d-other-slicers)
+ - [Subtractive Setup](#subtractive-setup)
+ - [Stock setup](#stock-setup)
+ - [Fusion360](#fusion360-1)
+ - [External Slicer](#external-slicer)
+ - [CAM setup](#cam-setup)
+ - [Tool Config](#tool-config)
+ - [2D Contour](#2d-contour)
+ - [2D Adaptive](#2d-adaptive)
+ - [3D Contour](#3d-contour)
+ - [Post Processing](#post-processing)
+ - [Fusion Add-in](#fusion-add-in)
+ - [Standalone](#standalone)
+ - [Config](#config)
+ - [Program](#program)
+ - [Run Standalone](#run-standalone)
+- [Contributions](#contributions)
+- [Authors and Acknowledgment](#authors-and-acknowledgment)
+- [License](#license)
+
+
+# Installation
+
+
+## Fusion 360 Add-in
+
+Install the repo in your desired folder location.
+
+**Windows**
+```bash
+git clone https://github.com/AndyEveritt/ASMBL.git
+cd ASMBL
+py -m venv env
+source env/Scripts/activate
+pip install -r requirements.txt
+```
+
+**Important** When setting the virtual environment, the python version must be **64 bit**. Otherwise it will only work as a standalone program but not as a Fusion add-in. Notes on how venv works can be found here https://docs.python.org/3/library/venv.html
+
+
+To run the standalone program, ensure the python virtual environment is enabled, then use `python main.py`
+
+* Open Fusion360
+* Click the add-in tool
+* Click the green plus to add an existing add-in
+
+
+
+* Navigate to the ASMBL repo location and select the folder
+
+
-These files require specific setup for this program to work
+* Select the ASMBL add-in from the list, click `Run on Startup`, then `Run`
-Download the latest release for the `ASMBL.exe`, an example `config.json`, and the Simply3d factory file.
+
+## Fusion360 Design Workspace
-# How to Setup
+To make orienting the coordinate axis between modeling, additive, and subtractive workspaces; it is highly recommended to change the `Default modeling orientation` in Fusion360.
+
+This can be done by:
+* Going to user preferences
+* Changing the `Default modeling orientation` to `Z up`
+
+
+
+## Setting up the code for standalone use (Simplify3D)
+
+Download the following files from the releases page:
+* `ASMBL.exe`
+* `config.json`
+* `ASMBL.factory`
+
+Ensure the config and exe are in the same folder for the program to run.
+
+To modify the source code follow the guide here: [Standalone Installation](docs/installation/standalone.md)
+
+# Usage
## Material Choice
-Material | Usage Advised | Comments
--------- | ------------- | --------
-PLA | No | Melts too much when cutting, causes the cutter to gunk up and strands of plastic to be left on/around part.
-MatX (ASA) | Yes | Cuts well
-EDGE (PET) | - | -
-XT-CF10 | - | -
+A details on materials that have been tested can be found [here](docs/materials.md).
+
+## Additive Setup
+
+The additive gcode can be setup in various ways.
+* Using Fusion360 for the complete workflow (recommended)
+* Using Simplify3D (or PrusaSlicer if you want to make a profile) to generate the FFF gcode and Fusion to generate the CAM gcode.
+
+### Fusion360
+First you need to create an offset of your model, this will control how much cut-in you have.
-## Simplify3D
+* Make a duplicate of the model body(s).
+ * Select the body from the Browser menu on the left and `Ctrl+C`, `Ctrl+V`
+ * Make sure both bodies perfectly overlaid.
+* Offset all the faces on the new body that you wish to machine.
+ * Hide the original body to make selecting faces easier.
+ * An offset amount of ~0.2-0.3 mm works well in my testing.
+ * You do not want to offset any face you will not be able to machine, **ie the base**
-* Open the `ASMBL.factory` file
-* Import the STL file
-* Orient the part in the desired orientation
-* Click `Center and Arrange`
-* Click `Prepare to Print!`
-* In the preview, use the layer view to find the height of the top layer of the raft, it is needed for `config.json`
-* Save the file to the desired project location
+
-### Settings that are important
+* You should have 2 of each body in your part, the exactly modelled part, and the offset part.
+* Enter the `Additive` Tab in the `Manufacturing` workspace in Fusion360.
+* Create a new setup
+ * Click `Select` Machine
+ * Import the `E3D - Tool Changer.machine` profile from the `settings` folder of this repo
+ * Click `Select` next to `Print Settings`
+ * Import the `ASMBL.printsetting` profile from the `settings` folder of this repo
+ * Under `Model` select the offset body created earlier
-Tab | Setting | Default | Effect | Other Notes
---- | ------- | ------- | ------ | -----------
-Layer | Primary Layer Height | `0.3` | Layer height of the print | Thicker layers can create smoother surfaces with ASMBL (requires further testing). Layers less than 0.2 mm should be avoided
-Additions | Use Raft | `Enabled` | Prevents cutting into bed
-Other | Horizontal size compensation | `0.25` | Amount of horizontal cut-in | Any dimension that is not CAM'd will be this much too large
+
+
+
-### Other points
+* Optionally rename the setup to `Additive`
-* It is important that the centre of the part is in the centre of the bed to ensure the CAM settings correctly align
-* The part must also be oriented with the same XYZ axis as the CAM'd part
+### Standalone (Simplify3D, Other Slicers)
-## Fusion360
+Guide on how to create a properly configured gcode file can be generated can be found [here](docs/usage/standalone.md)
+
+## Subtractive Setup
### Stock setup
* Create a new Setup by clicking `Setup` > `New Setup`
* Select `From solid` for the Stock mode
* Click on the part body to select it
+ * Select the offset body if created earlier
+* Under the `Model` option in the `Setup` tab, select the original part body.
+
+The origin changes depending on if you are using Fusion360 or an external slicer for the additive gcode.
+
+#### Fusion360
+
+* Under `Work Coordinate System` select:
+ * Orientation: `Model orientation`
+ * Origin: `Model origin`
+* The origin should now align with the previously configured FFF setup
+
+
+
+#### External Slicer
+
* Move the origin to the bottom middle of the part
* Orient the Z axis to be vertically upwards
@@ -66,6 +186,14 @@ Process | Usage
2D Adaptive | Used for top surfacing
3D Contour | Used for vertical & close to vertical side walls (including chamfers & filets). May not be able to cut internal features (ie walls with a roof over them)
+#### Tool Config
+
+When selecting the tool you must renumber the tool to match the tool number on your printer.
+
+A `Cutting Feedrate` of 500 mm/min works well.
+
+
+
#### 2D Contour
* `Tool`
@@ -85,7 +213,6 @@ Process | Usage
* Ensure this is an integer multiple of the layer height to get the most consistent results
* Disable `Stock to Leave`
* `Linking`
- * Set `Vertical Lead-In Radius` to `0` mm
* Disable `Ramp`
2D Contour can be used when fine control over the process is needed. Undercuts can be done using this process.
@@ -106,7 +233,6 @@ Process | Usage
* Set `Direction` to `Conventional`
* Disable `Stock to Leave`
* `Linking`
- * Set `Vertical Lead In/Out Radius` to `0` mm
* Set `Ramp Type` to `Plunge`
@@ -128,43 +254,54 @@ Multiple surfaces at different heights can be selected with the same process. Th
* ie top and bottom of the surface
* `Passes`
* Set `Direction` to `Conventional`
- * Set `Finishing Overlap` to non zero for better finish
* Set `Maximum Stepdown` to be equal to ~0.5-2 layers
* Disable `Stock to Leave`
* `Linking`
* Set `Maximum Stay Down Distance` to `0` mm
- * Set `Vertical Lead-In Radius` to `0` mm
* Set `Ramp Type` to `Profile`
3D Contour can be used for most none flat surfaces that have nothing above them. They are good for quickly CAM'ing a large number of faces.
-None flat surfaces that have something above them can be CAM'd with some Fusion 360 magic. But this can be an involved process depending on the geometry.
-
The machining boundary can be used to restrict which faces are machined. Here the centre sloped surface is diselected but everything within the inner centre hole is machined.
-Undercuts do not work with 3D Contour. 2D Contour can be used for this instead.
+Additional work is required to machine undercuts, however it can be done using 3D Contours. This is beyond the scope of this guide. Overhangs are even more work but again can be done by creating additional offset faces.
-
+
>**If any of the above CAM information is wrong or can be improved, please add an issue and I will update the guide**
-### Post Processing
+## Post Processing
+
+### Fusion Add-in
+
+* Click on the `ASMBL` tab along the top navigation bar
+* Click `Post Process`
+ * If all the toolpaths have not been previously generated or are out of date, you can tick the box to re generate all toolpaths
+ * This currently has a bug if the additive toolpath isn't the last to generate where the progress bar will not complete. If this happens just close the progress bar are rerun the post process command
+ * Set the remainder of the settings depending on your design by following the tooltips when hovering over them.
+ * Click `OK`
+* The output gcode will be saved in `~/ASMBL/output/`
+ * If the file name already exists, it will be overwritten without warning.
+ * The generated file will automatically open in your default `.gcode` editor.
+ * **Always preview the gcode fully to check it for mistakes** This is Beta software, there will be bugs.
+
+### Standalone
* Generate and Simulate the full Setup to ensure in looks sensible
* Click `Actions` > `Post Process`
-* Select the `BoXYZ (Grbl) / boxyz` config
+* Select the `asmbl_cam.cps` config from the `post_processors` folder in this repo
* Set the `Output folder` to the desired project location
* Click `Post`
-## Config
+#### Config
-The `config.json` contains the parameters that control how the ASMBL parser merges the 2 input files
+The `config.json` contains the parameters that control how the ASMBL parser merges the 2 input files if running the program standalone.
Update the `config.json` so that the following settings are correct for your project:
@@ -172,20 +309,18 @@ Update the `config.json` so that the following settings are correct for your pro
{
"InputFiles": {
"additive_gcode": "path to Simplify3D additive .gcode file",
- "subtractive_gcode": "path to Fusion360 CAM .nc file"
+ "subtractive_gcode": "path to Fusion360 CAM .gcode file"
},
"Printer": {
"bed_centre_x": "mm from origin to bed centre in x axis",
- "bed_centre_y": "mm from origin to bed centre in y axis",
- "cam_tool": "Tool used for CAM (eg 'T3')"
+ "bed_centre_y": "mm from origin to bed centre in y axis"
},
"PrintSettings": {
- "raft_height": "Height of the top layer of the raft",
- "layer_height": "layer height of printed part"
+ "raft_height": "Height of the top layer of the raft"
},
"CamSettings": {
- "layer_dropdown": "How many layers the tip of the cutter should be lower than the layers being cut",
- "layer_intersect": "What percentage (0-1) of a layer line should the tip of the cutter sit at when cutting"
+ "layer_overlap": "How many layers the tip of the cutter should be lower than the layers being cut",
+ "layer_dropdown": "What number of mm the tip of the cutter should be lowered by"
},
"OutputSettings": {
"filename": "Name of the output file containing the merged gcode script
@@ -193,7 +328,7 @@ Update the `config.json` so that the following settings are correct for your pro
}
```
-## Program
+#### Program
The program takes the following arguments:
@@ -201,7 +336,7 @@ Arg (long) | Arg (short) | Default | Usage
---------- | ----------- | ------- | -----
`--config` | `-C` | `config.json` | Path to the configuration JSON file
-## Run
+## Run Standalone
To run the program, ensure the `config.json` is configured correctly, then run the `ASMBL.exe`
@@ -215,17 +350,17 @@ The subtractive processes are displayed as travel moves, scroll through the laye
+# Contributions
-# Setting up the code for modification
+Process tbd, open to contributions.
-```bash
-git clone {repo address}
-python3 -m venv env
-pip install -r requirements.txt
-```
+# Authors and Acknowledgment
-To run the program, ensure the python virtual environment is enabled, then use `python main.py`
+Author | Contribution
+------ | -----------
+@AndyEveritt | Code
+Greg Holloway | Printer
-## Compiling source code
+# License
-Run `pyinstaller --onefile main.py` to create the compiled `.exe` in the `dist` folder
\ No newline at end of file
+GPL-3.0
\ No newline at end of file
diff --git a/config.json b/config.json
index a628b49..394b74e 100644
--- a/config.json
+++ b/config.json
@@ -1,20 +1,18 @@
{
"InputFiles": {
- "additive_gcode": "gcode/box/box.gcode",
- "subtractive_gcode": "gcode/box/tmp.nc"
+ "additive_gcode": "gcode/Spinner_Demo/Spinner_Demo_MM.gcode",
+ "subtractive_gcode": "gcode/Spinner_Demo/Spinner_Demo.nc"
},
"Printer": {
"bed_centre_x": 150,
- "bed_centre_y": 100,
- "cam_tool": "T3"
+ "bed_centre_y": 100
},
"PrintSettings": {
- "raft_height": 2.333,
- "layer_height": 0.3
+ "raft_height": 2.333
},
"CamSettings": {
- "layer_dropdown": 2,
- "layer_intersect": 0.6
+ "layer_overlap": 2,
+ "layer_dropdown": 0.2
},
"OutputSettings": {
"filename": "tmp"
diff --git a/output/tool_head/demo_(1).gcode b/docs/images/asmbl_demo.gif
similarity index 53%
rename from output/tool_head/demo_(1).gcode
rename to docs/images/asmbl_demo.gif
index dd18913..20f28d2 100644
Binary files a/output/tool_head/demo_(1).gcode and b/docs/images/asmbl_demo.gif differ
diff --git a/output/tool_head/demo_(2).gcode b/docs/images/stock.gif
similarity index 55%
rename from output/tool_head/demo_(2).gcode
rename to docs/images/stock.gif
index ee97f18..10900e7 100644
Binary files a/output/tool_head/demo_(2).gcode and b/docs/images/stock.gif differ
diff --git a/docs/installation/images/fusion_add_existing.png b/docs/installation/images/fusion_add_existing.png
new file mode 100644
index 0000000..be652c8
Binary files /dev/null and b/docs/installation/images/fusion_add_existing.png differ
diff --git a/docs/installation/images/fusion_run.png b/docs/installation/images/fusion_run.png
new file mode 100644
index 0000000..8ae1c39
Binary files /dev/null and b/docs/installation/images/fusion_run.png differ
diff --git a/docs/installation/images/fusion_select_location.png b/docs/installation/images/fusion_select_location.png
new file mode 100644
index 0000000..5718f90
Binary files /dev/null and b/docs/installation/images/fusion_select_location.png differ
diff --git a/docs/installation/images/fusion_z_up.png b/docs/installation/images/fusion_z_up.png
new file mode 100644
index 0000000..1153d8a
Binary files /dev/null and b/docs/installation/images/fusion_z_up.png differ
diff --git a/docs/installation/standalone.md b/docs/installation/standalone.md
new file mode 100644
index 0000000..201cb9a
--- /dev/null
+++ b/docs/installation/standalone.md
@@ -0,0 +1,20 @@
+[Back - README](../../README.md)
+
+# Setting up the code for standalone/modification
+
+This only needs to be done if you want to modify the source code. Otherwise the `ASMBL.exe` can be used to eliminate the setup of the program.
+
+**Windows**
+```bash
+git clone https://github.com/AndyEveritt/ASMBL.git
+cd ASMBL
+py -m venv env
+source env/Scripts/activate
+pip install -r requirements.txt
+```
+
+To run the standalone program, ensure the python virtual environment is enabled, then use `python main.py`
+
+## Compiling source code for standalone
+
+Run `pyinstaller --onefile main.py` to create the compiled `.exe` in the `dist` folder. The file will have the default name `main.exe`.
\ No newline at end of file
diff --git a/docs/materials.md b/docs/materials.md
new file mode 100644
index 0000000..1b44b8f
--- /dev/null
+++ b/docs/materials.md
@@ -0,0 +1,8 @@
+[Back - README](../../README.md)
+
+Material | Usage Advised | Comments
+-------- | ------------- | --------
+PLA | No | Melts too much when cutting, causes the cutter to gunk up and strands of plastic to be left on/around part.
+MatX (ASA) | Yes | Cuts well
+EDGE (PET) | - | -
+XT-CF10 | - | -
diff --git a/docs/usage/images/fusion_cam_setup.png b/docs/usage/images/fusion_cam_setup.png
new file mode 100644
index 0000000..d0b411e
Binary files /dev/null and b/docs/usage/images/fusion_cam_setup.png differ
diff --git a/docs/usage/images/fusion_cam_tool.png b/docs/usage/images/fusion_cam_tool.png
new file mode 100644
index 0000000..ee024b2
Binary files /dev/null and b/docs/usage/images/fusion_cam_tool.png differ
diff --git a/docs/usage/images/fusion_cam_undercuts.png b/docs/usage/images/fusion_cam_undercuts.png
new file mode 100644
index 0000000..713772c
Binary files /dev/null and b/docs/usage/images/fusion_cam_undercuts.png differ
diff --git a/docs/usage/images/fusion_fff_machine.png b/docs/usage/images/fusion_fff_machine.png
new file mode 100644
index 0000000..af83bf8
Binary files /dev/null and b/docs/usage/images/fusion_fff_machine.png differ
diff --git a/docs/usage/images/fusion_fff_offset.png b/docs/usage/images/fusion_fff_offset.png
new file mode 100644
index 0000000..6ea0f8f
Binary files /dev/null and b/docs/usage/images/fusion_fff_offset.png differ
diff --git a/docs/usage/images/fusion_fff_setup.png b/docs/usage/images/fusion_fff_setup.png
new file mode 100644
index 0000000..584b19a
Binary files /dev/null and b/docs/usage/images/fusion_fff_setup.png differ
diff --git a/docs/usage/images/fusion_fff_workspace.png b/docs/usage/images/fusion_fff_workspace.png
new file mode 100644
index 0000000..b0a9abd
Binary files /dev/null and b/docs/usage/images/fusion_fff_workspace.png differ
diff --git a/docs/usage/standalone.md b/docs/usage/standalone.md
new file mode 100644
index 0000000..1959cd1
--- /dev/null
+++ b/docs/usage/standalone.md
@@ -0,0 +1,32 @@
+[Back - README](../../README.md)
+
+# Simplify3D
+
+* Open the `ASMBL.factory` file
+* Import the STL file
+* Orient the part in the desired orientation
+* Click `Center and Arrange`
+* Click `Prepare to Print!`
+* In the preview, use the layer view to find the height of the top layer of the raft, it is needed for `config.json`
+* Save the file to the desired project location
+
+## Settings that are important
+
+Tab | Setting | Default | Effect | Other Notes
+--- | ------- | ------- | ------ | -----------
+Layer | Primary Layer Height | `0.3` | Layer height of the print | Thicker layers can create smoother surfaces with ASMBL (requires further testing). Layers less than 0.2 mm should be avoided
+Additions | Use Raft | `Enabled` | Prevents cutting into bed
+Other | Horizontal size compensation | `0.25` | Amount of horizontal cut-in | Any dimension that is not CAM'd will be this much too large
+
+## Other points
+
+* It is important that the centre of the part is in the centre of the bed to ensure the CAM settings correctly align
+* The part must also be oriented with the same XYZ axis as the CAM'd part
+
+# Other Slicers
+
+This program works by splitting the layers of both the additive and subtractive gcodes and merging them appropriately. It has been designed around Simplify3D and Fusion360 however in theory all the additive gcode requires to separate its layers is the following line on a layer change:
+
+`; layer`
+
+Currently it does not matter if anything comes after this.
\ No newline at end of file
diff --git a/fusion_api/Handlers.py b/fusion_api/Handlers.py
new file mode 100644
index 0000000..172a5eb
--- /dev/null
+++ b/fusion_api/Handlers.py
@@ -0,0 +1,302 @@
+import adsk.core
+import adsk.fusion
+import traceback
+import time
+import os
+
+from ..ASMBL_parser import Parser
+
+# Global list to keep all event handlers in scope.
+# This is only needed with Python.
+handlers = []
+
+
+def generateAllTootpaths(ui, cam):
+ # Check CAM data exists.
+ if not cam:
+ ui.messageBox('No CAM data exists in the active document.')
+ return
+
+ # Verify that there are any setups.
+ if cam.allOperations.count == 0:
+ ui.messageBox('No CAM operations exist in the active document.')
+ return
+
+ # Generate all toolpaths
+ future = cam.generateAllToolpaths(False)
+ message = '
Please do not press OK until the Additive toolpath has finished.\
+
The toolpaths for all cam operations in the document have been generated.'
+
+ numOps = future.numberOfOperations
+
+ # create and show the progress dialog while the toolpaths are being generated.
+ progress = ui.createProgressDialog()
+ progress.isCancelButtonShown = False
+ progress.show('Toolpath Generation Progress', 'Generating Toolpaths', 0, 10)
+
+ # Enter a loop to wait while the toolpaths are being generated and update
+ # the progress dialog.
+ while not future.isGenerationCompleted:
+ # since toolpaths are calculated in parallel, loop the progress bar while the toolpaths
+ # are being generated but none are yet complete.
+ n = 0
+ start = time.time()
+ while future.numberOfCompleted == 0:
+ if time.time() - start > .125: # increment the progess value every .125 seconds.
+ start = time.time()
+ n += 1
+ progress.progressValue = n
+ adsk.doEvents()
+ if n > 10:
+ n = 0
+
+ # The first toolpath has finished computing so now display better
+ # information in the progress dialog.
+
+ # set the progress bar value to the number of completed toolpaths
+ progress.progressValue = future.numberOfCompleted
+
+ # set the progress bar max to the number of operations to be completed.
+ progress.maximumValue = numOps
+
+ # set the message for the progress dialog to track the progress value and the total number of operations to be completed.
+ progress.message = 'Generating %v of %m' + ' Toolpaths'
+ adsk.doEvents()
+
+ progress.hide()
+ ui.messageBox(message)
+
+
+def postToolpaths(ui, cam, viewResult):
+ # Check CAM data exists.
+ if not cam:
+ ui.messageBox('No CAM data exists in the active document.')
+ return
+
+ # Verify that there are any setups.
+ if cam.allOperations.count == 0:
+ ui.messageBox('No CAM operations exist in the active document.')
+ return
+
+ setupsCount = cam.setups.count
+ if setupsCount < 2:
+ ui.messageBox('Only 1 setup, requires an additive & milling setup to work')
+ return
+ if setupsCount > 2:
+ ui.messageBox('Too many setups, requires an additive & milling setup to work')
+ return
+
+ outputFolder = cam.temporaryFolder
+
+ # specify the NC file output units
+ units = adsk.cam.PostOutputUnitOptions.DocumentUnitsOutput
+
+ for i in range(setupsCount):
+ setup = cam.setups.item(i)
+ setupOperationType = None
+ try:
+ setupOperationType = setup.operationType
+ except:
+ pass # there is a bug in Fusion as of writing that means Additive setups don't have an operation type
+
+ if setupOperationType == adsk.cam.OperationTypes.MillingOperation:
+ programName = 'tmpSubtractive'
+ postConfig = os.path.join(os.path.dirname(os.path.dirname(os.path.realpath(__file__))), 'post_processors', 'asmbl_cam.cps')
+
+ # create the postInput object
+ postInput = adsk.cam.PostProcessInput.create(programName, postConfig, outputFolder, units)
+ postInput.isOpenInEditor = viewResult
+
+ cam.postProcess(setup, postInput)
+
+ elif setupOperationType == None:
+ programName = 'tmpAdditive'
+ postConfig = os.path.join(os.path.dirname(os.path.dirname(os.path.realpath(__file__))), 'post_processors', 'asmbl_fff.cps')
+
+ # create the postInput object
+ postInput = adsk.cam.PostProcessInput.create(programName, postConfig, outputFolder, units)
+ postInput.isOpenInEditor = viewResult
+
+ cam.postProcess(setup, postInput)
+
+ # open the output folder in Finder on Mac or in Explorer on Windows
+ if (os.name == 'posix'):
+ os.system('open "%s"' % outputFolder)
+ elif (os.name == 'nt'):
+ os.startfile(outputFolder)
+
+
+# Event handler that reacts when the command definitio is executed which
+# results in the command being created and this event being fired.
+class PostProcessCreatedEventHandler(adsk.core.CommandCreatedEventHandler):
+ def __init__(self):
+ super().__init__()
+
+ def notify(self, args):
+ try:
+ app = adsk.core.Application.get()
+ ui = app.userInterface
+
+ # Get the command that was created.
+ cmd = adsk.core.Command.cast(args.command)
+
+ # Connect to the execute event.
+ onExecute = PostProcessExecuteHandler()
+ cmd.execute.add(onExecute)
+ handlers.append(onExecute)
+
+ # Get the CommandInputs collection associated with the command.
+ inputs = cmd.commandInputs
+
+ # # Create setup tab input.
+ # tabCmdInputSetup = inputs.addTabCommandInput('setup', 'Setup')
+ # tabSetupChildInputs = tabCmdInputSetup.children
+
+ # # Create input setups group.
+ # groupSetupCmdInput = tabSetupChildInputs.addGroupCommandInput('inputSetups', 'Input Setups')
+ # groupSetupCmdInput.isExpanded = True
+ # groupSetupChildInputs = groupSetupCmdInput.children
+
+ # # Create selection inputs for setups.
+ # additiveSetup = groupSetupChildInputs.addSelectionInput(
+ # 'additiveSetup', 'Additive Setup', 'Select the additive setup')
+ # additiveSetup.setSelectionLimits(1)
+
+ # camSetup = groupSetupChildInputs.addSelectionInput('camSetup', 'CAM Setup', 'Select the milling setup')
+ # camSetup.setSelectionLimits(1)
+
+ # Create settings tab inputs
+ tabCmdInputSettings = inputs.addTabCommandInput('settings', 'Settings')
+ tabSettingsChildInputs = tabCmdInputSettings.children
+
+ # Create bool value input to check whether you should generate toolpaths.
+ generateToolpathsInput = tabSettingsChildInputs.addBoolValueInput('generateToolpaths', 'Generate Toolpaths', True, '', False)
+ generateToolpathsInput.tooltip = 'Regenerated all toolpaths.'
+
+ viewIntermediateFilesInput = tabSettingsChildInputs.addBoolValueInput('viewIntermediateFiles', 'View Intermediate Files', True, '', False)
+ viewIntermediateFilesInput.tooltip = 'Pre-merged gcode files will be opened in your default txt editor.'
+
+ # Create an editable textbox input.
+ tabSettingsChildInputs.addTextBoxCommandInput('outputName', 'Output File Name', '1001', 1, False)
+
+ # groupPrintCmdInput = tabSettingsChildInputs.addGroupCommandInput('print', 'Print Settings')
+ # groupPrintCmdInput.isExpanded = True
+ # groupPrintChildInputs = groupPrintCmdInput.children
+
+ groupCamCmdInput = tabSettingsChildInputs.addGroupCommandInput('cam', 'CAM Settings')
+ groupCamCmdInput.isExpanded = True
+ groupCamChildInputs = groupCamCmdInput.children
+
+ # Create CAM inputs
+ layerOverlapInput = groupCamChildInputs.addIntegerSpinnerCommandInput('layerOverlap', 'Layer Overlap', 0, 10000, 1, 1)
+ layerOverlapInput.tooltip = 'Controls how many layers the cutting tip should overlap previously cut layers'
+ layerOverlapInput.tooltipDescription = '\
+
A higher value generally makes for a better finish as it uses the side of the cutter instead of the tip, \
+ however this is not always possible depending on the geometry.\
+
Limited by cutter length\
+
This does not alter the toolpath, only when it happens'
+ layerOverlapInput.toolClipFilename = os.path.join(os.path.dirname(os.path.dirname(os.path.realpath(__file__))), 'resources', 'GenerateAsmbl', 'tooltip_overlap.png')
+
+ layerDropdownInput = groupCamChildInputs.addFloatSpinnerCommandInput('layerDropdown', 'Layer Dropdown', 'mm', 0, 1, 0.1, 0)
+ layerDropdownInput.tooltip = 'Controls how much the cutting tip should be lowered on a global level'
+ layerDropdownInput.tooltipDescription = '\
+
Set this to 0 mm for accurate parts. Setting it equal to half a layer height can create smoother cut surfaces\
+
This shifts the entire subtractive toolpath by this amount