Neuzuordnung (engl. remap) für das Erweitern von G-Code

Mit "Neuzuordnung" (engl. Remapping) von Codes meinen wir eine der folgenden Optionen:

Der Satz von Codes (M,G,T,S,F), die derzeit vom RS274NGC-Interpreter verstanden werden, ist festgelegt und kann nicht durch Konfigurationsoptionen erweitert werden.

In particular, some of these codes implement a fixed sequence of steps to be executed. While some of these, like M6, can be moderately configured by activating or skipping some of these steps through INI file options, overall the behavior is fairly rigid. So - if your are happy with this situation, then this manual section is not for you.

In many cases, this means that supporting a non out of the box configuration or machine is either cumbersome or impossible, or requires resorting to changes at the C/C+\+ language level. The latter is unpopular for good reasons - changing internals requires in-depth understanding of interpreter internals, and moreover brings its own set of support issues. While it is conceivable that certain patches might make their way into the main LinuxCNC distribution, the result of this approach is a hodge-podge of special-case solutions.

A good example for this deficiency is tool change support in LinuxCNC: While random tool changers are well supported, it is next to impossible to reasonably define a configuration for a manual-tool change machine with, for example, an automatic tool length offset switch being visited after a tool change, and offsets set accordingly. Also, while a patch for a very specific rack tool changer exists, it has not found its way back into the main code base.

However, many of these things may be fixed by using an O-word procedure instead of a built in code - whenever the - insufficient - built in code is to be executed, call the O-word procedure instead. While possible, it is cumbersome - it requires source-editing of NGC programs, replacing all calls to the deficient code by a an O-word procedure call.

In its simplest form, a remapped code isn’t much more than a spontaneous call to an O-word procedure. This happens behind the scenes - the procedure is visible at the configuration level, but not at the NGC program level.

Im Allgemeinen kann das Verhalten eines umgewandelten Codes wie folgt definiert werden:

M- und G-Codes und O-Wörter Unterprogrammaufrufe haben eine recht unterschiedliche Syntax.

O-Wort-Prozeduren zum Beispiel nehmen Positionsparameter mit einer bestimmten Syntax wie folgt:

whereas M- or G-codes typically take required or optional word parameters. For instance, G76 (threading) requires the P,Z,I,J and K words, and optionally takes the R,Q,H, E and L words.

So it isn’t simply enough to say whenever you encounter code X, please call procedure Y - at least some checking and conversion of parameters needs to happen. This calls for some glue code between the new code, and its corresponding NGC procedure to execute before passing control to the NGC procedure.

This glue code is impossible to write as an O-word procedure itself, since the RS274NGC language lacks the introspective capabilities and access into interpreter internal data structures to achieve the required effect. Doing the glue code in - again - C/C+\+ would be an inflexible and therefore unsatisfactory solution.

Um eine einfache Situation einfach und eine komplexe Situation lösbar zu machen, wird das Problem des Glue Codes als Zwischenebene wie folgt angegangen:

Embedded Python functions in the Interpreter started out as glue code, but turned out very useful well beyond that. Users familiar with Python will likely find it easier to write remapped codes, glue, O-word procedures, etc. in pure Python, without resorting to the somewhat cumbersome RS274NGC language at all.

Many people are familiar with extending the Python interpreter by C/C++ modules, and this is heavily used in LinuxCNC to access Task, HAL and Interpreter internals from Python scripts. Extending Python basically means: Your Python script executes as it is in the driver seat, and may access non-Python code by importing and using extension modules written in C/C+\+. Examples for this are the LinuxCNC hal, gcode and emc modules.

Embedded Python is a bit different and less commonly known: The main program is written in C/C++ and may use Python like a subroutine. This is powerful extension mechanism and the basis for the scripting extensions found in many successful software packages. Embedded Python code may access C/C+\+ variables and functions through a similar extension module method.

Please note that currently only some existing codes can be redefined, while there are many free codes that may be available for remapping. When developing redefined existing code, it is a good idea to start with an unassigned G- or M- code, so that you can use both an existing behavior as well as a new one. When you’re done, redefine the existing code to use your remapping configuration.

Derzeit gibt es zwei vollständige, nur in Python verfügbare Remaps, die in stdglue.py verfügbar sind:

Diese sind für die Verwendung mit Drehmaschinen gedacht. Drehbänke verwenden nicht M6, um die Werkzeuge zu indexieren, sondern den Befehl T.

This remap also adds wear offsets to the tool offset, e.g. T201 would index to tool 2 (with tool 2’s tool offset) and adds wear offset 1. In the tool table, tools numbers above 10000 are wear offsets, e.g. in the tool table, tool 10001 would be wear offset 1.

Hier ist, was Sie in der INI brauchen, um sie zu verwenden:

You must also add the required Python file in your configuration folder.

Upgrade einer bestehenden Konfiguration

Note that currently only a few existing codes may be redefined, whereas there are many free codes which might be made available by remapping. When developing a redefined existing code, it might be a good idea to start with an unallocated G- or M-code, so both the existing and new behavior can be exercised. When done, redefine the existing code to use your remapping setup.

Let’s assume the new code will be defined by an NGC procedure, and needs some parameters, some of which might be required, others might be optional. We have the following options to feed values to the procedure:

The first method is preferred for parameters of dynamic nature, like positions. You need to define which words on the current block have any meaning for your new code, and specify how that is passed to the NGC procedure. Any easy way is to use the argspec statement. A custom prolog might provide better error messages.

Using to INI file variables is most useful for referring to setup information for your machine, for instance a fixed position like a tool-length sensor position. The advantage of this method is that the parameters are fixed for your configuration, regardless which NGC file you’re currently executing.

Es ist immer möglich, auf globale Variablen zu verweisen, aber sie werden leicht übersehen.

Beachten Sie, dass es nur eine begrenzte Anzahl von Wörtern gibt, die als Parameter verwendet werden können, so dass man möglicherweise auf die zweite und dritte Methode zurückgreifen muss, wenn viele Parameter benötigt werden.

Your new code might succeed or fail, for instance if passed an invalid parameter combination. Or you might choose to just execute the procedure and disregard results, in which case there isn’t much work to do.

Epilog-Handler helfen bei der Verarbeitung der Ergebnisse von Remap-Prozeduren - siehe den Referenzabschnitt.

Ausführbare G-Code-Wörter werden in Modalgruppen eingeteilt, was auch ihr relatives Ausführungsverhalten definiert.

Wenn ein G-Code-Block mehrere ausführbare Wörter in einer Zeile enthält, werden diese Wörter in einer vordefinierten Ausführungsreihenfolge ausgeführt, nicht in der Reihenfolge, in der sie im Block erscheinen.

When you define a new executable code, the interpreter does not yet know where your code fits into this scheme. For this reason, you need to choose an appropriate modal group for your code to execute in.

To give you an idea how the pieces fit together, let’s explore a fairly minimal but complete remapped code definition. We choose an unallocated M-code and add the following option to the INI file:

Zusammengefasst bedeutet dies:

Es wird erwartet, dass die Datei myprocedure.ngc im Verzeichnis [DISPLAY]NC_FILES oder [RS274NGC]SUBROUTINE_PATH existiert.

Eine ausführliche Erläuterung der REMAP (engl. für Neuzuordnung)-Parameter finden Sie im folgenden Referenzteil.

To remap a code, define it using the REMAP option in RS274NG section of your INI file. Use one REMAP line per remapped code.

Die Syntax von REMAP lautet:

It is an error to omit the <code> parameter.

The options of the REMAP statement are separated by whitespace. The options are keyword-value pairs and currently are:

The python, prolog and epilog options require the Python Interpreter plugin to be configured, and appropriate Python functions to be defined there so they can be referred to with these options.

The syntax for defining a new code, and redefining an existing code is identical.

Note that while many combinations of argspec options are possible, not all of them make sense. The following combinations are useful idioms:

Note that if all you want to achieve is to call some Python code from G-code, there is the somewhat easier way of calling Python functions like O-word procedures.

The argument specification (keyword argspec) describes required and optional words to be passed to an ngc procedure, as well as optional preconditions for that code to execute.

An argspec consists of 0 or more characters of the class [@A-KMNP-Za-kmnp-z^>]. It can by empty (like argspec=).

An empty argspec, or no argspec argument at all implies the remapped code does not receive any parameters from the block. It will ignore any extra parameters present.

Note that RS274NGC rules still apply - for instance you may use axis words (e.g., X, Y, Z) only in the context of a G-code.

Axis words may also only be used if the axis is enabled. If only XYZ are enabled, ABCUVW will not be available to be used in argspec.

Words F, S and T (short FST) will have the normal functions but will be available as variables in the remapped function. F will set feedrate, S will set spindle RPM, T will trigger the tool prepare function. Words FST should not be used if this behavior is not desired.

Words DEIJKPQR have no predefined function and are recommended for use as argspec parameters.

By default, parameters are passed as local named parameter to an NGC procedure. These local parameters appear as already set when the procedure starts executing, which is different from existing semantics (local variables start out with value 0.0 and need to be explicitly assigned a value).

Optional word parameters may be tested for presence by the EXISTS(#<word>) idiom.

Assume the code is defined as

REMAP=M400 modalgroup=10 argspec=Pq ngc=m400

and m400.ngc looks as follows:

Assume the code is defined as

REMAP=M410 modalgroup=10 argspec=@PQr ngc=m410

and m410.ngc looks as follows:

It’s possible to define new codes without any NGC procedure. Here’s a simple first example, a more complex one can be found in the next section.

Assume the code is defined as

REMAP=G88.6 modalgroup=1 argspec=XYZp python=g886

This instructs the interpreter to execute the Python function g886 in the module_basename.remap module, which might look like so:

Try this with out with: g88.6 x1 y2 z3 g88.6 x1 y2 z3 p33 (a comment here)

You’ll notice the gradual introduction of the embedded Python environment - see here for details. Note that with Python remapping functions, it make no sense to have Python prolog or epilog functions since it is executing a Python function in the first place.

Die Module interpreter und emccanon legen den größten Teil des Interpreters und einige Canon-Interna offen, so dass viele Dinge, die bisher in C/C+\+ programmiert werden mussten, nun in Python erledigt werden können.

The following example is based on the nc_files/involute.py script - but canned as a G-code with some parameter extraction and checking. It also demonstrates calling the interpreter recursively (see self.execute()).

Angenommen, die Definition lautet wie folgt (Anmerkung: Hier wird argspec nicht verwendet):

REMAP=G88.1 modalgroup=1 py=involute

The involute function in python/remap.py listed below does all word extraction from the current block directly. Note that interpreter errors can be translated to Python exceptions. Remember this is readahead time - execution time errors cannot be trapped this way.

Die bisher beschriebenen Beispiele finden Sie in "configs/sim/axis/remap/getting-started" mit vollständigen Arbeitskonfigurationen.

Wenn Sie mit den Interna von LinuxCNC nicht vertraut sind, lesen Sie zuerst den Abschnitt How tool change currently works (dire but necessary).

Note than when remapping an existing code, we completely disable this codes' built-in functionality of the interpreter.

Unser remapped Code muss also etwas mehr tun, als nur einige Befehle zu generieren, um die Maschine so zu bewegen, wie wir es wollen - er muss auch die Schritte aus dieser Sequenz wiederholen, die nötig sind, um den Interpreter und die Task bei Laune zu halten.

However, this does not affect the processing of tool change-related commands in task and iocontrol. This means when we execute step 6b this will still cause iocontrol to do its thing.

Decisions, decisions:

Je nach Antwort ergeben sich vier verschiedene Szenarien:

Der Gesamtansatz für unser erstes Beispiel lautet also:

iocontrol bietet zwei HAL-Interaktionssequenzen, die wir verwenden oder nicht verwenden können:

What you need to decide is whether the existing iocontrol HAL sequences are sufficient to drive your changer. Maybe you need a different interaction sequence - for instance more HAL pins, or maybe a more complex interaction. Depending on the answer, we might continue to use the existing iocontrol HAL sequences, or define our own ones.

For the sake of documentation, we’ll disable these iocontrol sequences, and roll our own - the result will look and feel like the existing interaction, but now we have complete control over them because they are executed in our own O-word procedure.

So what we’ll do is use some motion.digital-* and motion.analog-* pins, and the associated M62 .. M68 commands to do our own HAL interaction in our O-word procedure, and those will effectively replace the iocontrol tool-prepare/tool-prepared and tool-change/tool-changed sequences. So we’ll define our pins replacing existing iocontrol pins functionally, and go ahead and make the iocontrol interactions a loop. We’ll use the following correspondence in our example:

iocontrol pin correspondence in the examples

Let us assume you want to redefine the M6 command, and replace it by an O-word procedure, but other than that things should continue to work.

So what our O-word procedure would do is to replace the steps outlined here. Looking through these steps you’ll find that NGC code can be used for most of them, but not all. So the stuff NGC can’t handle will be done in Python prolog and epilog functions.

To convey the idea, we just replace the built in M6 semantics with our own. Once that works, you may go ahead and place any actions you see fit into the O-word procedure.

Going through the steps, we find:

So we need a prolog, and an epilog. Lets assume our INI file incantation of the M6 remap looks as follows:

So the prolog covering steps 1 and 2 would look like so - we decide to pass a few variables to the remap procedure which can be inspected and changed there, or used in a message. Those are: tool_in_spindle, selected_tool (tool numbers) and their respective tooldata indices current_pocket and selected_pocket:

You will find that most prolog functions look very similar:

Our first iteration of the O-word procedure is unexciting - just verify we got parameters right, and signal success by returning a positive value; steps 3-5 would eventually be covered here (see here for the variables referring to INI file settings):

Assuming success of change.ngc, we need to mop up steps 6-8:

This replacement M6 is compatible with the built in code, except steps 3-5 need to be filled in with your NGC code.

Again, most epilogs have a common scheme:

Note that the sequence of operations has changed: we do everything required in the O-word procedure - including any HAL pin setting/reading to get a changer going, and to acknowledge a tool change - likely with motion.digital-* and motion-analog-* IO pins. When we finally execute the CHANGE_TOOL() command, all movements and HAL interactions are already completed.

Normally only now iocontrol would do its thing as outlined here. However, we don’t need the HAL pin wiggling anymore - all iocontrol is left to do is to accept we’re done with prepare and change.

This means that the corresponding iocontrol pins have no function any more. Therefore, we configure iocontrol to immediately acknowledge a change by configuring like so:

If you for some reason want to remap Tx (prepare), the corresponding iocontrol pins need to be looped as well.

The standard prologs and epilogs found in ncfiles/remap_lib/python-stdglue/stdglue.py pass a few exposed parameters to the remap procedure.

An exposed parameter is a named local variable visible in a remap procedure which corresponds to interpreter-internal variable, which is relevant for the current remap. Exposed parameters are set up in the respective prolog, and inspected in the epilog. They can be changed in the remap procedure and the change will be picked up in the epilog. The exposed parameters for remappable built in codes are:

If you have specific needs for extra parameters to be made visible, that can simply be added to the prolog - practically all of the interpreter internals are visible to Python.

Remember that normally remapping a code completely disables all internal processing for that code.

However, in some situations it might be sufficient to add a few codes around the existing M6 built in implementation, like a tool length probe, but other than that retain the behavior of the built in M6.

Since this might be a common scenario, the built in behavior of remapped codes has been made available within the remap procedure. The interpreter detects that you are referring to a remapped code within the procedure which is supposed to redefine its behavior. In this case, the built in behavior is used - this currently is enabled for the set: M6, M61,T, S, F. Note that otherwise referring to a code within its own remap procedure would be a error - a remapping recursion.

Slightly twisting a built in would look like so (in the case of M6):

See the configs/sim/axis/remap/extend-builtins directory for a complete configuration, which is the recommended starting point for own work when extending built in codes.

If you’re confident with the default implementation, you wouldn’t need to do this. But remapping is also a way to work around deficiencies in the current implementation, for instance to not block until the "tool-prepared" pin is set.

What you could do, for instance, is: - In a remapped T, just set the equivalent of the tool-prepare pin, but not wait for tool-prepared here. - In the corresponding remapped M6, wait for the tool-prepared at the very beginning of the O-word procedure.

Again, the iocontrol tool-prepare/tool-prepared pins would be unused and replaced by motion.* pins, so those would pins must be looped:

So, here’s the setup for a remapped T:

The minimal ngc prepare procedure again looks like so:

And the epilog:

The functions prepare_prolog and prepare_epilog are part of the standard glue provided by nc_files/remap_lib/python-stdglue/stdglue.py. This module is intended to cover most standard remapping situations in a common way.

The built in tool change procedure has some precautions for dealing with a program abort, e.g., by hitting escape in AXIS during a change. Your remapped function has none of this, therefore some explicit cleanup might be needed if a remapped code is aborted. In particular, a remap procedure might establish modal settings which are undesirable to have active after an abort. For instance, if your remap procedure has motion codes (G0,G1,G38..) and the remap is aborted, then the last modal code will remain active. However, you very likely want to have any modal motion canceled when the remap is aborted.

The way to do this is by using the [RS274NGC]ON_ABORT_COMMAND feature. This INI option specifies a O-word procedure call which is executed if task for some reason aborts program execution. on_abort receives a single parameter indicating the cause for calling the abort procedure, which might be used for conditional cleanup.

Die Gründe sind in nml_intf/emc.hh definiert

Die vorgeschlagene on_abort-Prozedur würde folgendermaßen aussehen (passen Sie sie an Ihre Bedürfnisse an):

Stellen Sie sicher, dass sich on_abort.ngc im Suchpfad des Interpreters befindet (empfohlener Ort: SUBROUTINE_PATH, um Ihr NC_FILES-Verzeichnis nicht mit internen Prozeduren zu überladen).

Statements in that procedure typically would assure that post-abort any state has been cleaned up, like HAL pins properly reset. For an example, see configs/sim/axis/remap/rack-toolchange.

Beachten Sie, dass das Beenden eines remapped Codes durch Rückgabe von INTERP_ERROR aus dem Epilog (siehe vorheriger Abschnitt) auch den Aufruf der Prozedur on_abort bewirkt.

Wenn Sie in Ihrer Handler-Prozedur feststellen, dass eine Fehlerbedingung aufgetreten ist, verwenden Sie nicht M2, um Ihren Handler zu beenden - siehe oben:

If displaying an operator error message and stopping the current program is good enough, use the (abort, `__<message>__)` feature to terminate the handler with an error message. Note that you can substitute numbered, named, INI and HAL parameters in the text like in this example (see also tests/interp/abort-hot-comment/test.ngc):

Wenn eine feiner abgestufte Wiederherstellungsmaßnahme erforderlich ist, verwenden Sie die im vorherigen Beispiel beschriebene Redewendung:

Diese Fehlermeldung wird in der Benutzeroberfläche angezeigt, und wenn INTERP_ERROR zurückgegeben wird, dann wird dieser Fehler wie jeder andere Laufzeitfehler behandelt.

Note that both (abort, <msg> ) and returning INTERP_ERROR from an epilog will cause any ON_ABORT handler to be called as well if defined (see previous section).

A potential use for a remapped S code would be automatic gear selection depending on speed. In the remap procedure one would test for the desired speed attainable given the current gear setting, and change gears appropriately if not.

A use case for remapping M0/M1 would be to customize the behavior of the existing code. For instance, it could be desirable to turn off the spindle, mist and flood during an M0 or M1 program pause, and turn these settings back on when the program is resumed.

For a complete example doing just that, see configs/sim/axis/remap/extend-builtins/, which adapts M1 as laid out above.

For ad-hoc execution of commands the Python hot comment has been added. Python output by default goes to stdout, so you need to start LinuxCNC from a terminal window to see results. Example for the MDI window:

Note that the interpreter instance is available here as self, so you could also run:

The emcStatus structure is accessible, too:

The namespace is expected to be laid out as follows:

The interpreter is an existing C++ class (Interp) defined in src/emc/rs274ngc. Conceptually all oword.<function> and remap.<function> Python calls are methods of this Interp class, although there is no explicit Python definition of this class (it is a Boost.Python wrapper instance) and hence receive the as the first parameter self which can be used to access internals.

If the TOPLEVEL module defines a function __init__, it will be called once the interpreter is fully configured (INI file read, and state synchronized with the world model).

Wenn das Modul TOPLEVEL eine Funktion __delete__ definiert, wird sie einmal aufgerufen, bevor der Interpreter heruntergefahren wird und nachdem die persistenten Parameter in der PARAMETER_FILE gespeichert worden sind.

Note_ at this time, the __delete__ handler does not work for interpreter instances created by importing the gcode module. If you need an equivalent functionality there (which is quite unlikely), please consider the Python atexit module.

This function may be used to initialize any Python-side attributes which might be needed later, for instance in remap or O-word functions, and save or restore state beyond what PARAMETER_FILE provides.

If there are setup or cleanup actions which are to happen only in the milltask Interpreter instance (as opposed to the interpreter instance which sits in the gcode Python module and serves preview/progress display purposes but nothing else), this can be tested for by evaluating self.task.

An example use of __init__ and __delete__ can be found in configs/sim/axis/remap/cycle/python/toplevel.py initialising attributes, needed to handle cycles in ncfiles/remap_lib/python-stdglue/stdglue.py (and imported into configs/sim/axis/remap/cycle/python/remap.py).

Python code is called from NGC in the following situations:

Arguments:

Just as NGC procedures may return values, so do O-word Python subroutines. They are expected to either return

Any other return value type will raise a Python exception.

In a calling NGC environment, the following predefined named parameters are available:

Siehe auch tests/interp/value-returned für ein Beispiel.

Argumente sind:

Beispielaufruf:

Rückgabewerte:

Argumente sind:

Das minimale python=-Funktionsbeispiel:

Rückgabewerte:

If the handler needs to execute a queuebuster operation (tool change, probe, HAL pin reading) then it is supposed to suspend execution with the following statement:

Queue busters interrupt a procedure at the point where such an operation is called, hence the procedure needs to be restarted after the interpreter synch(). When this happens the procedure needs to know if it is restarted, and where to continue. The Python generator method is used to deal with procedure restart.

Dies zeigt die Fortsetzung des Anrufs mit einem einzigen Ausgangspunkt:

NGC-Code wird von Python ausgeführt, wenn

The prolog handler does not call the handler, but it prepares its call environment, for instance by setting up predefined local parameters.

Conceptually a prolog and an epilog execute at the same call level like the O-word procedure, that is after the subroutine call is set up, and before the subroutine endsub or return.

This means that any local variable created in a prolog will be a local variable in the O-word procedure, and any local variables created in the O-word procedure are still accessible when the epilog executes.

The self.params array handles reading and setting numbered and named parameters. If a named parameter begins with _ (underscore), it is assumed to be a global parameter; if not, it is local to the calling procedure. Also, numbered parameters in the range 1..30 are treated like local variables; their original values are restored on return/endsub from an O-word procedure.

Here is an example remapped code demonstrating insertion and extraction of parameters into/from the O-word procedure:

self.params() returns a list of all variable names currently defined. Since myname is local, it goes away after the epilog finishes.

You can recursively call the interpreter from Python code as follows:

Beispiele:

You might want to test for the return value being < INTERP_MIN_ERROR. If you are using lots of execute() statements, it is probably easier to trap InterpreterException as shown below.

CAUTION:

if interpreter.throw_exceptions is nonzero (default 1), and self.execute() returns an error, the exception InterpreterException is raised. InterpreterException has the following attributes:

Fehler können auf die folgende Python-Weise abgefangen werden:

The canon layer is practically all free functions. Example:

The actual canon functions are declared in src/emc/nml_intf/canon.hh and implemented in src/emc/task/emccanon.cc. The implementation of the Python functions can be found in src/emc/rs274ncg/canonmodule.cc.

Die folgenden Module sind bereits integriert:

These wrap a NGC procedure for Tx Tool Prepare.

Die folgenden Parameter werden für das NGC-Verfahren sichtbar gemacht:

Wenn die Werkzeugnummer Null angefordert wird (d.h. Werkzeug entladen), wird die entsprechende Tasche als -1 übergeben.

Es ist ein Fehler, wenn:

Note that unless you set the [EMCIO] RANDOM_TOOLCHANGER=1 parameter, tool and pocket number are identical, and the pocket number from the tool table is ignored. This is currently a restriction.

Diese schließen ein NGC-Verfahren für den M6-Werkzeugwechsel ein.

Anschließend werden die folgenden Parameter in das NGC-Verfahren exportiert:

These wrap a NGC procedure so it can act as a cycle, meaning the motion code is retained after finishing execution. If the next line just contains parameter words (e.g. new X,Y values), the code is executed again with the new parameter words merged into the set of the parameters given in the first invocation.

These routines are designed to work in conjunction with an argspec=<words> parameter. While this is easy to use, in a realistic scenario you would avoid argspec and do a more thorough investigation of the block manually in order to give better error messages.

Der Vorschlag für argspec lautet wie folgt:

This will permit cycle_prolog to determine the compatibility of any axis words give in the block, see below.

TBD

TBD

TBD

Normally, an O-word procedure is called with positional parameters. This scheme is very limiting in particular in the presence of optional parameters. Therefore, the calling convention has been extended to use something remotely similar to the Python keyword arguments model.

See LINKTO G-code/main Subroutines: sub, endsub, return, call.

Remapped codes may be nested just like procedure calls - that is, a remapped code whose NGC procedure refers to some other remapped code will execute properly.

The maximum nesting level remaps is currently 10.

Sequence numbers are propagated and restored like with O-word calls. See tests/remap/nested-remaps/word for the regression test, which shows sequence number tracking during nested remaps three levels deep.

Die folgenden Flags sind für das Mapping und die Ausführung in Python relevant:

or these flags into the [EMC]DEBUG variable as needed. For a current list of debug flags see src/emc/nml_intf/debugflags.h.

Debugging of embedded Python code is harder than debugging normal Python scripts, and only a limited supply of debuggers exists. A working open-source based solution is to use the Eclipse IDE, and the PydDev Eclipse plug in and its remote debugging feature.

Um diesen Ansatz zu verwenden:

To cover the last two steps: the o<pydevd> procedure helps to get into the debugger from MDI mode. See also the call_pydevd function in util.py and its usage in remap.involute to set a breakpoint.

Here’s a screen-shot of Eclipse/PyDevd debugging the involute procedure from above:

See the Python code in configs/sim/axis/remap/getting-started/python for details.

The current set of existing codes open to redefinition is:

Note that the use of M61 currently requires the use of iocontrol-v2.

Currently unallocated G-codes (for remapping) must be selected from the blank areas of the following tables. All the listed G-codes are already defined in the current implementation of LinuxCNC and may not be used to remap new G-codes. (Developers who add new G-codes to LinuxCNC are encouraged to also add their new G-codes to these tables.)

These M-codes are currently undefined in the current implementation of LinuxCNC and may be used to define new M-codes. (Developers who define new M-codes in LinuxCNC are encouraged to remove them from this table.)

Alle M-Codes von M100 bis M199 sind bereits benutzerdefinierte M-Codes, die nicht neu zugeordnet werden sollten.

Alle M-Codes von M200 bis M999 sind für die Neuzuordnung verfügbar.

FIXME Füge fehlende Informationen hinzu

FIXME Füge fehlende Informationen hinzu

FIXME Füge fehlende Informationen hinzu

FIXME Füge fehlende Informationen hinzu

FIXME Füge fehlende Informationen hinzu

FIXME Füge fehlende Informationen hinzu

FIXME Füge fehlende Informationen hinzu

FIXME Füge fehlende Informationen hinzu

Konzeptionell besteht der Zustand des Interpreters aus Variablen, die in die folgenden Kategorien fallen:

The task part of LinuxCNC is responsible for coordinating actual machine commands - movement, HAL interactions and so forth. It does not by itself handle the RS274NGC language. To do so, task calls upon the interpreter to parse and execute the next command - either from MDI or the current file.

The interpreter execution generates canonical machine operations, which actually move something. These are, however, not immediately executed but put on a queue. The actual execution of these codes happens in the task part of LinuxCNC: canon commands are pulled off that interpreter queue, and executed resulting in actual machine movements.

This means that typically the interpreter is far ahead of the actual execution of commands - the parsing of the program might well be finished before any noticeable movement starts. This behavior is called read-ahead.

To compute canonical machine operations in advance during read ahead, the interpreter must be able to predict the machine position after each line of G-code, and that is not always possible.

Let’s look at a simple example program which does relative moves (G91), and assume the machine starts at x=0,y=0,z=0. Relative moves imply that the outcome of the next move relies on the position of the previous one:

Here the interpreter can clearly predict machine positions for each line:

After N20: x=10 y=-5 z=20; after N30: x=10 y=15 z=15; after N40: x=10 y=15 z=45 and so can parse the whole program and generate canonical operations well in advance.

However, complete read ahead is only possible when the interpreter can predict the position impact for every line in the program in advance. Let’s look at a modified example:

To pre-compute the move in N90, the interpreter would need to know where the machine is after line N80 - and that depends on whether the probe command succeeded or not, which is not known until it is actually executed.

So, some operations are incompatible with further read-ahead. These are called queue busters, and they are:

Whenever the interpreter encounters a queue-buster, it needs to stop read ahead and wait until the relevant result is available. The way this works is:

Ein oder mehrere "Wörter" können in einem NGC-"Block" vorhanden sein, wenn sie kompatibel sind (einige schließen sich gegenseitig aus und müssen in verschiedenen Zeilen stehen). Das Ausführungsmodell schreibt jedoch eine strenge Reihenfolge der Ausführung von Codes vor, unabhängig von ihrem Auftreten in der Quellzeile (G-code Ausführungs-Reihenfolge).

Once a line is read (in either MDI mode, or from the current NGC file), it is parsed and flags and parameters are set in a struct block (struct _setup, member block1). This struct holds all information about the current source line, but independent of different ordering of codes on the current line: As long as several codes are compatible, any source ordering will result in the same variables set in the struct block. Right after parsing, all codes on a block are checked for compatibility.

Nach erfolgreichem Parsen wird der Block mit execute_block() ausgeführt, wobei die verschiedenen Elemente in der Reihenfolge ihrer Ausführung behandelt werden.

If a "queue buster" is found, a corresponding flag is set in the interpreter state (toolchange_flag, input_flag, probe_flag) and the interpreter returns an INTERP_EXECUTE_FINISH return value, signaling stop readahead for now, and resynch to the caller (task). If no queue busters are found after all items are executed, INTERP_OK is returned, signalling that read-ahead may continue.

When read ahead continues after the synch, task starts executing interpreter read() operations again. During the next read operation, the above mentioned flags are checked and corresponding variables are set (because the a synch() was just executed, the values are now current). This means that the next command already executes in the properly set variable context.

O-word procedures complicate handling of queue busters a bit. A queue buster might be found somewhere in a nested procedure, resulting in a semi-finished procedure call when INTERP_EXECUTE_FINISH is returned. Task makes sure to synchronize the world model, and continue parsing and execution as long as there is still a procedure executing (call_level > 0).

The actions happening in LinuxCNC are a bit involved, but it is necessary to get the overall idea what currently happens, before you set out to adapt those workings to your own needs.

Note that remapping an existing code completely disables all internal processing for that code. That means that beyond your desired behavior (probably described through an NGC O-word or Python procedure), you need to replicate those internal actions of the interpreter, which together result in a complete replacement of the existing code. The prolog and epilog code is the place to do this.

Mehrere Prozesse sind an Werkzeuginformationen "interessiert": task und sein Interpreter, sowie die Benutzeroberfläche. Außerdem der halui-Prozess.

Tool information is held in the emcStatus structure, which is shared by all parties. One of its fields is the toolTable array, which holds the description as loaded from the tool table file (tool number, diameter, frontangle, backangle and orientation for lathe, tool offset information).

The authoritative source and only process actually setting tool information in this structure is the iocontrol process. All others processes just consult this structure. The interpreter holds actually a local copy of the tool table.

For the curious, the current emcStatus structure can be accessed by Python statements. The interpreter’s perception of the tool currently loaded for instance is accessed by:

Um Felder in der globalen emcStatus-Struktur zu sehen, versuchen Sie dies: