Beta -- DynaPath Delta PP

Here's the place for discussion related to CAM/CNC and the development of the Path module.
Forum rules
Be nice to others! Respect the FreeCAD code of conduct!
Post Reply
User avatar
luvtofish
Posts: 83
Joined: Thu Mar 31, 2022 8:45 pm

Beta -- DynaPath Delta PP

Post by luvtofish »

I now have a working post processor that caters to the Dynapath Delta 40, 50 and 60 Control's. It is a work in progress and will likely require further tweaks as the FreeCAD Path engine continues to evolve. I've created several FreeCAD models with G81-G83 drill cycles, internal and external arcs, int and ext profiles, facemill ops, etc. and have not had to modify the resulting NC program beyond what is delivered by the PP. I have not tested arcs in the XZ or YZ planes, but the code is included for testing this. I began with sliptonic's LinuxCNC Post and added pieces from other Posts such as Philips and Grbl. There is likely further code cleanup that can be done but wanted to get this out there for anyone who may be looking for a post that works on this control.

In order to use this PP, the PathPost.py file in the pathscripts folder requires a simple modification. The Dynapath does not like the "GO Zxxx" command that is inserted after the Fixture assignment. I was unsuccessful at removing it via the post processor code so I made the following modification in the PathPost.py file to remove it from the output.
PathPost-MOD.jpg
PathPost-MOD.jpg (44.03 KiB) Viewed 723 times

DynaPath Delta Post processor (delta_post.py) attached below:

Dan

Code: Select all

# ***************************************************************************
# *   Copyright (c) 2014 sliptonic <shopinthewoods@gmail.com>               *
# *                                                                         *
# *   This file is part of the FreeCAD CAx development system.              *
# *                                                                         *
# *   This program is free software; you can redistribute it and/or modify  *
# *   it under the terms of the GNU Lesser General Public License (LGPL)    *
# *   as published by the Free Software Foundation; either version 2 of     *
# *   the License, or (at your option) any later version.                   *
# *   for detail see the LICENCE text file.                                 *
# *                                                                         *
# *   FreeCAD is distributed in the hope that it will be useful,            *
# *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
# *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
# *   GNU Lesser General Public License for more details.                   *
# *                                                                         *
# *   You should have received a copy of the GNU Library General Public     *
# *   License along with FreeCAD; if not, write to the Free Software        *
# *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  *
# *   USA                                                                   *
# *                                                                         *
# *   Additional changes 2020 adding arguments to control units, precision  *
# *   editor, header, etc. Now uses FreeCAD unit system to correctly        *
# *   set Feed rate - sliptonic                                             *
# *                                                                         *
# *   This file has been modified from Sliptonic original Linux CNC post    *
# *   for use with Dynapath Delta 40M,50M,60M controllers. All changes        *
# *   and modifications (c) luvtofish (luvtofish@gmail.com) 2022            *
# *                                                                         *
# ***************************************************************************

from __future__ import print_function
import FreeCAD
from FreeCAD import Units
import Path
import argparse
import datetime
import shlex
from PathScripts import PostUtils
from PathScripts import PathAreaOp


TOOLTIP = """
This is a postprocessor file for the FreeCAD Path workbench. It is used to
take a pseudo-gcode fragment outputted by a Path object, and output
real GCode suitable for Dynapath Delta 40,50, & 60 Controls. It has been written
and tested on FreeCAD Path workbench bundled with FreeCAD v20.
This postprocessor, once placed in the appropriate PathScripts folder, can be 
used directly from inside FreeCAD, via the GUI importer or via python scripts with: 

import delta_post
delta_post.export(object,"/path/to/file.ncc","")
"""

parser = argparse.ArgumentParser(prog="delta_post", add_help=False)
parser.add_argument("--no-header", action="store_true", help="suppress header output")
parser.add_argument(
    "--no-comments", action="store_true", help="suppress comment output"
)
parser.add_argument(
    "--line-numbers", action="store_true", help="prefix with line numbers"
)
parser.add_argument(
    "--no-show-editor",
    action="store_true",
    help="don't pop up editor before writing output",
)
parser.add_argument(
    "--precision", default="3", help="number of digits of precision, default=3"
)
parser.add_argument(
    "--preamble",
    help='set commands to be issued before the first command, default="G17\nG90\nG80\nG40"',
)
parser.add_argument(
    "--postamble",
    help='set commands to be issued after the last command, default="M09\nM05\nG80\nG40\nG17\nG90\nM30"',
)
parser.add_argument(
    "--inches", action="store_true", help="Convert output for US imperial mode (G70)"
)
parser.add_argument(
    "--modal",
    action="store_true",
    help="Suppress outputting the Same G-command",
)
parser.add_argument(
    "--axis-modal",
    action="store_true",
    help="Suppress outputting identical axis position",
)

TOOLTIP_ARGS = parser.format_help()

now = datetime.datetime.now()

# These globals set common customization preferences
OUTPUT_COMMENTS = True
OUTPUT_HEADER = True
OUTPUT_LINE_NUMBERS = False
SHOW_EDITOR = True
MODAL = False  # if true commands are suppressed if the same as previous line.
USE_TLO = False  # if true G43 will be output following tool changes
OUTPUT_DOUBLES = (
    True  # if false duplicate axis values are suppressed if the same as previous line.
)
COMMAND_SPACE = ""
LINENR = 0  # line number starting value
DWELL_TIME = 1  # Number of seconds to allow spindle to come up to speed.
RETRACT_MODE = False
QCYCLE_RANGE = (
    "G81",
    "G82",
    "G83",
    "G84",
    "G85",
)  # Quill Cycle range for conditional to enable 2nd reference plane.
SPINDLE_SPEED = 0
# These globals will be reflected in the Machine configuration of the project
UNITS = "G71"  # G71 for metric, G70 for US standard
UNIT_SPEED_FORMAT = "mm/min"
UNIT_FORMAT = "mm"
MACHINE_NAME = "TreeCNC"
CORNER_MIN = {"x": 0, "y": 0, "z": 0}
CORNER_MAX = {"x": 660, "y": 355, "z": 152}
PRECISION = 3

ABSOLUTE_CIRCLE_CENTER = True
# possible values:
#                  True      use absolute values for the circle center in commands G2, G3
#                  False     values for I & J are incremental from last point

# Create Map/ for renaming Fixture Commands from Gxx to Exx
GCODE_MAP = {
    "G54": "E01",
    "G55": "E02",
    "G56": "E03",
    "G57": "E04",
    "G58": "E05",
    "G59": "E06",
}

# Preamble text will appear at the beginning of the GCODE output file.
PREAMBLE = """G17
G90
G80
G40
"""

# Postamble text will appear following the last operation.
POSTAMBLE = """M05
G80
G40
G17
G90
M30
"""
clearanceHeight = None

# to distinguish python built-in open function from the one declared below
if open.__module__ in ["__builtin__", "io"]:
    pythonopen = open


def processArguments(argstring):
    global OUTPUT_HEADER
    global OUTPUT_COMMENTS
    global OUTPUT_LINE_NUMBERS
    global SHOW_EDITOR
    global PRECISION
    global PREAMBLE
    global POSTAMBLE
    global UNITS
    global UNIT_SPEED_FORMAT
    global UNIT_FORMAT
    global MODAL
    global USE_TLO
    global OUTPUT_DOUBLES

    try:
        args = parser.parse_args(shlex.split(argstring))
        if args.no_header:
            OUTPUT_HEADER = False
        if args.no_comments:
            OUTPUT_COMMENTS = False
        if args.line_numbers:
            OUTPUT_LINE_NUMBERS = True
        if args.no_show_editor:
            SHOW_EDITOR = False
            print("Show editor = %d" % SHOW_EDITOR)
        if args.precision is not None:
            PRECISION = args.precision
        if args.preamble is not None:
            PREAMBLE = args.preamble
        if args.postamble is not None:
            POSTAMBLE = args.postamble
        if args.inches:
            UNITS = "G70"
            UNIT_SPEED_FORMAT = "in/min"
            UNIT_FORMAT = "in"
            PRECISION = 3
        if args.modal:
            MODAL = True
            print("Command duplicates suppressed")
        if args.axis_modal:
            OUTPUT_DOUBLES = False
            print("Doubles suppressed")

    except Exception:
        return False

    return True


def export(objectslist, filename, argstring):
    if not processArguments(argstring):
        return None
    global UNITS
    global UNIT_FORMAT
    global UNIT_SPEED_FORMAT
    global clearanceHeight

    for obj in objectslist:
        if not hasattr(obj, "Path"):
            print(
                "the object "
                + obj.Name
                + " is not a path. Please select only path and Compounds."
            )
            return None

    print("postprocessing...")
    gcode = ""

    # write header
    if OUTPUT_HEADER:
        gcode += "(%s)\n" % str.upper(
            obj.Document.Label[0:8]
        )  # Added program name entry and limited to 8 chars.
        gcode += linenumber() + "(T)" + "EXPORTED BY FREECAD$\n"
        gcode += linenumber() + "(T)" + str.upper("Post Processor: " + __name__) + "$\n"
        gcode += linenumber() + "(T)" + str.upper("Output Time:") + str(now) + "$\n"

    # Write the preamble
    if OUTPUT_COMMENTS:
        gcode += linenumber() + "(T)" + "BEGIN PREAMBLE$\n"
    for line in PREAMBLE.splitlines(True):
        gcode += linenumber() + line
    gcode += linenumber() + UNITS + "\n"

    for obj in objectslist:

        # Skip inactive operations
        if hasattr(obj, "Active"):
            if not obj.Active:
                continue
        if hasattr(obj, "Base") and hasattr(obj.Base, "Active"):
            if not obj.Base.Active:
                continue
        if hasattr(obj, "ClearanceHeight"):
            clearanceHeight = obj.ClearanceHeight.Value

        # Fix fixture Offset label...
        if obj.Label in GCODE_MAP:
            obj.Label = GCODE_MAP[obj.Label]

        # do the pre_op
        if OUTPUT_COMMENTS:
            gcode += (
                linenumber()
                + "(T)"
                + str.upper("begin operation: " + obj.Label)
                + "$\n"
            )
            gcode += (
                linenumber()
                + "(T)"
                + str.upper("machine units: ")
                + "%s/%s$\n"
                % (str.upper(UNIT_SPEED_FORMAT[0:2]), str.upper(UNIT_SPEED_FORMAT[3:6]))
            )

        # get coolant mode
        coolantMode = "None"
        if (
            hasattr(obj, "CoolantMode")
            or hasattr(obj, "Base")
            and hasattr(obj.Base, "CoolantMode")
        ):
            if hasattr(obj, "CoolantMode"):
                coolantMode = obj.CoolantMode
            else:
                coolantMode = obj.Base.CoolantMode

        # turn coolant on if required
        if OUTPUT_COMMENTS:
            if not coolantMode == "None":
                gcode += (
                    linenumber()
                    + "(T)"
                    + str.upper("Coolant On:" + coolantMode)
                    + "$\n"
                )
        if coolantMode == "Flood":
            gcode += linenumber() + "M8" + "\n"
        # if coolantMode == "Mist":
        #    gcode += linenumber() + "M7" + "\n"

        # process the operation gcode
        gcode += parse(obj)

        # do the post_op
        if OUTPUT_COMMENTS:
            gcode += (
                linenumber()
                + "(T)"
                + str.upper("finish operation: " + obj.Label)
                + "$\n"
            )

        # turn coolant off if required
        if not coolantMode == "None":
            if OUTPUT_COMMENTS:
                gcode += (
                    linenumber()
                    + "(T)"
                    + str.upper("Coolant Off:" + coolantMode)
                    + "$\n"
                )
            gcode += linenumber() + "M9" + "\n"

    # do the post_amble
    if OUTPUT_COMMENTS:
        gcode += linenumber() + "(T)" + "BEGIN POSTAMBLE$\n"
    for line in POSTAMBLE.splitlines(True):
        gcode += linenumber() + line
    gcode += "E\n"

    if FreeCAD.GuiUp and SHOW_EDITOR:
        dia = PostUtils.GCodeEditorDialog()
        dia.editor.setText(gcode)
        result = dia.exec_()
        if result:
            final = dia.editor.toPlainText()
        else:
            final = gcode
    else:
        final = gcode

    print("done postprocessing.")

    if not filename == "-":
        gfile = pythonopen(filename, "w")
        gfile.write(final)
        gfile.close()

    return final


def linenumber():
    global LINENR
    if OUTPUT_LINE_NUMBERS is True:
        LINENR += 1
        return "N" + "%04d" % (
            LINENR
        )  # + " "  # Added formating for 4 digit line number.
    return ""


def parse(pathobj):
    global PRECISION
    global MODAL
    global OUTPUT_DOUBLES
    global UNIT_FORMAT
    global UNIT_SPEED_FORMAT
    global RETRACT_MODE
    global DWELL_TIME
    global clearanceHeight

    lastX = 0
    lastY = 0
    lastZ = 0
    out = ""
    lastcommand = None
    precision_string = "." + str(PRECISION) + "f"
    currLocation = {}  # keep track for no doubles

    # the order of parameters
    # params = ['X','Y','Z','A','B','I','J','K','F','S'] #This list control the order of parameters
    params = [
        "X",
        "Y",
        "Z",
        "A",
        "B",
        "C",
        "I",
        "J",
        "F",
        "S",
        "T",
        "Q",
        "R",
        "L",
        "K",
        "P",
        "O",
    ]

    firstmove = Path.Command("G0", {"X": -1, "Y": -1, "Z": -1, "F": 0.0})
    currLocation.update(firstmove.Parameters)  # set first location parameters

    if hasattr(pathobj, "Group"):  # We have a compound or project.
        if OUTPUT_COMMENTS:
            out += (
                linenumber() + "(T)" + str.upper("compound: " + pathobj.Label) + "$\n"
            )
        for p in pathobj.Group:
            out += parse(p)
        return out
    else:  # parsing simple path

        # groups might contain non-path things like stock.
        if not hasattr(pathobj, "Path"):
            return out

        for c in pathobj.Path.Commands:
            outstring = []
            command = c.Name
            # Convert G54-G59 Fixture offsets to E01-E06 for Dynapath Delta Control
            if command in GCODE_MAP:
                command = GCODE_MAP[command]

            if command.startswith("("):
                if OUTPUT_COMMENTS:
                    command = "(T)" + str.upper(command) + "$"

            outstring.append(command)

            # if modal: suppress the command if it is the same as the last one
            if MODAL is True:
                if command == lastcommand:
                    outstring.pop(0)

            if c.Name[0] == "(" and not OUTPUT_COMMENTS:  # command is a comment
                continue

            # Now add the remaining parameters in order
            for param in params:
                if param in c.Parameters:
                    if param == "F" and (
                        currLocation[param] != c.Parameters[param] or OUTPUT_DOUBLES
                    ):
                        if c.Name not in [
                            "G0",
                            "G00",
                        ]:
                            speed = Units.Quantity(
                                c.Parameters["F"], FreeCAD.Units.Velocity
                            )
                            if speed.getValueAs(UNIT_SPEED_FORMAT) > 0.0:
                                outstring.append(
                                    param
                                    + format(
                                        float(speed.getValueAs(UNIT_SPEED_FORMAT)),
                                        precision_string,
                                    )
                                )
                        else:
                            continue
                    elif param == "Z" and (
                        c.Parameters["Z"] == clearanceHeight
                        and c.Parameters["Z"] != lastZ
                    ):
                        x = 0
                        y = 0
                        outstring.insert(
                            1,
                            "X"
                            + PostUtils.fmt(x, PRECISION, UNITS)
                            + "Y"
                            + PostUtils.fmt(y, PRECISION, UNITS),
                        )
                        outstring.append(
                            param + PostUtils.fmt(c.Parameters["Z"], PRECISION, UNITS)
                        )
                    elif param == "X" and (command in QCYCLE_RANGE):
                        pos = Units.Quantity(c.Parameters["X"], FreeCAD.Units.Length)
                        outstring.append(
                            param
                            + format(
                                float(pos.getValueAs(UNIT_FORMAT)), precision_string
                            )
                        )
                    elif param == "Y" and (command in QCYCLE_RANGE):
                        pos = Units.Quantity(c.Parameters["Y"], FreeCAD.Units.Length)
                        outstring.append(
                            param
                            + format(
                                float(pos.getValueAs(UNIT_FORMAT)), precision_string
                            )
                        )
                    # Remove X and Y betwen QCYCLE's since we already included them.
                    elif lastcommand in QCYCLE_RANGE and (param == "X" or "Y"):
                        outstring = []
                    elif param == "S":
                        SPINDLE_SPEED = c.Parameters["S"]
                        outstring.append(
                            param + "{:.0f}".format(c.Parameters["S"])
                        )  # Added formating to strip trailing .000 from RPM
                    elif param == "T":
                        outstring.append(
                            param + "{:.0f}".format(c.Parameters["T"])
                        )  # Added formating to strip trailing .000 from Tool number
                    elif param == "I" and (command == "G2" or command == "G3"):
                        # Convert incremental arc center to absolute in I and J
                        i = c.Parameters["I"]
                        if ABSOLUTE_CIRCLE_CENTER:
                            i += lastX
                            outstring.append(param + PostUtils.fmt(i, PRECISION, UNITS))
                    elif param == "J" and (command == "G2" or command == "G3"):
                        # Convert incremental arc center to absolute in I and J
                        j = c.Parameters["J"]
                        if ABSOLUTE_CIRCLE_CENTER:
                            j += lastY
                            outstring.append(param + PostUtils.fmt(j, PRECISION, UNITS))
                    elif param == "K" and (command == "G2" or command == "G3"):
                        # Convert incremental arc center to absolute in K (Z axis arc)
                        k = c.Parameters["K"]
                        if ABSOLUTE_CIRCLE_CENTER:
                            k += lastZ
                            if command == ("G18" or "G19"):
                                outstring.append(
                                    param + PostUtils.fmt(k, PRECISION, UNITS)
                                )
                    elif param == "Q":
                        pos = Units.Quantity(c.Parameters["Q"], FreeCAD.Units.Length)
                        outstring.append(
                            "K"
                            + format(
                                float(pos.getValueAs(UNIT_FORMAT)), precision_string
                            )
                        )
                    elif (param == "R") and ((command in QCYCLE_RANGE)):
                        pos = Units.Quantity(
                            pathobj.ClearanceHeight.Value, FreeCAD.Units.Length
                        )
                        outstring.insert(
                            6,
                            "O"
                            + format(
                                float(pos.getValueAs(UNIT_FORMAT)), precision_string
                            ),
                        )  # Insert "O" param for 2nd reference plane (Clearance Height)
                        pos = Units.Quantity(c.Parameters["R"], FreeCAD.Units.Length)
                        outstring.append(
                            param
                            + format(
                                float(pos.getValueAs(UNIT_FORMAT)), precision_string
                            )
                        )  # First Reference plan (Safe Height)
                    elif param == "P":
                        outstring.append(
                            "L" + format(c.Parameters[param], precision_string)
                        )
                    else:
                        if (
                            (not OUTPUT_DOUBLES)
                            and (param in currLocation)
                            and (currLocation[param] == c.Parameters[param])
                        ):
                            continue
                        else:
                            pos = Units.Quantity(
                                c.Parameters[param], FreeCAD.Units.Length
                            )
                            outstring.append(
                                param
                                + format(
                                    float(pos.getValueAs(UNIT_FORMAT)), precision_string
                                )
                            )

            # save the last X, Y values
            if "X" in c.Parameters:
                lastX = c.Parameters["X"]
            if "Y" in c.Parameters:
                lastY = c.Parameters["Y"]
            if "Z" in c.Parameters:
                lastZ = c.Parameters["Z"]

            # store the latest command
            lastcommand = command
            currLocation.update(c.Parameters)

            # Check for Tool Change:
            if command == "M6":
                if OUTPUT_COMMENTS:
                    out += linenumber() + "(T)" + "BEGIN TOOLCHANGE$\n"

            if command == "message":
                if OUTPUT_COMMENTS is False:
                    out = []
                else:
                    outstring.pop(0)  # remove the command
            # G98 is not used by dynapath and G99 is not used in Drilling/Boring/Tapping.
            if c.Name == "G98" or (c.Name == "G99" and pathobj.Label == "Drilling"):
                outstring = []

            # prepend a line number and append a newline
            if len(outstring) >= 1:
                if OUTPUT_LINE_NUMBERS:
                    outstring.insert(0, (linenumber()))

                # append the line to the final output
                for w in outstring:
                    out += w.strip() + COMMAND_SPACE
                out += "\n"

            # Add a DWELL after spindle start based on RPM.
            if DWELL_TIME > 0.0:
                if command in ["M3", "M03", "M4", "M04"]:
                    DWELL_TIME = (SPINDLE_SPEED / 100) / 10
                    out += linenumber() + "L%.1f\n" % DWELL_TIME

        return out


# print(__name__ + " gcode postprocessor loaded.")


Last edited by luvtofish on Wed May 25, 2022 1:40 am, edited 2 times in total.
User avatar
luvtofish
Posts: 83
Joined: Thu Mar 31, 2022 8:45 pm

Re: Beta -- DynaPath Delta PP

Post by luvtofish »

Not sure why, but found an issue with the post processor on Linux using the latest AppImage.

Code: Select all

File "/home/dhenderson/FreeCAD/delta_post.py", line 465, in parse
    elif param == "Z" and (c.Parameters["Z"] == pathobj.ClearanceHeight.Value and

'_TempObject' object has no attribute 'ClearanceHeight'
The line of code in question is utilizing the pathobj.ClearanceHeight.Value to insert X and Y values in the solo Z parameter line(s) that get inserted at the beginning and end of of each new Operation. Dynapath barfs all over this if there is no X / Y defined WITH the Z move on the initial G0.

This code works perfectly fine on the latest Windows Conda image. Any idea why it works on one and not the other? I'm going to assume it's because the windows distribution comes with all the relevant folders and supporting PathScript files along with the binary. Whereas the Linux AppImage only has the singe binary. Can anyone confirm this?
User avatar
luvtofish
Posts: 83
Joined: Thu Mar 31, 2022 8:45 pm

Re: Beta -- DynaPath Delta PP

Post by luvtofish »

Okay -- After further investigation it seems this is now broken in both Linux and Windows on the very latest "weekly development build". That's a better problem to have because if I solve it once it should be solved in both places ;)

UPDATE:
Issue resolved. It was a case of variable SCOPE. The fix was to assign a global variable to 'obj.ClearanceHeight.Value' within the "export" method. I was then able to access the value in the "parse" method. I've updated the delta_post.py file attachment above!

Code: Select all

OS: CentOS Stream 8 (GNOME/gnome)
Word size of FreeCAD: 64-bit
Version: 0.20.28918 (Git) AppImage
Build type: Release
Branch: (HEAD detached at 69a4963)
Hash: 69a4963ebfdbdda0d069347d013f28f2d6ba687a
Python 3.9.12, Qt 5.12.9, Coin 4.0.0, OCC 7.5.3
Locale: English/United States (en_US)
Installed mods: 
  * Render 2022.1.0
  * A2plus 0.4.56
[/code]
Post Reply