interne Befehlsausführung

[__deets__]

Nicht gleich schwarzmalen. Bei aller Liebe zum guten Programmieren, Rom wurde nicht an einem Tag erbaut. Wird schon.

@domperle

Was mir zumindest helfen wuerde, ist das Problem mal ohne die Loesung im Kopf zu bschreiben. Das ist unabhaengig von der Programmiersprache immer eine gute Idee. So wie es bisher aussieht, willst du Textersetzungen in Variablen durchfuehren. So weit, so einfach. Was mir aber unklar ist: woher kommen denn diese CNC Anweisungen? Sind das Textdateien, die du einliest? Und wie wird die Ausgabe erzeugt, und weiter verarbeitet?

[Domperle]

Einen kleinen Ausschnitt:
Hauptprogramm
10 CALL PGM 15019901
11 TOOL DEF 10 L+50 R+Q80 <<<--------- Hier wird der Parameter Q80 nach dem Programmaufruf 15019901 automatisch gesetzt

das Programm 15019901
2 Q30 = 5 ; Abhebeweg
3 Q62 = 2 ; 1= Bohren, 2= Bohren m. Spanbrechen,
3 ; 3= Tiefbohren mit Spanbrechen,
3 ; 4= Gewinde, 5= Reiben
4 Q69 = 850 ; Drehzahl
4 Q80 = 5 ; Fräserradius <<<------------ Das Paramterprogramm-

Dasselbe Programm umgesetzt nach ISO. ISO-Programme kennen keine Q-Paramter
N0007 % 15019901*
N0008 G99 T10 L+50 R+5* <<<------------ Hier brauche ich den echten Wert von Q80

Gibt es die Möglichkeit einen screeshot anzuhängen? Das könnte vielleicht zu einem besseren Verständis führen.

[__deets__]

Du kannst die bei Imgur hochladen & dann einen Forums-Link erzeugen, da haben die einen Button für.

Wo steht denn dieses Programm? Also ist das eine Text Datei? Und wo landet die Ausgabe?

[nezzcarth]

Hier mal, wie ich mit dem "Parameterprogramm" verfahren würde, auf Basis der bisherigen Infos hier im Thread.

Datei "15019901.ini'":

Code: Alles auswählen

[parameters]
Q30 = 5 ; Abhebeweg
Q62 = 2 ; 1= Bohren, 2= Bohren m. Spanbrechen,
; 3= Tiefbohren mit Spanbrechen,
;4= Gewinde, 5= Reiben
Q69 = 850 ; Drehzahl
Q80 = 5 ; Fräserradius

Python-Code zum Auslesen und verarbeiten (Ipython):

Code: Alles auswählen

In [1]: import configparser

In [2]: config = configparser.ConfigParser(inline_comment_prefixes=';')

In [3]: config.read('15019901.ini')
Out[3]: ['15019901.ini']

In [4]: parameters = config['parameters']

In [5]: parameters.getint('Q80')
Out[5]: 5

In [6]: parameters.getint('Q80') * parameters.getint('Q69')
Out[6]: 4250

Was ich an dem Rexx-Codebeispiel oben sehe, ist die Struktur, wie gesagt, komplett anders, als man das in Python aufbauen würde.

[Domperle]

Anbei ein screen shot
https://imgur.com/a/HTXERXN

[__blackjack__]

Also mir ist aus dem bisher beschriebenen noch nicht klar was gemacht werden soll. Was ist hier das Programm das geschrieben werden soll, und was sind die Eingabe und Ausgabedaten und wie steht das alles in Beziehung. Wir haben auch noch keinen Rexx-Quelltext gesehen der irgend etwas mit diesen Daten macht, oder? *Das* wäre doch aber interessant, zu sehen was dieses Programm machen soll.

[grubenfox]

Dem schliesse ich mich mal an... wo stehen wir, wo wollen wir hin?
Q80 einen Wert z.b. 5 zuweisen (steht unten in Zeile5) und den Wert von Q80 abfragen (wie unten in Zeile 6) kann es doch wohl nicht sein?

Code: Alles auswählen

In [5]: Q80 = 5 # Fraeserradius

In [6]: Q80
Out[6]: 5

Wie kommt das was Python liefern soll an oder in die Heidenhain-Steuerung?

Keine Ahnung ob das was hilft, aber hier ein Link den ich eben gefunden hatte:
https://stackoverflow.com/questions/567 ... ompound-va

[sparrow]

@grubenfox: Nee, kann es nicht sein. Denn die falsche Lösung wird ja gerade benutzt.

[Domperle]

Also, in der Schlosserei befinden sich 2 Fräsmaschinen, eine mit einer alten Steuerung TNC155 von Heidenhain und eine mit einer noch älteren DECKEL-Steuerung.
Die aktuelle Steuerung von Heidenhain ist die TNC640
Mit der Heidenhain-Software (TNC640) erstellt man CNC-Programme.
Der TNC640-Code kann aber auf der Fräse mit der TNC155 Steuerung nicht eingesetzt werden.
Und da komm ich.
Ich konvertiere den TNC640-Code in den TNC155-Code (dasselbe mache ich auch für DECKEL in abgespeckter Form) in Rexx
Um nicht bei Änderungen jedesmal ins Programm einsteigen zu müssen, verwendet Heidenhain s.g. Q-Parameter.
z.B.
Heute fräs ich einen Kreis mit Q30 = 20, morgen einen mit Q30 = 4.5. Auf diese Weise ändere ich nur die Parameter und muß von der Programmierung, keine Ahnung haben.
Der Befehl dafür CR X+50 Y+45 R+Q30 DR- F20

Die Parameter sind in einem Unterprogramm zusammengefasst.
z.B.
0 BEGIN PGM 15039901 MM
1 Q32 = 3 ;ANZAHL ZUSTELLUNGEN IN DER FLÄCHE
2 Q33 = 5 ;ANZAHL ZUSTELLUNGEN IN DER TIEFE
3 Q34 = 63 ;BOHRTIEFE
4 Q35 = 55 ;NUTENBREITE
5 Q36 = 100 ;NUTENLÄNGE
6 Q39 = 0 ;DREHLAGE
7 Q45 = 2 ;SICHERHEITSABSTAND
8 Q46 = 0 ;STARTWINKEL
9 Q47 = 25 ;FRÄSTIEFE
10 Q50 = 120 ;VORSCHUB IN DER FLÄCHE
11 Q51 = 10 ;VORSCHUB BEIM TAUCHEN
12 Q52 = 20 ;WINKELSCHRITT
13 Q53 = 59.5 ;X-KOORDINATE Nullpunkt
14 Q54 = 49.5 ;Y-KOORDINATE Nullpunkt
15 Q55 = 1 ;Z-KOORDINATE Nullpunkt
16 Q64 = 1 ; Verarbeitungsart
17 ; 1=Tasche,
18 ; 2=Zapfen,
19 ; 3=Rechtecktasche,
20 ; 4=Rechteckzapfen,
21 ; 5=Rechtecktasche mit Rundung,
22 ; 6=Rechteckzapfen mit Rundung
24 Q68 = 100 ; Vorschub beim Fräsen
25 Q69 = 800 ;Drehzahl
26 Q80 = 3 ;Fräserradius
27 END PGM 15039901 MM

Im Hauptprogramm wird dieses Unterprogramm aufgerufen
BEGIN PGM 15030000 MM
1 BLK FORM 0.1 Z X+0 Y+0 Z-30
2 BLK FORM 0.2 X+119 Y+99 Z+0
3 TOOL DEF 1 L+50 R+10
4 STOP
5 TOOL CALL 1 Z S850
6 CALL PGM 15039901
7 STOP
8 CYCL DEF 7.0 NULLPUNKT
9 CYCL DEF 7.1 X+Q53
10 CYCL DEF 7.2 Y+Q54
11 CYCL DEF 7.3 Z+Q55
12 L Z+Q45 F10 M3 ; Sicherheitsabstand
13 L X+0 Y+0
14 L Z+0 FQ51
15 CALL PGM 7901
16 L Z+100 FMAX
17 L X-50 Y-50 FMAX M2
18 END PGM 15030000 MM

Die o.g. Programme sind nun mit der Software TNC640 erstellt worden.
Nun Konvertierung von TNC640 auf TNC155
Um die Q-Werte bei der Konvertierung immer dann zur Verfügung zu haben wenn sie gebraucht werden habe ich in Rexx folgende Routine:
/*_______________________________________________________________________________
Call-Befehl Parameterprogramm Q-Werte ermitteln aus Unterprogramm nnnn99nn
*/
If SubWord(EinBer.I0,1,2) = 'CALL PGM' &,
Substr(Word(EinBer.I0,3),5,2) = '99' Then Do
U_PGM = Word(EinBer.I0,3)||'.h'

Do while Lines(TNC||U_PGM)
Parameter = LineIn(TNC||U_PGM)

/* Nummerierung abschneiden */
Parameter = Substr(Parameter,4)

/* Kommentar löschen */
LPos = LastPos(';',Parameter)
If LPos > 0 Then
Parameter = Left(Parameter,Lpos-1,' ')

/* Befehl interpretieren */
If Substr(Parameter,1,1) = 'Q' Then
Interpret Parameter
End
Call LineOut TNC||U_PGM /* Close Datei */
say 'Hallo ' Q32 Q33 '<<<<<<<<<<<<<<<<<<'
End

>>> Hallo ' 3 5 '<<<<<<<<<<<<<<<<<<

[__blackjack__]

Spätestens bei Quelltext mit Einrückung macht es Sinn hier im Forum Code-Tags zu verwenden, damit das erhalten bleibt:

Code: Alles auswählen

/*_______________________________________________________________________________
  Call-Befehl Parameterprogramm Q-Werte ermitteln aus Unterprogramm nnnn99nn
*/
   If SubWord(EinBer.I0,1,2) = 'CALL PGM' &,
      Substr(Word(EinBer.I0,3),5,2) = '99' Then Do
         U_PGM = Word(EinBer.I0,3)||'.h'

      Do while Lines(TNC||U_PGM)
         Parameter = LineIn(TNC||U_PGM)

/* Nummerierung abschneiden */
         Parameter = Substr(Parameter,4)

/* Kommentar löschen */
         LPos = LastPos(';',Parameter)
         If LPos > 0 Then
            Parameter = Left(Parameter,Lpos-1,' ')

/* Befehl interpretieren */
         If Substr(Parameter,1,1) = 'Q' Then
            Interpret Parameter
      End
      Call LineOut TNC||U_PGM /* Close Datei */
   say 'Hallo ' Q32 Q33 '<<<<<<<<<<<<<<<<<<'
   End

Die Antwort(en) bleibt/bleiben die gleiche(n): Man würde das in Python über ein Wörterbuch lösen, welches die Q-Nummern auf die Werte abbildet.

Code: Alles auswählen

#!/usr/bin/python3
from pathlib import Path
from pprint import pprint

BASE_PATH = Path(".")


def parse_number(text):
    result = float(text)
    return int(result) if result.is_integer() else result


def main():
    q_variables = {}
    line = "6  CALL PGM 15039901"

    words = line.split()
    if words[1:3] == ["CALL", "PGM"] and words[3][4:6] == "99":
        with (BASE_PATH / (words[3] + ".h")).open(encoding="utf-8") as lines:
            for line in lines:
                line = line[3:]  # Remove line number.
                if line.startswith("Q"):
                    line, _, _ = line.partition(";")  # Remove comment.
                    name, _, value_text = line.strip().partition("=")
                    q_variables[parse_number(name[1:])] = parse_number(
                        value_text
                    )

        print("Hallo", q_variables[32], q_variables[33], "<" * 20)
        pprint(q_variables)


if __name__ == "__main__":
    main()

Ausgabe:

Code: Alles auswählen

Hallo 3 5 <<<<<<<<<<<<<<<<<<<<
{32: 3,
 33: 5,
 34: 63,
 35: 55,
 36: 100,
 39: 0,
 45: 2,
 46: 0,
 47: 25,
 50: 120,
 51: 10,
 52: 20,
 53: 59.5,
 54: 49.5,
 55: 1,
 64: 1,
 68: 100,
 69: 800,
 80: 3}

Wobei ich das einlesen dringend in eine eigene Funktion auslagern würde, da hier im Moment `line` ”wiederverwendet” wird, und wer weiss was sonst noch so im grösseren Kontext existiert.

[__blackjack__]

Falls mehrere Zeilenformate über so etwas wie `words` unterschieden werden sollen, könnte `match`/`case` interessant sein:

Code: Alles auswählen

#!/usr/bin/python3
from pathlib import Path
from pprint import pprint

BASE_PATH = Path(".")


def parse_number(text):
    result = float(text)
    return int(result) if result.is_integer() else result


def read_definitions(file_path):
    result = {}
    with file_path.open(encoding="utf-8") as lines:
        for line in lines:
            line = line[3:]  # Remove line number.
            if line.startswith("Q"):
                line, _, _ = line.partition(";")  # Remove comment.
                name, _, value_text = line.strip().partition("=")
                result[parse_number(name[1:])] = parse_number(value_text)

    return result


def main():
    line = "6  CALL PGM 15039901\n"
    q_variables = {}

    match line.split():
        case [_, "CALL", "PGM", name] if name[4:6] == "99":
            q_variables.update(read_definitions(BASE_PATH / (name + ".h")))

            print("Hallo", q_variables[32], q_variables[33], "<" * 20)
            pprint(q_variables)


if __name__ == "__main__":
    main()

[Kebap]

Wie werden Konfigurationsdateien in Delphi(Pascal) gehandhabt?

[__blackjack__]

@Kebap: Wäre das nicht eine Frage für ein anderes Thema? In einem anderen Forum?

Warum fragst Du? Hier geht es ja um ein Rexx-Programm das CNC-Programme in „Heidenhain Klartext“ (so heisst die Sprache glaube ich) in andere CNC-Programmiersprachen ”übersetzt”. Und dieses Rexx-Programm soll durch Python ersetzt werden. Konfigurationsdateien kommen hier nicht vor, beziehungsweise ist da die Sprache oder das Format nicht frei wählbar. Die liegen ja bereits fertig vor, in „Heidenhain Klartext“.

Ansonsten gibt es in Delphi wohl eine `TIniFile`-Klasse mit der man INI-Dateien verarbeiten kann.

[Domperle]

Ich habe für mein Problem nun folgende Lösung, die genau das macht, was ich will.

Code: Alles auswählen

file = "C:\\Program Files\\HEIDENHAIN\\TNC640\\340595\\TNC640 (340595)\\TNC\\Programme\\15039901.h"

Q_99 = open(file, "r")
for zeile in Q_99:
befehl = zeile.strip()
print(befehl)
if befehl.find('Q') > -1: # suche alle Zeilen mit 'Q'
von = befehl.index('Q') # ab Position 'Q'
bis = befehl.index(';') # bis Position ';'
befehl = befehl[von:bis] # übertrage alles von Stelle 'Q' bis zum ';'
exec(str(befehl))
Q_99.close()

print(Q32)
print(Q33)
print(Q35)
print(Q54)
print(Q69)
print("Q80 =",type(Q80))
print("Q54 =",type(Q54))

print("CR X+50 Y+45 R+", Q80, "DR- F20")
print("CR X+50 Y+45 R+", Q54, "DR- F20")

Ergebnis:
0 BEGIN PGM 15039901 MM
1 Q32 = 3 ;ANZAHL ZUSTELLUNGEN IN DER FLÄCHE
2 Q33 = 5 ;ANZAHL ZUSTELLUNGEN IN DER TIEFE
3 Q34 = 63 ;BOHRTIEFE
4 Q35 = 55 ;NUTENBREITE
5 Q36 = 100 ;NUTENLÄNGE
6 Q39 = 0 ;DREHLAGE
7 Q45 = 2 ;SICHERHEITSABSTAND
8 Q46 = 0 ;STARTWINKEL
9 Q47 = 25 ;FRÄSTIEFE
10 Q50 = 120 ;VORSCHUB IN DER FLÄCHE
11 Q51 = 10 ;VORSCHUB BEIM TAUCHEN
12 Q52 = 20 ;WINKELSCHRITT
13 Q53 = 59.5 ;X-KOORDINATE Nullpunkt
14 Q54 = 49.5 ;Y-KOORDINATE Nullpunkt
15 Q55 = 1 ;Z-KOORDINATE Nullpunkt
16 Q64 = 1 ; Verarbeitungsart
17 ; 1=Tasche,
18 ; 2=Zapfen,
19 ; 3=Rechtecktasche,
20 ; 4=Rechteckzapfen,
21 ; 5=Rechtecktasche mit Rundung,
22 ; 6=Rechteckzapfen mit Rundung
24 Q68 = 100 ; Vorschub beim Fräsen
25 Q69 = 800 ;Drehzahl
26 Q80 = 3 ;Fräserradius
27 END PGM 15039901 MM
3
5
55
49.5
800
Q80 = <class 'int'>
Q54 = <class 'float'>
CR X+50 Y+45 R+ 3 DR- F20
CR X+50 Y+45 R+ 49.5 DR- F20

Was ich jetzt noch nicht erreicht habe, in den CR-Befehlen befindet sich zwischen 'R+' und dem eingesetzten Q-Wert ein blank. Es soll nicht heißen R+ 3 oder R+ 49.5 sonder R+3 bzw. R+49.5.
Das blank krieg ich einfach nicht weg.

[__blackjack__]

@Domperle: Echt jetzt? Wenn Du nicht Python programmieren möchtest, dann mach das doch einfach nicht.

[Kebap]

@Kebap: Wäre das nicht eine Frage für ein anderes Thema? In einem anderen Forum?

Warum fragst Du? Hier geht es ja um ein Rexx-Programm das CNC-Programme in „Heidenhain Klartext“ (so heisst die Sprache glaube ich) in andere CNC-Programmiersprachen ”übersetzt”. Und dieses Rexx-Programm soll durch Python ersetzt werden. Konfigurationsdateien kommen hier nicht vor, beziehungsweise ist da die Sprache oder das Format nicht frei wählbar. Die liegen ja bereits fertig vor, in „Heidenhain Klartext“.

Ansonsten gibt es in Delphi wohl eine `TIniFile`-Klasse mit der man INI-Dateien verarbeiten kann.

Ich hatte gefragt, ohne zu sehen, dass dieses Thema schon zwei Seiten hat. Dort hatte Domperle erwähnt, mit Delphi(Pascal) bis heute zu programmieren, und auf das Wissen wollte ich aufbauen. Wie ich sehe, ging es hier seitdem noch einige Runden weiter, und inzwischen ist auch mehr über das Problemumfeld und Ziel bekannt geworden.

[Sirius3]

@Domperle: Variablennamen sollten sprechend sein und werden komplett klein geschrieben, Q_99 für eine Datei? Wie kommt man auf so einen Namen?
Dateien öffnet man immer mit dem with-Statement.
String mit Index zu bearbeiten, versucht man zu vermeiden, weil das schwer verständlich ist, in Deinem Fall kann man gut mit partition arbeiten.
Vergiss dass es `exec` gibt, das macht Dein Programm fehleranfällig.

Code: Alles auswählen

file = "C:\\Program Files\\HEIDENHAIN\\TNC640\\340595\\TNC640 (340595)\\TNC\\Programme\\15039901.h"

variables = {}
with open(file, encoding="ASCII") as lines:
    for line in lines:
        line, _, _ = line.partition(';') # drop comments
        key, equal, value = line.partition('=')
        if equal:
            variables[key.strip()] = value.strip()

Ach nein, dsas ist ja fast der Code, den __blackjack__ schon gepostet hat, vielleicht solltest Du den auch mal anschauen und wenn Du was daran nicht verstanden hast, nachfragen.

[Domperle]

Ich habe die Routine, die __blackjack__ gepostet hat auch probiert, doch das ist ja nicht das was ich benötige. In meiner Routine bringt mir der print(Q54) den Wert 49.5, ohne dass ich Q54 definieren mußte. Durch exec() wird intern der Bezeichner Q54 definiert und die Zuweisung in den Bezeichner durchgeführt. Überall da, wo ich Q54 im Programm anspreche steht mir dann der entsprechende Wert zur Verfügung.
Velleicht nochmal zum besseren Verständnis diesen Programmauschnitt:
10 CALL PGM 15019901 >>> Hier hat Q54 den Wert 49.5
11 TOOL DEF 10 L+50 R+Q80
12 TOOL CALL 10 Z S850
13 L Z+5 FMAX
14 CALL LBL 8801
15 CALL PGM 15019902 >>> Hier hat Q54 den Wert 35
16 CALL LBL 8801
17 CALL PGM 15019903 >>> Hier hat Q54 den Wert 28,25
18 CALL LBL 8801
21 CALL PGM 15019904 >>> Hier dat Q54 den Wert 20
22 TOOL DEF 11 L+50 R+Q80
23 TOOL CALL 11 Z S850
24 L Z+5 FMAX
25 CALL LBL 8801
26 STOP

Ich verstehe nicht, weshalb exec() nicht verwendet werden sollte. Es handelt sich doch um eine Python Built-in Function wie z. B. print(), input(), format() etc.

[__deets__]

Das haben wir schon verstanden. Man macht's halt nicht so. Du kannst die Radmuttern deines Autos mit der Wasserpumpenzange loesen und anziehen. Aber das hat halt Konsequenzen, weil es das falsche Werkzeug ist. Und exec ist eben auch falsch, auch wenn's oberflaechlich betrachtet das richtige tut. Es hat potentiell gefaehrliche Seiteneffekte, und das Programm wird unlesbar, weil ploetzlich magisch Variablen auftauchen.

[Sirius3]

Und genau den selben Wert bekommst Du über `variables['Q54']`. `exec` ist schlecht, weil Du damit beliebigen Python-Code ausführen kannst, der beliebig den Zustand Deines Programms ändern kann, Du hast keine direkte Kontrolle darüber was passiert, und das ist im günstigsten Fall eine Fehlerquelle, die sehr schwer nachvollziehbar ist.
Du willst aber gar keinen Python-Code ausführen, sondern Heidenhain-Code interpretieren.
Und genauso mußt Du dann noch dein komplettes Programm interpretieren, um die Stellen zu finden, wo Du die Q-Variablen ersetzen mußt.