def cmd_filter(self, userCmd):
"""! Implement the filter command
@param[in] userCmd a twistedActor command with a parsedCommand attribute
"""
subCmd = userCmd.parsedCommand.subCommand
userCmd = expandUserCmd(userCmd)
if subCmd.cmdName == "initialize":
if not self.filterWheelDev.isConnected:
self.filterWheelDev.connect(userCmd)
else:
self.filterWheelDev.init(userCmd)
elif subCmd.cmdName == "connect":
self.filterWheelDev.connect(userCmd)
elif subCmd.cmdName == "disconnect":
self.filterWheelDev.disconnect(userCmd)
elif subCmd.cmdName == "status":
self.filterWheelDev.startCmd("status", userCmd=userCmd)
elif subCmd.cmdName == "home":
self.filterWheelDev.startCmd("home", userCmd=userCmd)
elif subCmd.cmdName == "talk":
talkTxt = subCmd.parsedPositionalArgs[0]
self.filterWheelDev.startCmd(talkTxt, userCmd=userCmd)
else:
userCmd.setState(userCmd.Failed, "unhandled sub command: %s. bug"%(subCmd.cmdName,))
return True
def getStatus(self, userCmd=None):
"""Return current telescope status. Continuously poll.
"""
log.info("%s.getStatus(userCmd=%s)" % (self, userCmd)) # logging this will flood the log
# print("%s.getStatus(userCmd=%s)" % (self, userCmd))
userCmd = expandUserCmd(userCmd)
if not self.conn.isConnected:
userCmd.setState(userCmd.Failed, "Not Connected to M2")
return userCmd
self._statusTimer.cancel() # incase a status is pending
userCmd = expandUserCmd(userCmd)
# userCmd.addCallback(self._statusCallback)
# gather list of status elements to get
statusCmd = self.queueDevCmd("status", userCmd)
LinkCommands(userCmd, [statusCmd])
return userCmd
def focus(self, focusValue, offset=False, userCmd=None):
"""Command an offset or absolute focus move
@param[in] focusValue: float, focus value in microns
@param[in] offset, if true this is offset, else absolute
@param[in] userCmd: a twistedActor BaseCommand
WARNING!!!
At APO increasing focus corresponds to decreasing M1-M2 dist.
The mirror controller at LCO convention is the opposite.
"""
log.info("%s.focus(userCmd=%s, focusValue=%.2f, offset=%s)" % (self, userCmd, focusValue, str(bool(offset))))
# if this focus value is < 50 microns
userCmd = expandUserCmd(userCmd)
if offset:
deltaFocus = focusValue
else:
deltaFocus = self.status.secFocus - focusValue
if abs(deltaFocus) < MIN_FOCUS_MOVE:
# should focus be cancelled or just set to done?
self.writeToUsers("w", "Focus offset below threshold of < %.2f, moving anyways."%MIN_FOCUS_MOVE, userCmd)
# userCmd.setState(userCmd.Done)
# return userCmd
# focusDir = 1 # use M2's natural coordinates
# focusDir = -1 # use convention at APO
return self.move(valueList=[focusValue], offset=offset, userCmd=userCmd)
def move(self, position, userCmd=None):
"""!Move to a position
@param[in] postion: a float, position to move to (mm)
@param[in] userCmd: a twistedActor BaseCommand
"""
log.info("%s.move(postion=%.6f, userCmd=%s)" % (self, position, userCmd))
userCmd=expandUserCmd(userCmd)
if self.isMoving:
userCmd.setState(userCmd.Failed, "Cannot move, device is busy moving")
return userCmd
# verify position is in range
minPos, maxPos = self.status.moveRange
if not minPos<=position<=maxPos:
userCmd.setState(userCmd.Failed, "Move %.6f not in range [%.4f, %.4f]"%(position, minPos, maxPos))
return userCmd
self.iter = 1
self.targetPos = position
self.moveUserCmd = userCmd
print("moving threadring to: ", self.targetPos)
if not self.moveUserCmd.isActive:
self.moveUserCmd.setState(self.moveUserCmd.Running)
self.writeToUsers("i", "DesThreadRingPos=%.4f"%self.targetPos)
moveDevCmd = self.queueDevCmd(self.getMoveCmdStr(), self.moveUserCmd)
moveDevCmd.addCallback(self._moveCallback)
return userCmd
def target(self, ra, dec, doHA, userCmd=None):
"""Set coordinates for a slew.
@param[in] ra: right ascension decimal degrees
@param[in] dec: declination decimal degrees
@param[in] doHA: if True, use degrees in hour angle rather than ra.
@param[in] userCmd: a twistedActor BaseCommand.
"""
log.info("%s.slew(userCmd=%s, ra=%.2f, dec=%.2f)" % (self, userCmd, ra, dec))
userCmd = expandUserCmd(userCmd)
if not self.conn.isConnected:
userCmd.setState(userCmd.Failed, "Not Connected to TCS")
return userCmd
if doHA:
enterRa = "HAD %.8f"%ra
else:
enterRa = "RAD %.8f"%ra
enterDec = "DECD %.8f"%dec
enterEpoch = "MP %.2f"%2000 # LCO: HACK should coords always be 2000?
devCmdList = [DevCmd(cmdStr=cmdStr) for cmdStr in [enterRa, enterDec, enterEpoch]]#, cmdSlew]]
# set userCmd done only when each device command finishes
# AND the pending slew is also done.
# when the last dev cmd is done (the slew), set axis cmd statue to slewing
LinkCommands(userCmd, devCmdList) #LCO: HACK don't wait for a slew to finish + [self.waitSlewCmd])
for devCmd in devCmdList:
self.queueDevCmd(devCmd)
statusStr = self.status.getStatusStr()
if statusStr:
self.writeToUsers("i", statusStr, userCmd)
return userCmd
def getStatus(self, userCmd=None, timeLim=None, linkState=True):
"""!Get status of the device. If the device is
busy (eg moving), send the cached status
note that during moves the thread_ring_axis actual_position gets
periodically output and thus updated in the status
"""
# note measScaleDevice could be read even if
# scaling ring is moving. do this at somepoint?
userCmd = expandUserCmd(userCmd)
if timeLim is None:
timeLim = 2
if self.isMoving:
self.writeToUsers("i", "text=showing cached status", userCmd)
self.writeStatusToUsers(userCmd)
userCmd.setState(userCmd.Done)
else:
# get a completely fresh status from the device
statusDevCmd = self.queueDevCmd("status", userCmd)
# get encoder values too
encStatusDevCmd = self.measScaleDev.getStatus()
statusDevCmd.addCallback(self._statusCallback)
statusDevCmd.setTimeLimit(timeLim)
if linkState:
LinkCommands(userCmd, [statusDevCmd, encStatusDevCmd])
return userCmd
else:
# return the device command to be linked outside
return statusDevCmd
def getStatus(self, userCmd=None):
"""!Query the device for status
@param[in] userCmd a twistedActor.BaseCommand
"""
userCmd = expandUserCmd(userCmd)
self.queueDevCmd("status", userCmd)
userCmd.addCallback(self._statusCallback)
return userCmd
def getStatus(self, userCmd=None):
"""!Query the device for status
@param[in] userCmd a twistedActor.BaseCommand
"""
userCmd = expandUserCmd(userCmd)
self.queueDevCmd("status", userCmd)
userCmd.addCallback(self._statusCallback)
return userCmd
def setZero(self, userCmd=None, timeLim=1):
"""!Set the Mitutoyo EV counter into the counting state,
this is required after a power cycle
"""
userCmd = expandUserCmd(userCmd)
zeroDevCmd = self.queueDevCmd(ZERO_SET, userCmd)
zeroDevCmd.setTimeLimit(timeLim)
LinkCommands(userCmd, [zeroDevCmd])
return userCmd
def close(self, userCmd=None):
"""!Close the shutter
@param[in] userCmd a twistedActor.BaseCommand
"""
userCmd = expandUserCmd(userCmd)
self.queueDevCmd(userCmd, "close")
# when this command finishes set state to closed
userCmd.addCallback(self._closeCallback)
return userCmd
def holdOpen(self, expTime):
userCmd = expandUserCmd(None)
def _holdOpen(userCmd):
Timer(float(expTime), userCmd.setState, userCmd.Done)
self.status.shutterTimer.startTimer()
self.status.lastExpTime = -1
self.status.lastDesExpTime = expTime
self.cmdQueue.addCmd(userCmd, _holdOpen)
return userCmd
def init(self, userCmd=None, timeLim=3, getStatus=True):
"""Called automatically on startup after the connection is established.
Only thing to do is query for status or connect if not connected
getStatus ignored?
"""
log.info("%s.init(userCmd=%s, timeLim=%s, getStatus=%s)" % (self, userCmd, timeLim, getStatus))
userCmd = expandUserCmd(userCmd)
self.getStatus(userCmd) # status links the userCmd
return userCmd
def open(self, userCmd=None):
"""!Open the shutter
@param[in] position an integer
@param[in] userCmd a twistedActor.BaseCommand
"""
userCmd = expandUserCmd(userCmd)
self.queueDevCmd(userCmd, "open")
userCmd.addCallback(self._openCallback)
return userCmd
def init(self, userCmd=None, timeLim=10, getStatus=True):
"""!Initialize the device and cancel all pending commands
@param[in] userCmd user command that tracks this command, if any
@param[in] timeLim maximum time before command expires, in sec; None for no limit
@param[in] getStatus IGNORED (status is automatically output sometime after stop)
@return userCmd (a new one if the provided userCmd is None)
"""
userCmd = expandUserCmd(userCmd)
self.startCmd(cmdStr="init", userCmd=userCmd, timeLim=timeLim)
return userCmd
def cmd_status(self, userCmd=None, setDone=True):
"""! Implement the status command
@param[in] userCmd a twistedActor command with a parsedCommand attribute
"""
log.info("%s.cmd_status(userCmd=%s)" % (self, str(userCmd)))
userCmd = expandUserCmd(userCmd)
self.getStatus()
self.writeToUsers("i", self.status.statusStr, cmd=userCmd)
if setDone:
userCmd.setState(userCmd.Done)
return True
def init(self, userCmd=None, timeLim=10, getStatus=True):
"""!Initialize the device and cancel all pending commands
@param[in] userCmd user command that tracks this command, if any
@param[in] timeLim maximum time before command expires, in sec; None for no limit
@param[in] getStatus IGNORED (status is automatically output sometime after stop)
@return userCmd (a new one if the provided userCmd is None)
"""
userCmd = expandUserCmd(userCmd)
self.startCmd(cmdStr="init", userCmd=userCmd, timeLim=timeLim)
return userCmd
def init(self, userCmd=None, timeLim=None, getStatus=False):
"""Called automatically on startup after the connection is established.
Only thing to do is query for status or connect if not connected
"""
log.info("%s.init(userCmd=%s, timeLim=%s, getStatus=%s)" % (self, userCmd, timeLim, getStatus))
userCmd = expandUserCmd(userCmd)
# stop, set speed, then status?
stopCmd = self.queueDevCmd("stop", userCmd)
speedCmd = self.queueDevCmd("speed %.4f"%self.nomSpeed, userCmd)
statusCmd = self.queueDevCmd("status", userCmd)
LinkCommands(userCmd, [stopCmd, speedCmd, statusCmd])
return userCmd
def setCountState(self, userCmd=None, timeLim=1):
"""!Set the Mitutoyo EV counter into the counting state,
this is required after a power cycle
"""
userCmd = expandUserCmd(userCmd)
countDevCmd = self.queueDevCmd(COUNTING_STATE, userCmd)
currValDevCmd = self.queueDevCmd(DISPLAY_CURR, userCmd)
currValDevCmd.addCallback(self._statusCallback)
countDevCmd.setTimeLimit(timeLim)
currValDevCmd.setTimeLimit(timeLim)
LinkCommands(userCmd, [countDevCmd, currValDevCmd])
return userCmd
def init(self, userCmd=None, timeLim=None, getStatus=None):
"""!Initialize the shutter
@param[in] userCmd a twistedActor.BaseCommand
@param[in] timeLim time limit for the init
@param[in] getStatus required argument for init
"""
userCmd = expandUserCmd(userCmd)
if not hasattr(userCmd, "cmdVerb"):
userCmd.cmdVerb = "init"
if timeLim is not None:
userCmd.setTimeLimit(timeLim)
self.queueDevCmd("init", userCmd)
return userCmd
def init(self, userCmd=None, timeLim=None, getStatus=True):
"""Called automatically on startup after the connection is established.
Only thing to do is query for status or connect if not connected
"""
log.info("%s.init(userCmd=%s, timeLim=%s, getStatus=%s)" % (self, userCmd, timeLim, getStatus))
# print("%s.init(userCmd=%s, timeLim=%s, getStatus=%s)" % (self, userCmd, timeLim, getStatus))
userCmd = expandUserCmd(userCmd)
# if not self.isConnected:
# return self.connect(userCmd=userCmd)
# get the speed on startup
# ignore getStatus flag, just do it always
self.queueDevCmd("speed")
return self.getStatus(userCmd=userCmd)
def stop(self, userCmd=None):
userCmd = expandUserCmd(userCmd)
if not self.waitMoveCmd.isDone:
self.waitMoveCmd.setState(self.waitMoveCmd.Cancelled, "Stop commanded")
#print("sec stop commanded")
stopCmd = self.queueDevCmd("stop", userCmd)
galilOffCmd = self.queueDevCmd("galil off", userCmd)
status = self.queueDevCmd("status", userCmd)
status2 = self.queueDevCmd("status", userCmd)
# first status gets the error state
# second status clears it
LinkCommands(userCmd, [stopCmd, status, galilOffCmd, status2])
return userCmd
def init(self, userCmd=None, timeLim=None, getStatus=None):
"""!Initialize the shutter
@param[in] userCmd a twistedActor.BaseCommand
@param[in] timeLim time limit for the init
@param[in] getStatus required argument for init
"""
userCmd = expandUserCmd(userCmd)
if not hasattr(userCmd, "cmdVerb"):
userCmd.cmdVerb = "init"
if timeLim is not None:
userCmd.setTimeLimit(timeLim)
self.queueDevCmd("init", userCmd)
return userCmd
def getStatus(self, userCmd=None):
"""Return current telescope status. Continuously poll.
"""
log.info("%s.getStatus(userCmd=%s)" % (self, userCmd)) # logging this will flood the log
userCmd = expandUserCmd(userCmd)
if not self.conn.isConnected:
userCmd.setState(userCmd.Failed, "Not Connected to TCS")
return userCmd
self._statusTimer.cancel() # incase a status is pending
userCmd = expandUserCmd(userCmd)
userCmd.addCallback(self._statusCallback)
# record the present RA, DEC (for determining when offsets are done)
# self.status.previousRA = self.status.statusFieldDict["ra"].value
# self.status.previousDec = self.status.statusFieldDict["dec"].value
if self.status.statusFieldDict["mpos"].value is None:
self.status.previousRA, self.status.previousDec = None, None
else:
self.status.previousRA = self.status.statusFieldDict["mpos"].value[0]
self.status.previousDec = self.status.statusFieldDict["mpos"].value[1]
# gather list of status elements to get
devCmdList = [DevCmd(cmdStr=cmdVerb) for cmdVerb in self.status.statusFieldDict.keys()]
LinkCommands(userCmd, devCmdList)
for devCmd in devCmdList:
self.queueDevCmd(devCmd)
if not self.status.isClamped or self.rotDelay:
# rotator is moving, get status frequently
pollTime = PollTimeRot
elif self.isSlewing:
# slewing, get status kinda frequently
pollTime = PollTimeSlew
elif self.isTracking:
# tracking, get status less frequently
pollTime = PollTimeTrack
else:
# idle, get status infrequently (as things shouldn't be changing fast)
pollTime = PollTimeIdle
self._statusTimer.start(pollTime, self.getStatus)
return userCmd
def init(self, userCmd=None, getStatus=True, timeLim=DefaultTimeLim):
"""! Initialize all devices, and get status if wanted
@param[in] userCmd a UserCmd or None
@param[in] getStatus if true, query all devices for status
@param[in] timeLim
"""
userCmd = expandUserCmd(userCmd)
log.info("%s.init(userCmd=%s, timeLim=%s, getStatus=%s)" %
(self, userCmd, timeLim, getStatus))
if getStatus:
self.cmd_status(userCmd) # sets done
else:
userCmd.setState(userCmd.Done)
return userCmd
def expose(self, expTime, userCmd=None):
"""!Open the shutter for the desired amount of time, then close it, and get
exposure time
@param[in] expTime amount of time to open the shutter for (seconds, float)
@param[in] userCmd a twistedActor.BaseCommand
"""
userCmd = expandUserCmd(userCmd)
openCmd = self.open()
holdCmd = self.holdOpen(expTime)
closeCmd = self.close()
statusCmd = self.status()
LinkCommands(userCmd, (openCmd, holdCmd, closeCmd, statusCmd))
return userCmd
def init(self, userCmd=None, getStatus=True, timeLim=DefaultTimeLim):
"""! Initialize all devices, and get status if wanted
@param[in] userCmd a UserCmd or None
@param[in] getStatus if true, query all devices for status
@param[in] timeLim
"""
userCmd = expandUserCmd(userCmd)
log.info("%s.init(userCmd=%s, timeLim=%s, getStatus=%s)" % (self, userCmd, timeLim, getStatus))
# initialize camera
self.setCamera()
subCmdList = []
# connect (if not connected) and initialize devices
filterDevCmd = expandUserCmd(None)
shutterDevCmd = expandUserCmd(None)
subCmdList.append(filterDevCmd)
subCmdList.append(shutterDevCmd)
if not self.filterWheelDev.isConnected:
self.filterWheelDev.connect(userCmd=filterDevCmd)
else:
self.filterWheelDev.init(userCmd=filterDevCmd)
if not self.shutterDev.isConnected:
self.shutterDev.connect(userCmd=shutterDevCmd)
else:
self.shutterDev.init(userCmd=shutterDevCmd)
if getStatus:
# get status only when the conn/initialization is done
def getStatus(foo):
if userCmd.isDone:
self.getStatus()
userCmd.addCallback(getStatus)
LinkCommands(mainCmd=userCmd, subCmdList=subCmdList)
if not self.exposeCmd.isDone:
self.exposeCmd.setState(self.exposeCmd.Failed, "currently running exposure killed via init")
self.exposeCleanup()
return userCmd
def init(self, userCmd=None, timeLim=None, getStatus=True):
"""Called automatically on startup after the connection is established.
Only thing to do is query for status or connect if not connected
"""
log.info("%s.init(userCmd=%s, timeLim=%s, getStatus=%s)" % (self, userCmd, timeLim, getStatus))
# print("%s.init(userCmd=%s, timeLim=%s, getStatus=%s)" % (self, userCmd, timeLim, getStatus))
userCmd = expandUserCmd(userCmd)
# if not self.isConnected:
# # time lim handled by lco.deviceCmd
# return self.connect(userCmd=userCmd)
if getStatus:
return self.getStatus(userCmd=userCmd)
else:
userCmd.setState(userCmd.Done)
return userCmd
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 queueDevCmd(self, cmdStr, userCmd=None):
"""Add a device command to the device command queue
@param[in] cmdStr, string to send to the device.
"""
log.info("%s.queueDevCmd(cmdStr=%r, cmdQueue: %r"%(self, cmdStr, self.devCmdQueue))
# print("%s.queueDevCmd(devCmd=%r, devCmdStr=%r, cmdQueue: %r"%(self, devCmd, devCmd.cmdStr, self.devCmdQueue))
# append a cmdVerb for the command queue (other wise all get the same cmdVerb and cancel eachother)
# could change the default behavior in CommandQueue?
userCmd = expandUserCmd(userCmd)
devCmd = DevCmd(cmdStr)
devCmd.cmdVerb = cmdStr.split()[0]
devCmd.userCmd = userCmd
def queueFunc(devCmd):
self.startDevCmd(devCmd)
self.devCmdQueue.addCmd(devCmd, queueFunc)
return devCmd
def getStatus(self, userCmd=None, timeLim=1, linkState=True):
"""!Read all enc positions 1-6 channels, 3 physical gauges.
"""
# first flush the current status to ensure we don't
# have stale values
print("reading migs!")
userCmd = expandUserCmd(userCmd)
self.encPos = [None]*6
statusDevCmd = self.queueDevCmd(READ_ENC, userCmd)
statusDevCmd.addCallback(self._statusCallback)
statusDevCmd.setTimeLimit(timeLim)
if linkState:
LinkCommands(userCmd, [statusDevCmd])
return userCmd
else:
# return the device command to be linked outside
return statusDevCmd
def move(self, valueList, offset=False, userCmd=None):
"""Command an offset or absolute orientation move
@param[in] valueList: list of 1 to 5 values specifying pistion(um), tiltx("), tilty("), transx(um), transy(um)
@param[in] offset, if true this is offset, else absolute
@param[in] userCmd: a twistedActor BaseCommand
Note: increasing distance eg pistion means increasing spacing between primary and
secondary mirrors.
"""
log.info("%s.move(userCmd=%s, valueList=%s, offset=%s)" % (self, userCmd, str(valueList), str(bool(offset))))
userCmd = expandUserCmd(userCmd)
if not self.waitMoveCmd.isDone:
userCmd.setState(userCmd.Failed, "Mirror currently moving")
return userCmd
if not 1<=len(valueList)<=5:
userCmd.setState(userCmd.Failed, "Must specify 1 to 5 numbers for a move")
return userCmd
self.waitMoveCmd = UserCmd()
self.waitMoveCmd.userCmd = userCmd # for write to users
self.status.desOrientation = self.status.orientation[:]
if offset:
# if offset is specified, offset from current value
for ii, value in enumerate(valueList):
self.status.desOrientation[ii] += value
else:
# if absolute is wanted, overwrite all those
# specified
for ii, value in enumerate(valueList):
self.status.desOrientation[ii] = value
cmdType = "offset" if offset else "move"
strValList = " ".join(["%.2f"%val for val in valueList])
cmdStr = "%s %s"%(cmdType, strValList)
moveCmd = self.queueDevCmd(cmdStr, userCmd)
statusCmd = self.queueDevCmd("status", userCmd)
# status immediately to see moving state
# determine total time for move
# just use focus distance as proxy (ignore)
galilOverHead = 2 # galil take roughly 2 secs to boot up.
extraOverHead = 2 #
self.status._moveTimeTotal = self.getTimeForMove()
timeout = self.status._moveTimeTotal+galilOverHead+extraOverHead
userCmd.setTimeLimit(timeout)
LinkCommands(userCmd, [moveCmd, statusCmd, self.waitMoveCmd])
return userCmd
def stop(self, userCmd=None):
"""Stop any scaling movement, cancelling any currently executing
command and any commands waiting on queue
@param[in] userCmd: a twistedActor BaseCommand
"""
userCmd=expandUserCmd(userCmd)
# kill any commands pending on the queue
# nicely kill move command if it's running
# if not self.currExeDevCmd.userCmd.isDone:
# self.currExeDevCmd.userCmd.setState(self.currExeDevCmd.userCmd.Failed, "Killed by stop")
if self.moveUserCmd.isActive:
self.moveUserCmd.setState(self.moveUserCmd.Cancelled, "Scaling ring move cancelled by stop command.")
stopDevCmd = self.queueDevCmd("stop", userCmd)
statusDevCmd = self.queueDevCmd("status", userCmd)
statusDevCmd.addCallback(self._statusCallback)
LinkCommands(userCmd, [stopDevCmd, statusDevCmd])
return userCmd
def speed(self, speedValue, userCmd=None):
"""Set the desired move speed for the thread ring
@param[in] speedValue: a float, scale value to be converted to steps and sent to motor
@param[in] userCmd: a twistedActor BaseCommand
"""
speedValue = float(speedValue)
userCmd = expandUserCmd(userCmd)
if self.isMoving:
userCmd.setState(userCmd.Failed, "Cannot set speed, device is busy moving")
return userCmd
elif float(speedValue) > self.status.maxSpeed:
userCmd.setState(userCmd.Failed, "Max Speed Exceeded: %.4f > %.4f"%(speedValue, self.status.maxSpeed))
return userCmd
else:
speedDevCmd = self.queueDevCmd("speed %.6f"%speedValue, userCmd)
statusDevCmd = self.queueDevCmd("status", userCmd)
statusDevCmd.addCallback(self._statusCallback)
LinkCommands(userCmd, [speedDevCmd, statusDevCmd])
return userCmd
def slewOffset(self, ra, dec, userCmd=None):
"""Offset telescope in right ascension and declination.
@param[in] ra: right ascension in decimal degrees
@param[in] dec: declination in decimal degrees
@param[in] userCmd a twistedActor BaseCommand
@todo, consolidate similar code with self.target?
"""
log.info("%s.slewOffset(userCmd=%s, ra=%.6f, dec=%.6f)" % (self, userCmd, ra, dec))
userCmd = expandUserCmd(userCmd)
# zero the delta computation so the offset isn't marked done immediately
self.status.previousDec = ForceSlew
self.status.previousRA = ForceSlew
if not self.conn.isConnected:
userCmd.setState(userCmd.Failed, "Not Connected to TCS")
return userCmd
if not self.waitOffsetCmd.isDone:
self.waitOffsetCmd.setState(self.waitOffsetCmd.Cancelled, "Superseded by new offset")
waitOffsetCmd = UserCmd()
self.waitOffsetCmd = waitOffsetCmd
enterRa = "OFRA %.8f"%(ra*ArcSecPerDeg)
enterDec = "OFDC %.8f"%(dec*ArcSecPerDeg) #lcohack
devCmdList = [DevCmd(cmdStr=cmdStr) for cmdStr in [enterRa, enterDec, CMDOFF]]
# set userCmd done only when each device command finishes
# AND the pending slew is also done.
# set an offset done after 6 seconds no matter what
def setWaitOffsetCmdDone(aWaitingOffsetCmd):
print("wait offset command state", aWaitingOffsetCmd.state)
if not aWaitingOffsetCmd.isDone:
print("Wait offset timed out!!!!")
self.writeToUsers("w", "Text=OFFSET SET DONE ON TIMER.")
aWaitingOffsetCmd.setState(aWaitingOffsetCmd.Done, "offset set done on a timer")
self.waitOffsetTimer.start(8, setWaitOffsetCmdDone, waitOffsetCmd)
# self.waitOffsetCmd.setTimeLimit(6)
LinkCommands(userCmd, devCmdList + [self.waitOffsetCmd])
for devCmd in devCmdList:
self.queueDevCmd(devCmd)
statusStr = self.status.getStatusStr()
if statusStr:
self.writeToUsers("i", statusStr, userCmd)
return userCmd
def getStatus(self, userCmd=None, doCamera=True, doFilter=True, doShutter=True):
"""! A generic status command, arguments specify which statuses are wanted
@param[in] userCmd a twistedActor UserCmd or none
@param[in] doCamera: bool, if true get camera status
@param[in] doFilter: bool, if true get filter wheel status
@param[in] doShutter: bool, if true get shutter status
"""
assert True in [doFilter, doShutter, doCamera]
userCmd = expandUserCmd(userCmd)
if doCamera:
statusStr = self.getCameraStatus()
self.writeToUsers("i", statusStr, cmd=userCmd)
subCmdList = []
if doShutter:
subCmdList.append(self.shutterDev.getStatus())
if doFilter:
subCmdList.append(self.filterWheelDev.startCmd("status"))
if subCmdList:
LinkCommands(userCmd, subCmdList)
else:
userCmd.setState(userCmd.Done)
return userCmd
