1. Einführung

Gscreen is an infrastructure to display a custom screen to control LinuxCNC. Gscreen borrows heavily from GladeVCP. GladeVCP uses the GTK widget editor GLADE to build virtual control panels (VCP) by point and click. Gscreen combines this with Python programming to create a GUI screen for running a CNC machine.

Gscreen is customizable if you want different buttons and status LEDs. Gscreen supports GladeVCP which is used to add controls and indicators. To customize Gscreen you use the Glade editor. Gscreen is not restricted to adding a custom panel on the right or a custom tab it is fully editable.

Gscreen Maske für Fräsmaschinen
Abbildung 1. Gscreen Standardbildschirm
Gscreen Silverdragon-Bildschirm
Abbildung 2. Gscreen Silverdragon-Bildschirm
Gscreen Spartan-Bildschirm
Abbildung 3. Gscreen Spartan-Bildschirm
Gscreen Gaxis-Bildschirm
Abbildung 4. Gscreen Gaxis-Bildschirm
Gscreen Industrieller Bildschirm
Abbildung 5. Gscreen Industrieller Bildschirm

Gscreen is based on Glade (the editor), PyGTK (the widget toolkit), and GladeVCP (LinuxCNC’s connection to Glade and PyGTK). GladeVCP has some special widgets and actions added just for LinuxCNC A widget is just the generic name used for the buttons, sliders, labels etc of the PyGTK toolkit.

1.1. Glade-Datei

A Glade file is a text file organized in the XML standard that describes the layout and the widgets of the screen. PyGTK uses this file to actually display and react to those widgets. The Glade editor makes it relatively easy to build and edit this file You must use the Glade 3.38.2 editor that uses the GTK3 widgets.

1.2. PyGTK

PyGTK is the Python binding to GTK. GTK is the toolkit of visual widgets, it is programmed in C. PyGTK uses Python to bind with GTK.

2. GladeVCP

GladeVCP binds LinuxCNC, HAL, PyGTK and Glade all together. LinuxCNC requires some special widgets so GladeVCP supplies them. Many are just HAL extensions to existing PyGTK widgets. GladeVCP creates the HAL pins for the special widgets described in the Glade file. GladeVCP also allows one to add Python commands to interact with the widgets, to make them do things not available in their default form. If you can build a GladeVCP panel you can customize Gscreen!

2.1. Übersicht

There are two files that can be used, individually or in combination to add customizations. Local Glade files and handler files. Normally Gscreen uses the stock Glade file and possibly a handler file (if using a sample skin). You can specify Gscreen to use local Glade and handler files. Gscreen looks in the folder that holds all the configuration files for the configuration you selected.

Lokale Glade-Dateien

If present, local Glade files in the configuration folder will be loaded instead of the stock Glade files. Local Glade files allow you to use your customized designs rather then the default screens. There is a switch in the INI file to set set the base name: -c name so Gscreen looks for MYNAME.glade and MYNAME_handler.py.

You can tell Gscreen to just load the Glade file and not connect its internal signals to it. This allows gscreen to load any GTK builder saved Glade file. This means you can display a completely custom screen, but also requires you to use a handler file. Gscreen uses the Glade file to define the widgets, so it can show and interact with them. Many of them have specific names, others have Glade given generic names. If the widget will be displayed but never changed then a generic name is fine. If one needs to control or interact with the widget then a hopefully purposeful name is given (all names must be unique). Widgets can also have signals defined for them in the GLADE editor. It defines what signal is given and what method to call.

Ändern von Standard-Skins

If you change the name of a widget, Gscreen might not be able to find it. If this widget is referenced to from Python code, at best this makes the widget not work anymore at worst it will cause an error when loading Gscreen’s default screens don’t use many signals defined in the editor, it defines them in the Python code. If you move (cut and paste) a widget with signals, the signals will not be copied. You must add them again manually.

Handler-Dateien

A handler file is a file containing Python code, which Gscreen adds to its default routines. A handler file allows one to modify defaults, or add logic to a Gscreen skin without having to modify Gscreen proper. You can combine new functions with Gscreen’s function to modify behavior as you like. You can completely bypass all of Gscreen’s functions and make if work completely differently. If present a handler file named gscreen_handler.py (or MYNAME_handler.py if using the INI switch) will be loaded and registered only one file is allowed Gscreen looks for the handler file, if found it will look for specific function names and call them instead of the default ones. If adding widgets you can set up signal calls from the Glade editor to call routines you have written in the handler file. In this way you can have custom behavior. Handler routines can call Gscreen’s default routines, either before or after running its own code. In this way you can tack on extra behavior such as adding a sound. Please see the GladeVCP Chapter for the basics to GladeVCP handler files. Gscreen uses a very similar technique.

Themen

Gscreen verwendet das PyGTK-Toolkit zur Anzeige des Bildschirms. PyGTK ist die Python-Sprachbindung an GTK. GTK unterstützt "Themen". Themes sind eine Möglichkeit, das Aussehen der Widgets auf dem Bildschirm zu verändern. Zum Beispiel kann die Farbe oder Größe von Schaltflächen und Schiebereglern mit Themen geändert werden. Es gibt viele GTK-Themen im Internet. Themes können auch angepasst werden, um das Erscheinungsbild bestimmter benannter Widgets zu verändern. Dies bindet die Themendatei enger an die Glade-Datei. Einige der Beispielscreen-Skins erlauben es dem Benutzer, ein beliebiges Thema auf dem System auszuwählen. Das Beispiel gscreen ist ein Beispiel dafür. Andere laden das Thema, das den gleichen Namen in der Konfigurationsdatei hat. Das Beispiel gscreen-gaxis ist ein Beispiel dafür. Dazu wird der Theme-Ordner in den Konfigurationsordner mit den INI- und HAL-Dateien gelegt und benannt: SCREENNAME_theme (SCREENNAME ist der Basisname der Dateien, z. B. gaxis_theme). Innerhalb dieses Ordners befindet sich ein weiterer Ordner namens gtk-2.0, in dem sich die Themadateien befinden. Wenn Sie diese Datei hinzufügen, wird Gscreen beim Starten standardmäßig dieses Thema verwenden. gscreen-gaxis enthält ein Beispiel für ein benutzerdefiniertes Thema, das nach bestimmten benannten Widgets sucht und das visuelle Verhalten dieser spezifischen Widgets ändert. Die Schaltflächen "Estop" und "Maschine ein" verwenden andere Farben als die übrigen Schaltflächen, damit sie sich abheben. Dies geschieht in der Handler-Datei, indem man ihnen bestimmte Namen gibt und indem man bestimmte Befehle in der gtkrc-Datei des Themas hinzufügt. Für einige Informationen über GTK-Themen (das Beispielthema verwendet die Pixmap-Themen-Engine), siehe: GTK-Themen, Pixmap-Themen-Engine.

2.2. Ein GladeVCP-Panel erstellen

Gscreen is just a big complicated GladeVCP panel, with Python code to control it. To customize it we need the Glade file loaded in the Glade editor.

Installiertes LinuxCNC

If you have LinuxCNC 2.6+ installed on Ubuntu 10.04 just start the Glade editor from the applications menu or from the terminal. Newer versions of Linux will require you to install Glade 3.8.0 - 3.8.6 (you may need to compile it yourself).

RIP-kompilierte Befehle

Using a compiled from source version of LinuxCNC open a terminal and cd to the top of the LinuxCNC folder. Set up the environment by entering . ./scripts/rip-environment now enter glade, you see a bunch of warnings in the terminal that you can ignore and the editor should open. The stock Gscreen Glade file is in: src/emc/usr_intf/gscreen/ sample skins are in /share/gscreen/skins/. This should be copied to a configuration folder. Or you can make a clean-sheet Glade file by saving it in a configuration folder.

Ok you have loaded the stock Glade file and now can edit it. The first thing you notice is it does not look in the editor like what it is displayed like Gscreen uses some tricks, such as hiding all boxes of buttons except one and changing that one depending on the mode. The same goes for notebooks, some screens use notebooks with the tabs not shown. To change pages in the editor you need to temporarily show those tabs.

When making changes it is far easier to add widgets then subtract widgets and still have the screen work properly making objects not visible is one way to change the display without getting errors. This won’t always work some widgets will be set visible again. Changing the names of Gscreen’s regular widgets is probably not gonna work well without changing the Python code, but moving a widget while keeping the name is usually workable.

Gscreen leverages GladeVCP widgets as much as possible, to avoid adding Python code. Learning about GladeVCP widgets is a prerequisite. If the existing widgets give you the function you want or need then no Python code needs be added, just save the Glade file in your configuration folder. If you need something more custom then you must do some Python programming. The name of the parent window needs to be window1. Gscreen assumes this name.

Denken Sie daran, wenn Sie eine benutzerdefinierte Bildschirmoption verwenden, sind SIE dafür verantwortlich, diese zu reparieren (falls erforderlich), wenn Sie LinuxCNC aktualisieren.

3. Erstellen eines einfachen benutzerdefinierten Bildschirms

Gscreen einfacher nutzbarer Bildschirm

Lassen Sie uns einen einfachen brauchbaren Bildschirm erstellen. Erstellen Sie diesen im Glade-Editor (wenn Sie ein RIP-Paket verwenden, führen Sie ihn von einem Terminal aus, nachdem Sie . scripts/rip-environment verwendet haben).

Zu beachtende Punkte:

  • Das Fenster der obersten Ebene muss den Standardnamen "window1" tragen - Gscreen verlässt sich auf diesen Namen.

  • Add actions by right clicking, and selecting add as toplevel widget they don’t add anything visual to the window but are added to the right most action list. Add all the ones you see on the top right.

  • Nach dem Hinzufügen der Aktionen müssen wir die Schaltflächen mit den Aktionen verknüpfen, damit sie funktionieren (siehe unten).

  • Das Gremlin-Widget hat keine Standardgröße, daher ist die Angabe einer gewünschten Größe hilfreich (siehe unten).

  • The sourceview widget will try to use the whole window so adding it to a scrolled window will cover this. (This is already done in the example.)

  • Die Schaltflächen werden sich ausdehnen, wenn das Fenster vergrößert wird, was unschön ist, also werden wir das Feld, in dem sie sich befinden, so einstellen, dass es sich nicht ausdehnt (siehe unten).

  • Die zu verwendenden Button-Typen hängen von der verwendeten VCP_action ab -eg vcp_toggle_action erfordern in der Regel Toggle-Schaltflächen (folgen Sie zunächst dem Beispiel).

  • Die Tasten in diesem Beispiel sind normale Tasten und keine HAL-Buttons. Wir brauchen die HAL-Pins nicht.

Glade editor tester.glade

In this screen we are using VCP_actions to communicate to LinuxCNC the actions we want. This allows us standard functions without adding Python code in the handler file. Let’s link the estop toggle button to the estop action Select the estop toggle button and under the general tab look for Related Action and click the button beside it. Now select the toggle estop action. Now the button will toggle estop on and off when clicked. Under the general tab you can change the text of the button’s label to describe its function. Do this for all the buttons.

Wählen Sie das Gremlin-Widget aus, klicken Sie auf die Registerkarte Allgemein, setzen Sie die gewünschte Höhe auf 100 und klicken Sie auf das Kontrollkästchen daneben.

Click the horizontal box that holds the buttons. Click the packing tab and click expand to No.

Save it as tester.glade and save it in sim/gscreen/gscreen_custom/ folder. Now launch LinuxCNC and click to sim/gscreen/gscreen_custom/tester and start it. If all goes well our screen will pop up and the buttons will do their job. This works because the tester.ini tells gscreen to look for and load tester.glade and tester_handler.py. The tester_handler.py file is included in that folder and is coded just show the screen and not much else. Since the special widgets directly communicate with LinuxCNC you can still do useful things. If your screen needs are covered by the available special widgets then this is as far as you need to go to build a screen. If you want something more there are still many tricks available from just adding function calls to get canned behaviour. To coding your own Python code to customize exactly what you want. But that means learning about handler files.

4. Beispiel für eine Handler-Datei

Es gibt spezielle Funktionen, auf die Gscreen die Handler-Datei überprüft. Wenn Sie diese in Ihre Handler-Datei aufnehmen, ruft Gscreen sie anstelle der gleichnamigen internen Funktionen von Gscreen auf.

  • initialize_preferences(self): Sie können neue Einstellungsroutinen installieren.

  • initialize_keybindings(self) You can install new keybinding routines. In most cases you won’t want to do this, you will want to override the individual keybinding calls. You can also add more keybindings that will call an arbitrary function.

  • initialize_pins(self): erzeugt / initialisiert HAL-Pins

  • connect_signals(self,handlers): If you are using a completely different screen the default Gscreen you must add this or gscreen will try to connect signals to widgets that are not there. Gscreen’s default function is called with self.gscreen.connect_signals(handlers). If you wish to just add extra signals to your screen but still want the default ones call this first then add more signals. If you signals are simple (no user data passed) then you can also use the Glade signal selection in the Glade editor.

  • initialize_widgets(self): You can use this to set up any widgets. Gscreen usually calls self.gscreen.initialize_widgets() which actually calls many separate functions. If you wish to incorporate some of those widgets then just call those functions directly. Or add self.gscreen.init_show_windows() so widgets are just shown. Then if desired, initialize/adjust your new widgets.

  • initialize_manual_toolchange(self): Ermöglicht eine vollständige Überarbeitung des manuellen Werkzeugwechselsystems.

  • set_restart_line(self.line):

  • timer_interrupt(self): allows one to complete redefine the interrupt routine. This is used for calling periodic() and checking for errors from linuxcnc.status.

  • check_mode(self): wird verwendet, um zu prüfen, in welchem Modus sich der Bildschirm befindet. Liefert eine Liste[] 0 -manual 1- mdi 2- auto 3- jog.

  • on_tool_change(self,widget): Sie können dies verwenden, um den manuellen Werkzeugwechsel-Dialog zu überschreiben - dieser wird aufgerufen, wenn gscreen.tool-change den Status ändert.

  • dialog_return(self,dialog_widget,displaytype,pinname): Use this to override any user message or manual tool change dialog. Called when the dialog is closed.

  • periodic(self): This is called every (default 100) milliseconds. Use it to update your widgets/HAL pins. You can call Gscreen regular periodic afterwards too, self.gscreen.update_position() or just add pass to not update anything. Gscreen’s update_position() actually calls many separate functions. If you wish to incorporate some of those widgets then just call those functions directly.

Sie können auch eigene Funktionen hinzufügen, die in dieser Datei aufgerufen werden sollen. Normalerweise würden Sie einem Widget ein Signal hinzufügen, um Ihre Funktion aufzurufen.

4.1. Hinzufügen von Funktionen für Tastenkombinationen

Unser Tester-Beispiel wäre nützlicher, wenn es auf Tastaturbefehle reagieren würde. Es gibt eine Funktion namens keybindings(), die versucht, dies einzurichten. Man kann sie zwar komplett außer Kraft setzen, was wir nicht getan haben, aber sie setzt einige Dinge voraus:

  • Es wird davon ausgegangen, dass die Umschalttaste für den Ausstieg button_estop heißt und mit der Taste F1 gesteuert wird.

  • Es wird davon ausgegangen, dass der Netzschalter "button_machine_on" heißt und mit der Taste F2 gesteuert wird.

Diese lassen sich leicht beheben, indem man die Schaltflächen im Glade-Editor entsprechend umbenennt. Aber stattdessen werden wir die Standardaufrufe außer Kraft setzen und unsere eigenen hinzufügen.

Fügen Sie diese Befehle in die Handler-Datei ein:

# Gscreen-Funktionen überschreiben
# Tastatur-Funktionen (engl. key binding)-Aufrufe
def on_keycall_ESTOP(self,state,SHIFT,CNTRL,ALT):
  if state: # only if pressed, not released
    self.widgets.togglebutton1.emit('activate')
    self.gscreen.audio.set_sound(self.data.alert_sound)
    self.gscreen.audio.run()
    return True # stop progression of signal to other widgets
def on_keycall_POWER(self,state,SHIFT,CNTRL,ALT):
  if state:
    self.widgets.togglebutton2.emit('activate')
    return True
def on_keycall_ABORT(self,state,SHIFT,CNTRL,ALT):
  if state:
    self.widgets.button3.emit('activate')
    return True

Jetzt haben wir die gleichnamigen Funktionsaufrufe von Gscreen überschrieben und behandeln sie in unserer Handler-Datei. Wir verweisen jetzt auf die Widgets mit dem Namen, den wir im Glade-Editor verwendet haben. Wir haben auch eine eingebaute Gscreen-Funktion hinzugefügt, um einen Ton zu erzeugen, wenn sich Estop ändert. Beachten Sie, dass wir die eingebauten Gscreen-Funktionen mit self.gscreen.[FUNKTIONSNAME]() aufrufen müssen. Wenn wir self.[FUNKTIONSNAME]() verwenden, wird die Funktion in unserer Handler-Datei aufgerufen.

Fügen wir eine weitere Tastenkombination hinzu, die das Halmeter lädt, wenn F4 gedrückt wird.

In der Handler-Datei unter def initialize_widgets(self): ändern in:

  def initialize_widgets(self):
    self.gscreen.init_show_windows()
    self.gscreen.keylookup.add_conversion('F4','TEST','on_keycall_HALMETER')

Fügen Sie dann diese Funktionen unter der Klasse "HandlerClass" hinzu:

  def on_keycall_HALMETER(self,state,SHIFT,CNTRL,ALT):
    if state:
      self.gscreen.on_halmeter()
      return True

Dies fügt eine Keybinding-Konvertierung hinzu, die gscreen anweist, wenn F4 gedrückt wird on_keycall_HALMETER aufzurufen. Dann fügen wir die Funktion zur Handle-Datei hinzu, um eine Gscreen-Builtin-Funktion zum Starten von Halmeter aufzurufen.

4.2. LinuxCNC-Status Status

Das Modul Gstat fragt den Zustand von LinuxCNC alle 100 ms ab und sendet Callback-Nachrichten an Benutzerfunktionen, wenn sich der Zustand ändert. Sie können Nachrichten registrieren, um auf bestimmte Zustandsänderungen zu reagieren. Als Beispiel werden wir uns registrieren, um file-loaded-Meldungen zu erhalten, wenn LinuxCNC eine neue Datei lädt. Zuerst müssen wir das Modul importieren und instanziieren: Fügen Sie in der Import-Sektion der Handler-Datei hinzu:

from hal_glib import GStat
GSTAT = GStat()

In der Handler-Datei unter def __init__(self): hinzufügen:

GSTAT.connect('file-loaded', self.update_filepath)

Fügen Sie dann in der HandlerClass folgende Funktion hinzu:

self.update_filepath(self, obj, path):
    self.widgets.my_path_label.set_text(path)

When LinuxCNC loads a new file, Gstat will send a callback message to the function update_filepath. In this example we update a label with that path name (assuming there is a label named my_path_label) in the GLADE file.

4.3. Jogging-Tasten

Es gibt keine speziellen Widgets für ein Bildschirm-Button-Joggen, also müssen wir es mit Python-Code tun. Fügen Sie unter der Funktion connect_signals folgenden Code hinzu:

        for i in('x','y','z'):
            self.widgets[i+'neg'].connect("pressed", self['jog_'+i],0,True)
            self.widgets[i+'neg'].connect("released", self['jog_'+i],0,False)
            self.widgets[i+'pos'].connect("pressed", self['jog_'+i],1,True)
            self.widgets[i+'pos'].connect("released", self['jog_'+i],1,False)
        self.widgets.jog_speed.connect("value_changed",self.jog_speed_changed)

Fügen Sie diese Funktionen unter der Klasse HandlerClass hinzu:

    def jog_x(self,widget,direction,state):
        self.gscreen.do_key_jog(_X,direction,state)
    def jog_y(self,widget,direction,state):
        self.gscreen.do_key_jog(_Y,direction,state)
    def jog_z(self,widget,direction,state):
        self.gscreen.do_key_jog(_Z,direction,state)
    def jog_speed_changed(self,widget,value):
        self.gscreen.set_jog_rate(absolute = value)

Schließlich fügen Sie der GLADE-Datei für jede Achse zwei Schaltflächen hinzu - eine für die positive und eine für die negative Richtung des Tippens. Nennen Sie diese Schaltflächen xneg, xpos, yneg, ypos bzw. zneg, zpos. Fügen Sie ein SpeedControl-Widget in die GLADE-Datei ein und nennen Sie es jog_speed.

5. Gscreen Start

Gscreen ist wirklich nur eine Infrastruktur, um eine benutzerdefinierte GladeVCP-Datei zu laden und damit zu interagieren.

  1. Gscreen liest die Optionen, mit denen es gestartet wurde.

  2. Gscreen stellt den Debug-Modus ein und setzt den optionalen Skin-Namen.

  3. Gscreen checks to see if there are local XML, handler and/or locale files in the configuration folder. It will use them instead of the default ones (in share/gscreen/skins/) (There can be two separate screens displayed).

  4. The main screen is loaded and translations set up. If present the second screen will be loaded and translations set up.

  5. Optionales Audio wird initialisiert, falls vorhanden.

  6. Es liest einen Teil der INI-Datei, um die Einheiten und die Anzahl/Typen der Achsen zu initialisieren.

  7. Initializes Python’s binding to HAL to build a non-realtime component with the Gscreen name.

  8. GladeVCP’s makepins wird aufgerufen, um die XML-Datei zu parsen, um HAL-Pins für die HAL-Widgets zu erstellen und die mit LinuxCNC verbundenen Widgets zu registrieren.

  9. Prüft, ob eine "local" Handler-Datei im Konfigurationsordner vorhanden ist, oder verwendet die Standard-Handler-Datei aus dem Skin-Ordner.

  10. Wenn eine Handler-Datei vorhanden ist, analysiert Gscreen diese und registriert die Funktionsaufrufe im Namensraum von Gscreen.

  11. Glade gleicht/registriert alle Signalaufrufe an Funktionen in Gscreen und der Handler-Datei.

  12. Gscreen prüft die INI-Datei auf den Namen einer Optionseinstellungsdatei, andernfalls verwendet es .gscreen_preferences =.

  13. Gscreen prüft, ob ein Aufruf der Einstellungsfunktion (initialize_preferences(self)) in der Handler-Datei vorhanden ist, andernfalls wird die Standardfunktion von Gscreen verwendet.

  14. Gscreen sucht nach der "ClassicLadder"-Echtzeit-Komponente.

  15. Gscreen prüft auf das systemweite GTK-Thema.

  16. Gscreen holt sich das Inkrement beim Joggen aus der INI-Datei.

  17. Gscreen holt sich die Winkelschritte für das Joggen aus der INI-Datei.

  18. Gscreen holt sich die Standard- und die maximale Jog-Geschwindigkeit aus der INI.

  19. Gscreen sammelt die maximale Geschwindigkeit aller Achsen aus dem TRAJ-Abschnitt der INI.

  20. Gscreen prüft, ob Winkelachsen vorhanden sind, und entnimmt dann die Standard- und Höchstgeschwindigkeit aus der INI-Datei.

  21. Gscreen sammelt alle Override-Einstellungen aus der INI.

  22. Gscreen prüft, ob es sich um eine Drehbankkonfiguration aus der INI-Datei handelt.

  23. Gscreen findet den Namen der tool_table-, tool editor- und param-Datei in der INI.

  24. Gscreen prüft die Handler-Datei auf die Funktion "keybindings" ("initialize_keybindings(self)") oder verwendet die von Gscreen bereitgestellte Funktion.

  25. Gscreen checks the handler file for pins function (initialize_pins(self)) or else use Gscreen stock one.

  26. Gscreen prüft die Handler-Datei auf die Funktion manual_toolchange (initialize_manual_toolchange(self)) oder verwendet die regulär von Gscreen zur Verfügung gestellte.

  27. Gscreen überprüft die Handler-Datei auf die Funktion connect_signals (initialize_connect_signals(self)) oder verwendet andernfalls eine Standarddatei von Gscreen.

  28. Gscreen prüft die Handler-Datei für die Widgets-Funktion (initialize_widgets(self)) oder verwendet die regulär von Gscreen zur Verfügung gestellte.

  29. Gscreen richtet die in der INI-Datei angegebenen Meldungen ein.

  30. Gscreen tells HAL the Gscreen HAL component is finished making pins and is ready. If there is a terminal widget in the screen it will print all the Gscreen pins to it.

  31. Gscreen stellt die Anzeigezykluszeit auf der Grundlage der INI-Datei ein.

  32. Gscreen prüft die Handler-Datei auf den Aufruf der Funktion timer_interupt(self), andernfalls wird der Standardfunktionsaufruf von Gscreen verwendet.

6. INI-Einstellungen

Unter der Überschrift [DISPLAY]:

DISPLAY = gscreen -c tester
  options:
   -d debugging on
   -v verbose debugging on

The -c switch allows one to select a skin. Gscreen assumes the Glade file and the handler file use this same name. The optional second screen will be the same name with a 2 (e.g., tester2.glade). There is no second handler file allowed. It will only be loaded if it is present. Gscreen will search the LinuxCNC configuration file that was launched first for the files, then in the system skin folder.

7. Benutzerdialog-Meldungen

Diese Funktion wird verwendet, um Pop-up-Dialogmeldungen auf dem Bildschirm anzuzeigen. Diese werden in der INI-Datei definiert und über HAL-Pins gesteuert:

MESSAGE_BOLDTEXT

ist im Allgemeinen ein Titel.

MESSAGE_TEXT

ist darunter und in der Regel länger.

MESSAGE_DETAILS

ist ausgeblendet, wenn nicht darauf geklickt wird.

MESSAGE_PINNAME

ist der Basisname der HAL-Pins.

MESSAGE_TYPE

gibt an, ob es sich um eine Ja/Nein-, eine Ok- oder eine Statusmeldung handelt

  • Statusmeldungen

    • wird in der Statusleiste und im Benachrichtigungsdialog angezeigt,

    • erfordern keinen Benutzereingriff.

  • OK-Meldungen

    • den Benutzer auffordern, auf ok zu klicken, um den Dialog zu schließen.

    • have one HAL pin to launch the dialog and one to signify it is waiting for response.

  • Ja/Nein-Meldungen

    • den Benutzer auffordern, die Schaltflächen "Ja" oder "Nein" auszuwählen, um den Dialog zu schließen.

    • have three HAL pins:

      1. eine, um den Dialog anzuzeigen,

      2. eine für das Warten, und

      3. eine für die Antwort.

Hier ist ein Beispiel für einen INI-Code. Er befindet sich unter der Überschrift [DISPLAY].

# Dies wird nur in der Statusleiste und im Popup-Fenster für Desktop-Benachrichtigungen angezeigt.
MESSAGE_BOLDTEXT = NONE
MESSAGE_TEXT = This is a statusbar test
MESSAGE_DETAILS = STATUS DETAILS
MESSAGE_TYPE = status
MESSAGE_PINNAME = statustest

# Es wird ein Dialog mit einer Ja-Nein-Frage eingeblendet
MESSAGE_BOLDTEXT = NONE
MESSAGE_TEXT = This is a yes no dialog test
MESSAGE_DETAILS = Y/N DETAILS
MESSAGE_TYPE = yesnodialog
MESSAGE_PINNAME = yndialogtest

# Es erscheint ein Dialog, der eine OK-Antwort erfordert und in der Statusleiste und
# dem Desktop-Benachrichtigungs-Popup.
MESSAGE_BOLDTEXT = This is the short text
MESSAGE_TEXT = This is the longer text of the both type test. It can be longer then the status bar text
MESSAGE_DETAILS = BOTH DETAILS
MESSAGE_TYPE = okdialog status
MESSAGE_PINNAME = bothtest

7.1. Kopieren Sie die Datei "Stock Handler/Glade" zur Bearbeitung

If you wish to use a stock screen but modify its handler file, you need to copy the stock file to your config file folder. Gscreen will see this and use the copied file. But where is the original file? If using a RIP LinuxCNC the sample skins are in /share/gscreen/skins/SCREENNAME Installed versions of LinuxCNC have them in slightly different places depending on the distribution used. An easy way to find the location is to open a terminal and start the sim screen you wish to use. In the terminal the file locations will be printed. It may help to add the -d switch to the gscreen load line in the INI.

Hier ist ein Beispiel:

chris@chris-ThinkPad-T500 ~/emc-dev/src $ linuxcnc
LINUXCNC - 2.7.14
Machine configuration directory is '/home/chris/emc-dev/configs/sim/gscreen/gscreen_custom'
Machine configuration file is 'industrial_lathe.ini'
Starting LinuxCNC...
Found file(lib): /home/chris/emc-dev/lib/hallib/core_sim.hal
Note: Using POSIX non-realtime
Found file(lib): /home/chris/emc-dev/lib/hallib/sim_spindle_encoder.hal
Found file(lib): /home/chris/emc-dev/lib/hallib/axis_manualtoolchange.hal
Found file(lib): /home/chris/emc-dev/lib/hallib/simulated_home.hal
**** GSCREEN WARNING: no audio alerts available - Is python-gst0.10 library installed?
**** GSCREEN INFO ini: /home/chris/emc-dev/configs/sim/gscreen/gscreen_custom/industrial_lathe.ini
**** GSCREEN INFO: Skin name = industrial

**** GSCREEN INFO:  Using SKIN glade file from /home/chris/emc-dev/share/gscreen/skins/industrial/industrial.glade ****

**** GSCREEN INFO:  No Screen 2 glade file present
**** GSCREEN INFO: handler file path: ['/home/chris/emc-dev/share/gscreen/skins/industrial/industrial_handler.py']

Die Zeile:

**** GSCREEN INFO: handler file path: ['/home/chris/emc-dev/share/gscreen/skins/industrial/industrial_handler.py']

zeigt, wo sich die Bestandsdatei befindet. Kopieren Sie diese Datei in Ihren Konfigurationsordner. Das Gleiche gilt für die Glade-Datei.