GladeVCP: Glade Virtual Control Panel

Beide unterstützen die Erstellung von Panels mit "HAL Widgets" - Benutzeroberfläche Elemente wie LED’s, Tasten, Schieberegler usw., deren Werte zu einem HAL-Pin, die wiederum Schnittstellen zu den Rest von LinuxCNC verbunden sind.

PyVCP:

GladeVCP:

While running configs/sim/axis/gladevcp_panel.ini or configs/sim/axis/gladevcp_tab.ini, explore Show HAL Configuration - you will find the gladevcp HAL component and may observe their pin values while interacting with the widgets in the panel. The HAL setup can be found in configs/axis/gladevcp/manual-example.hal.

The example panel has two frames at the bottom. The panel is configured so that resetting ESTOP activates the Settings frame and turning the machine on enables the Commands frame at the bottom. The HAL widgets in the Settings frame are linked to LEDs and labels in the Status frame, and to the current and prepared tool number - play with them to see the effect. Executing the T<toolnumber> and M6 commands in the MDI window will change the current and prepared tool number fields.

The buttons in the Commands frame are MDI Action widgets - pressing them will execute an MDI command in the interpreter. The third button Execute Oword subroutine is an advanced example - it takes several HAL pin values from the Settings frame, and passes them as parameters to the Oword subroutine. The actual parameters received by the routine are displayed by (DEBUG, ) commands - see ../../nc_files/oword.ngc for the subroutine body.

Um zu sehen, wie das Panel in AXIS integriert ist, sehen Sie die Anweisung [DISPLAY]GLADEVCP in configs/sim/axis/gladevcp/gladevcp_panel.ini, die Anweisung [DISPLAY]EMBED* in configs/sim/axis/gladevcp/gladevcp_tab.ini und [HAL]POSTGUI_HALFILE sowohl in configs/sim/axis/gladevcp/gladevcp_tab.ini als auch in configs/sim/axis/gladevcp/gladevcp_panel.ini.

The user interface is created with the Glade UI editor - to explore it, you need to have Glade installed. To edit the user interface, run the command

Das erforderliche glade-Programm kann auf neueren Systemen den Namen glade-gtk2 tragen.

The center window shows the appearance of the UI. All user interface objects and support objects are found in the right top window, where you can select a specific widget (or by clicking on it in the center window). The properties of the selected widget are displayed, and can be changed, in the right bottom window.

Um zu sehen, wie MDI-Befehle von den MDI-Aktions-Widgets weitergegeben werden, erkunden Sie die Widgets, die unter "Aktionen" im Fenster oben rechts aufgeführt sind, und im Fenster unten rechts unter der Registerkarte "Allgemein" die Eigenschaft "MDI-Befehl".

Sehen Sie, wie ein Python-Callback in das Beispiel integriert wird:

Dies ist nur ein kurzer Überblick über das Konzept - der Callback-Mechanismus wird im Abschnitt GladeVCP Programming ausführlicher behandelt.

To view or modify Glade UI files, you need Glade 3.38.2 or later installed - it is not needed just to run a GladeVCP panel. If the glade command is missing, install it with the command:

Überprüfen Sie dann die installierte Version, die gleich oder höher als 3.6.7 sein muss:

Glade enthält einen internen Python-Interpreter, und es wird nur Python3 unterstützt. Dies gilt für Debian Bullseye, Ubuntu 21 und Mint 21 oder später. Ältere Versionen werden nicht funktionieren, Sie werden einen Python-Fehler erhalten.

This section just outlines the initial LinuxCNC-specific steps. For more information and a tutorial on Glade, see http://glade.gnome.org. Some Glade tips & tricks may also be found on youtube.

Ändern Sie entweder eine bestehende UI-Komponente, indem Sie glade <Datei>.ui ausführen, oder starten Sie eine neue, indem Sie einfach den Befehl glade in der Shell ausführen.

This will look like this:

Glade tends to write a lot of messages to the shell window, which mostly can be ignored. Select File→Save as, give it a name like myui.ui and make sure it is saved as GtkBuilder file (radio button left bottom corner in Save dialog). GladeVCP will also process the older libglade format correctly but there is no point in using it. The convention for GtkBuilder file extension is .ui.

Sie sind jetzt bereit, es auszuprobieren (während LinuxCNC, z. B. AXIS läuft) mit:

GladeVCP creates a HAL component named like the basename of the UI file - myui in this case - unless overridden by the -c <component name> option. If running AXIS, just try Show HAL configuration and inspect its pins.

You might wonder why widgets contained a HAL_Hbox or HAL_Table appear greyed out (inactive). HAL containers have an associated HAL pin which is off by default, which causes all contained widgets to render inactive. A common use case would be to associate these container HAL pins with halui.machine.is-on or one of the halui.mode signals, to assure some widgets appear active only in a certain state.

To just activate a container, execute the HAL command setp gladevcp.<container-name> 1.

The suggested way of linking HAL pins in a GladeVCP panel is to collect them in a separate file with extension .hal. This file is passed via the POSTGUI_HALFILE= option in the HAL section of your INI file.

Platzieren Sie das GladeVCP-Panel im rechten Seitenbereich, indem Sie in der INI-Datei Folgendes angeben:

The default HAL component name of a GladeVCP application started with the GLADEVCP option is: gladevcp.

Die von AXIS in der obigen Konfiguration tatsächlich ausgeführte Befehlszeile lautet wie folgt:

You may add arbitrary gladevcp options here, as long as they dont collide with the above command line options.

Es ist möglich, einen benutzerdefinierten HAL-Komponentennamen zu erstellen, indem Sie die Option -c hinzufügen:

Die Befehlszeile, die von AXIS für die obigen Schritte ausgeführt wird, lautet:

Bearbeiten Sie dazu Ihre INI-Datei und fügen Sie die Abschnitte DISPLAY und HAL der INI-Datei wie folgt hinzu:

Note the halcmd loadusr way of starting the tab command - this assures that POSTGUI_HALFILE will only be run after the HAL component is ready. In rare cases you might run a command here which uses a tab but does not have an associated HAL component. Such a command can be started without halcmd loadusr, and this signifies to AXIS that it does not have to wait for a HAL component since there is none.

When changing the component name in the above example, note that the names used in -Wn <component> and -c <component> must be identical.

Try it out by running AXIS - there should be a new tab called GladeVCP demo near the DRO tab. Select that tab, you should see the example panel nicely fit within AXIS.

Um eine GladeVCP-Registerkarte zu "Touchy" hinzuzufügen, bearbeiten Sie Ihre INI-Datei wie folgt:

Beachten Sie die folgenden Unterschiede zur Einrichtung der Registerkarte von AXIS:

Die meisten HAL-Widgets haben einen einzigen zugehörigen HAL-Pin mit demselben HAL-Namen wie das Widget (glade: General→Name).

Ausnahmen von dieser Regel sind derzeit:

HAL widgets are instances of GtKWidgets and hence inherit the methods, properties and signals of the applicable GtkWidget class. For instance, to figure out which GtkWidget-related methods, properties and signals a HAL_Button has, lookup the description of GtkButton in the PyGObject API Reference.

An easy way to find out the inheritance relationship of a given HAL widget is as follows: Run glade, place the widget in a window, and select it; then choose the Signals tab in the Properties window. For example, selecting a HAL_LED widget, this will show that a HAL_LED is derived from a GtkWidget, which in turn is derived from a GtkObject, and eventually a GObject.

Full class hierarchy can be seen by invoking the GtkInspector while in the Glade GUI by selecting a widget then pressing Control-Shift-I. If the Inspector doesn’t open then it can be enabled from a terminal by entering:

The Inspector is also handy for testing css style changes "on the fly" as well as determining all the properties and signals available for a widget.

HAL-Widgets haben auch einige HAL-spezifische Python-Attribute:

Es gibt mehrere HAL-spezifische Methoden von HAL Widgets, aber die einzige relevante Methode ist:

As a general rule, if you need to set a HAL output widget’s value from Python code, do so by calling the underlying Gtk setter (e.g., set_active(), set_value()). Do not try to set the associated pin’s value by halcomp[pinname] = value directly because the widget will not take notice of the change!

It might be tempting to set HAL widget input pins programmatically. Note this defeats the purpose of an input pin in the first place - it should be linked to, and react to signals generated by other HAL components. While there is currently no write protection on writing to input pins in HAL Python, this doesn’t make sense. You might use setp _pinname_ _value_ in the associated HAL file for testing though.

Es ist völlig in Ordnung, den Wert eines Ausgangs-HAL-Pins mit halcomp[pinname] = value zu setzen, vorausgesetzt, dieser HAL-Pin ist nicht mit einem Widget verbunden, d.h. er wurde mit der Methode hal_glib.GPin(halcomp.newpin(<name>,<type>,<direction>)) erstellt (siehe GladeVCP Programming für ein Beispiel).

Event-driven programming means that the UI tells your code when "something happens" - through a callback, like when a button was pressed. The output HAL widgets (those which display a HAL pin’s value) like LED, Bar, VBar, Meter, etc., support the hal-pin-changed signal, which may cause a callback into your Python code when - well, a HAL pin changes its value. This means there’s no more need for permanent polling of HAL pin changes in your code, the widgets do that in the background and let you know.

Here is an example how to set a hal-pin-changed signal for a HAL_LED in the Glade UI editor:

Das Beispiel in configs/apps/gladevcp/complex zeigt, wie dies in Python gehandhabt wird.

This group of widgets are derived from various Gtk buttons and consists of HAL_Button, HAL_ToggleButton, HAL_RadioButton and CheckButton widgets. All of them have a single output BIT pin named identical to the widget. Buttons have no additional properties compared to their base Gtk classes.

Siehe configs/apps/gladevcp/by-widget/ für eine GladeVCP-Anwendung und UI-Datei für die Arbeit mit Optionsfeldern.

HAL_HScale und HAL_VScale sind von GtkHScale bzw. GtkVScale abgeleitet.

To make a scale useful in Glade, add an Adjustment (General → Adjustment → New or existing adjustment) and edit the adjustment object. It defines the default/min/max/increment values. Also, set adjustment Page size and Page increment to zero to avoid warnings.

HAL SpinButton ist von GtkSpinButton abgeleitet und besitzt zwei Pins:

Um nützlich zu sein, benötigen SpinButtons einen Einstellwert wie Skalen, siehe oben.

Das hal_dial Widget simuliert ein Jogwheel oder ein Einstellrad.
Es kann mit der Maus bedient werden. Sie können einfach das Mausrad benutzen, während sich der Mauszeiger über dem Hal_Dial-Widget befindet, oder Sie halten die linke Maustaste gedrückt und bewegen den Mauszeiger in kreisförmiger Richtung, um die Zählungen zu erhöhen oder zu verringern.
Mit einem Doppelklick auf die linke oder rechte Taste kann der Skalierungsfaktor erhöht oder verringert werden.

The jogwheel widget simulates a real jogwheel. It can be operated with the mouse. You can just use the mouse wheel, while the mouse cursor is over the JogWheel widget, or you push the left mouse button and move the cursor in circular direction to increase or degrease the counts.

Da das Bewegen der Maus per Drag & Drop schneller sein kann, als das Widget sich selbst zu aktualisieren vermag, kann, dass Sie Zähler verlieren, wenn Sie zu schnell drehen. Es wird empfohlen, das Mausrad zu verwenden, und nur für sehr grobe Bewegungen die Drag-and-Drop-Methode.

speedcontrol is a widget specially made to control an adjustment with a touch screen. It is a replacement to the normal scale widget which is difficult to slide on a touch screen.

The value is controlled with two button to increase or decrease the value. The increment will change as long a button is pressed. The value of each increment as well as the time between two changes can be set using the widget properties.

hal_label ist ein einfaches Widget, das auf GtkLabel basiert und einen HAL-Pin-Wert in einem benutzerdefinierten Format darstellt.

Diese Container sollen dazu dienen, ihre Kinder zu insensibilisieren (auszugrauen) oder zu verstecken. +
Nicht sensibilisierte Kinder reagieren nicht auf Eingaben.

The hal_led simulates a real indicator LED.
It has a single input BIT pin which controls its state: ON or OFF.

Die HAL_ComboBox ist von der gtk.ComboBox abgeleitet. Sie ermöglicht die Auswahl eines Wertes aus einer Dropdown-Liste.

HAL_Bar- und HAL_VBar-Widgets für horizontale und vertikale Balken, die Gleitkommawerte darstellen.

HAL_Meter ist ein Widget ähnlich dem PyVCP-Meter - es stellt einen Gleitkommawert dar.

Dieses Widget dient zum Auftragen von Werten über die Zeit.

Gremlin is a plot preview widget similar to the AXIS preview window. It assumes a running LinuxCNC environment like AXIS or Touchy. To connect to it, inspects the INI_FILE_NAME environment variable. Gremlin displays the current NGC file - it does monitor for changes and reloads the ngc file if the file name in AXIS/Touchy changes. If you run it in a GladeVCP application when LinuxCNC is not running, you might get a traceback because the Gremlin widget can’t find LinuxCNC status, like the current file name.

Das HAL_Offset-Widget wird verwendet, um den Offset einer einzelnen Achse anzuzeigen.

Das DRO-Widget wird verwendet, um die aktuelle Achsenposition anzuzeigen.

Das Combi_DRO-Widget wird verwendet, um die aktuelle, die relative Achsenposition und die zu fahrende Strecke in einem DRO anzuzeigen.
Durch Klicken auf das DRO wird die Reihenfolge der DRO umgeschaltet.
Im relativen Modus wird das aktuelle Koordinatensystem angezeigt.

Dies ist ein Touchscreen-freundliches Widget zur Auswahl einer Datei und zum Wechseln von Verzeichnissen.

Dies ist ein einfaches Taschenrechner-Widget, das für numerische Eingaben verwendet werden kann. +
Sie können die Anzeige voreinstellen und das Ergebnis oder den voreingestellten Wert abrufen.

Dies ist ein "Werkzeug-Editor"-Widget zum Anzeigen und Ändern einer Werkzeugdatei. +
Im Drehmaschinenmodus werden Verschleißkorrekturen und Werkzeugkorrekturen separat angezeigt. +
Verschleißkorrekturen werden durch Werkzeugnummern über 10000 (Fanuc-Stil) gekennzeichnet. +
Es überprüft die aktuelle Datei einmal pro Sekunde, um zu sehen, ob LinuxCNC es aktualisiert.

Das Widget Offsetpage dient der Anzeige/Bearbeitung der Offsets aller Achsen.
Es hat praktische Schaltflächen für die Nullstellung von G92- und Rotation-Around-Z-Offsets.
Sie können den Bearbeitungsmodus nur auswählen, wenn die Maschine eingeschaltet und im Leerlauf ist.
Zu diesem Zeitpunkt können Sie die Offsets in der Tabelle direkt bearbeiten. Heben Sie die Auswahl der Schaltfläche "Bearbeiten" auf, damit die Offset-Seite die Änderungen wiedergeben kann.

This is for displaying and simple editing of G-code. It looks for .ngc highlighting specs in ~/share/gtksourceview-4/language-specs/. The current running line will be highlighted.

Mit externem Python-Glue-Code kann dies:

This is for displaying and entering MDI codes.
It will be automatically grayed out when MDI is not available, e.g., during E-stop and program running.

Für einige Anwendungen kann es wünschenswert sein, ein Hintergrundbild zu haben - wie ein Funktionsdiagramm - und Widgets an geeigneten Stellen in diesem Bild zu positionieren. Eine gute Kombination ist das Setzen eines Bitmap-Hintergrundbildes, z.B. aus einer .png-Datei, das Festlegen der Größe des GladeVCP-Fensters und die Verwendung des Glade Fixed-Widgets zur Positionierung von Widgets auf diesem Bild. Der Code für das folgende Beispiel ist in configs/apps/gladevcp/animated-backdrop zu finden:

VCP Action widgets are one-shot type widgets. They implement a single action and are for use in simple buttons, menu entries or radio/check groups.

This widget is used to execute small arbitrary Python code.

Der Befehlsstring kann spezielle Schlüsselwörter für den Zugriff auf wichtige Funktionen enthalten.

Es gibt Optionen für

Beispiel für einen Befehl, um einfach eine Nachricht auf dem Terminal zu auszugeben:

Beispiel für einen Befehl, um die Maschine in den Aus-Zustand zu versetzen:

Beispiel für einen Befehl für den Aufruf einer Handler-Funktion, die Daten übergibt:

You can use a semicolon to separate multiple commands;

More information on INFO and ACTION can be found here: GladeVCP Libraries modules.

More information on GStat can be found here: GStat.

These are bi-modal widgets. They implement two actions or use a second (usually pressed) state to indicate that currently an action is running. Toggle actions are aimed for use in ToggleButtons, ToggleToolButtons or toggling menu items. A simplex example is the ESTOP toggle button.

Derzeit sind die folgenden Widgets verfügbar:

Die folgenden Toggle-Aktionen haben nur einen zugehörigen Befehl und verwenden den Zustand "gedrückt", um anzuzeigen, dass der angeforderte Vorgang ausgeführt wird:

Diese Widgets bieten eine Möglichkeit, beliebige MDI-Befehle auszuführen.
Das Action_MDI-Widget wartet nicht auf die Beendigung des Befehls, wie es das Action_MDI-Toggle tut, das deaktiviert bleibt, bis der Befehl beendet ist.

configs/apps/gladevcp/mdi-command-example/whoareyou.ui ist eine Glade UI-Datei, welche die Grundlagen vermittelt:

Sie werden feststellen, dass die mit der Aktion Action_MDI verbundene Schaltfläche ausgegraut ist, wenn die Maschine ausgeschaltet ist, sich im E-Stop befindet oder der Interpreter läuft. Sie wird automatisch aktiv, wenn die Maschine eingeschaltet ist und sich nicht mehr im Notaus-Modus befindet und das Programm im Leerlauf ist.

Optional können bei "MDI Befehl"-Zeichenketten Parameter ersetzt werden, bevor sie an den Interpreter übergeben werden. Parameter können derzeit Namen von HAL-Pins in der GladeVCP-Komponente sein. So funktioniert es:

Die Beispiel-UI-Datei ist "configs/apps/gladevcp/mdi-command-example/speed.ui". So sieht das Ergebnis aus, wenn man sie ausführt:

Es ist völlig in Ordnung, eine O-Wort-Unterroutine in einem MDI-Befehl aufzurufen und HAL-Pin-Werte als aktuelle Parameter zu übergeben. Eine Beispiel-UI-Datei befindet sich in configs/apps/gladevcp/mdi-command-example/owordsub.ui.

Legen Sie nc_files/gladevcp_lib/oword.ngc so ab, dass AXIS es finden kann, und führen Sie gladevcp owordsub.ui in einem Terminalfenster aus. Das sieht dann so aus:

The LinuxCNC G-code interpreter has a single global set of variables, like feed, spindle speed, relative/absolute mode and others. If you use G-code commands or O-word subs, some of these variables might get changed by the command or subroutine - for example, a probing subroutine will very likely set the feed value quite low. With no further precautions, your previous feed setting will be overwritten by the probing subroutine’s value.

To deal with this surprising and undesirable side effect of a given O-word subroutine or G-code statement executed with an LinuxCNC ToggleAction_MDI, you might associate pre-MDI and post-MDI handlers with a given LinuxCNC ToggleAction_MDI. These handlers are optional and provide a way to save any state before executing the MDI Action, and to restore it to previous values afterwards. The signal names are mdi-command-start and mdi-command-stop; the handler names can be set in Glade like any other handler.

Here’s an example how a feed value might be saved and restored by such handlers (note that LinuxCNC command and status channels are available as self.linuxcnc and self.stat through the VCP_ActionBase class):

Nur das Toggle-Widget Action_MDI unterstützt diese Signale.

Many actions depend on LinuxCNC status - is it in manual, MDI or auto mode? Is a program running, paused or idle? You cannot start an MDI command while a G-code program is running, so this needs to be taken care of. Many LinuxCNC actions take care of this themselves, and related buttons and menu entries are deactivated when the operation is currently impossible.

When using Python event handlers - which are at a lower level than Actions - one needs to take care of dealing with status dependencies oneself. For this purpose, there’s the LinuxCNC Stat widget: to associate LinuxCNC status changes with event handlers.

LinuxCNC Stat has no visible component - you just add it to your UI with Glade. Once added, you can associate handlers with its following signals:

Most widget sets, and their associated user interface editors, support the concept of callbacks, i.e. functions in user-written code which are executed when something happens in the UI - events like mouse clicks, characters typed, mouse movement, timer events, window hiding and exposure and so forth.

HAL output widgets typically map input-type events like a button press to a value change of the associated HAL pin by means of such a - predefined - callback. Within PyVCP, this is really the only type of event handling supported - doing something more complex, like executing MDI commands to call a G-code subroutine, is not supported.

Within GladeVCP, HAL pin changes are just one type of the general class of events (called signals) in GTK+. Most widgets may originate such signals, and the Glade editor supports associating such a signal with a Python method or function name.

If you decide to use user-defined actions, your job is to write a Python module whose class methods - or in the simple case, just functions - can be referred to in Glade as event handlers. GladeVCP provides a way to import your module(s) at startup and will automatically link your event handlers with the widget signals as set in the Glade UI description.

Es gibt drei Bibliotheken mit Funktionen, die zur Programmierung von GladeVCP verwendet werden können.

Importieren und Instanziieren der Bibliotheken:

Using the library functions:

More information can be found here: GladeVCP Libraries modules. There is a sample configuration that demonstrates using the core library with GladeVCP’s action Python widgets and with a Python handler file. Try loading sim/axis/gladevcp/gladevcp_panel_tester.

Dies ist nur ein minimales Beispiel, um die Idee zu vermitteln - Details werden im restlichen Teil dieses Abschnitts erläutert.

GladeVCP can not only manipulate or display HAL pins, you can also write regular event handlers in Python. This could be used, among others, to execute MDI commands. Here’s how you do it:

Schreiben Sie ein Python-Modul wie folgt und speichern Sie es z. B. als handlers.py:

In Glade, define a button or HAL button, select the Signals tab, and in the GtkButton properties select the pressed line. Enter on_button_press there, and save the Glade file.

Then add the option -u handlers.py to the GladeVCP command line. If your event handlers are spread over several files, just add multiple -u <pyfilename> options.

Now, pressing the button should change its label since it is set in the callback function.

What the +-u+ flag does: all Python functions in this file are collected and setup as potential callback handlers for your Gtk widgets - they can be referenced from Glade Signals tabs. The callback handlers are called with the particular object instance as parameter, like the GtkButton instance above, so you can apply any GtkButton method from there.

Oder machen Sie etwas Nützlicheres, wie den Aufruf eines MDI-Befehls!

HAL-Eingangs-Widgets, wie z.B. eine LED, assoziieren automatisch ihren HAL-Pin-Status (an/aus) mit dem optischen Erscheinungsbild des Widgets (LED leuchtet/dunkelt).

Beyond this built-in functionality, one may associate a change callback with any HAL pin, including those of predefined HAL widgets. This fits nicely with the event-driven structure of a typical widget application: Every activity, be it mouse click, key, timer expired, or the change of a HAL pin’s value, generates a callback and is handled by the same orthogonal mechanism.

Für benutzerdefinierte HAL-Pins, die nicht mit einem bestimmten HAL-Widget verbunden sind, lautet der Signalname value-changed. Siehe den Abschnitt AL Pins hinzufügen weiter unten für Details.

HAL Widgets werden mit einem vordefinierten Signal namens hal-pin-changed geliefert. Siehe den Abschnitt HAL Widgets für Details.

Das Gesamtkonzept sieht folgendermaßen aus:

Es ist wichtig zu wissen, in welchem Zustand die Funktion get_handlers() aufgerufen wird, damit Sie wissen, was Sie dort sicher tun können und was nicht. Zunächst werden die Module in der Befehlszeilenreihenfolge importiert und initialisiert. Nach erfolgreichem Import wird get_handlers() im folgenden Zustand aufgerufen:

Nachdem alle Module importiert und die Methodennamen extrahiert wurden, werden die folgenden Schritte durchgeführt:

So when your handler class is initialized, all widgets are existent but not yet realized (displayed on screen). And the HAL component isn’t ready as well, so its unsafe to access pins values in your __init__() method.

If you want to have a callback to execute at program start after it is safe to access HAL pins, then a connect a handler to the realize signal of the top level window1 (which might be its only real purpose). At this point GladeVCP is done with all setup tasks, the HAL file has been run, and GladeVCP is about to enter the Gtk main loop.

Within a class, method names must be unique. However, it is OK to have multiple class instances passed to GladeVCP by get_handlers() with identically named methods. When the corresponding signal occurs, these methods will be called in definition order - module by module, and within a module, in the order class instances are returned by get_handlers().

Instead of extending GladeVCP for any conceivable option which could potentially be useful for a handler class, you may use the -U <useroption> flag (repeatedly if you wish). This flag collects a list of <useroption> strings. This list is passed to the get_handlers() function (useropts argument). Your code is free to interpret these strings as you see fit. An possible usage would be to pass them to the Python exec function in your get_handlers() as follows:

Auf diese Weise können Sie beliebige Python-Anweisungen an Ihr Modul übergeben, zum Beispiel durch die Option gladevcp -U:

Dies sollte debug auf 2 setzen und bestätigen, dass Ihr Modul es tatsächlich getan hat.

An annoying aspect of GladeVCP in its earlier form and PyVCP is the fact that you may change values and HAL pins through text entry, sliders, spin boxes, toggle buttons, etc., but their settings are not saved and restored at the next run of LinuxCNC - they start at the default value as set in the panel or widget definition.

GladeVCP verfügt über einen einfach zu bedienenden Mechanismus zum Speichern und Wiederherstellen des Zustands von HAL-Widgets und Programmvariablen (in der Tat jedes Instanzattribut vom Typ int, float, bool oder string).

Dieser Mechanismus verwendet das weit verbreitete INI-Dateiformat, um dauerhafte Attribute zu speichern und wieder zu laden.

Imagine renaming, adding or deleting widgets in Glade: An .INI file lying around from a previous program version, or an entirely different user interface, would be not be able to restore the state properly since variables and types might have changed.

GladeVCP detects this situation by a signature which depends on all object names and types which are saved and to be restored. In the case of signature mismatch, a new INI file with default settings is generated.

Wenn Sie möchten, dass der Status des Gtk-Widgets, die Werte des HAL-Widgets-Ausgabepins und/oder die Klassenattribute Ihrer Handler-Klasse über Aufrufe hinweg erhalten bleiben, gehen Sie wie folgt vor:

Dann verknüpfen Sie eine INI-Datei mit diesem Deskriptor:

Nach restore_state() werden die Attribute von self gesetzt, wenn sie wie folgt ablaufen:

Note that types are saved and preserved on restore. This example assumes that the INI file didn’t exist or had the default values from self.defaults.

Nach dieser Beschwörung können Sie die folgenden IniFile-Methoden verwenden:

Um den Zustand des Widgets und/oder der Variablen beim Beenden zu speichern, gehen Sie wie folgt vor:

Dadurch wird der Status gespeichert und GladeVCP ordnungsgemäß heruntergefahren, unabhängig davon, ob das Panel in AXIS eingebettet oder ein eigenständiges Fenster ist.

Wenn Sie die GladeVCP-Anwendung das nächste Mal starten, sollten die Widgets in dem Zustand angezeigt werden, in dem sie beim Schließen der Anwendung waren.

By default, the reaction of GladeVCP to a Ctrl-C event is to just exit - without saving state. To make sure that this case is covered, add a handler call on_unix_signal which will be automatically be called on Ctrl-C (actually on the SIGINT and SIGTERM signals). Example:

You can do that, but note that the values in self.defaults override your edits if there is a syntax or type error in your edit. The error is detected, a console message will hint about that happened, and the bad inifile will be renamed to have the .BAD suffix. Subsequent bad INI files overwrite earlier .BAD files.

Wenn Sie HAL-Pins benötigen, die nicht mit einem bestimmten HAL-Widget verbunden sind, fügen Sie sie wie folgt hinzu:

To get a callback when this pin’s value changes, associate a value-change callback with this pin, add:

and define a callback method (or function, in this case leave out the self parameter):

Since GladeVCP uses Gtk widgets which rely on the PyGObject base class, the full GLib functionally is available. Here is an example for a timer callback:

With Glade, widget properties are typically set fixed while editing. You can, however, set widget properties at runtime, for instance from INI file values, which would typically be done in the handler initialization code. Setting properties from HAL pin values is possible, too.

Im folgenden Beispiel (unter der Annahme eines HAL Meter-Widgets mit dem Namen meter) wird der Minimalwert des Zählers beim Start über einen INI-Dateiparameter und der Maximalwert über einen HAL-Pin eingestellt, wodurch die Skala des Widgets dynamisch angepasst wird:

GladeVCP nutzt die hal_glib-Bibliothek, die dazu verwendet werden kann, ein "watcher" Signal an einen HAL-Eingangspin anzuschließen.
Dieses Signal kann verwendet werden, um eine Funktion zu registrieren, die aufgerufen wird, wenn sich der Zustand des HAL-Pins ändert.

One must import the hal_glib and the hal modules:

Erstellen Sie dann einen Pin und verbinden Sie ein value-changed Signal (den Watcher) mit einem Funktionsaufruf:

Und eine Funktion haben, die aufgerufen werden soll:

Visit linuxcnc_root_directory/configs/apps/gladevcp for running examples and starters for your own projects.