def __init__(self, name, host, port, callFunc=None):
"""!Construct a ScaleDevice
Inputs:
@param[in] name name of device
@param[in] host host address of scaling ring controller
@param[in] port port of scaling ring controller
@param[in] callFunc function to call when state of device changes;
note that it is NOT called when the connection state changes;
register a callback with "conn" for that task.
"""
# the mitutoyos will be zeroed when the scaling ring is moved to 20
# so this zero point keep track fo the offset.
# if I could preset the mitutoyo's this would be unnecessary
# the preset command "CP**" doesn't seem to work.
self.zeroPoint = 20.0 # mm. Position where scale = 1
self.encPos = [None]*6
self.devCmdQueue = CommandQueue({})
TCPDevice.__init__(self,
name = name,
host = host,
port = port,
callFunc = callFunc,
cmdInfo = (),
)
def __init__(self, name, host, port, measScaleDev=None, nomSpeed=NOM_SPEED, callFunc=None):
"""!Construct a ScaleDevice
Inputs:
@param[in] name name of device
@param[in] host host address of scaling ring controller
@param[in] port port of scaling ring controller
@param[in] measScaleDev instance of a MeasScaleDev (access to the mitutoyos for servoing)
@param[in] nom_speed nominal speed at which to move (this can be modified via the speed command)
@param[in] callFunc function to call when state of device changes;
note that it is NOT called when the connection state changes;
register a callback with "conn" for that task.
"""
self.targetPos = None
# holds a userCommand for "move"
# set done only when move has reached maxIter
# or is within tolerance
self.iter = 0
self.moveUserCmd = expandUserCmd(None)
self.moveUserCmd
self.nomSpeed = nomSpeed
self.measScaleDev = measScaleDev
self.status = Status()
# all commands of equal priority
# except stop kills a running (or pending move) move
# priorityDict = {"stop": CommandQueue.Immediate}
priorityDict = {
"stop":1,
"status":1,
"move":1,
"speed":1,
}
self.devCmdQueue = CommandQueue(
priorityDict,
killFunc = self.killFunc,
)
# stop will kill a running move
# else everything queues with equal prioirty
self.devCmdQueue.addRule(CommandQueue.KillRunning, ["stop"], ["move"])
TCPDevice.__init__(self,
name = name,
host = host,
port = port,
callFunc = callFunc,
cmdInfo = (),
)
def __init__(self, name, host, port, callFunc=None):
"""!Construct an BaseDevice
Inputs:
@param[in] name name of device
@param[in] host host address of Galil controller
@param[in] port port of Galil controller
@param[in] callFunc function to call when state of device changes;
note that it is NOT called when the connection state changes;
register a callback with "conn" for that task.
"""
self.cmdQueue = self.setupCmdQueue()
self.currDevCmdStr = "" # last string sent to the device
self.waitingForInitEcho = False
TCPDevice.__init__(self,
name = name,
host = host,
port = port,
callFunc = callFunc,
cmdInfo = (),
)
def __init__(self, name, host, port, callFunc=None):
"""!Construct an BaseDevice
Inputs:
@param[in] name name of device
@param[in] host host address of Galil controller
@param[in] port port of Galil controller
@param[in] callFunc function to call when state of device changes;
note that it is NOT called when the connection state changes;
register a callback with "conn" for that task.
"""
self.cmdQueue = self.setupCmdQueue()
self.currDevCmdStr = "" # last string sent to the device
self.waitingForInitEcho = False
TCPDevice.__init__(
self,
name=name,
host=host,
port=port,
callFunc=callFunc,
cmdInfo=(),
)
def __init__(self, name, host, port, callFunc=None):
"""!Construct a LCODevice
Inputs:
@param[in] name name of device
@param[in] host host address of tcs controller
@param[in] port port of tcs controller
@param[in] callFunc function to call when state of device changes;
note that it is NOT called when the connection state changes;
register a callback with "conn" for that task.
"""
self.status = Status()
self._statusTimer = Timer()
self.waitRotCmd = UserCmd()
self.waitRotCmd.setState(self.waitRotCmd.Done)
self.waitRotTimer = Timer()
# self.waitFocusCmd = UserCmd()
# self.waitFocusCmd.setState(self.waitFocusCmd.Done)
self.waitOffsetCmd = UserCmd()
self.waitOffsetCmd.setState(self.waitOffsetCmd.Done)
self.waitOffsetTimer = Timer()
self.rotDelay = False
self.devCmdQueue = CommandQueue({}) # all commands of equal priority
self.lastGuideRotApplied = None
self.doGuideRot = True
TCPDevice.__init__(self,
name = name,
host = host,
port = port,
callFunc = callFunc,
cmdInfo = (),
)
def __init__(self, name, host, port, callFunc=None):
"""!Construct a LCODevice
Inputs:
@param[in] name name of device
@param[in] host host address of m2 controller
@param[in] port port of m2 controller
@param[in] callFunc function to call when state of device changes;
note that it is NOT called when the connection state changes;
register a callback with "conn" for that task.
"""
self.status = Status()
self._statusTimer = Timer()
self.waitMoveCmd = UserCmd()
self.waitMoveCmd.setState(self.waitMoveCmd.Done)
# self.waitGalilCmd = UserCmd()
# self.waitGalilCmd.setState(self.waitGalilCmd.Done)
# give status commands equal priority so they don't kill eachother
priorityDict = {
"status": 1,
"speed": 1,
"stop": 1,
"move": 1,
"galil": 1,
"offset": 1,
}
self.devCmdQueue = CommandQueue(priorityDict) # all commands of equal priority
TCPDevice.__init__(self,
name = name,
host = host,
port = port,
callFunc = callFunc,
cmdInfo = (),
)
