1. Einführung

Gscreen ist eine Infrastruktur zur Anzeige eines benutzerdefinierten Bildschirms zur Steuerung von LinuxCNC. Gscreen lehnt sich stark an GladeVCP an. GladeVCP verwendet den GTK-Widget-Editor GLADE, um virtuelle Bedienfelder (VCP) durch Zeigen und Klicken zu erstellen. Gscreen kombiniert dies mit Python-Programmierung, um einen GUI-Bildschirm für den Betrieb einer CNC-Maschine zu erstellen.

Gscreen ist anpassbar, wenn Sie verschiedene Tasten und Status-LEDs wünschen. Gscreen unterstützt GladeVCP, das zum Hinzufügen von Steuerelementen und Anzeigen verwendet wird. Zum Anpassen von Gscreen verwenden Sie den Glade-Editor. Gscreen ist nicht auf das Hinzufügen eines benutzerdefinierten Panels auf der rechten Seite oder einer benutzerdefinierten Registerkarte beschränkt, sondern kann vollständig bearbeitet werden.

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 basiert auf Glade (dem Editor), PyGTK (dem Widget-Toolkit) und GladeVCP (die Verbindung von LinuxCNC zu Glade und PyGTK). GladeVCP hat einige spezielle Widgets und Aktionen, die nur für LinuxCNC hinzugefügt wurden. Ein Widget ist nur der allgemeine Name, der für die Buttons, Schieberegler, Beschriftungen usw. des PyGTK-Toolkits verwendet wird.

1.1. Glade-Datei

Eine Glade-Datei ist eine Textdatei, die im XML-Standard organisiert ist und das Layout und die Widgets des Bildschirms beschreibt. PyGTK verwendet diese Datei, um diese Widgets anzuzeigen und darauf zu reagieren. Der Glade-Editor macht es relativ einfach, diese Datei zu erstellen und zu bearbeiten. Sie müssen den Glade-Editor 3.38.2 verwenden, der die GTK3-Widgets verwendet.

1.2. PyGTK

PyGTK ist die Python-Bindung an GTK. GTK ist das Toolkit von visuellen Widgets, es ist in C programmiert. PyGTK verwendet Python, um sich mit GTK zu binden.

2. GladeVCP

GladeVCP verbindet LinuxCNC, HAL, PyGTK und Glade miteinander. LinuxCNC benötigt einige spezielle Widgets und GladeVCP liefert diese. Viele sind nur HAL-Erweiterungen zu bestehenden PyGTK-Widgets. GladeVCP erzeugt die HAL-Pins für die speziellen Widgets, die in der Glade-Datei beschrieben sind. GladeVCP erlaubt es auch, Python-Befehle hinzuzufügen, um mit den Widgets zu interagieren und sie Dinge tun zu lassen, die in ihrer Standardform nicht verfügbar sind. Wenn Sie ein GladeVCP-Panel bauen können, dann können Sie auch Gscreen anpassen!

2.1. Übersicht

Es gibt zwei Dateien, die einzeln oder in Kombination verwendet werden können, um Anpassungen vorzunehmen. Lokale Glade-Dateien und Handler-Dateien. Normalerweise verwendet Gscreen die Standard-Gladedatei und möglicherweise eine Handler-Datei (bei Verwendung eines Beispiel-"Skins"). Sie können Gscreen so einstellen, dass es "lokale" Glade- und Handler-Dateien verwendet. Gscreen sucht in dem Ordner, der alle Konfigurationsdateien für die von Ihnen gewählte Konfiguration enthält.

Lokale Glade-Dateien

Wenn vorhanden, werden lokale Glade-Dateien im Konfigurationsordner anstelle der Standard-Gladedateien geladen. Lokale Glade-Dateien ermöglichen es Ihnen, Ihre eigenen Designs anstelle der Standardbildschirme zu verwenden. Es gibt einen Schalter in der INI-Datei, um den Basisnamen festzulegen: -c name, damit Gscreen nach MYNAME.glade und MYNAME_handler.py sucht.

Sie können Gscreen anweisen, nur die Glade-Datei zu laden und seine internen Signale nicht mit ihr zu verbinden. Dies erlaubt gscreen, jede vom GTK-Builder gespeicherte Glade-Datei zu laden. Das bedeutet, dass Sie einen komplett benutzerdefinierten Bildschirm anzeigen können, aber auch, dass Sie eine Handler-Datei verwenden müssen. Gscreen verwendet die Glade-Datei, um die Widgets zu definieren, damit es sie anzeigen und mit ihnen interagieren kann. Viele von ihnen haben spezifische Namen, anderen hat Glade generische Namen gegeben. Wenn das Widget angezeigt, aber nie verändert wird, ist ein allgemeiner Name in Ordnung. Wenn man das Widget steuern oder mit ihm interagieren muss, wird ein hoffentlich zweckmäßiger Name vergeben (alle Namen müssen eindeutig sein). Für Widgets können im GLADE-Editor auch Signale definiert werden. Hier wird festgelegt, welches Signal gegeben wird und welche Methode aufgerufen werden soll.

Ändern von Standard-Skins

Wenn Sie den Namen eines Widgets ändern, kann es sein, dass Gscreen es nicht finden kann. Wenn auf dieses Widget im Python-Code verwiesen wird, funktioniert das Widget im besten Fall nicht mehr, im schlimmsten Fall führt es zu einem Fehler beim Laden. Die Standardbildschirme von Gscreen verwenden nicht viele Signale, die im Editor definiert sind, sondern im Python-Code. Wenn Sie ein Widget mit Signalen verschieben (ausschneiden und einfügen), werden die Signale nicht kopiert. Sie müssen sie manuell wieder hinzufügen.

Handler-Dateien

Eine Handler-Datei ist eine Datei, die Python-Code enthält, den Gscreen zu seinen Standardroutinen hinzufügt. Eine Handler-Datei ermöglicht es, Standardeinstellungen zu ändern oder einem Gscreen-Skin Logik hinzuzufügen, ohne Gscreen selbst ändern zu müssen. Sie können neue Funktionen mit den Funktionen von Gscreen kombinieren, um das Verhalten nach Belieben zu ändern. Sie können alle Funktionen von Gscreen komplett umgehen und sie völlig anders arbeiten lassen. Wenn eine Handler-Datei mit dem Namen gscreen_handler.py (oder MYNAME_handler.py, wenn Sie den INI-Schalter verwenden) vorhanden ist, wird diese geladen, und wenn nur eine Datei registriert ist, sucht Gscreen nach der Handler-Datei; wenn sie gefunden wird, sucht sie nach bestimmten Funktionsnamen und ruft diese anstelle der Standardfunktionen auf. Wenn Sie Widgets hinzufügen, können Sie Signalaufrufe aus dem Glade-Editor einrichten, um Routinen aufzurufen, die Sie in der Handler-Datei geschrieben haben. Auf diese Weise können Sie benutzerdefiniertes Verhalten haben. Handler-Routinen können die Standardroutinen von Gscreen aufrufen, entweder vor oder nach der Ausführung ihres eigenen Codes. Auf diese Weise können Sie zusätzliches Verhalten, wie z.B. das Hinzufügen eines Tons, einbauen. Bitte lesen Sie das GladeVCP Kapitel für die Grundlagen der GladeVCP Handler-Dateien. Gscreen verwendet eine sehr ähnliche Technik.

Themen

Gscreen uses the PyGTK toolkit to display the screen. PyGTK is the Python language binding to GTK. GTK supports themes. Themes are a way to modify the look and feel of the widgets on the screen. For instance the color or size of buttons and sliders can be changed using themes. There are many GTK themes available on the web. Themes can also be customized to modify visuals of particular named widgets. This ties the theme file to the Glade file more tightly. Some of the sample screen skins allow the user to select any of the themes on the system. The sample gscreen is an example. Some will load the theme that is the same name in the config file. The sample gscreen-gaxis is an example. This is done by putting the theme folder in the config folder that has the INI and HAL files and naming it: SCREENNAME_theme (SCREENNAME being the base name of the files eg. gaxis_theme). Inside this folder is another folder call gtk-2.0, inside that is the theme files. If you add this file, Gscreen will default to this theme on start up. gscreen-gaxis has a sample custom theme that looks for certain named widgets and changes the visual behavior of those specific widgets. The Estop and machine-on buttons use different colors then the rest of the buttons so that they stand out. This is done in the handler file by giving them specific names an by adding specific commands in the theme’s gtkrc file. For some info on GTK theming (the sample theme uses the pixmap theme engine), see: GTK Themes, Pixmap Theme Engine.

2.2. Ein GladeVCP-Panel erstellen

Gscreen ist nur ein großes, kompliziertes GladeVCP-Panel, mit Python-Code zur Steuerung. Um es anzupassen, müssen wir die Glade-Datei im Glade-Editor laden.

Installiertes LinuxCNC

Wenn Sie LinuxCNC 2.6+ auf Ubuntu 10.04 installiert haben, starten Sie einfach den Glade-Editor aus dem Anwendungsmenü oder über das Terminal. Neuere Versionen von Linux benötigen Sie Glade 3.8.0 - 3.8.6 zu installieren (möglicherweise müssen Sie es selbst kompilieren).

RIP-kompilierte Befehle

Mit einer aus dem Quellcode kompilierten Version von LinuxCNC öffnen Sie ein Terminal und cd zum Anfang des LinuxCNC-Ordners. Richten Sie die Umgebung ein, indem Sie . ./scripts/rip-environment eingeben. Geben Sie nun glade ein, Sie sehen eine Reihe von Warnungen im Terminal, die Sie ignorieren können und der Editor sollte sich öffnen. Die Standard-Gscreen-Gladedatei befindet sich in: src/emc/usr_intf/gscreen/ Beispielskins befinden sich in /share/gscreen/skins/. Diese sollte in einen Konfigurationsordner kopiert werden. Sie können auch eine saubere Glade-Datei erstellen, indem Sie sie in einem Konfigurationsordner speichern.

Ok, Sie haben die Glade-Datei geladen und können sie nun bearbeiten. Das erste, was Ihnen auffällt, ist, dass es im Editor nicht so aussieht, wie es angezeigt wird. Gscreen verwendet einige Tricks, wie z. B. das Ausblenden aller Schaltflächenfelder bis auf eines und das Ändern dieses Feldes je nach Modus. Dasselbe gilt für die Notizbücher. Einige Bildschirme verwenden Notizbücher, bei denen die Registerkarten nicht angezeigt werden. Um die Seiten im Editor zu wechseln, müssen Sie diese Registerkarten vorübergehend einblenden.

Wenn Sie Änderungen vornehmen, ist es viel einfacher, Widgets hinzuzufügen, als Widgets zu entfernen, damit der Bildschirm trotzdem richtig funktioniert. Das funktioniert nicht immer, manche Widgets werden wieder sichtbar gemacht. Das Ändern der Namen der regulären Widgets von Gscreen wird wahrscheinlich nicht gut funktionieren, ohne den Python-Code zu ändern, aber das Verschieben eines Widgets unter Beibehaltung des Namens ist normalerweise machbar.

Gscreen nutzt die GladeVCP-Widgets so weit wie möglich, um das Hinzufügen von Python-Code zu vermeiden. Die Kenntnis der GladeVCP-Widgets ist eine Voraussetzung. Wenn die vorhandenen Widgets die gewünschte oder benötigte Funktion bieten, muss kein Python-Code hinzugefügt werden, sondern nur die Glade-Datei im Konfigurationsordner gespeichert werden. Wenn Sie etwas benutzerdefinierteres benötigen, müssen Sie etwas Python-Programmierung vornehmen. Der Name des übergeordneten Fensters muss window1 lauten. Gscreen nimmt diesen Namen an.

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.

  • Fügen Sie Aktionen hinzu, indem Sie mit der rechten Maustaste klicken und "Als Toplevel-Widget hinzufügen" wählen. Sie fügen dem Fenster nichts Visuelles hinzu, sondern werden der rechten Aktionsliste hinzugefügt. Fügen Sie alle Aktionen hinzu, die Sie oben rechts sehen.

  • 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).

  • Das Sourceview-Widget wird versuchen, das gesamte Fenster zu verwenden, so dass das Hinzufügen zu einem gescrollten Fenster dies abdeckt. (Dies wurde bereits im Beispiel getan.)

  • 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 diesem Bildschirm verwenden wir VCP_actions, um LinuxCNC die Aktionen, die wir wollen, zu kommunizieren. Dies ermöglicht es uns, Standard-Funktionen ohne Hinzufügen von Python-Code in der Handler-Datei. Verknüpfen wir den Toggle-Estop-Knopf mit der Estop-Aktion Wählen Sie den Toggle-Estop-Knopf und suchen Sie unter der Registerkarte "Allgemein" nach "Related Action" und klicken Sie auf die Schaltfläche daneben. Wählen Sie nun die Aktion zum Umschalten der Sperrung aus. Jetzt schaltet die Schaltfläche die Sperrung ein und aus, wenn sie angeklickt wird. Auf der Registerkarte "Allgemein" können Sie den Text der Schaltflächenbeschriftung ändern, um die Funktion der Schaltfläche zu beschreiben. Tun Sie dies für alle Schaltflächen.

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.

Klicken Sie auf das horizontale Feld, in dem sich die Schaltflächen befinden. Klicken Sie auf die Registerkarte "Verpackung" (engl. packing) und klicken Sie bei "Erweitern" (engl. expand) auf "Nein".

Speichern Sie es als tester.glade und speichern Sie es in sim/gscreen/gscreen_custom/ Ordner. Nun starten Sie LinuxCNC und klicken Sie auf sim/gscreen/gscreen_custom/tester und starten Sie es. Wenn alles gut geht, wird unser Bildschirm auftauchen und die Knöpfe werden ihre Arbeit tun. Das funktioniert, weil die tester.ini gscreen anweist, nach tester.glade und tester_handler.py zu suchen und zu laden. Die Datei tester_handler.py befindet sich in diesem Ordner und ist so programmiert, dass sie nur den Bildschirm anzeigt und nicht viel mehr. Da die speziellen Widgets direkt mit LinuxCNC kommunizieren, können Sie trotzdem nützliche Dinge tun. Wenn Ihr Bedarf an Bildschirmen durch die verfügbaren speziellen Widgets abgedeckt ist, dann ist das alles, was Sie brauchen, um einen Bildschirm zu erstellen. Wenn Sie etwas mehr wollen, gibt es immer noch viele Tricks zur Verfügung von nur Hinzufügen von "Funktionsaufrufe", um canned Verhalten zu erhalten. Sie können auch Ihren eigenen Python-Code programmieren, um genau das zu erreichen, was Sie wollen. Das bedeutet aber, dass Sie sich mit Handler-Dateien vertraut machen müssen.

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) Sie können neue Tastenbindungsroutinen installieren. In den meisten Fällen werden Sie dies nicht tun wollen, sondern die einzelnen Tastaturbindungsaufrufe außer Kraft setzen wollen. Sie können auch weitere Tastenbindungen hinzufügen, die eine beliebige Funktion aufrufen.

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

  • connect_signals(self,handlers): Wenn Sie einen völlig anderen Bildschirm als den Standard-Gscreen verwenden, müssen Sie dies hinzufügen, da gscreen sonst versucht, Signale mit Widgets zu verbinden, die nicht vorhanden sind. Die Standardfunktion von Gscreen wird mit self.gscreen.connect_signals(handlers) aufgerufen. Wenn Sie nur zusätzliche Signale zu Ihrem Bildschirm hinzufügen möchten, aber trotzdem die Standardsignale verwenden wollen, rufen Sie zuerst diese Funktion auf und fügen dann weitere Signale hinzu. Wenn Ihre Signale einfach sind (keine Benutzerdaten übergeben), können Sie auch die Glade-Signalauswahl im Glade-Editor verwenden.

  • initialize_widgets(self): Hiermit können Sie alle Widgets einrichten. Gscreen ruft normalerweise self.gscreen.initialize_widgets() auf, das eigentlich viele separate Funktionen aufruft. Wenn Sie einige dieser Widgets einbinden möchten, rufen Sie diese Funktionen einfach direkt auf. Oder fügen Sie self.gscreen.init_show_windows() hinzu, damit die Widgets nur angezeigt werden. Dann, falls gewünscht, initialisieren/anpassen Sie Ihre neuen Widgets.

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

  • set_restart_line(self.line):

  • timer_interrupt(self): ermöglicht die vollständige Neudefinition der Interrupt-Routine. Dies wird für den Aufruf von periodic() und die Überprüfung auf Fehler von linuxcnc.status verwendet.

  • 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): Verwenden Sie diese Funktion, um eine Benutzermeldung oder einen manuellen Werkzeugwechsel-Dialog außer Kraft zu setzen. Wird aufgerufen, wenn der Dialog geschlossen wird.

  • periodisch(self): Diese Funktion wird alle (standardmäßig 100) Millisekunden aufgerufen. Verwenden Sie es, um Ihre Widgets/HAL-Pins zu aktualisieren. Sie können danach auch Gscreen regular periodic aufrufen, self.gscreen.update_position() oder einfach pass hinzufügen, um nichts zu aktualisieren. Die Funktion update_position() von Gscreen ruft eigentlich viele separate Funktionen auf. Wenn Sie einige dieser Widgets einbinden möchten, rufen Sie diese Funktionen einfach direkt auf.

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)

Wenn LinuxCNC eine neue Datei lädt, sendet Gstat eine Callback-Nachricht an die Funktion update_filepath. In diesem Beispiel aktualisieren wir ein Label mit dem Pfadnamen (vorausgesetzt, es gibt ein Label mit dem Namen my_path_label) in der Glade-Datei.

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 prüft, ob im Konfigurationsordner "lokale" XML-, Handler- und/oder Locale-Dateien vorhanden sind. Diese werden dann anstelle der Standarddateien (in share/gscreen/skins/) verwendet (es können zwei verschiedene Bildschirme angezeigt werden).

  4. Der Hauptbildschirm wird geladen und die Übersetzungen werden eingerichtet. Falls vorhanden, wird der zweite Bildschirm geladen und die Übersetzungen werden eingerichtet.

  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. Initialisiert die Bindung von Python an HAL, um eine Nicht-Echtzeit-Komponente mit dem Namen Gscreen zu erstellen.

  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 prüft die Handler-Datei auf die Pin-Funktion (initialize_pins(self)) oder verwendet die regulär von Gscreen zur Verfügung gestellte.

  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 teilt HAL mit, dass die Gscreen-HAL-Komponente mit der Erstellung von Pins fertig ist und bereit ist. Wenn ein Terminal-Widget auf dem Bildschirm vorhanden ist, werden alle Gscreen-Pins dorthin ausgegeben.

  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

Mit der Option (engl. auch switch, möglicherweise in anderem Kontext dann auch fälschlich als Schalter bezeichnet) -c kann man einen "Skin" auswählen. Gscreen geht davon aus, dass die Glade-Datei und die Handler-Datei denselben Namen haben. Der optionale zweite Bildschirm ist derselbe Name mit einer 2 (z.B. tester2.glade). Es ist keine zweite Handler-Datei erlaubt. Sie wird nur geladen, wenn sie vorhanden ist. Gscreen sucht in der LinuxCNC-Konfigurationsdatei, die zuerst gestartet wurde, nach den Dateien, dann im System-Skin-Ordner.

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.

    • einen HAL-Pin haben, um den Dialog zu starten, und einen, um zu signalisieren, dass er auf eine Antwort wartet.

  • Ja/Nein-Meldungen

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

    • haben drei 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

Wenn Sie einen Standardbildschirm verwenden, aber dessen Handler-Datei ändern möchten, müssen Sie die Standarddatei in Ihren Konfigurationsdateiordner kopieren. Gscreen wird dies erkennen und die kopierte Datei verwenden. Aber wo ist die Originaldatei? Wenn Sie ein RIP LinuxCNC verwenden, befinden sich die Beispiel-Skins in /share/gscreen/skins/SCREENNAME Installierte Versionen von LinuxCNC haben sie an leicht unterschiedlichen Orten, je nach verwendeter Distribution. Eine einfache Möglichkeit, den Speicherort zu finden, besteht darin, ein Terminal zu öffnen und den gewünschten Sim-Screen zu starten. Im Terminal werden die Speicherorte der Dateien ausgegeben. Es kann hilfreich sein, den Schalter -d in die Zeile gscreen load in der INI einzufügen.

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.