Path scripting/es

Introducción
El banco de trabajo Trayectoria ofrece herramientas para importar, crear, manipular y exportar trayectorias de herramientas de maquina en FreeCAD. Con esto, el usuario es capaz de importar, visualizar y modificar programas existentes de código G, generar trayectorias de herramienta a partir de formas 3D, y exportar estas trayectorias de herramientas a código G.

En el estado actual,piensa que el banco de trabajo Trayectoria esta en muy recientes estados de desarrollo, y no te ofrecerá las muy avanzadas funcionalidades encontradas en algunas alternativas comerciales. Sin embargo, la amplia interface de guión de python lo hace fácil de modificar o desarrollar herramientas mas poderozas, y es por lo tanto hasta ahora mas directo para usuarios con algo de conocimiento de guión de python que los usuarios finales.

Debajo encontraras una descripción mas en profundidad de la API de guión de python.

Inicio rapido
Los objectos trayectoria de FreeCAD son hechos de una secuencia de comandos de movimiento. Un uso típico es este:

Formato de código G interno de FreeCAD
Un concepto preliminar es importante para comprenter.La mayoría de la implementación debajo, se relaciona fuertemente en comandos de movimientos, pero no significa que tiene que ser apegados a una implementación de controlador. Nosotros elegimos nombres tal como 'G0' para representar movimiento'rapido' o 'G1' para representar movimiento 'avance' para rendimiento (guardado de archivo eficiente) y para minimizar el trabajo necesario para traducir de un formato de código G a otro. Desde que el mundo de CNC habla miles de dialetos de código G, nosotros estar junto a un subconjunto muy simplificado de este. Tu podrias describir el formato de código G de FreeCAD como una forma de "agnostica de maquina" para código G.

Inside .FCStd files, Path data is saved directly into that GCode form.

All translations to/from dialects to FreeCAD GCode are done through pre and post scripts. That means that if you want to work with a machine that uses a specific LinuxCNC, Fanuc, Mitusubishi, or HAAS controller etc, you will have to use (or write if inexistant) a post processor for that particular control (see the "Importing and exporting GCode" section below).

GCode reference
The following rules and guidelines define the GCode subset used internally in FreeCAD:


 * GCode data, inside FreeCAD Path objects, is separated into "Commands". A Command is defined by a command name, which must begin with G or M, and (optionally) arguments, which are in the form Letter = Float, for example X 0.02 or Y 3.5 or F 300. These are examples of typical GCode commands in FreeCAD:

G0 X2.5 Y0 (The command name is G0, the arguments are X=2.5 and Y=0)

G1 X30 (The command name is G1, the only argument is X=30)

G90 (The command name is G90, there are no arguments)


 * For the numeric part of a G or M command, both "G1" or "G01" forms are supported.
 * Only commands starting with G or M are supported at the moment.
 * Only millimeters are accepted at the moment. G20/G21 are not considered.
 * Arguments are always sorted alphabetically. This means that if you create a command with "G1 X2 Y4 F300", it will be stored as "G1 F300 X2 Y4"
 * Arguments cannot be repeated inside a same command. For example, "G1 X1 Y2 X2 Y3" will not work. You will need to split it into two commands, for example: "G1 X1 Y2, G1 X2 Y3"
 * X, Y, Z, A, B, C arguments are absolute or relative, depending on the current G90/G91 mode. Default (if not specified) is absolute.
 * I, J, K are always relative to the last point. K can be omitted.
 * X, Y, or Z (and A, B, C) can be omitted. In this case, the previous X, Y or Z coordinates are maintained.
 * Gcode commands other than the ones listed in the table below are supported, that is, they are saved inside the path data (as long as they comply to the rules above, of course), but they simply won't produce any visible result on screen. For example, you could add a G81 command, it will be stored, but not displayed.

The Command object
The Command object represents a gcode command. It has three attributes: Name, Parameters and Placement, and two methods: toGCode and setFromGCode. Internally, it contains only a name and a dictionary of parameters. The rest (placement and gcode) is computed to/from this data.

The Path object
The Path object holds a list of commands As a shortcut, a Path object can also be created directly from a full GCode sequence. It will be divided into a sequence of commands automatically.

The Path feature
The Path feature is a FreeCAD document object, that holds a path, and represents it in the 3D view. The Path feature also holds a Placement property. Changing the value of that placement will change the position of the Feature in the 3D view, although the Path information itself won't be modified. The transformation is purely visual. This allows you, for example, to create a Path around a face that has a particular orientation on your model, that is not the same orientation as your cutting material will have on the CNC machine.

However, Path Compounds can make use of the Placement of their children (see below).

The Tool and Tooltable objects
The Tool object contains the definitions of a CNC tool. The Tooltable object contains an ordered list of tools. Tooltables are attached as a property to Path Project features, and can also be edited via the GUI, by double-clicking a project in the tree view, and clicking the "Edit tooltable" button in the task views that opens.

From that dialog, tooltables can be imported from FreeCAD's .xml and HeeksCad's .tooltable formats, and exported to FreeCAD's .xml format.

The Path Compound feature
The aim of this feature is to gather one or more toolpaths and associate it (them) with a tooltable. The Compound feature also behaves like a standard FreeCAD group, so you can add or remove objects to/from it directly from the tree view. You can also reorder items by double-clicking the Compound object in the Tree view, and reorder its elements in the Task view that opens. An important feature of Path Compounds is the possibility to take into account the Placement of their child paths or not, by setting their UsePlacements property to True or False. If not, the Path data of their children will simply be added sequentially. If True, each command of the child paths, if containing position information (G0, G1, etc..) will first be transformed by the Placement before being added.

Creating a compound with just one child path allows you therefore to turn the child path's Placement "real" (it affects the Path data).

The Path Project feature
The Path project is an extended kind of Compound, that has a couple of additional machine-related properties such as a tooltable. It is made mainly to be the main object type you'll want to export to gcode once your whole path setup is ready. The Project object is now coded in python, so its creation mechanism is a bit different: The Path module also features a GUI tooltable editor that can be called from python, giving it an object that has a ToolTable property:

Getting Path from Shape
Assign the shape of wire Part to a normal Path object, using Path.fronShape script function (or more powerful Path.fronShapes). By giving as parameter a wire Part object, its path will be automatically calculated from the shape. Note that in this case the placement is automatically set to the first point of the wire, and the object is therefore not movable anymore by changing its placement. To move it, the underlying shape itself must be moved.

Python features
Both Path::Feature and Path::FeatureShape features have a python version, respectively named Path::FeaturePython and Path::FeatureShapePython, that can be used in python code to create more advanced parametric objects derived from them.

Native format
GCode files can be directly imported and exported via the GUI, by using the "open", "insert" or "export" menu items. After the file name is acquired, a dialog pops up to ask which processing script must be used. It can also be done from python:

Path information is stored into Path objects using a subset of gcode described in the "FreeCAD's internal GCode format"section above. This subset can be imported or exported "as is", or converted to/from a particular version of GCode suited for your machine.

If you have a very simple and standard GCode program, that complies to the rules described in the "FreeCAD's internal GCode format" section above, for example the boomerang from http://www.cnccookbook.com/GWESampleFiles.html, it can be imported directly into a Path object, without translation (this is equivalent to using the "None" option of the GUI dialog):

In the same manner, you can obtain the path information as "agnostic" gcode, and store it manually in a file:

If you need a different output, though, you will need to convert this agnostic GCode into a format suited for your machine. That is the job of post-processing scripts.

Using pre- and post-processing scripts
If you have a gcode file written for a particular machine, which doesn't comply to the internal rules used by FreeCAD, described in the "FreeCAD's internal GCode format" section above, it might fail to import and/or render properly in the 3D view. To remedy to this, you must use a pre-processing script, which will convert from your machine-specific format to the FreeCAD format.

If you know the name of the pre-processing script to use, you can import your file using it, from the python console like this: In the same manner, you can output a path object to GCode, using a post_processor script like this:

Writing processing scripts
Pre- and post-processing scripts behave like other common FreeCAD imports/exporters. When choosing a pre/post processing script from the dialog, the import/export process will be redirected to the specified given script. Preprocessing scripts must contain at least the following methods open(filename) and insert(filename,docname). Postprocessing scripts need to implement export(objectslist,filename).

Scripts are placed into either the Mod/Path/PathScripts folder or the user's macro path directory. You can give them any name you like but by convention, and to be picked by the GUI dialog, pre-processing scripts names must end with "_pre", post-processing scripts with "_post" (make sure to use the underscore, not the hyphen, otherwise python cannot import it). This is an example of a very, very simple preprocessor. More complex examples are found in the Mod/Path/PathScripts folder: Pre- and post-processors work exactly the same way. They just do the contrary: The pre scripts convert from specific GCode to FreeCAD's "agnostic" GCode, while post scripts convert from FreeCAD's "agnostic" GCode to machine-specific GCode.

Adding all faces of a ShapeString to the BaseFeature's list of a ProfileFromFaces operation
This example is based on a discussion in the german forum.

Prerequisits

 * Create a solid with ShapeString as Cutout
 * Create a Job using this solid as its BaseObject
 * Create a ProfileFromFaces operation named "Profile_Faces" with empty BaseGeometry.

The code
The following code will then add all faces from ShapeString and create the paths: