Python-Beispiele

Instanz einer .NET Klasse erstellen

Dieses Beispiel zeigt, wie Sie eine .NET-Assembly der CLR (Common Language Runtime) als Referenz hinzufügen, und wie Sie eine Instanz einer Klasse erstellen.

Erstellen einer Instanz der Klasse Loehnert.TypeAndResult.Station

import clr (1)
clr.AddReference('Loehnert.TypeAndResult') (2)
from Loehnert.TypeAndResult import Station (3)

station = Station('my_station') (4)

1	Import des CLR (Common Language Runtime) Moduls
2	Um eine .NET-Assembly zu verwenden, muss diese der CLR als Referenz hinzugefügt werden
3	Den Typ Station aus dem Namespace Loehnert.TypeAndResult importieren
4	Aufruf des Konstruktors

Viele nützliche Tipps zur .NET Integration finden Sie in der IronPython .NET Integration Dokumentation.

Die Assemblies system und mscorlib müssen nicht als clr Referenz hinzugefügt werden, da diese automatisch von der DLR (Dynamic Language Runtime) geladen werden.

Messzyklus erstellen und Merkmal bewerten

Es sollen ein Messzyklus und ein Messprozess erstellt werden und ein Merkmal bewertet werden. Die Station hat ein Typdatenmodul und ein Werkstückmodul mit dem Namen WorkPiece. Es sind die Typdaten aus dem Typdaten-Beispiel geladen.

WorkPiece.SetWorkPiece('1234') (1)
measure_cycle = WorkPiece.GetNewMeasureCycle() (2)
measure_process = measure_cycle.AddNewMeasureProcess('HighVoltageTest') (3)

current = 0.004 # 4mA (4)
measure_process.EvaluateAttribute('Current', current) (5)

measure_process.Evaluate() (6)
measure_cycle.Evaluate() (7)
WorkPiece.RemoveWorkPiece() (8)

1	Werkstück (Prüfling) über eine ID laden. Die eindeutigen ID 1234 könnte z.B. eine Trace-ID oder eine Seriennummer sein
2	Messzyklus, für ein Werkstück, erstellen
3	Messprozess, für den Prozess HighVoltageTest, erstellen
4	Messwert generieren, dieser würde von einem Messgerät erzeugt werden
5	Merkmal Current bewerten
6	Messprozess bewerten
7	Messzyklus bewerten
8	Werkstück aus dem Werkstückmodul entfernen

Abbildung 1 zeigt die Ergebnisansicht im Servicefenster des Werkstückmoduls. Die Gesamtklassifikation des Messzyklus wird in dem gewählten Beispiel als Nicht in Ordnung bewertet, da nicht alle Merkmale des HighVoltage-Prozesses gemessen wurden.

Abbildung 1. Ansicht der Ergebnisse, Servicefenster des Werkstückmoduls

Prozess-, Parameter- und Merkmalnamen können per Drag’n’Drop aus dem Typdateneditor oder dem Servicefenster des Typdatenmoduls in das Script kopiert werden.

Einen Dialog anzeigen

In diesem Beispiel sehen Sie, wie Sie einen Dialog mit einem Eingabefeld anzeigen.

import clr
clr.AddReference('Loehnert.Controls') (1)
from Loehnert.Controls.Dialogs import DialogService

dialog = DialogService.GetDialogBuilder()\ (2)
.WithTitle('Eingabe Seriennummer')\ (3)
.WithInput(str, 'Seriennummer')\ (4)
.WithOkButton().IsDefaultButton()\  (5) (6)
.WithCancelButton()\ (7)
.ThrowExceptionOnCancel()\ (8)
.Build()

result = dialog.Show() (9)

serial_number = result.Values[0] (10)

1	.NET-Assembly Loehnert.Controls.dll der CLR als Referenz hinzufügen
2	Einen DialogBuilder erstellen
3	Titel hinzufügen
4	Eingabefeld für eine Zeichenfolge hinzufügen
5	OK-Button hinzufügen
6	OK-Button als Standardbutton festlegen, dieser reagiert auf die Enter-Taste
7	Abbruch-Button hinzufügen
8	Bei Abbruch soll eine Ausnahme geworfen werden (siehe OperationCanceledException), diese führt zum Abbruch des Skripts
9	Dialog anzeigen
10	Die Seriennummer aus dem Ergebnis des Dialogs holen

Abbildung 2. Ansicht des Eingabedialogs

Weitere Beispiele für Dialoge finden Sie in der Dokumentation des DialogBuilders.

Einen Dialog anzeigen und parallel auf eine Code-Eingabe warten

In diesem Beispiel wird gezeigt, wie ein Benutzer-Dialog erstellt wird, in dem zur Eingabe des Codes per Tastatur oder durch Scannen eines Codes aufgefordert wird. Wenn eine Benutzereingabe erfolgt ist oder wenn gescannt wurde, wird der Benutzer-Dialog geschlossen.

Über einen Scanner oder per Tastatureingabe wird ein Code erhalten

import clr
clr.AddReference('Loehnert.Controls')
from Loehnert.Controls.Dialogs import DialogService

dialog = None
code = None

def code_scanned_callback(object, args): (1)
    global code (2)
    code = args
    if dialog is not None:
        dialog.Close('CodeScanned')

Scanner.CodeScanned += code_scanned_callback (3)
try:
    dialog = DialogService.GetDialogBuilder()\
    .WithTitle('Enter a code')\
    .WithMessage('Please scan the code or enter it using the keyboard.')\
    .WithInput(str, 'Code').Left()\
    .WithOkButton().IsDefaultButton()\
    .WithCancelButton().ThrowExceptionOnCancel()\
    .Build()

    task = dialog.ShowAsync()
    result = task.Result

finally:
    Scanner.CodeScanned -= code_scanned_callback (4)

actual_code = code if code is not None else result.Values[0]
print str('actual_code: ' + actual_code)

1	Callback der ausgeführt wird, wenn ein Code gescannt wurde
2	Damit die Variable code, die außerhalb der Funktion erstellt wurde, verändert werden kann, muss diese Variable global sein
3	Anhängen an das CodeScanned-Event
4	Der Callback muss wieder freigegeben werden

Threading

Hier wird gezeigt, wie Sie eine Funktion parallel zum Haupthread ausführen können. Die asynchrone Funktion kann abgebrochen werden.

import threading

def async_operation(stop): (1)
    while True:
        if stop():
            break

stop_threads = False
t1 = threading.Thread(target = async_operation, args = (lambda : stop_threads, ))
t1.start()
try:
    # Run here synchronous code
finally:
    stop_threads = True
    t1.join()

1	Der stop Parameter is eine Funktion die zurückgibt, ob die asynchrone Funktion abgebrochen werden soll

Loggen

Dieses Beispiel erstellt einen Logger und erzeugt einen Logeintrag.

import clr

clr.AddReference('Loehnert.Lisrt')

from Loehnert.Lisrt.Messaging import MessageService
from Loehnert.Lisrt.Contracts import LogLevel

logger = MessageService.Instance.LoggerFactory.GetLogger('MyLogger') (1)
logger.Log(LogLevel.Info, 'Das ist ein Logeintrag mit dem Log-Level Info') (2)

1	Einen Logger mit dem Namen MyLogger erstellen
2	Einen Logeintrag mit dem Log-Level Info erzeugen

Typdaten vererben

Das folgende Beispiel zeigt, wie Typdaten mittels Vererbung kombiniert werden können.

import clr

clr.AddReference('Caliburn.Micro')
clr.AddReference('Loehnert.TypeAndResult')
clr.AddReference('Loehnert.Lisrt.TypeAndResult')

from Caliburn.Micro import IoC
from Loehnert.TypeAndResult import TypeData as type_data_class
from Loehnert.TypeAndResult.Provider import ITypeDataProvider
from Loehnert.Lisrt.TypeAndResult.GeminiModule import GeminiTypeDataModule


def combine_type_data(types):
    provider = IoC.Get[GeminiTypeDataModule]().DefaultProvider  # type: ITypeDataProvider (1)
    combined_type_data = None
    for type_identifier in types:
        current_type_data = provider.Load(type_identifier)
        combined_type_data = current_type_data if combined_type_data == None else type_data_class.Inherit(combined_type_data, current_type_data) (2)

    return combined_type_data

types = ['Type_A', 'Type_B', 'Type_C']
type_data = combine_type_data(types)
type_data.TypeIdentifier = 'MySuperType' (3)
TypeData.SetTypeData(type_data) (4)

1	Standardtypdatenanbieter holen (z.B. XML-Dateidatenquelle)
2	Typdaten vererben
3	Die kombinierten Typdaten erhalten einen neuen Namen
4	Die Typdaten in das Typdatenmodul laden

Abbildung 3. Klassendiagramm der Typdaten

Feedback

War diese Seite hilfreich?

Freut uns zu hören! Falls du doch Verbesserungsvorschläge hast schreibe uns.

Tut uns leid, das zu hören. Bitte schreibe uns was wir verbessern können.

Zuletzt geändert 16.12.2024