s1dx

This VmExecutor controls the horizontal opening.

#!/bin/env python

# File name: /usr/local/experiment/Tango/VmCode/s1dx.py

import PyTango
import math

## Detector Slit Horizontal Gap
##
## This motor does the combined move of two motors
## to control the horizontal opening of the slits

MOTOR_LEFT  = "p99/motor/d1.03"
MOTOR_RIGHT = "p99/motor/d1.04"

class VM:
    #
    # init_device
    #
	def __init__( self):
		self.PositionSim = 0
		self.ResultSim = []
		self.ResultSim.append("Horizontal Gap: PositionSim not set")
		self.ResultSim.append("slit_left: PositionSim not set")
		self.ResultSim.append("slit_right: PositionSim not set")
		self.proxies = []
		self.proxies.append( PyTango.DeviceProxy( MOTOR_LEFT))
		self.proxies.append( PyTango.DeviceProxy( MOTOR_RIGHT))
		return
	#
	# dev_state
	#
	def dev_state( self):
		argout = PyTango.DevState.ON
		#
		# if one device is in FAULT the VM is in FAULT too
		#
		for proxy in self.proxies:
			if proxy.state() == PyTango.DevState.FAULT:
				argout = PyTango.DevState.FAULT
				break
		if argout == PyTango.DevState.ON:
			#
			# if one device is MOVING the VM is MOVING too
			#
			for proxy in self.proxies:
				if proxy.state() == PyTango.DevState.MOVING:
					argout = PyTango.DevState.MOVING
					break
			
		return argout
	#
	# Position
	#
	def read_Position( self):
		position = self.calc_pos()
		return position

	def write_Position( self, argin):
		pos_left = self.proxies[0].Position
		pos_right = self.proxies[1].Position

		delta = self.calc_delta(argin)

		self.proxies[0].Position = pos_left + delta/2.
		self.proxies[1].Position = pos_right - delta/2.
		
		return 1
	#
	# UnitLimitMax
	#
	def read_UnitLimitMax( self):
	        pos_left = self.proxies[0].Position
		pos_right = self.proxies[1].Position
		opening = pos_left - pos_right
		check_limit_left = self.proxies[0].UnitLimitMax - pos_left
		check_limit_right = pos_right - self.proxies[1].UnitLimitMin
		if check_limit_left < check_limit_right:
			limit_max = opening + 2*check_limit_left
		elif check_limit_right < check_limit_left:
			limit_max = opening + 2*check_limit_right
		else:
			limit_max = (self.proxies[0].UnitLimitMax - self.proxies[1].UnitLimitMin) 
		return limit_max

	def write_UnitLimitMax( self, argin):
		pass
		#PyTango.Except.throw_exception( "vm", "UnitLimitMax can not be written", "VmExecutor")
	#
	# UnitLimitMin
	#
	def read_UnitLimitMin( self):
		pos_left = self.proxies[0].Position
		pos_right = self.proxies[1].Position
		opening = pos_left - pos_right
		check_limit_left = pos_left - self.proxies[0].UnitLimitMin
		check_limit_right = self.proxies[1].UnitLimitMax - pos_right
		if check_limit_left < check_limit_right:
			limit_min = opening - 2*check_limit_left
		elif check_limit_right < check_limit_left:
			limit_min = opening - 2*check_limit_right
		else:
			limit_min = (self.proxies[0].UnitLimitMin - self.proxies[1].UnitLimitMax) 
		return limit_min
	
	def write_UnitLimitMin( self, argin):
		pass		
		#PyTango.Except.throw_exception( "vm", "UnitLimitMin can not be written", "VmExecutor")
	#
	# CwLimit, CcwLimit
	#
	def read_CwLimit( self):
		argout = 0
		#
		# if one of the motors is in the limit return 1
		#
		for proxy in self.proxies:
			if proxy.CwLimit == 1:
				argout = 1
				break
		return argout

	def read_CcwLimit( self):
		argout = 0
		#
		# if one of the motors is in the limit return 1
		#
		for proxy in self.proxies:
			if proxy.CcwLimit == 1:
				argout = 1
				break
		return argout

	#	
	# PositionSim	
	#	
	def read_PositionSim( self):
		return self.PositionSim

	def write_PositionSim( self, argin):
		self.PositionSim = argin

	def read_ResultSim( self):
		pos_left = self.proxies[0].Position
		pos_right = self.proxies[1].Position

		delta = self.calc_delta(self.PositionSim)

		self.ResultSim[0] = "Horizontal Gap: %g " % self.PositionSim
		self.ResultSim[1] = "slit_left: %g " % (pos_left + delta/2.)
		self.ResultSim[2] = "slit_right: %g " % (pos_right - delta/2.)
		
		return self.ResultSim

	def StopMove( self):
		for proxy in self.proxies:
			proxy.StopMove()
		return 1
	
	def Calibrate(self, argin):
		pos_left = self.proxies[0].Position
		pos_right = self.proxies[1].Position

		center = (pos_left + pos_right)/2.

		newpos_left = center + argin/2.
		newpos_right = center - argin/2.
			
 		self.proxies[0].Calibrate(newpos_left)
		self.proxies[1].Calibrate(newpos_right)

		return 1
		
	def calc_pos(self):
		p1 = self.proxies[0].Position
		p2 = self.proxies[1].Position

		pos = p1 - p2
	
		return pos
		
	def calc_delta(self, argin):
		pos = self.calc_pos()
		delta = argin - pos
		return delta