def main():
pv1 = sys.argv[1]
print "Test post move delay handling."
lib = motor_lib()
g = motor_globals()
caput(pv1 + ":DelayTime", 0, wait=True, timeout=g.TIMEOUT)
stat = lib.move(pv1, 0, g.TIMEOUT)
if (stat == g.FAIL):
sys.exit(lib.testComplete(g.FAIL))
delays = [0, 0.1, 0.2, 0.5, 1, 2, 5, 20]
positions = range(0, 10)
for delay in delays:
caput(pv1 + ":DelayTime", delay, wait=True, timeout=g.TIMEOUT)
for pos in positions:
print "Move to " + str(float(
pos / 10.0)) + " with post move delay " + str(delay)
stat = lib.move(pv1, float(pos / 10.0), g.TIMEOUT)
if (stat == g.FAIL):
sys.exit(lib.testComplete(g.FAIL))
positions = range(0, 20, 2)
for delay in delays:
caput(pv1 + ":DelayTime", delay, wait=True, timeout=g.TIMEOUT)
for pos in positions:
print "Move to " + str(pos) + " with post move delay " + str(delay)
stat = lib.move(pv1, pos, g.TIMEOUT)
if (stat == g.FAIL):
sys.exit(lib.testComplete(g.FAIL))
sys.exit(lib.testComplete(g.SUCCESS))
def main():
pv = str(sys.argv[1])
print "Test small move sequence on motor " + pv
lib = motor_lib()
g = motor_globals()
positions = range(0,100)
for pos in positions:
pos = float(pos)/100.0
print "Move to " + str(pos)
stat = lib.move(pv, pos, g.TIMEOUT)
if (stat == g.FAIL):
sys.exit(lib.testComplete(g.FAIL))
positions = range(0,100)
for pos in positions:
pos = float(pos)/1000
print "Move to " + str(pos)
stat = lib.move(pv, pos, g.TIMEOUT)
if (stat == g.FAIL):
sys.exit(lib.testComplete(g.FAIL))
sys.exit(lib.testComplete(g.SUCCESS))
def main():
pv1 = sys.argv[1]
print "Test post move delay handling."
lib = motor_lib()
g = motor_globals()
caput(pv1+":DelayTime", 0, wait=True, timeout=g.TIMEOUT)
stat = lib.move(pv1, 0, g.TIMEOUT)
if (stat == g.FAIL):
sys.exit(lib.testComplete(g.FAIL))
delays = [0, 0.1, 0.2, 0.5, 1, 2, 5, 20]
positions = range(0,10)
for delay in delays:
caput(pv1+":DelayTime", delay, wait=True, timeout=g.TIMEOUT)
for pos in positions:
print "Move to " + str(float(pos/10.0)) + " with post move delay " + str(delay)
stat = lib.move(pv1, float(pos/10.0), g.TIMEOUT)
if (stat == g.FAIL):
sys.exit(lib.testComplete(g.FAIL))
positions = range(0,20,2)
for delay in delays:
caput(pv1+":DelayTime", delay, wait=True, timeout=g.TIMEOUT)
for pos in positions:
print "Move to " + str(pos) + " with post move delay " + str(delay)
stat = lib.move(pv1, pos, g.TIMEOUT)
if (stat == g.FAIL):
sys.exit(lib.testComplete(g.FAIL))
sys.exit(lib.testComplete(g.SUCCESS))
class Test(unittest.TestCase):
lib = motor_lib()
__g = motor_globals()
motor = os.getenv("TESTEDMOTORAXIS")
lib.initializeMotorRecordSimulatorAxis(motor, '240')
saved_DLY = epics.caget(motor + '.DLY')
msta = int(epics.caget(motor + '.MSTA'))
hlm = epics.caget(motor + '.HLM')
llm = epics.caget(motor + '.LLM')
per10_UserPosition = round((9 * llm + 1 * hlm) / 10)
per90_UserPosition = round((1 * llm + 9 * hlm) / 10)
# Assert that motor is homed
def test_TC_241(self):
motor = self.motor
tc_no = "TC-241"
if not (self.msta & self.lib.MSTA_BIT_HOMED):
self.assertNotEqual(0, self.msta & self.lib.MSTA_BIT_HOMED, 'MSTA.homed (Axis has been homed)')
# Jog, wait for start, stop behind MR
def test_TC_242(self):
motor = self.motor
tc_no = "TC-242-JOGF_stopped"
print '%s' % tc_no
if (self.msta & self.lib.MSTA_BIT_HOMED):
epics.caput(motor + '.DLY', 0)
destination = self.per10_UserPosition
res1 = self.lib.move(motor, destination, 60)
UserPosition = epics.caget(motor + '.RBV', use_monitor=False)
print '%s postion=%f per10_UserPosition=%f' % (
tc_no, UserPosition, self.per90_UserPosition)
epics.caput(motor + '.JOGF', 1)
ret2 = self.lib.waitForStart(motor, tc_no, 2.0)
time.sleep(1)
epics.caput(motor + '-Stop', 1)
ret3 = self.lib.waitForStop(motor, tc_no, 2.0)
val = epics.caget(motor + '.VAL')
try:
res4 = self.lib.verifyPosition(motor, val)
except:
e = sys.exc_info()
print str(e)
res4 = self.__g.FAIL
epics.caput(motor + '.DLY', self.saved_DLY)
self.assertEqual(res1, self.__g.SUCCESS, 'move returned SUCCESS')
self.assertEqual(res4, self.__g.SUCCESS, 'VAL synched with RBV')
def main():
pv1 = "BL99:Mot:Sim1"
pv2 = "BL99:Mot:Sim2"
defer = "BL99:Mot:Sim:Defer"
print "Test deferred move sequence on both motors"
lib = motor_lib()
g = motor_globals()
positions = range(20)
for pos in positions:
pos2 = pos+1
print "Set deferred flag."
caput(defer, 1, wait=True)
print "Set positions pos: " + str(pos) + " pos2: " + str(pos2)
caput(pv1, pos, wait=False)
caput(pv2, pos2, wait=False)
print "Execute deferred move."
caput(defer, 0, wait=True)
#Wait for both motors to finish
done = 0
count = 0
while (done == 0):
dmov1 = caget(pv1+".DMOV")
dmov2 = caget(pv2+".DMOV")
if (dmov1 == 1) and (dmov2 == 1):
done = 1
count = 0
print "Move Finished"
count = count + 1
if count > 1000:
print "Moves did not complete."
sys.exit(lib.testComplete(g.FAIL))
time.sleep(0.1)
try:
lib.verifyPosition(pv1, pos)
except Exception as e:
print str(e)
sys.exit(lib.testComplete(g.FAIL))
try:
lib.verifyPosition(pv2, pos2)
except Exception as e:
print str(e)
sys.exit(lib.testComplete(g.FAIL))
sys.exit(lib.testComplete(g.SUCCESS))
def main():
pv1 = "BL99:Mot:P6K1"
pv2 = "BL99:Mot:P6K2"
defer = "BL99:Mot:Controller1:Defer"
print "Test deferred move sequence on both motors"
lib = motor_lib()
g = motor_globals()
positions = range(20)
for pos in positions:
pos2 = pos + 1
print "Set deferred flag."
caput(defer, 1, wait=True)
print "Set positions pos: " + str(pos) + " pos2: " + str(pos2)
caput(pv1, pos, wait=False)
caput(pv2, pos2, wait=False)
print "Execute deferred move."
caput(defer, 0, wait=True)
#Wait for both motors to finish
done = 0
count = 0
while (done == 0):
dmov1 = caget(pv1 + ".DMOV")
dmov2 = caget(pv2 + ".DMOV")
if (dmov1 == 1) and (dmov2 == 1):
done = 1
count = 0
print "Move Finished"
count = count + 1
if count > 1000:
print "Moves did not complete."
sys.exit(lib.testComplete(g.FAIL))
time.sleep(0.1)
try:
lib.verifyPosition(pv1, pos)
except Exception as e:
print str(e)
sys.exit(lib.testComplete(g.FAIL))
try:
lib.verifyPosition(pv2, pos2)
except Exception as e:
print str(e)
sys.exit(lib.testComplete(g.FAIL))
sys.exit(lib.testComplete(g.SUCCESS))
class Test(unittest.TestCase):
lib = motor_lib()
__g = motor_globals()
motor = os.getenv("TESTEDMOTORAXIS")
motor2 = "IOC:m2"
hlm = epics.caget(motor + '.HLM')
llm = epics.caget(motor + '.LLM')
msta = int(epics.caget(motor + '.MSTA'))
per10_UserPosition = round((9 * llm + 1 * hlm) / 10)
per90_UserPosition = round((1 * llm + 9 * hlm) / 10)
# Assert that motor is homed
def test_TC_231(self):
motor = self.motor
tc_no = "TC-231"
if not (self.msta & self.lib.MSTA_BIT_HOMED):
self.assertNotEqual(0, self.msta & self.lib.MSTA_BIT_HOMED,
'MSTA.homed (Axis has been homed)')
# Jog, wait for start, power off, check error, reset error
def test_TC_232(self):
motor = self.motor
motor2 = self.motor2
tc_no = "TC-232-NetYetStarted"
print '%s' % tc_no
if (self.msta & self.lib.MSTA_BIT_HOMED):
setValueOnSimulator(self, motor2, tc_no, "usleep", 1700000)
destination = self.per90_UserPosition
res1 = self.lib.move(motor, destination, 60)
UserPosition = epics.caget(motor + '.RBV', use_monitor=False)
print '%s postion=%f per90_UserPosition=%f' % (
tc_no, UserPosition, self.per90_UserPosition)
destination = self.per10_UserPosition
res2 = self.lib.move(motor, destination, 60)
UserPosition = epics.caget(motor + '.RBV', use_monitor=False)
print '%s postion=%f per10_UserPosition=%f' % (
tc_no, UserPosition, self.per90_UserPosition)
setValueOnSimulator(self, motor2, tc_no, "usleep", 0)
self.assertNotEqual(res1 == self.__g.SUCCESS,
'move returned SUCCESS')
self.assertNotEqual(res2 == self.__g.SUCCESS,
'move returned SUCCESS')
def main():
pv = str(sys.argv[1])
print "Set position test on motor " + pv
lib = motor_lib()
g = motor_globals()
positions = [0, 1, 1.234, -1.1, 0]
for pos in positions:
print "Set position to " + str(pos)
stat = lib.setPosition(pv, pos, g.TIMEOUT)
if (stat == g.FAIL):
sys.exit(lib.testComplete(g.FAIL))
sys.exit(lib.testComplete(g.SUCCESS))
def main():
pv = str(sys.argv[1])
delay = 1
print "Test move sequence on motor " + pv + " with delays " + str(delay)
lib = motor_lib()
g = motor_globals()
positions = range(10)
for pos in positions:
print "Move to " + str(pos)
stat = lib.move(pv, pos, g.TIMEOUT)
if (stat == g.FAIL):
sys.exit(lib.testComplete(g.FAIL))
time.sleep(delay)
sys.exit(lib.testComplete(g.SUCCESS))
class Test(unittest.TestCase):
lib = motor_lib()
g = motor_globals()
motor = os.getenv("TESTEDMOTORAXIS")
pv_Err = epics.PV(os.getenv("TESTEDMOTORAXIS") + "-Err")
pv_nErrorId = epics.PV(os.getenv("TESTEDMOTORAXIS") + "-ErrId")
pv_nErrRst = epics.PV(os.getenv("TESTEDMOTORAXIS") + "-ErrRst")
saved_LLM = epics.caget(motor + '.LLM')
saved_CNEN = epics.caget(motor + '.CNEN')
saved_PwrAuto = epics.caget(motor + '-PwrAuto')
saved_PwrOnDly = epics.caget(motor + '-PwrOnDly')
saved_PwrOffDly = epics.caget(motor + '-PwrOffDly')
def test_TC_2200(self):
motor = self.motor
tc_no = "TC-2201-Enable_goto_LLM"
#Enable power
print '%s Enable drive and move to LLM' % tc_no
epics.caput(motor + '-PwrAuto', 2, wait=True, timeout=self.g.TIMEOUT)
epics.caput(motor + '-PwrOnDly', PwrOnDly, wait=True, timeout=self.g.TIMEOUT)
epics.caput(motor + '.CNEN', 1)
res = self.lib.move(motor, self.saved_LLM, self.g.TIMEOUT)
restorePwrSettings(self, motor, tc_no, self.saved_PwrAuto, self.saved_PwrOnDly, self.saved_PwrOffDly)
assert(res == 0)
def test_TC_2201(self):
motor = self.motor
tc_no = "TC-2201-Auto_power_mode_1"
print '%s autopower ' % tc_no
do_220_autopower(self, motor, tc_no, 1)
def test_TC_2202(self):
motor = self.motor
tc_no = "TC-2202-Auto_power_mode_2"
print '%s autopower ' % tc_no
do_220_autopower(self, motor, tc_no, 2)
class motor_lib(object):
"""
Library of useful test functions for motor record applications
"""
__g = motor_globals()
MSTA_BIT_HOMED = 1 << (15 - 1) #4000
MSTA_BIT_MINUS_LS = 1 << (14 - 1) #2000
MSTA_BIT_COMM_ERR = 1 << (13 - 1) #1000
MSTA_BIT_GAIN_SUPPORT = 1 << (12 - 1) #0800
MSTA_BIT_MOVING = 1 << (11 - 1) #0400
MSTA_BIT_PROBLEM = 1 << (10 - 1) #0200
MSTA_BIT_PRESENT = 1 << (9 - 1) #0100
MSTA_BIT_HOME = 1 << (8 - 1) #0080
MSTA_BIT_SLIP_STALL = 1 << (7 - 1) #0040
MSTA_BIT_AMPON = 1 << (6 - 1) #0020
MSTA_BIT_UNUSED = 1 << (5 - 1) #0010
MSTA_BIT_HOMELS = 1 << (4 - 1) #0008
MSTA_BIT_PLUS_LS = 1 << (3 - 1) #0004
MSTA_BIT_DONE = 1 << (2 - 1) #0002
MSTA_BIT_DIRECTION = 1 << (1 - 1) #0001
MIP_BIT_JOGF = 0x0001
MIP_BIT_JOGR = 0x0002
MIP_BIT_JOG_BL1 = 0x0004
MIP_BIT_HOMF = 0x0008
MIP_BIT_HOMR = 0x0010
MIP_BIT_MOVE = 0x0020
MIP_BIT_RETRY = 0x0040
MIP_BIT_LOAD_P = 0x0080
MIP_BIT_MOVE_BL = 0x0100
MIP_BIT_STOP = 0x0200
MIP_BIT_DELAY_REQ = 0x0400
MIP_BIT_DELAY_ACK = 0x0800
MIP_BIT_JOG_REQ = 0x1000
MIP_BIT_JOG_STOP = 0x2000
MIP_BIT_JOG_BL2 = 0x4000
MIP_BIT_EXTERNAL = 0x8000
# Values to be used for backlash test
# Note: Make sure to use different values to hae a good
# test coverage
myVELO = 10.0 # positioning velocity
myACCL = 1.0 # Time to VELO, seconds
myAR = myVELO / myACCL # acceleration, mm/sec^2
myJVEL = 5.0 # Jogging velocity
myJAR = 6.0 # Jogging acceleration, mm/sec^2
myBVEL = 2.0 # backlash velocity
myBACC = 1.5 # backlash acceleration, seconds
myBAR = myBVEL / myBACC # backlash acceleration, mm/sec^2
myRTRY = 3
myDLY = 0.0
myBDST = 24.0 # backlash destination, mm
myFRAC = 1.0 #
myPOSlow = 48 #
myPOSmid = 72 # low + BDST
myPOShig = 96 # low + 2*BDST
def initializeMotorRecordOneField(self, motor, tc_no, field, value):
channelname = motor + field
oldVal = epics.caget(channelname)
if (oldVal != None):
print '%s: initializeMotorRecordOneField field=%s oldVal=%f value=%f' % (
tc_no, channelname, oldVal, value)
if (oldVal != value):
epics.caput(channelname, value)
else:
print '%s: initializeMotorRecordOneField field=%s not found value=%f' % (
tc_no, channelname, value)
def initializeMotorRecordSimulatorAxis(self, motor, tc_no):
# If there are usful values in the controller, use them
dhlm = epics.caget(motor + '-CfgDHLM')
dllm = epics.caget(motor + '-CfgDLLM')
if (dhlm == None or dllm == None or dhlm <= dllm):
dhlm = 53.0
dllm = -54.0
self.initializeMotorRecordOneField(motor, tc_no, '.VMAX', 50.0)
self.initializeMotorRecordOneField(motor, tc_no, '.VELO', 20.0)
self.initializeMotorRecordOneField(motor, tc_no, '.ACCL', 5.0)
self.initializeMotorRecordOneField(motor, tc_no, '.JVEL', 5.0)
self.initializeMotorRecordOneField(motor, tc_no, '.JAR', 20.0)
self.initializeMotorRecordOneField(motor, tc_no, '.RDBD', 0.1)
#self.initializeMotorRecordOneField(motor, tc_no, '.SPDB', 0.1)
self.initializeMotorRecordOneField(motor, tc_no, '.BDST', 0.0)
self.setSoftLimitsOff(motor)
self.initializeMotorRecordOneField(motor, tc_no, '-CfgDHLM', dhlm)
self.initializeMotorRecordOneField(motor, tc_no, '-CfgDLLM', dllm)
self.initializeMotorRecordOneField(motor, tc_no, '-CfgDHLM-En', 1)
self.initializeMotorRecordOneField(motor, tc_no, '-CfgDLLM-En', 1)
self.initializeMotorRecordOneField(motor, tc_no, '.DHLM', dhlm)
self.initializeMotorRecordOneField(motor, tc_no, '.DLLM', dllm)
def getMSTAtext(self, msta):
ret = ''
if (msta & self.MSTA_BIT_HOMED):
ret = ret + 'Hmd'
else:
ret = ret + '...'
if (msta & self.MSTA_BIT_MINUS_LS):
ret = ret + 'Lls'
else:
ret = ret + '...'
#if (msta & self.MSTA_BIT_GAIN_SUPPORT):
# ret = ret + 'G'
#else:
# ret = ret +'.'
if (msta & self.MSTA_BIT_MOVING):
ret = ret + 'Mov'
else:
ret = ret + '...'
if (msta & self.MSTA_BIT_PROBLEM):
ret = ret + 'Prb'
else:
ret = ret + '.'
if (msta & self.MSTA_BIT_PRESENT):
ret = ret + 'Enc'
else:
ret = ret + '...'
if (msta & self.MSTA_BIT_HOME):
ret = ret + 'Hom'
else:
ret = ret + '..'
if (msta & self.MSTA_BIT_SLIP_STALL):
ret = ret + 'Slp'
else:
ret = ret + '....'
if (msta & self.MSTA_BIT_AMPON):
ret = ret + 'Amp'
else:
ret = ret + '...'
if (msta & self.MSTA_BIT_HOMELS):
ret = ret + 'Hsw'
else:
ret = ret + '...'
if (msta & self.MSTA_BIT_PLUS_LS):
ret = ret + 'Hls'
else:
ret = ret + '...'
if (msta & self.MSTA_BIT_DONE):
ret = ret + 'Don'
else:
ret = ret + '...'
return ret
def getMIPtext(self, mip):
ret = ''
if (mip & self.MIP_BIT_JOGF):
ret = ret + 'JOGF '
if (mip & self.MIP_BIT_JOGR):
ret = ret + 'JOGR '
if (mip & self.MIP_BIT_JOG_BL1):
ret = ret + 'JOG_BL1 '
if (mip & self.MIP_BIT_HOMF):
ret = ret + 'HOMF '
if (mip & self.MIP_BIT_HOMR):
ret = ret + 'HOMR '
if (mip & self.MIP_BIT_MOVE):
ret = ret + 'MOVE '
if (mip & self.MIP_BIT_LOAD_P):
ret = ret + 'LOAD_P '
if (mip & self.MIP_BIT_MOVE_BL):
ret = ret + 'MOVE_BL '
if (mip & self.MIP_BIT_DELAY_REQ):
ret = ret + 'DELAY_REQ '
if (mip & self.MIP_BIT_DELAY_ACK):
ret = ret + 'DELAY_ACK '
if (mip & self.MIP_BIT_JOG_REQ):
ret = ret + 'JOG_REQ '
if (mip & self.MIP_BIT_JOG_STOP):
ret = ret + 'JOG_STOP '
if (mip & self.MIP_BIT_JOG_BL2):
ret = ret + 'JOG_BL2 '
if (mip & self.MIP_BIT_EXTERNAL):
ret = ret + 'EXTERNAL '
return ret
def calcAlmostEqual(self, motor, tc_no, expected, actual, maxdelta):
delta = math.fabs(expected - actual)
inrange = delta < maxdelta
print '%s: assertAlmostEqual expected=%f actual=%f delta=%f maxdelta=%f inrange=%d' % (
tc_no, expected, actual, delta, maxdelta, inrange)
return inrange
def waitForStart(self, motor, tc_no, wait_for_start):
while wait_for_start > 0:
wait_for_start -= polltime
dmov = int(epics.caget(motor + '.DMOV', use_monitor=False))
movn = int(epics.caget(motor + '.MOVN', use_monitor=False))
rbv = epics.caget(motor + '.RBV')
print '%s: wait_for_start=%f dmov=%d movn=%d rbv=%f' % (
tc_no, wait_for_start, dmov, movn, rbv)
if movn and not dmov:
return True
time.sleep(polltime)
wait_for_start -= polltime
return False
def waitForStop(self, motor, tc_no, wait_for_stop):
while wait_for_stop > 0:
wait_for_stop -= polltime
dmov = int(epics.caget(motor + '.DMOV', use_monitor=False))
movn = int(epics.caget(motor + '.MOVN', use_monitor=False))
rbv = epics.caget(motor + '.RBV', use_monitor=False)
print '%s: wait_for_stop=%f dmov=%d movn=%d rbv=%f' % (
tc_no, wait_for_stop, dmov, movn, rbv)
if not movn and dmov:
return True
time.sleep(polltime)
wait_for_stop -= polltime
return False
def waitForStartAndDone(self, motor, tc_no, wait_for_done):
wait_for_start = 2
while wait_for_start > 0:
wait_for_start -= polltime
dmov = int(caget(motor + '.DMOV'))
movn = int(caget(motor + '.MOVN'))
print '%s: wait_for_start=%f dmov=%d movn=%d dpos=%f' % (
tc_no, wait_for_start, dmov, movn,
caget(motor + '.DRBV', use_monitor=False))
if movn and not dmov:
break
time.sleep(polltime)
wait_for_done = math.fabs(wait_for_done) #negative becomes positive
wait_for_done += 1 # One extra second for rounding
while wait_for_done > 0:
dmov = int(caget(motor + '.DMOV'))
movn = int(caget(motor + '.MOVN'))
print '%s: wait_for_done=%f dmov=%d movn=%d dpos=%f' % (
tc_no, wait_for_done, dmov, movn,
caget(motor + '.DRBV', use_monitor=False))
if dmov and not movn:
return True
time.sleep(polltime)
wait_for_done -= polltime
return False
def waitForMipZero(self, motor, tc_no, wait_for_MipZero):
while wait_for_MipZero > -10.0: # Extra long wait
wait_for_MipZero -= polltime
mip = int(epics.caget(motor + '.MIP', use_monitor=False))
print '%s: wait_for_MipZero=%f mip=%s (%x)' % (
tc_no, wait_for_MipZero, self.getMIPtext(mip), mip)
if not mip:
return True
time.sleep(polltime)
wait_for_MipZero -= polltime
return False
def testComplete(self, fail):
"""
Function to be called at end of test
fail = true or false
"""
if not fail:
print "Test Complete"
return self.__g.SUCCESS
else:
print "Test Failed"
return self.__g.FAIL
def jogDirection(self, motor, tc_no, direction, time_to_wait):
if direction > 0:
epics.caput(motor + '.JOGF', 1)
else:
epics.caput(motor + '.JOGR', 1)
done = self.waitForStartAndDone(motor, tc_no + " jogDirection",
30 + time_to_wait + 3.0)
if direction > 0:
epics.caput(motor + '.JOGF', 0)
else:
epics.caput(motor + '.JOGR', 0)
def move(self, motor, position, timeout):
"""
Move motor to position. We use put_callback
and check final position is within RDBD.
"""
try:
caput(motor, position, wait=True, timeout=timeout)
except:
e = sys.exc_info()
print str(e)
print "ERROR: caput failed."
print(motor + " pos:" + str(position) + " timeout:" + str(timeout))
return self.__g.FAIL
rdbd = motor + ".RDBD"
rbv = motor + ".RBV"
final_pos = caget(rbv, use_monitor=False)
deadband = caget(rdbd)
success = True
if ((final_pos < position - deadband)
or (final_pos > position + deadband)):
print "ERROR: final_pos out of deadband."
success = False
else:
print "Final_pos inside deadband."
print(motor + " pos=" + str(position) + " timeout=" + str(timeout) +
" final_pos=" + str(final_pos) + " deadband=" + str(deadband))
if (success):
return self.postMoveCheck(motor)
else:
self.postMoveCheck(motor)
return self.__g.FAIL
def movePosition(self, motor, tc_no, destination, velocity, acceleration):
time_to_wait = 30
if velocity > 0:
distance = math.fabs(caget(motor + '.RBV') - destination)
time_to_wait += distance / velocity + 2 * acceleration
caput(motor + '.VAL', destination)
done = self.waitForStartAndDone(motor, tc_no + " movePosition",
time_to_wait)
def setPosition(self, motor, position, timeout):
"""
Set position on motor and check it worked ok.
"""
_set = motor + ".SET"
_rbv = motor + ".RBV"
_dval = motor + ".DVAL"
_off = motor + ".OFF"
offset = caget(_off)
caput(_set, 1, wait=True, timeout=timeout)
caput(_dval, position, wait=True, timeout=timeout)
caput(_off, offset, wait=True, timeout=timeout)
caput(_set, 0, wait=True, timeout=timeout)
if (self.postMoveCheck(motor) != self.__g.SUCCESS):
return self.__g.FAIL
try:
self.verifyPosition(motor, position + offset)
except Exception as e:
print str(e)
return self.__g.FAIL
def checkInitRecord(self, motor):
"""
Check the record for correct state at start of test.
"""
self.postMoveCheck()
def verifyPosition(self, motor, position):
"""
Verify that field == reference.
"""
_rdbd = motor + ".RDBD"
deadband = caget(_rdbd)
_rbv = motor + ".RBV"
current_pos = caget(_rbv)
if ((current_pos < position - deadband)
or (current_pos > position + deadband)):
print "ERROR: verifyPosition out of deadband."
msg = (motor + " pos=" + str(position) + " currentPos=" +
str(current_pos) + " deadband=" + str(deadband))
raise Exception(__name__ + msg)
return self.__g.SUCCESS
def verifyField(self, pv, field, reference):
"""
Verify that field == reference.
"""
full_pv = pv + "." + field
if (caget(full_pv) != reference):
msg = "ERROR: " + full_pv + " not equal to " + str(reference)
raise Exception(__name__ + msg)
return self.__g.SUCCESS
def postMoveCheck(self, motor):
"""
Check the motor for the correct state at the end of move.
"""
DMOV = 1
MOVN = 0
STAT = 0
SEVR = 0
LVIO = 0
MISS = 0
RHLS = 0
RLLS = 0
try:
self.verifyField(motor, "DMOV", DMOV)
self.verifyField(motor, "MOVN", MOVN)
self.verifyField(motor, "STAT", STAT)
self.verifyField(motor, "SEVR", SEVR)
self.verifyField(motor, "LVIO", LVIO)
self.verifyField(motor, "MISS", MISS)
self.verifyField(motor, "RHLS", RHLS)
self.verifyField(motor, "RLLS", RLLS)
except Exception as e:
print str(e)
return self.__g.FAIL
return self.__g.SUCCESS
def setValueOnSimulator(self, motor, tc_no, var, value):
var = str(var)
value = str(value)
outStr = 'Sim.this.' + var + '=' + value
print '%s: DbgStrToMCU motor=%s var=%s value=%s outStr=%s' % \
(tc_no, motor, var, value, outStr)
assert (len(outStr) < 40)
epics.caput(motor + '-DbgStrToMCU', outStr, wait=True)
err = int(epics.caget(motor + '-Err', use_monitor=False))
print '%s: DbgStrToMCU motor=%s var=%s value=%s err=%d' % \
(tc_no, motor, var, value, err)
assert (not err)
def motorInitAllForBDST(self, motor, tc_no):
self.setValueOnSimulator(motor, tc_no, "nAmplifierPercent", 100)
self.setValueOnSimulator(motor, tc_no, "bAxisHomed", 1)
self.setValueOnSimulator(motor, tc_no, "fLowHardLimitPos", -100)
self.setValueOnSimulator(motor, tc_no, "fHighHardLimitPos", 100)
self.setValueOnSimulator(motor, tc_no, "setMRES_23", 0)
self.setValueOnSimulator(motor, tc_no, "setMRES_24", 0)
epics.caput(motor + '-ErrRst', 1)
# Prepare parameters for jogging and backlash
self.setSoftLimitsOff(motor)
epics.caput(motor + '.VELO', self.myVELO)
epics.caput(motor + '.ACCL', self.myACCL)
epics.caput(motor + '.JVEL', self.myJVEL)
epics.caput(motor + '.JAR', self.myJAR)
epics.caput(motor + '.BVEL', self.myBVEL)
epics.caput(motor + '.BACC', self.myBACC)
epics.caput(motor + '.BDST', self.myBDST)
epics.caput(motor + '.FRAC', self.myFRAC)
epics.caput(motor + '.RTRY', self.myRTRY)
epics.caput(motor + '.RMOD', motorRMOD_D)
epics.caput(motor + '.DLY', self.myDLY)
def writeExpFileRMOD_X(self, motor, tc_no, rmod, dbgFile, expFile, maxcnt,
frac, encRel, motorStartPos, motorEndPos):
cnt = 0
if motorEndPos - motorStartPos > 0:
directionOfMove = 1
else:
directionOfMove = -1
if self.myBDST > 0:
directionOfBL = 1
else:
directionOfBL = -1
print '%s: writeExpFileRMOD_X motor=%s encRel=%d motorStartPos=%f motorEndPos=%f directionOfMove=%d directionOfBL=%d' % \
(tc_no, motor, encRel, motorStartPos, motorEndPos, directionOfMove, directionOfBL)
if dbgFile != None:
dbgFile.write('#%s: writeExpFileRMOD_X motor=%s rmod=%d encRel=%d motorStartPos=%f motorEndPos=%f directionOfMove=%d directionOfBL=%d\n' % \
(tc_no, motor, rmod, encRel, motorStartPos, motorEndPos, directionOfMove, directionOfBL))
if rmod == motorRMOD_I:
maxcnt = 1 # motorRMOD_I means effecttivly "no retry"
encRel = 0
if abs(motorEndPos - motorStartPos) <= abs(
self.myBDST) and directionOfMove == directionOfBL:
while cnt < maxcnt:
# calculate the delta to move
# The calculated delta is the scaled, and used for both absolute and relative
# movements
delta = motorEndPos - motorStartPos
if cnt > 1:
if rmod == motorRMOD_A:
# From motorRecord.cc:
#factor = (pmr->rtry - pmr->rcnt + 1.0) / pmr->rtry;
factor = 1.0 * (self.myRTRY - cnt + 1.0) / self.myRTRY
delta = delta * factor
elif rmod == motorRMOD_G:
#factor = 1 / pow(2.0, (pmr->rcnt - 1));
rcnt_1 = cnt - 1
factor = 1.0
while rcnt_1 > 0:
factor = factor / 2.0
rcnt_1 -= 1
delta = delta * factor
if encRel:
line1 = "move relative delta=%g max_velocity=%g acceleration=%g motorPosNow=%g" % \
(delta * frac, self.myBVEL, self.myBAR, motorStartPos)
else:
line1 = "move absolute position=%g max_velocity=%g acceleration=%g motorPosNow=%g" % \
(motorStartPos + delta, self.myBVEL, self.myBAR, motorStartPos)
expFile.write('%s\n' % (line1))
cnt += 1
else:
# As we don't move the motor (it is simulated, we both times start at motorStartPos
while cnt < maxcnt:
# calculate the delta to move
# The calculated delta is the scaled, and used for both absolute and relative
# movements
delta = motorEndPos - motorStartPos - self.myBDST
if cnt > 1:
if rmod == motorRMOD_A:
# From motorRecord.cc:
#factor = (pmr->rtry - pmr->rcnt + 1.0) / pmr->rtry;
factor = 1.0 * (self.myRTRY - cnt + 1.0) / self.myRTRY
delta = delta * factor
elif rmod == motorRMOD_G:
#factor = 1 / pow(2.0, (pmr->rcnt - 1));
rcnt_1 = cnt - 1
factor = 1.0
while rcnt_1 > 0:
factor = factor / 2.0
rcnt_1 -= 1
delta = delta * factor
if encRel:
line1 = "move relative delta=%g max_velocity=%g acceleration=%g motorPosNow=%g" % \
(delta * frac, self.myVELO, self.myAR, motorStartPos)
# Move forward with backlash parameters
# Note: This should be self.myBDST, but since we don't move the motor AND
# the record uses the readback value, use "motorEndPos - motorStartPos"
delta = motorEndPos - motorStartPos
line2 = "move relative delta=%g max_velocity=%g acceleration=%g motorPosNow=%g" % \
(delta * frac, self.myBVEL, self.myBAR, motorStartPos)
else:
line1 = "move absolute position=%g max_velocity=%g acceleration=%g motorPosNow=%g" % \
(motorStartPos + delta, self.myVELO, self.myAR, motorStartPos)
# Move forward with backlash parameters
line2 = "move absolute position=%g max_velocity=%g acceleration=%g motorPosNow=%g" % \
(motorEndPos, self.myBVEL, self.myBAR, motorStartPos)
expFile.write('%s\n%s\n' % (line1, line2))
cnt += 1
def writeExpFileJOG_BDST(self, motor, tc_no, dbgFileName, expFileName,
myDirection, frac, encRel, motorStartPos,
motorEndPos):
# Create a "expected" file
expFile = open(expFileName, 'w')
# The jogging command
line1 = "move velocity axis_no=1 direction=%d max_velocity=%g acceleration=%g motorPosNow=%g" % \
(myDirection, self.myJVEL, self.myJAR, motorStartPos)
deltaForth = self.myBDST * frac
# The record tells us to go "delta * frac". Once we have travelled, we are too far
# The record will read that we are too far, and ask to go back "too far", overcompensated
# again with frac
deltaBack = deltaForth * frac
if encRel:
# Move back in relative mode
line2 = "move relative delta=%g max_velocity=%g acceleration=%g motorPosNow=%g" % \
(0 - deltaForth, self.myVELO, self.myAR, motorEndPos)
# Move relative forward with backlash parameters
line3 = "move relative delta=%g max_velocity=%g acceleration=%g motorPosNow=%g" % \
(deltaBack, self.myBVEL, self.myBAR, motorEndPos - deltaForth)
else:
# Move back in positioning mode
line2 = "move absolute position=%g max_velocity=%g acceleration=%g motorPosNow=%g" % \
(motorEndPos - self.myBDST, self.myVELO, self.myAR, motorEndPos)
# Move forward with backlash parameters
line3 = "move absolute position=%g max_velocity=%g acceleration=%g motorPosNow=%g" % \
(motorEndPos, self.myBVEL, self.myBAR, motorEndPos - self.myBDST)
expFile.write('%s\n%s\n%s\n' % (line1, line2, line3))
expFile.close()
def cmpUnlinkExpectedActualFile(self, dbgFileName, expFileName,
actFileName):
# compare actual and expFile
sameContent = filecmp.cmp(expFileName, actFileName, shallow=False)
if not sameContent:
file = open(expFileName, 'r')
for line in file:
if line[-1] == '\n':
line = line[0:-1]
print("%s: %s" % (expFileName, str(line)))
file.close()
file = open(actFileName, 'r')
for line in file:
if line[-1] == '\n':
line = line[0:-1]
print("%s: %s" % (actFileName, str(line)))
file.close()
assert (sameContent)
elif dbgFileName == None:
unlinkOK = True
try:
os.unlink(expFileName)
except:
unlinkOK = False
e = sys.exc_info()
print str(e)
try:
os.unlink(actFileName)
except:
unlinkOK = False
e = sys.exc_info()
print str(e)
assert (unlinkOK)
def setSoftLimitsOff(self, motor):
"""
Switch off the soft limits
"""
# switch off the controller soft limits
try:
epics.caput(motor + '-CfgDHLM-En', 0, wait=True, timeout=2)
epics.caput(motor + '-CfgDLLM-En', 0, wait=True, timeout=2)
finally:
oldRBV = epics.caget(motor + '.RBV')
if oldRBV > 0:
epics.caput(motor + '.LLM', 0.0)
epics.caput(motor + '.HLM', 0.0)
else:
epics.caput(motor + '.HLM', 0.0)
epics.caput(motor + '.LLM', 0.0)
def setSoftLimitsOn(self, motor, low_limit, high_limit):
"""
Set the soft limits
"""
# switch on the controller soft limits
try:
epics.caput(motor + '-CfgDHLM-En', 1, wait=True, timeout=2)
epics.caput(motor + '-CfgDLLM-En', 1, wait=True, timeout=2)
finally:
oldRBV = epics.caget(motor + '.RBV')
if oldRBV < 0:
epics.caput(motor + '.LLM', low_limit)
epics.caput(motor + '.HLM', high_limit)
else:
epics.caput(motor + '.HLM', high_limit)
epics.caput(motor + '.LLM', low_limit)
def doSTUPandSYNC(self, motor, tc_no):
stup = epics.caget(motor + '.STUP', use_monitor=False)
while stup != 0:
stup = epics.caget(motor + '.STUP', use_monitor=False)
print '%s .STUP=%s' % (tc_no, stup)
time.sleep(polltime)
epics.caput(motor + '.STUP', 1)
epics.caput(motor + '.SYNC', 1)
rbv = epics.caget(motor + '.RBV', use_monitor=False)
print '%s .RBV=%f .STUP=%s' % (tc_no, rbv, stup)
while stup != 0:
stup = epics.caget(motor + '.STUP', use_monitor=False)
rbv = epics.caget(motor + '.RBV', use_monitor=False)
print '%s .RBV=%f .STUP=%s' % (tc_no, rbv, stup)
time.sleep(polltime)
class Test(unittest.TestCase):
lib = motor_lib()
__g = motor_globals()
motor = os.getenv("TESTEDMOTORAXIS")
hlm = epics.caget(motor + '.HLM')
llm = epics.caget(motor + '.LLM')
per10_UserPosition = round((9 * llm + 1 * hlm) / 10)
per20_UserPosition = round((8 * llm + 2 * hlm) / 10)
msta = int(epics.caget(motor + '.MSTA'))
accs = epics.caget(motor + '.ACCS')
homedAndPwrAndACCS = (accs != None) and (msta & lib.MSTA_BIT_HOMED) and (
msta & lib.MSTA_BIT_AMPON)
# Assert that motor is homed and has the ACCS field
def test_TC_411(self):
motor = self.motor
tc_no = "TC-411"
if not (self.homedAndPwrAndACCS):
self.assertNotEqual(self.msta & self.lib.MSTA_BIT_HOMED, 0,
'Axis has been homed')
self.assertNotEqual(self.msta & self.lib.MSTA_BIT_AMPON, 0,
'Amplifier is on')
self.assertNotEqual(self.accs, None, 'ACCS field in record')
self.lib.initializeMotorRecordSimulatorAxis(motor, '411')
# 10% dialPosition
def test_TC_412(self):
tc_no = "TC-412-10-percent"
print '%s' % tc_no
motor = self.motor
if (self.msta & self.lib.MSTA_BIT_HOMED):
ret = self.lib.move(self.motor, self.per10_UserPosition, 60)
assert (ret == 0)
def test_TC_41311(self):
tc_no = "TC-41311"
print '%s' % tc_no
motor = self.motor
if (self.homedAndPwrAndACCS):
# vbas, velo. accl, accs, expAccEGU
check_VBAS_VELO_ACCL_ACCS_accEGU(self, motor, tc_no, 0, 6.0, 0.2,
-1, 30)
def test_TC_41312(self):
tc_no = "TC-41312"
print '%s' % tc_no
motor = self.motor
if (self.homedAndPwrAndACCS):
# vbas, velo. accl, accs, expAccEGU
check_VBAS_VELO_ACCL_ACCS_accEGU(self, motor, tc_no, 1, 2.0, 0.2,
-1, 5)
def test_TC_41313(self):
tc_no = "TC-41313"
print '%s' % tc_no
motor = self.motor
if (self.homedAndPwrAndACCS):
# vbas, velo. accl, accs, expAccEGU
check_VBAS_VELO_ACCL_ACCS_accEGU(self, motor, tc_no, 1, 2.0, 0.4,
-1, 2.5)
def test_TC_41314(self):
tc_no = "TC-41314"
print '%s' % tc_no
motor = self.motor
if (self.homedAndPwrAndACCS):
# vbas, velo. accl, accs, expAccEGU
check_VBAS_VELO_ACCL_ACCS_accEGU(self, motor, tc_no, 4.0, 4.0, 0.5,
-1, 8.0)
def test_TC_41315(self):
tc_no = "TC-41315"
print '%s' % tc_no
motor = self.motor
if (self.homedAndPwrAndACCS):
# vbas, velo. accl, accs, expAccEGU
check_VBAS_VELO_ACCL_ACCS_accEGU(self, motor, tc_no, 0.0, 8.0, 0.5,
-1, 16.0)
def test_TC_41316(self):
tc_no = "TC-41316"
print '%s' % tc_no
motor = self.motor
if (self.homedAndPwrAndACCS):
# vbas, velo. accl, accs, expAccEGU
check_VBAS_VELO_ACCL_ACCS_accEGU(self, motor, tc_no, 0.0, 8.0,
-1.0, 16.0, 16.0)
# Keep ACCS and expAccEGU if velociy is changed
def test_TC_41317(self):
tc_no = "TC-41317"
print '%s' % tc_no
motor = self.motor
if (self.homedAndPwrAndACCS):
# vbas, velo. accl, accs, expAccEGU
check_VBAS_VELO_ACCL_ACCS_accEGU(self, motor, tc_no, 0.0, 4.0,
-1.0, -1.0, 16.0)
class Test(unittest.TestCase):
lib = motor_lib()
__g = motor_globals()
motor = os.getenv("TESTEDMOTORAXIS")
hlm = epics.caget(motor + '.HLM')
llm = epics.caget(motor + '.LLM')
per90_UserPosition = round((1 * llm + 9 * hlm) / 10)
range_postion = hlm - llm
msta = int(epics.caget(motor + '.MSTA'))
print 'llm=%f hlm=%f per90_UserPosition=%f' % (llm, hlm,
per90_UserPosition)
# Assert that motor is homed
def test_TC_1231(self):
motor = self.motor
tc_no = "TC-1231"
if not (self.msta & self.lib.MSTA_BIT_HOMED):
self.assertNotEqual(0, self.msta & self.lib.MSTA_BIT_HOMED,
'MSTA.homed (Axis has been homed)')
self.lib.initializeMotorRecordSimulatorAxis(motor, '1231')
# per90 UserPosition
def test_TC_1232(self):
motor = self.motor
if (self.msta & self.lib.MSTA_BIT_HOMED):
tc_no = "TC-1232-90-percent-UserPosition"
print '%s' % tc_no
destination = self.per90_UserPosition
res = self.lib.move(motor, destination, 60)
UserPosition = epics.caget(motor + '.RBV', use_monitor=False)
print '%s postion=%f per90_UserPosition=%f' % (
tc_no, UserPosition, self.per90_UserPosition)
self.assertEqual(res, self.__g.SUCCESS, 'move returned SUCCESS')
# High soft limit in controller when using MoveVel
def test_TC_1233(self):
motor = self.motor
if (self.msta & self.lib.MSTA_BIT_HOMED):
tc_no = "TC-1233-high-soft-limit MoveVel"
print '%s' % tc_no
jar = epics.caget(motor + '.JAR')
epics.caput(motor + '-ACCS', jar)
jvel = epics.caget(motor + '.JVEL')
res = epics.caput(motor + '-MoveVel', jvel)
if (res == None):
print '%s caput -MoveVel res=None' % (tc_no)
self.assertNotEqual(
res, None,
'caput -MoveVel retuned not None. PV not found ?')
else:
print '%s caput -MoveVel res=%d' % (tc_no, res)
self.assertEqual(res, 1, 'caput -MoveVel returned 1')
time_to_wait = 180
done = self.lib.waitForStartAndDone(motor, tc_no, time_to_wait)
msta = int(epics.caget(motor + '.MSTA'))
miss = int(epics.caget(motor + '.MISS'))
if (msta & self.lib.MSTA_BIT_PROBLEM):
epics.caput(motor + '-ErrRst', 1)
self.assertEqual(0, msta & self.lib.MSTA_BIT_MINUS_LS,
'DLY Minus hard limit not reached MoveVel')
self.assertEqual(0, msta & self.lib.MSTA_BIT_PLUS_LS,
'DLY Plus hard limit not reached MoveVel')
self.assertEqual(0, miss, 'DLY MISS not set MoveVel')
class Test(unittest.TestCase):
lib = motor_lib()
__g = motor_globals()
motor = os.getenv("TESTEDMOTORAXIS")
hlm = epics.caget(motor + '.HLM')
llm = epics.caget(motor + '.LLM')
per10_UserPosition = round((9 * llm + 1 * hlm) / 10)
per20_UserPosition = round((8 * llm + 2 * hlm) / 10)
msta = int(epics.caget(motor + '.MSTA'))
def getAcceleration(self, motor, tc_no):
print '%s: getAcceleration %s' % (tc_no, motor)
res = epics.caget(motor + '-Acc-RB', use_monitor=False)
return res
# Assert that motor is homed
def test_TC_401(self):
motor = self.motor
tc_no = "TC-401"
if not (self.msta & self.lib.MSTA_BIT_HOMED):
self.assertNotEqual(0, self.msta & self.lib.MSTA_BIT_HOMED,
'MSTA.homed (Axis has been homed)')
self.lib.initializeMotorRecordSimulatorAxis(motor, '1211')
# 10% dialPosition
def test_TC_402(self):
tc_no = "TC-402-10-percent"
print '%s' % tc_no
motor = self.motor
if (self.msta & self.lib.MSTA_BIT_HOMED):
ret = self.lib.move(self.motor, self.per10_UserPosition, 60)
assert (ret == 0)
# 20% dialPosition
def test_TC_403(self):
tc_no = "TC-403-20-percent"
print '%s' % tc_no
motor = self.motor
if (self.msta & self.lib.MSTA_BIT_HOMED):
saved_ACCL = float(epics.caget(motor + '.ACCL'))
saved_VELO = float(epics.caget(motor + '.VELO'))
used_ACCL = saved_ACCL + 1.0 # Make sure we have an acceleration != 0
epics.caput(motor + '.ACCL', used_ACCL)
ret = self.lib.move(self.motor, self.per20_UserPosition, 60)
resacc = self.getAcceleration(motor, tc_no)
expacc = saved_VELO / used_ACCL
epics.caput(motor + '.ACCL', saved_ACCL)
print '%s ACCL=%f expacc=%f resacc=%f' % (tc_no, used_ACCL, expacc,
resacc)
assert self.lib.calcAlmostEqual(self.motor, tc_no, expacc, resacc,
2)
assert (ret == 0)
# JOGR
def test_TC_404(self):
tc_no = "TC-404-JOGR"
print '%s' % tc_no
motor = self.motor
if (self.msta & self.lib.MSTA_BIT_HOMED):
accl = float(epics.caget(motor + '.ACCL'))
jvel = float(epics.caget(motor + '.JVEL'))
saved_JAR = float(epics.caget(motor + '.JAR'))
used_JAR = jvel / (accl + 2.0)
epics.caput(motor + '.JAR', used_JAR)
epics.caput(motor + '.JOGR', 1, wait=True)
resacc = self.getAcceleration(motor, tc_no)
expacc = used_JAR
epics.caput(motor + '.JAR', saved_JAR)
print '%s JAR=%f expacc=%f resacc=%f' % (tc_no, used_JAR, expacc,
resacc)
assert self.lib.calcAlmostEqual(self.motor, tc_no, expacc, resacc,
2)
#!/usr/bin/env python
import epics
import unittest
import os
import sys
import math
import time
from motor_lib import motor_lib
from motor_globals import motor_globals
__g = motor_globals()
###
def getAccEGUfromMCU(self, motor, tc_no):
print '%s: getAccEGUfromMCU %s' % (tc_no, motor)
res = epics.caget(motor + '-Acc-RB', use_monitor=False)
return res
def check_VBAS_VELO_ACCL_ACCS_accEGU(self, motor, tc_no, vbas, velo, accl,
accs, expAccEGU):
# Put the values which the test case wanted
if vbas > -1:
epics.caput(motor + '.VBAS', vbas)
if velo > -1:
epics.caput(motor + '.VELO', velo)
if accl > -1:
epics.caput(motor + '.ACCL', accl)
class motor_lib(object):
"""
Library of useful test functions for motor record applications
"""
__g = motor_globals()
MSTA_BIT_HOMED = 1 << (15 - 1) #4000
MSTA_BIT_MINUS_LS = 1 << (14 - 1) #2000
MSTA_BIT_COMM_ERR = 1 << (13 - 1) #1000
MSTA_BIT_GAIN_SUPPORT = 1 << (12 - 1) #0800
MSTA_BIT_MOVING = 1 << (11 - 1) #0400
MSTA_BIT_PROBLEM = 1 << (10 - 1) #0200
MSTA_BIT_PRESENT = 1 << (9 - 1) #0100
MSTA_BIT_HOME = 1 << (8 - 1) #0080
MSTA_BIT_SLIP_STALL = 1 << (7 - 1) #0040
MSTA_BIT_AMPON = 1 << (6 - 1) #0020
MSTA_BIT_UNUSED = 1 << (5 - 1) #0010
MSTA_BIT_HOMELS = 1 << (4 - 1) #0008
MSTA_BIT_PLUS_LS = 1 << (3 - 1) #0004
MSTA_BIT_DONE = 1 << (2 - 1) #0002
MSTA_BIT_DIRECTION = 1 << (1 - 1) #0001
def getMSTAtext(self, msta):
ret = ''
if (msta & self.MSTA_BIT_HOMED):
ret = ret + 'Hmd'
else:
ret = ret + '...'
if (msta & self.MSTA_BIT_MINUS_LS):
ret = ret + 'Lls'
else:
ret = ret + '...'
#if (msta & self.MSTA_BIT_GAIN_SUPPORT):
# ret = ret + 'G'
#else:
# ret = ret +'.'
if (msta & self.MSTA_BIT_MOVING):
ret = ret + 'Mov'
else:
ret = ret + '...'
if (msta & self.MSTA_BIT_PROBLEM):
ret = ret + 'Prb'
else:
ret = ret + '.'
if (msta & self.MSTA_BIT_PRESENT):
ret = ret + 'Enc'
else:
ret = ret + '...'
if (msta & self.MSTA_BIT_HOME):
ret = ret + 'Hom'
else:
ret = ret + '..'
if (msta & self.MSTA_BIT_SLIP_STALL):
ret = ret + 'Slp'
else:
ret = ret + '....'
if (msta & self.MSTA_BIT_AMPON):
ret = ret + 'Amp'
else:
ret = ret + '...'
if (msta & self.MSTA_BIT_HOMELS):
ret = ret + 'Hsw'
else:
ret = ret + '...'
if (msta & self.MSTA_BIT_PLUS_LS):
ret = ret + 'Hls'
else:
ret = ret + '...'
if (msta & self.MSTA_BIT_DONE):
ret = ret + 'Don'
else:
ret = ret + '...'
return ret
def calcAlmostEqual(self, motor, tc_no, expected, actual, maxdelta):
delta = math.fabs(expected - actual)
inrange = delta < maxdelta
print '%s: assertAlmostEqual expected=%f actual=%f delta=%f maxdelta=%f inrange=%d' % (
tc_no, expected, actual, delta, maxdelta, inrange)
return inrange
def waitForStart(self, motor, tc_no, wait_for_start):
while wait_for_start > 0:
wait_for_start -= polltime
dmov = int(epics.caget(motor + '.DMOV', use_monitor=False))
movn = int(epics.caget(motor + '.MOVN', use_monitor=False))
rbv = epics.caget(motor + '.RBV')
print '%s: wait_for_start=%f dmov=%d movn=%d rbv=%f' % (
tc_no, wait_for_start, dmov, movn, rbv)
if movn and not dmov:
return True
time.sleep(polltime)
wait_for_start -= polltime
return False
def waitForStop(self, motor, tc_no, wait_for_stop):
while wait_for_stop > 0:
wait_for_stop -= polltime
dmov = int(epics.caget(motor + '.DMOV', use_monitor=False))
movn = int(epics.caget(motor + '.MOVN', use_monitor=False))
rbv = epics.caget(motor + '.RBV', use_monitor=False)
print '%s: wait_for_stop=%f dmov=%d movn=%d rbv=%f' % (
tc_no, wait_for_stop, dmov, movn, rbv)
if not movn and dmov:
return True
time.sleep(polltime)
wait_for_stop -= polltime
return False
def waitForStartAndDone(self, motor, tc_no, wait_for_done):
wait_for_start = 2
while wait_for_start > 0:
wait_for_start -= polltime
dmov = int(caget(motor + '.DMOV'))
movn = int(caget(motor + '.MOVN'))
print '%s: wait_for_start=%f dmov=%d movn=%d dpos=%f' % (
tc_no, wait_for_start, dmov, movn,
caget(motor + '.DRBV', use_monitor=False))
if movn and not dmov:
break
time.sleep(polltime)
wait_for_done = math.fabs(wait_for_done) #negative becomes positive
wait_for_done += 1 # One extra second for rounding
while wait_for_done > 0:
dmov = int(caget(motor + '.DMOV'))
movn = int(caget(motor + '.MOVN'))
print '%s: wait_for_done=%f dmov=%d movn=%d dpos=%f' % (
tc_no, wait_for_done, dmov, movn,
caget(motor + '.DRBV', use_monitor=False))
if dmov and not movn:
return True
time.sleep(polltime)
wait_for_done -= polltime
return False
def testComplete(self, fail):
"""
Function to be called at end of test
fail = true or false
"""
if not fail:
print "Test Complete"
return self.__g.SUCCESS
else:
print "Test Failed"
return self.__g.FAIL
def jogDirection(self, motor, tc_no, direction, time_to_wait):
if direction > 0:
epics.caput(motor + '.JOGF', 1)
else:
epics.caput(motor + '.JOGR', 1)
done = self.waitForStartAndDone(motor, tc_no + " jogDirection",
30 + time_to_wait + 3.0)
if direction > 0:
epics.caput(motor + '.JOGF', 0)
else:
epics.caput(motor + '.JOGR', 0)
def move(self, motor, position, timeout):
"""
Move motor to position. We use put_callback
and check final position is within RDBD.
"""
try:
caput(motor, position, wait=True, timeout=timeout)
except:
e = sys.exc_info()
print str(e)
print "ERROR: caput failed."
print(motor + " pos:" + str(position) + " timeout:" + str(timeout))
return self.__g.FAIL
rdbd = motor + ".RDBD"
rbv = motor + ".RBV"
final_pos = caget(rbv)
deadband = caget(rdbd)
success = True
if ((final_pos < position - deadband)
or (final_pos > position + deadband)):
print "ERROR: final_pos out of deadband."
print(motor + " " + str(position) + " " + str(timeout) + " " +
str(final_pos) + " " + str(deadband))
success = False
if (success):
return self.postMoveCheck(motor)
else:
self.postMoveCheck(motor)
return self.__g.FAIL
def movePosition(self, motor, tc_no, destination, velocity, acceleration):
time_to_wait = 30
if velocity > 0:
distance = math.fabs(caget(motor + '.RBV') - destination)
time_to_wait += distance / velocity + 2 * acceleration
caput(motor + '.VAL', destination)
done = self.waitForStartAndDone(motor, tc_no + " movePosition",
time_to_wait)
def setPosition(self, motor, position, timeout):
"""
Set position on motor and check it worked ok.
"""
_set = motor + ".SET"
_rbv = motor + ".RBV"
_dval = motor + ".DVAL"
_off = motor + ".OFF"
offset = caget(_off)
caput(_set, 1, wait=True, timeout=timeout)
caput(_dval, position, wait=True, timeout=timeout)
caput(_off, offset, wait=True, timeout=timeout)
caput(_set, 0, wait=True, timeout=timeout)
if (self.postMoveCheck(motor) != self.__g.SUCCESS):
return self.__g.FAIL
try:
self.verifyPosition(motor, position + offset)
except Exception as e:
print str(e)
return self.__g.FAIL
def checkInitRecord(self, motor):
"""
Check the record for correct state at start of test.
"""
self.postMoveCheck()
def verifyPosition(self, motor, position):
"""
Verify that field == reference.
"""
_rdbd = motor + ".RDBD"
deadband = caget(_rdbd)
_rbv = motor + ".RBV"
current_pos = caget(_rbv)
if ((current_pos < position - deadband)
or (current_pos > position + deadband)):
print "ERROR: final_pos out of deadband."
msg = (motor + " " + str(position) + " " + str(current_pos) + " " +
str(deadband))
raise Exception(__name__ + msg)
return self.__g.SUCCESS
def verifyField(self, pv, field, reference):
"""
Verify that field == reference.
"""
full_pv = pv + "." + field
if (caget(full_pv) != reference):
msg = "ERROR: " + full_pv + " not equal to " + str(reference)
raise Exception(__name__ + msg)
return self.__g.SUCCESS
def postMoveCheck(self, motor):
"""
Check the motor for the correct state at the end of move.
"""
DMOV = 1
MOVN = 0
STAT = 0
SEVR = 0
LVIO = 0
MISS = 0
RHLS = 0
RLLS = 0
try:
self.verifyField(motor, "DMOV", DMOV)
self.verifyField(motor, "MOVN", MOVN)
self.verifyField(motor, "STAT", STAT)
self.verifyField(motor, "SEVR", SEVR)
self.verifyField(motor, "LVIO", LVIO)
self.verifyField(motor, "MISS", MISS)
self.verifyField(motor, "RHLS", RHLS)
self.verifyField(motor, "RLLS", RLLS)
except Exception as e:
print str(e)
return self.__g.FAIL
return self.__g.SUCCESS
def cmpUnlinkExpectedActualFile(self, expFileName, actFileName):
# compare actual and expFile
sameContent = filecmp.cmp(expFileName, actFileName, shallow=False)
if not sameContent:
file = open(expFileName, 'r')
for line in file:
if line[-1] == '\n':
line = line[0:-1]
print("%s: %s" % (expFileName, str(line)))
file.close()
file = open(actFileName, 'r')
for line in file:
if line[-1] == '\n':
line = line[0:-1]
print("%s: %s" % (actFileName, str(line)))
file.close()
assert (sameContent)
else:
unlinkOK = True
try:
os.unlink(expFileName)
except:
unlinkOK = False
e = sys.exc_info()
print str(e)
try:
os.unlink(actFileName)
except:
unlinkOK = False
e = sys.exc_info()
print str(e)
assert (unlinkOK)
def setSoftLimitsOff(self, motor):
"""
Switch off the soft limits
"""
# switch off the controller soft limits
try:
epics.caput(motor + '-CHLM-En', 0, wait=True)
epics.caput(motor + '-CLLM-En', 0, wait=True)
finally:
oldRBV = epics.caget(motor + '.RBV')
if oldRBV > 0:
epics.caput(motor + '.LLM', 0.0)
epics.caput(motor + '.HLM', 0.0)
else:
epics.caput(motor + '.HLM', 0.0)
epics.caput(motor + '.LLM', 0.0)
class Test(unittest.TestCase):
lib = motor_lib()
__g = motor_globals()
motor = os.getenv("TESTEDMOTORAXIS")
hlm = epics.caget(motor + '.HLM')
llm = epics.caget(motor + '.LLM')
per10_UserPosition = round((9 * llm + 1 * hlm) / 10)
range_postion = hlm - llm
msta = int(epics.caget(motor + '.MSTA'))
print 'llm=%f hlm=%f per10_UserPosition=%f' % (llm, hlm, per10_UserPosition)
# Assert that motor is homed
def test_TC_1341(self):
motor = self.motor
tc_no = "TC-1341"
if not (self.msta & self.lib.MSTA_BIT_HOMED):
self.assertNotEqual(0, self.msta & self.lib.MSTA_BIT_HOMED, 'MSTA.homed (Axis has been homed)')
self.lib.initializeMotorRecordSimulatorAxis(motor, '1341')
# per10 UserPosition
def test_TC_1342(self):
motor = self.motor
if (self.msta & self.lib.MSTA_BIT_HOMED):
tc_no = "TC-1342-90-percent-UserPosition"
print '%s' % tc_no
destination = self.per10_UserPosition
res = self.lib.move(motor, destination, 60)
UserPosition = epics.caget(motor + '.RBV', use_monitor=False)
print '%s postion=%f per10_UserPosition=%f' % (
tc_no, UserPosition, self.per10_UserPosition)
self.assertEqual(res, self.__g.SUCCESS, 'move returned SUCCESS')
# Low soft limit in controller when using MoveAbs
def test_TC_1343(self):
motor = self.motor
if (self.msta & self.lib.MSTA_BIT_HOMED):
tc_no = "TC-1343-low-soft-limit Moveabs"
print '%s' % tc_no
drvUseEGU = epics.caget(motor + '-DrvUseEGU-RB')
if drvUseEGU == 1:
mres = 1.0
else:
mres = epics.caget(motor + '.MRES')
rbv = epics.caget(motor + '.RBV')
jar = epics.caget(motor + '.JAR')
epics.caput(motor + '-ACCS', jar/mres)
jvel = epics.caget(motor + '.JVEL')
epics.caput(motor + '-VELO', jvel/mres)
jvel = epics.caget(motor + '.JVEL')
res = epics.caput(motor + '-MoveAbs', (self.llm - 1) / mres)
if (res == None):
print '%s caput -Moveabs res=None' % (tc_no)
self.assertNotEqual(res, None, 'caput -Moveabs retuned not None. PV not found ?')
else:
print '%s caput -Moveabs res=%d' % (tc_no, res)
self.assertEqual(res, 1, 'caput -Moveabs returned 1')
time_to_wait = 180
done = self.lib.waitForStartAndDone(motor, tc_no, time_to_wait)
msta = int(epics.caget(motor + '.MSTA'))
miss = int(epics.caget(motor + '.MISS'))
success = self.lib.verifyPosition(motor, rbv)
if (msta & self.lib.MSTA_BIT_PROBLEM):
epics.caput(motor + '-ErrRst', 1)
self.assertEqual(success, self.__g.SUCCESS, 'verifyPosition returned SUCCESS')
self.assertEqual(0, msta & self.lib.MSTA_BIT_MINUS_LS, 'DLY Minus hard limit not reached Moveabs')
self.assertEqual(0, msta & self.lib.MSTA_BIT_PLUS_LS, 'DLY Plus hard limit not reached Moveabs')
self.assertEqual(0, miss, 'DLY MISS not set Moveabs')
#!/usr/bin/env python
import unittest
import os
import sys
import math
import time
from motor_lib import motor_lib
lib = motor_lib()
from motor_globals import motor_globals
globals = motor_globals()
import capv_lib
###
polltime = 0.2
class Test(unittest.TestCase):
motor = os.getenv("TESTEDMOTORAXIS")
capv_lib.capvput(motor + '-DbgStrToLOG',
"Start " + os.path.basename(__file__)[0:20])
hlm = capv_lib.capvget(motor + '.HLM')
llm = capv_lib.capvget(motor + '.LLM')
per10_UserPosition = round((9 * llm + 1 * hlm) / 10)
per20_UserPosition = round((8 * llm + 2 * hlm) / 10)
msta = int(capv_lib.capvget(motor + '.MSTA'))
def getAcceleration(self, motor, tc_no):
class Test(unittest.TestCase):
lib = motor_lib()
__g = motor_globals()
motor = os.getenv("TESTEDMOTORAXIS")
saved_DLY = epics.caget(motor + '.DLY')
hlm = epics.caget(motor + '.HLM')
llm = epics.caget(motor + '.LLM')
per90_UserPosition = round((1 * llm + 9 * hlm) / 10)
range_postion = hlm - llm
msta = int(epics.caget(motor + '.MSTA'))
print 'llm=%f hlm=%f per90_UserPosition=%f' % (llm, hlm,
per90_UserPosition)
# Assert that motor is homed
def test_TC_1211(self):
motor = self.motor
tc_no = "TC-1211"
if not (self.msta & self.lib.MSTA_BIT_HOMED):
self.assertNotEqual(0, self.msta & self.lib.MSTA_BIT_HOMED,
'MSTA.homed (Axis has been homed)')
self.lib.initializeMotorRecordSimulatorAxis(motor, '1211')
# per90 UserPosition
def test_TC_1212(self):
motor = self.motor
if (self.msta & self.lib.MSTA_BIT_HOMED):
tc_no = "TC-1212-90-percent-UserPosition"
print '%s' % tc_no
destination = self.per90_UserPosition
res = self.lib.move(motor, destination, 60)
UserPosition = epics.caget(motor + '.RBV', use_monitor=False)
print '%s postion=%f per90_UserPosition=%f' % (
tc_no, UserPosition, self.per90_UserPosition)
self.assertNotEqual(res == self.__g.SUCCESS,
'move returned SUCCESS')
# High soft limit JOGF
def test_TC_1213(self):
motor = self.motor
if (self.msta & self.lib.MSTA_BIT_HOMED):
tc_no = "TC-1213-low-soft-limit JOGF"
print '%s' % tc_no
epics.caput(motor + '.DLY', 1.0)
epics.caput(motor + '.JOGF', 1, wait=True)
lvio = int(epics.caget(motor + '.LVIO'))
msta = int(epics.caget(motor + '.MSTA'))
miss = int(epics.caget(motor + '.MISS'))
epics.caput(motor + '.DLY', self.saved_DLY)
epics.caput(motor + '.JOGF', 0)
self.assertEqual(0, msta & self.lib.MSTA_BIT_PROBLEM,
'DLY No MSTA.Problem JOGF')
self.assertEqual(0, msta & self.lib.MSTA_BIT_MINUS_LS,
'DLY Minus hard limit not reached JOGF')
self.assertEqual(0, msta & self.lib.MSTA_BIT_PLUS_LS,
'DLY Plus hard limit not reached JOGF')
self.assertEqual(0, miss, 'DLY MISS not set JOGF')
self.assertEqual(1, lvio, 'LVIO == 1 JOGF')
# per90 UserPosition
def test_TC_1214(self):
motor = self.motor
if (self.msta & self.lib.MSTA_BIT_HOMED):
tc_no = "TC-1214-90-percent-UserPosition"
print '%s' % tc_no
destination = self.per90_UserPosition
res = self.lib.move(motor, destination, 60)
UserPosition = epics.caget(motor + '.RBV', use_monitor=False)
print '%s postion=%f per90_UserPosition=%f' % (
tc_no, UserPosition, self.per90_UserPosition)
self.assertNotEqual(res == self.__g.SUCCESS,
'move returned SUCCESS')
def test_TC_1215(self):
motor = self.motor
if (self.msta & self.lib.MSTA_BIT_HOMED):
tc_no = "TC-1215-high-soft-limit JOGF"
print '%s' % tc_no
epics.caput(motor + '.DLY', 0.0)
epics.caput(motor + '.JOGF', 1, wait=True)
lvio = int(epics.caget(motor + '.LVIO'))
msta = int(epics.caget(motor + '.MSTA'))
miss = int(epics.caget(motor + '.MISS'))
epics.caput(motor + '.DLY', self.saved_DLY)
epics.caput(motor + '.JOGF', 0)
resW = self.lib.waitForMipZero(motor, tc_no, self.saved_DLY)
self.assertEqual(0, msta & self.lib.MSTA_BIT_PROBLEM,
'ndly No MSTA.Problem JOGF')
self.assertEqual(0, msta & self.lib.MSTA_BIT_MINUS_LS,
'ndly Minus hard limit not reached JOGF')
self.assertEqual(0, msta & self.lib.MSTA_BIT_PLUS_LS,
'ndly Plus hard limit not reached JOGF')
self.assertEqual(0, miss, 'ndly MISS not set JOGF')
self.assertEqual(1, resW, 'ndly resW')
self.assertEqual(1, lvio, 'LVIO == 1 JOGF')
def test_TC_12152(self):
motor = self.motor
if (self.msta & self.lib.MSTA_BIT_HOMED):
tc_no = "TC-12152-high-soft-limit JOGF"
print '%s' % tc_no
epics.caput(motor + '.DLY', 0.0)
mip1 = int(epics.caget(motor + '.MIP'))
epics.caput(motor + '.JOGF', 1, wait=True)
lvio = int(epics.caget(motor + '.LVIO'))
msta = int(epics.caget(motor + '.MSTA'))
miss = int(epics.caget(motor + '.MISS'))
resW = self.lib.waitForMipZero(motor, tc_no, self.saved_DLY)
mip2 = int(epics.caget(motor + '.MIP'))
jogf = int(epics.caget(motor + '.JOGF'))
epics.caput(motor + '.DLY', self.saved_DLY)
print '%s mip1=%x mip2=%x' % (tc_no, mip1, mip2)
self.assertEqual(0, msta & self.lib.MSTA_BIT_PROBLEM,
'ndly2 No MSTA.Problem JOGF')
self.assertEqual(0, msta & self.lib.MSTA_BIT_MINUS_LS,
'ndly2 Minus hard limit not reached JOGF')
self.assertEqual(0, msta & self.lib.MSTA_BIT_PLUS_LS,
'ndly2 Plus hard limit not reached JOGF')
self.assertEqual(0, miss, 'ndly2 MISS not set JOGF')
self.assertEqual(0, mip1, 'ndly2 MIP1 not set JOGF')
self.assertEqual(0, mip2 & self.lib.MIP_BIT_JOGF,
'ndly2 MIP2.JOGF not set JOGF')
#self.assertEqual(1, resW, 'ndly1 JOGF not set')
self.assertEqual(0, jogf, 'ndly2 MIP1 not set JOGF')
self.assertEqual(1, lvio, 'LVIO == 1 JOGF')
# per90 UserPosition
def test_TC_1216(self):
motor = self.motor
if (self.msta & self.lib.MSTA_BIT_HOMED):
tc_no = "TC-1216-90-percent-UserPosition"
print '%s' % tc_no
destination = self.per90_UserPosition
res = self.lib.move(motor, destination, 60)
UserPosition = epics.caget(motor + '.RBV', use_monitor=False)
print '%s postion=%f per90_UserPosition=%f' % (
tc_no, UserPosition, self.per90_UserPosition)
self.assertNotEqual(res == self.__g.SUCCESS,
'move returned SUCCESS')
# High soft limit JOGR + DIR
def test_TC_1217(self):
motor = self.motor
if (self.msta & self.lib.MSTA_BIT_HOMED):
tc_no = "TC-1217-low-soft-limit JOGF DIR"
print '%s' % tc_no
saved_DIR = epics.caget(motor + '.DIR')
saved_FOFF = epics.caget(motor + '.FOFF')
epics.caput(motor + '.FOFF', 1)
epics.caput(motor + '.DIR', 1)
epics.caput(motor + '.JOGR', 1, wait=True)
lvio = int(epics.caget(motor + '.LVIO'))
msta = int(epics.caget(motor + '.MSTA'))
### commit 4efe15e76cefdc060e14dbc3 needed self.assertEqual(1, lvio, 'LVIO == 1 JOGF')
epics.caput(motor + '.JOGF', 0)
epics.caput(motor + '.DIR', saved_DIR)
epics.caput(motor + '.FOFF', saved_FOFF)
self.assertEqual(0, msta & self.lib.MSTA_BIT_PROBLEM,
'No Error MSTA.Problem JOGF DIR')
self.assertEqual(0, msta & self.lib.MSTA_BIT_MINUS_LS,
'Minus hard limit not reached JOGF DIR')
self.assertEqual(0, msta & self.lib.MSTA_BIT_PLUS_LS,
'Plus hard limit not reached JOGF DIR')
