5.
7 Using Python based move preprocessors
MachSim has the capability of processing each move with a custom Python script.
You can use it to:
a) change the axis values
b) synthesize new values. (Insert new moves in the simulation)
To enable it, add a line like this to the machine .xml file:
a) for chaning axis values:
<preprocessor fileName="preprocessor.py" instance="preprocessor" />
b) for inserting new moves into the simulation:
<preprocessor fileName="preprocessor.py" instance="preprocessor" type="inserter" />
fileName is the path to python script that needs to be processed. It can be relative to machine directory or full path.
instance is the name of the python object declared in script. It will be used to process each move.
type is the type of preprocessing. When missing it is assumed that preprocessing will change axis values. When declared as
"inserter" it will insert additional moves into the simulation.
Multiple <preprocessor ../> tags may be used in xml file.
One important thing to remember is that changing axis values is done via method ProcessMove and insertion of new moves is
done via GetNewMoves nethod. The discussion further will treat methods separatelly as there are differencies in the parameters
passed to them.
5.7.1 MachSim python interpreter
MachSim does not use installed python program on the computer where it runs. Instead he is compiled with a python interpreter. In
this case it is important to validate your script with a similar version. To find out which version requires MachSim one can use the
next script (setup).
a) xml tag
<preprocessor fileName="module1.py" instance="move_filter" />
b) module1.py
#-------------------------------------------------------
import sys
class Module1:
VERSION = 1
TYPE = "move"
AXIS = []
def __init__(self):
self.count = 0
self.f = open(__file__+".log", "w+")
def ProcessMove(self, environment, operation, move):
if self.count == 0:
(major,minor,micro,release,serial) = tuple(sys.version_info)
ver = "python version {0:d}.{1:d}.{2:d}".format(major,minor,micro)
self.f.write("%s\n" % ver)
self.f.close()
self.count += 1
move_filter = Module1()
#-------------------------------------------------------
Start machine simulation, load machine definition. It should be enough to get a call to move_filter.ProcessMove.
In the machine directory look for log file module1.py.log
It may contain a string similar with: python version 2.7.1
5.7.2 Minimum requirements to change axis values (ProcessMove)
The minimum required by the MachSim python implementation is:
a) xml tag
<preprocessor fileName="module1.py" instance="move_filter" />
b) module1.py
#-------------------------------------------------------
class Module1:
VERSION = 1
TYPE = "move"
AXIS = []
def ProcessMove(self, environment, operation, move):
pass
move_filter = Module1()
#-------------------------------------------------------
VERSION is mandatory class attribute with value 1.
TYPE is mandatory class attribute with value "move".
AXIS is mandatory class attribute.
ProcessMove is mandatory class method having 4 parameters.
move_filter is mandatory object having same name as xml's instance attribute.
Obviously the script above does nothing. It just declares the minimum necessary to change axis values.
5.7.3 ProcessMove method parameters
I will use a 5AxHeadHead machine with 5 axes : X, Y, Z, C, B and a CL file to load a simple simulation and log into file
module1.py.log the parameters passed by MachSim to method ProcessMove.
The setup for python is:
a) A snippet from 5AxHeadHead.xml file with <preprocessor .../> tag
<machine_definition>
<machine_data name="5AxHeadHead" version="1.7" units="metric" />
<preprocessor fileName="module1.py" instance="move_filter" />
<axis id="X" type="translation" ...
b) module1.py
#-------------------------------------------------------
class Module1:
VERSION = 1
TYPE = "move"
AXIS = ['X','Y','Z','C','B']
def __init__(self):
self.f = open(__file__+".log", "w+")
self.count = 0
return
def DebugMove(self, environment, operation, move):
self.f.write("\ncount: %d\n" % self.count)
self.f.write("environment: %s\n" % environment)
self.f.write("operation: %s\n" % operation)
self.f.write("move: %s\n" % move)
self.f.flush()
self.count += 1
def ProcessMove(self, environment, operation, move):
self.DebugMove(environment, operation, move)
move_filter = Module1()
#-------------------------------------------------------
c) module1.py.log - the logging file with the structure of ProcessMove parameters.
#-------------------------------------------------------
environment: {'globalMoveCount': 434}
operation: {
'comment': '"Sample 5 axis operation"',
'tool': {
'comment': ('"Sample tool"',),
'number': 1,
'name': 'tool'
},
'number': 1,
'transform': {
'workpiece_transform': (1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0),
'holder_transform': (1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, -12.0, 0.0, 0.0, 0.0, 1.0)
},
'size': 434}
move: {
'simulationIndex': 121,
'axisValue': {'Y': 1.5460000038146973, 'X': -48.779998779296875, 'C': 0.0, 'Z': 18.0, 'B': 0.0},
'globalIndex': 120
}
#-------------------------------------------------------
d) ProcessMove parameters:
environment [ 'globalMoveCount' ] => total number of moves in the simulation.
operation [ 'comment' ] => current operation comment
operation [ 'tool' ] [ 'comment' ] => comment for the first tool of the current operation
operation [ 'tool' ] [ 'number' ] => number of the first tool of the current operation
operation [ 'tool' ] [ 'name' ] => name of the first tool of the current operation
operation [ 'number' ] => current operation number
operation [ 'transform' ] [ 'workpiece_transform' ] => a tuple with 16 values representing the 4x4 matrix applied to machine's
workpiece_transform.
operation [ 'transform' ] [ 'holder_transform' ] => a tuple with 16 values representing the 4x4 matrix applied to machine's
holder_transform.
operation [ 'size' ] => total number of moves of the current operation
move [ 'simulationIndex' ] => 1 based index of current move acczoss entire simulation
move [ 'globalIndex' ] = 0 based index of current move across entire simulation.
move [ 'axisValue' ] [ 'Y' ] => provide access to axis value. Changed value will be visible to machine simulation.
5.7.4 Limit machine movement on Z axis using ProcessMove method
a) xml tag
<preprocessor fileName="module1.py" instance=" preserve_axes_limit" />
b) module1.py
#-------------------------------------------------------
class Module1:
VERSION = 1
TYPE = "move"
AXIS = ['X','Y','Z','C','B']
def ProcessMove(self, environment, operation, move):
if move[ 'axisValue' ] [ 'Z' ] > 20:
move [ 'axisValue' ] [ 'Z' ] = 20.
preserve_axes_limit = Module1()
#-------------------------------------------------------
5.7.5 Minimum requirements to insert new moves (GetNewMoves)
The minimum required by the MachSim python implementation is:
a) xml tag
<preprocessor fileName="module1.py" instance="move_insert" type="inserter" />
b) module1.py
#-------------------------------------------------------
class Module1:
VERSION = 1
TYPE = "move"
AXIS = []
def GetNewMoves(self, environment, operation, currMove, nextMove):
pass
move_insert = Module1()
#-------------------------------------------------------
VERSION is mandatory class attribute with value 1.
TYPE is mandatory class attribute with value "move".
AXIS is mandatory class attribute.
GetNewMoves is mandatory class method having 5 parameters.
move_filter is mandatory object having same name as xml's instance attribute.
Obviously the script above does nothing. It just declares the minimum necessary to use insert of new values functionality. In this
mode modifing axis values of existing moves is not possible. Only isertion is possible.
5.7.6 GetNewMoves method parameters
I will use a 5AxHeadHead machine with 5 axes : X, Y, Z, C, B and a CL file to load a simple simulation and log into file
module1.py.log the parameters passed by MachSim to method GetNewMoves.
The setup for python is:
a) xml tag
<preprocessor fileName="module1.py" instance="move_insert" type="inserter" />
b) module1.py
#-------------------------------------------------------
class Module1:
VERSION = 1
TYPE = "move"
AXIS = ['X','Y','Z','C','B']
def __init__(self):
self.f = open(__file__+".log", "w+")
self.count = 0
return
def DebugMove(self, environment, operation, move, nextmove):
self.f.write("\ncount: %d\n" % self.count)
self.f.write("environment: %s\n" % environment)
self.f.write("operation: %s\n" % operation)
self.f.write("move: %s\n" % move)
self.f.write("nextmove: %s\n" % nextmove)
self.f.flush()
self.count += 1
def GetNewMoves(self, environment, operation, move, nextmove):
self.DebugMove(environment, operation, move, nextmove)
# return value object to insert 1 move
insert_move_on_origin = {
'forwardInsertion' : 0 ,
'newMovesList' : [ { 'axisValue' : { 'X' : 0, 'Y' : 0, 'Z' : 0, 'B' : 0, 'C' : 0 } } ]
}
if move [ 'relativeIndex' ] == 0:
return insert_move_on_origin
move_insert = Module1()
#-------------------------------------------------------
c) module1.py.log - the logging file with the structure of GetNewMoves parameters.
#-------------------------------------------------------
environment: { }
operation: {
'comment': '"Sample 5 axis operation"',
'tool': {
'comment': ('"Sample tool"',),
'number': 1,
'name': 'tool'
},
'number': 1,
'transform': {
'workpiece_transform': (1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0),
'holder_transform': (1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, -12.0, 0.0, 0.0, 0.0, 1.0)},
'size': 434}
move: {
'relativeIndex': 431,
'axisValue': {'Y': -6.306000232696533, 'X': -39.33300018310547, 'C': 0.0, 'Z': 14.050000190734863, 'B': 0.0}, 'time':
0.004000000189989805
}
nextmove: {
'relativeIndex': 431,
'axisValue': {'Y': -6.482999801635742, 'X': -45.29499816894531, 'C': 0.0, 'Z': 24.049999237060547, 'B': 0.0}, 'time':
0.006000000052154064
}
#-------------------------------------------------------
d) GetNewMoves parameters:
environment => empty dictionary
operation [ 'comment' ] => current operation comment
operation [ 'tool' ] [ 'comment' ] => comment for the first tool of the current operation
operation [ 'tool' ] [ 'number' ] => number of the first tool of the current operation
operation [ 'tool' ] [ 'name' ] => name of the first tool of the current operation
operation [ 'number' ] => current operation number
operation [ 'transform' ] [ 'workpiece_transform' ] => a tuple with 16 values representing the 4x4 matrix applied to machine's
workpiece_transform.
operation [ 'transform' ] [ 'holder_transform' ] => a tuple with 16 values representing the 4x4 matrix applied to machine's
holder_transform.
operation [ 'size' ] => total number of moves of the current operation
move [ 'relativeIndex' ] => 0 based index of current move across entire simulation
move [ 'axisValue' ] [ 'Y' ] => provide access to axis value. Changed value will NOT be visible to machine simulation.
move [ 'time' ] => time in seconds needed to complete this move when MachSim runs in time-base mode.
nextmove [ 'relativeIndex' ] => 0 based index of next move across entire simulation
nextmove [ 'axisValue' ] [ 'Y' ] => provide access to axis value. Changed value will NOT be visible to machine simulation.
nextmove [ 'time' ] => time in seconds needed to complete next move when MachSim runs in time-base mode.
insert_move_on_origin [ 'forwardInsertion' ] => 1 to insert move after current move or 0 to insert move before current move
insert_move_on_origin [ 'newMovesList' ] => list with the new moves to be inserted
insert_move_on_origin [ 'newMovesList' ] [ 0 ] [ 'axisValue' ] [ 'X' ] => X value for a new move at position 0 in list.
5.7.7 Insert 2 moves at the beginning of simulation using GetNewMoves method
a) xml tag:
<preprocessor fileName="module1.py" instance="insert_new_moves" type="inserter" />
b) module1.py
#-------------------------------------------------------
class Module1:
VERSION = 1
TYPE = "move"
AXIS = ['X','Y','Z','C','B']
def __init__(self):
self.insert_moves_from_machine_origin = {
'forwardInsertion': 0,
'newMovesList': [{'axisValue': {'X':500, 'Y':500, 'Z':900, 'B':0, 'C':0} },
{'axisValue': {'X':500, 'Y':500, 'Z':850, 'B':0, 'C':0} }
]}
def GetNewMoves(self, environment, operation, move, nextmove):
if move[ 'relativeIndex' ] == 0:
return self.insert_moves_from_machine_origin
insert_new_moves = Module1()
#-------------------------------------------------------
5.7.8 Sample of a real-life preprocessing script
The following script automatically closes and opens the machine doors at the start/end of the simulation and spins a warning light.
Also, all of the axis values and operation properties are logged to a file with the same name but with the .log extension.
import time
from math import *
LOGGING_ENABLED = True
LOG_FILE = __file__.replace(".py", ".log")
def Log(text):
if LOGGING_ENABLED:
f = open(LOG_FILE, "a+t")
f.write(text)
f.close()
def LogMove(operation, move):
if LOGGING_ENABLED:
Log("operation=%r, move=%r\n" % (operation, move))
class DoorClosePreprocessorBase(object):
def __init__(self, axisName, closedValue, openedValue, stepsToClose):
self.__axisName = axisName
self.__closedValue = closedValue
self.__openedValue = openedValue
self.__stepsToClose = stepsToClose
self.__moveScale = (self.__closedValue - self.__openedValue) / self.__stepsToClose
def ProcessMove(self, environment, operation, move):
globalIndex = move["globalIndex"]
globalMoveCount = environment["globalMoveCount"]
if globalIndex <= self.__stepsToClose:
value = self.__openedValue + globalIndex * self.__moveScale
else:
threshold = globalMoveCount - self.__stepsToClose - 1
if globalIndex >= threshold:
value = self.__closedValue - (globalIndex - threshold) * self.__moveScale
else:
value = self.__closedValue
move["axisValue"][self.__axisName] = value
class DoorClosePreprocessor(object):
VERSION = 1
TYPE = "move"
AXIS = ["LH-Door", "RH-Door"]
def __init__(self):
stepsToClose = 50
self.__leftDoor = DoorClosePreprocessorBase("LH-Door", 0.0, -499.0, stepsToClose)
self.__rightDoor = DoorClosePreprocessorBase("RH-Door", 0.0, 499.0, stepsToClose)
def ProcessMove(self, environment, operation, move):
LogMove(operation, move)
self.__leftDoor.ProcessMove(environment, operation, move)
self.__rightDoor.ProcessMove(environment, operation, move)
class WarningLightPreprocessor(object):
VERSION = 1
TYPE = "move"
AXIS = ["Light"]
def ProcessMove(self, environment, operation, move):
LogMove(operation, move)
move["axisValue"]["Light"] = (move["globalIndex"] * 5.0) % 360.0
doorClosePreprocessor = DoorClosePreprocessor()
warningLightPreprocessor = WarningLightPreprocessor()
Log("Preprocessor module imported - %s\n" % time.strftime("%a, %d %B %Y, %H:%M:%S"))
