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:
capv_lib.capvput(motor + '.VBAS', vbas)
if velo > -1:
capv_lib.capvput(motor + '.VELO', velo)
if accl > -1:
capv_lib.capvput(motor + '.ACCL', accl)
if accs > -1:
capv_lib.capvput(motor + '.ACCS', accs)
# Move the motor 2 mm (hardcoded)
destination = 2.0 + capv_lib.capvget(motor + '.VAL')
res = lib.move(motor, destination, 60)
resAccEGU = getAccEGUfromMCU(self, motor, tc_no)
print('%s: check_accEGU_ACCS_ACCL_VELO %s vbas=%f velo=%f accl=%f accs=%f expAccEGU=%f resAccEGU=%f' % \
(tc_no, motor, vbas, velo, accl, accs, expAccEGU, resAccEGU))
actVelo = capv_lib.capvget(motor + '.VELO', use_monitor=False)
actAccl = capv_lib.capvget(motor + '.ACCL', use_monitor=False)
actAccs = capv_lib.capvget(motor + '.ACCS', use_monitor=False)
expAccs = actVelo / actAccl
expAccl = actVelo / actAccs
print('%s expAccl=%f expAccs=%f actVelo=%f actAccl=%f actAccs=%f' %
(tc_no, expAccl, expAccs, actVelo, actAccl, actAccs))
assert lib.calcAlmostEqual(self.motor, tc_no, expAccEGU, resAccEGU, 0.1)
self.assertEqual(res, globals.SUCCESS, 'move returned SUCCESS')
# Check if VELO, ACCL and ACCS are aligned
assert lib.calcAlmostEqual(self.motor, tc_no, expAccl, actAccl, 0.1)
assert lib.calcAlmostEqual(self.motor, tc_no, expAccs, actAccs, 0.1)
def jogDirection(self, motor, tc_no, direction):
jvel = capv_lib.capvget(motor + ".JVEL")
hlm = capv_lib.capvget(motor + ".HLM")
llm = capv_lib.capvget(motor + ".LLM")
rbv = capv_lib.capvget(motor + ".RBV")
accl = capv_lib.capvget(motor + '.ACCL')
deltah = math.fabs(hlm - rbv)
deltal = math.fabs(llm - rbv)
# TODO: we could use at the DIR field, which delta to use
# This can be done in a cleanup
if deltah > deltal:
delta = deltah
else:
delta = deltal
# TODO: add JAR to the calculation
time_to_wait = delta / jvel + 2 * accl + 2.0
if direction > 0:
capv_lib.capvput(motor + '.JOGF', 1)
else:
capv_lib.capvput(motor + '.JOGR', 1)
done = self.waitForStartAndDone(motor, tc_no + " jogDirection",
30 + time_to_wait + 3.0)
if direction > 0:
capv_lib.capvput(motor + '.JOGF', 0)
else:
capv_lib.capvput(motor + '.JOGR', 0)
print('%s: jogDirection done=%d' % (tc_no, done))
return done
def Xtest_TC_232(self):
motor = self.motor
motor2 = self.motor2
tc_no = "TC-232-NetYetStarted"
print('%s' % tc_no)
if (self.msta & lib.MSTA_BIT_HOMED):
setValueOnSimulator(self, motor2, tc_no, "usleep", 1700000)
destination = self.per90_UserPosition
res1 = lib.move(motor, destination, 60)
UserPosition = capv_lib.capvget(motor + '.RBV', use_monitor=False)
print('%s postion=%f per90_UserPosition=%f' %
(tc_no, UserPosition, self.per90_UserPosition))
destination = self.per10_UserPosition
res2 = lib.move(motor, destination, 60)
UserPosition = capv_lib.capvget(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 == globals.SUCCESS,
'move returned SUCCESS')
self.assertNotEqual(res2 == globals.SUCCESS,
'move returned SUCCESS')
def setAndReadBackParam(self, motor, tc_no, pvSuffix, paramInSimu):
pvname = motor + pvSuffix
valRB = capv_lib.capvget(pvname)
newVal = round(valRB + 1, 2)
print('%s:%d %s valRB=%f newVal=%f' %
(tc_no, lineno(), pvname, valRB, newVal))
lib.setValueOnSimulator(motor, tc_no, paramInSimu, newVal)
maxTime = 30 # 30 seconds maximum to poll all parameters
testPassed = False
maxDelta = math.fabs(newVal) * 0.02 # 2 % error tolerance margin
while maxTime > 0:
newValRB = capv_lib.capvget(pvname)
print('%s:%d %s newVal=%f newValRB=%f' %
(tc_no, lineno(), pvname, newVal, newValRB))
if lib.calcAlmostEqual(motor, tc_no, newVal, newValRB, maxDelta):
testPassed = True
maxTime = 0
else:
time.sleep(polltime)
maxTime = maxTime - polltime
# restore the original value
# Avoid overlong strings (and therefore not working with channel access)
# like "Sim.this.fAcceleration=2.0999999046325684"
lib.setValueOnSimulator(motor, tc_no, paramInSimu, round(valRB, 2))
assert (testPassed)
def test_TC_9402(self):
motor = self.motor
tc_no = "TC-9402-EnabledFailed"
capv_lib.capvput(motor + '.CNEN', 0, wait=True)
setValueOnSimulator(self, motor, tc_no, "bAmplifierLockedToBeOff",
AMPLIFIER_LOCKED_TO_BE_OFF_SILENT)
capv_lib.capvput(motor + '-PwrAuto', 0)
time.sleep(1.0)
capv_lib.capvput(motor + '.CNEN', 1, wait=True)
time.sleep(4.0)
mstaErr = int(capv_lib.capvget(motor + '.MSTA', use_monitor=False))
print('%s Error mstaErr=%s' % (tc_no, lib.getMSTAtext(mstaErr)))
capv_lib.capvput(motor + '-ErrRst',1)
setValueOnSimulator(self, motor, tc_no, "bAmplifierLockedToBeOff", 0)
mstaOKagain = int(capv_lib.capvget(motor + '.MSTA', use_monitor=False))
bError = capv_lib.capvget(motor + '-Err', use_monitor=False)
nErrorId = capv_lib.capvget(motor + '-ErrId', use_monitor=False)
print('%s Clean lib.MSTA_BIT_PROBLEM=%x mstaOKagain=%s bError=%d nErrorId=%d' % (tc_no, lib.MSTA_BIT_PROBLEM, lib.getMSTAtext(mstaOKagain), bError, nErrorId))
capv_lib.capvput(motor + '.CNEN', self.saved_CNEN)
capv_lib.capvput(motor + '-PwrAuto', self.saved_PwrAuto)
self.assertNotEqual(0, mstaErr & lib.MSTA_BIT_PROBLEM, 'Error MSTA.Problem should be set)')
self.assertEqual(0, mstaErr & lib.MSTA_BIT_SLIP_STALL, 'Error MSTA.Slip stall Error should not be set)')
self.assertEqual(0, mstaErr & lib.MSTA_BIT_MOVING, 'Error MSTA.Moving)')
self.assertEqual(0, mstaOKagain & lib.MSTA_BIT_MOVING, 'Clean MSTA.Moving)')
self.assertEqual(0, bError, 'bError')
self.assertEqual(0, nErrorId, 'nErrorId')
def test_TC_2402(self):
motor = self.motor
tc_no = "2402-JOGF_stopped"
print('%s' % tc_no)
if (self.msta & lib.MSTA_BIT_HOMED):
capv_lib.capvput(motor + '-DbgStrToLOG', "Start " + tc_no[0:20])
capv_lib.capvput(motor + '.DLY', 0)
destination = self.per10_UserPosition
done = lib.moveWait(motor, tc_no, destination)
UserPosition = capv_lib.capvget(motor + '.RBV', use_monitor=False)
print('%s postion=%f per10_UserPosition=%f' %
(tc_no, UserPosition, self.per90_UserPosition))
capv_lib.capvput(motor + '.JOGF', 1)
ret2 = lib.waitForStart(motor, tc_no, 2.0)
time.sleep(1)
capv_lib.capvput(motor + '-Stop', 1)
ret3 = lib.waitForStop(motor, tc_no, 2.0)
val = capv_lib.capvget(motor + '.VAL')
try:
res4 = lib.verifyPosition(motor, val)
except:
e = sys.exc_info()
print(str(e))
res4 = globals.FAIL
capv_lib.capvput(motor + '.DLY', self.saved_DLY)
capv_lib.capvput(motor + '-DbgStrToLOG', "End " + tc_no[0:20])
self.assertEqual(1, done, 'moveWait should return done')
self.assertEqual(res4, globals.SUCCESS, 'VAL synched with RBV')
def setSoftLimitsOff(self, motor):
"""
Switch off the soft limits
"""
# switch off the controller soft limits
try:
capv_lib.capvput(motor + '-CfgDHLM-En', 0, wait=True, timeout=2)
capv_lib.capvput(motor + '-CfgDLLM-En', 0, wait=True, timeout=2)
finally:
oldRBV = capv_lib.capvget(motor + '.RBV')
wait_for_done = 1.0
while wait_for_done > 0:
if oldRBV > 0:
capv_lib.capvput(motor + '.LLM', 0.0)
capv_lib.capvput(motor + '.HLM', 0.0)
else:
capv_lib.capvput(motor + '.HLM', 0.0)
capv_lib.capvput(motor + '.LLM', 0.0)
llm = capv_lib.capvget(motor + '.LLM', use_monitor=False)
hlm = capv_lib.capvget(motor + '.HLM', use_monitor=False)
print('%s: setSoftLimitsOff llm=%f hlm=%f' % (motor, llm, hlm))
if llm == 0.0 and hlm == 0.0:
return
time.sleep(polltime)
wait_for_done -= polltime
def do_220_autopower(self, motor, tc_no, autopower):
lib.setCNENandWait(motor, tc_no, 0)
capv_lib.capvput(motor + '-PwrAuto',
autopower,
wait=True,
timeout=globals.TIMEOUT)
capv_lib.capvput(motor + '-PwrOnDly',
PwrOnDly,
wait=True,
timeout=globals.TIMEOUT)
capv_lib.capvput(motor + '-PwrOffDly',
PwrOffDly,
wait=True,
timeout=globals.TIMEOUT)
print('%s Enable move to LLM +10' % tc_no)
res1 = lib.move(motor, self.saved_LLM + 10 + 2 * autopower,
globals.TIMEOUT)
#Make sure drive is still enabled
power1 = capv_lib.capvget(motor + '.CNEN', use_monitor=False)
print('%s Check drive is still enabled power1=%d' % (tc_no, power1))
time.sleep(PwrOnDly + PwrOffDly + 2.0)
power2 = capv_lib.capvget(motor + '.CNEN', use_monitor=False)
print('%s Wait 8s and check drive is now disabled power2=%d' %
(tc_no, power2))
restorePwrSettings(self, motor, tc_no, self.saved_PwrAuto,
self.saved_PwrOnDly, self.saved_PwrOffDly)
assert (res1 == 0)
assert (power1 == 1)
assert (power2 == 0)
def test_TC_242(self):
motor = self.motor
tc_no = "TC-242-JOGF_stopped"
print('%s' % tc_no)
if (self.msta & lib.MSTA_BIT_HOMED):
capv_lib.capvput(motor + '.DLY', 0)
destination = self.per10_UserPosition
res1 = lib.move(motor, destination, 60)
UserPosition = capv_lib.capvget(motor + '.RBV', use_monitor=False)
print('%s postion=%f per10_UserPosition=%f' %
(tc_no, UserPosition, self.per90_UserPosition))
capv_lib.capvput(motor + '.JOGF', 1)
ret2 = lib.waitForStart(motor, tc_no, 2.0)
time.sleep(1)
capv_lib.capvput(motor + '-Stop', 1)
ret3 = lib.waitForStop(motor, tc_no, 2.0)
val = capv_lib.capvget(motor + '.VAL')
try:
res4 = lib.verifyPosition(motor, val)
except:
e = sys.exc_info()
print(str(e))
res4 = globals.FAIL
capv_lib.capvput(motor + '.DLY', self.saved_DLY)
self.assertEqual(res1, globals.SUCCESS, 'move returned SUCCESS')
self.assertEqual(res4, globals.SUCCESS, 'VAL synched with RBV')
def test_TC_1318(self):
motor = self.motor
if (self.msta & lib.MSTA_BIT_HOMED):
tc_no = "TC-1315-low-soft-limit JOGF DIR"
print('%s' % tc_no)
saved_DIR = capv_lib.capvget(motor + '.DIR')
saved_FOFF = capv_lib.capvget(motor + '.FOFF')
capv_lib.capvput(motor + '.FOFF', 1)
capv_lib.capvput(motor + '.DIR', 1)
done = lib.jogDirection(motor, tc_no, 1)
lvio = int(capv_lib.capvget(motor + '.LVIO'))
msta = int(capv_lib.capvget(motor + '.MSTA'))
capv_lib.capvput(motor + '.DIR', saved_DIR)
capv_lib.capvput(motor + '.FOFF', saved_FOFF)
self.assertEqual(True, done,
'done should be True after jogDirection')
self.assertEqual(0, msta & lib.MSTA_BIT_PROBLEM,
'No Error MSTA.Problem JOGF DIR')
self.assertEqual(0, msta & lib.MSTA_BIT_MINUS_LS,
'Minus hard limit not reached JOGF DIR')
self.assertEqual(0, msta & lib.MSTA_BIT_PLUS_LS,
'Plus hard limit not reached JOGR DIR')
def initializeMotorRecordSimulatorAxis(self, motor, tc_no):
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)
# If there are usful values in the controller, use them
cfgDHLM = capv_lib.capvget(motor + '-CfgDHLM')
cfgDLLM = capv_lib.capvget(motor + '-CfgDLLM')
if (cfgDHLM == None or cfgDLLM == None or cfgDHLM <= cfgDLLM):
cfgDHLM = 53.0
cfgDLLM = -54.0
self.setSoftLimitsOff(motor)
self.initializeMotorRecordOneField(motor, tc_no, '-CfgDHLM',
cfgDHLM)
self.initializeMotorRecordOneField(motor, tc_no, '-CfgDLLM',
cfgDLLM)
self.initializeMotorRecordOneField(motor, tc_no, '-CfgDHLM-En', 1)
self.initializeMotorRecordOneField(motor, tc_no, '-CfgDLLM-En', 1)
self.initializeMotorRecordOneField(motor, tc_no, '.DHLM', cfgDHLM)
self.initializeMotorRecordOneField(motor, tc_no, '.DLLM', cfgDLLM)
def checkForEmergenyStop(self, motor, tc_no, wait, direction, oldRBV, TweakValue):
outOfRange = 0
lls = 0
hls = 0
outOfRange = 0
rbv = capv_lib.capvget(motor + '.RBV', use_monitor=False)
msta = int(capv_lib.capvget(motor + '.MSTA', use_monitor=False))
dmov = int(capv_lib.capvget(motor + '.DMOV', use_monitor=False))
movn = int(capv_lib.capvget(motor + '.MOVN', use_monitor=False))
if (rbv - oldRBV) > 2 * TweakValue:
outOfRange = 1
if (oldRBV -rbv) > 2 * TweakValue:
outOfRange = -1
if (msta & lib.MSTA_BIT_MINUS_LS):
lls = 1
if (msta & lib.MSTA_BIT_PLUS_LS):
hls = 1
print('%s:%d wait=%f dmov=%d movn=%d direction=%d lls=%d hls=%d OOR=%d oldRBV=%f rbv=%f' % \
(tc_no, lineno(), wait, dmov, movn, direction, lls, hls, outOfRange, oldRBV, rbv))
if ((hls and (direction > 0)) or
(lls and (direction <= 0)) or
outOfRange != 0):
print('%s:%d STOP=1 CNEN=0 Emergency stop' % (tc_no, lineno()))
capv_lib.capvput(motor + '.STOP', 1)
capv_lib.capvput(motor + '.CNEN', 0)
return (lls, hls, movn, dmov, outOfRange)
def test_TC_1315(self):
motor = self.motor
if (self.msta & lib.MSTA_BIT_HOMED):
tc_no = "TC-1315-low-soft-limit JOGR"
print('%s' % tc_no)
capv_lib.capvput(motor + '.DLY', 0.0)
done = lib.jogDirection(motor, tc_no, 0)
lvio = int(capv_lib.capvget(motor + '.LVIO'))
msta = int(capv_lib.capvget(motor + '.MSTA'))
miss = int(capv_lib.capvget(motor + '.MISS'))
capv_lib.capvput(motor + '.DLY', self.saved_DLY)
capv_lib.capvput(motor + '.JOGF', 0)
resW = lib.waitForMipZero(motor, tc_no, self.saved_DLY)
self.assertEqual(True, done,
'ndly JOGF should be done after jogDirection')
self.assertEqual(0, msta & lib.MSTA_BIT_PROBLEM,
'ndly JOGF should not give MSTA.Problem')
self.assertEqual(0, msta & lib.MSTA_BIT_MINUS_LS,
'ndly JOGF should not reach LLS')
self.assertEqual(0, msta & lib.MSTA_BIT_PLUS_LS,
'ndly JOGF should not reach HLS')
self.assertEqual(0, miss, 'ndly JOGF should not have MISS set')
self.assertEqual(1, resW, 'ndly JOGF should have MIP = 0')
self.assertEqual(1, lvio, 'ndly JOGF should have LVIO set')
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)
msta = int(capv_lib.capvget(motor + '.MSTA'))
print('llm=%f hlm=%f' % (llm, hlm))
# Assert that motor is homed
def test_TC_1601(self):
motor = self.motor
tc_no = "TC-1601"
if not (self.msta & lib.MSTA_BIT_HOMED):
self.assertNotEqual(0, self.msta & lib.MSTA_BIT_HOMED,
'MSTA.homed (Axis is not homed)')
# per10 UserPosition
def test_TC_1602(self):
motor = self.motor
if (self.msta & lib.MSTA_BIT_HOMED):
tc_no = "TC-1602-10-percent-UserPosition"
print('%s' % tc_no)
done = lib.moveWait(motor, tc_no, self.per10_UserPosition)
UserPosition = capv_lib.capvget(motor + '.RBV', use_monitor=False)
print('%s postion=%f jog_start_pos=%f done=%s' %
(tc_no, UserPosition, self.per10_UserPosition, done))
self.assertEqual(1, done, 'moveWait should return done')
# stress test; start and stop the motor quickly..
def test_TC_1603(self):
motor = self.motor
tc_no = "TC-1603"
msta = int(capv_lib.capvget(motor + '.MSTA'))
nErrorId = capv_lib.capvget(motor + '-ErrId')
for i in range(1, 10):
if not (msta & lib.MSTA_BIT_PROBLEM):
res = capv_lib.capvput(motor + '-MoveAbs',
self.per10_UserPosition + i * 10)
time.sleep(0.01)
res2 = capv_lib.capvput(motor + '.STOP', 1)
time.sleep(0.01)
msta = int(capv_lib.capvget(motor + '.MSTA'))
nErrorId = capv_lib.capvget(motor + '-ErrId')
print('%s i=%d nErrorId=%x msta=%s' %
(tc_no, i, nErrorId, lib.getMSTAtext(msta)))
if (msta & lib.MSTA_BIT_PROBLEM):
capv_lib.capvput(motor + '-ErrRst', 1)
self.assertEqual(0, nErrorId, 'nErrorId must be 0')
self.assertEqual(0, msta & lib.MSTA_BIT_PROBLEM,
'Problem bit must not be set')
class Test(unittest.TestCase):
motor = os.getenv("TESTEDMOTORAXIS")
capv_lib.capvput(motor + '-DbgStrToLOG',
"Start " + os.path.basename(__file__)[0:20])
saved_DLY = capv_lib.capvget(motor + '.DLY')
msta = int(capv_lib.capvget(motor + '.MSTA'))
hlm = capv_lib.capvget(motor + '.HLM')
llm = capv_lib.capvget(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_2401(self):
motor = self.motor
tc_no = "2401"
if not (self.msta & lib.MSTA_BIT_HOMED):
self.assertNotEqual(0, self.msta & lib.MSTA_BIT_HOMED,
'MSTA.homed (Axis is not homed)')
# Jog, wait for start, stop behind MR
def test_TC_2402(self):
motor = self.motor
tc_no = "2402-JOGF_stopped"
print('%s' % tc_no)
if (self.msta & lib.MSTA_BIT_HOMED):
capv_lib.capvput(motor + '-DbgStrToLOG', "Start " + tc_no[0:20])
capv_lib.capvput(motor + '.DLY', 0)
destination = self.per10_UserPosition
done = lib.moveWait(motor, tc_no, destination)
UserPosition = capv_lib.capvget(motor + '.RBV', use_monitor=False)
print('%s postion=%f per10_UserPosition=%f' %
(tc_no, UserPosition, self.per90_UserPosition))
capv_lib.capvput(motor + '.JOGF', 1)
ret2 = lib.waitForStart(motor, tc_no, 2.0)
time.sleep(1)
capv_lib.capvput(motor + '-Stop', 1)
ret3 = lib.waitForStop(motor, tc_no, 2.0)
val = capv_lib.capvget(motor + '.VAL')
try:
res4 = lib.verifyPosition(motor, val)
except:
e = sys.exc_info()
print(str(e))
res4 = globals.FAIL
capv_lib.capvput(motor + '.DLY', self.saved_DLY)
capv_lib.capvput(motor + '-DbgStrToLOG', "End " + tc_no[0:20])
self.assertEqual(1, done, 'moveWait should return done')
self.assertEqual(res4, globals.SUCCESS, 'VAL synched with RBV')
def test_TC_501(self):
motor = str(self.motor)
tc_no = "TC_501-10-percent-dialPosition"
print('%s' % tc_no)
saved_HLM = capv_lib.capvget(motor + '.HLM')
saved_LLM = capv_lib.capvget(motor + '.LLM')
destination = (1 * saved_HLM + 9 * saved_LLM) / 10
done = lib.moveWait(motor, tc_no, destination)
self.assertEqual(1, done, 'moveWait should return done')
class Test(unittest.TestCase):
motor = os.getenv("TESTEDMOTORAXIS")
#capv_lib.capvput(motor + '-DbgStrToLOG', "Start " + os.path.basename(__file__))
hlm = capv_lib.capvget(motor + '.HLM')
llm = capv_lib.capvget(motor + '.LLM')
velo = capv_lib.capvget(motor + '.VELO')
vmax = capv_lib.capvget(motor + '.VMAX')
if vmax == 0.0:
vmax = velo * 100.0
msta = int(capv_lib.capvget(motor + '.MSTA'))
per10_UserPosition = round((9 * llm + 1 * hlm) / 10)
per90_UserPosition = round((1 * llm + 9 * hlm) / 10)
def test_TC_1400(self):
motor = self.motor
tc_no = "TC-1400"
if not (self.msta & lib.MSTA_BIT_HOMED):
self.assertNotEqual(0, self.msta & lib.MSTA_BIT_HOMED,
'MSTA.homed (Axis is not homed)')
def test_TC_1401(self):
motor = self.motor
tc_no = "TC-1401"
motorPositionTC(self, motor, tc_no, self.llm, self.velo)
def test_TC_1402(self):
motor = self.motor
tc_no = "TC-1402"
motorPositionTC(self, motor, tc_no, self.per10_UserPosition, self.velo)
def test_TC_1403(self):
motor = self.motor
tc_no = "TC-1403"
motorPositionTC(self, motor, tc_no, self.per90_UserPosition, self.velo)
def test_TC_1404(self):
motor = self.motor
tc_no = "TC-1404"
motorPositionTC(self, motor, tc_no, self.hlm, self.velo)
def test_TC_1405(self):
motor = self.motor
tc_no = "TC-1405"
motorPositionTC(self, motor, tc_no, self.per90_UserPosition, self.vmax)
def test_TC_1406(self):
motor = self.motor
tc_no = "TC-1406"
motorPositionTC(self, motor, tc_no, self.per10_UserPosition, self.vmax)
def test_TC_1407(self):
motor = self.motor
tc_no = "TC-1407"
motorPositionTC(self, motor, tc_no, self.llm, self.vmax)
def waitForStart(self, motor, tc_no, wait_for, direction, oldRBV):
TweakValue = capv_lib.capvget(motor + '.TWV')
while wait_for > 0:
wait_for -= polltime
(lls, hls, movn, dmov, outOfRange) = checkForEmergenyStop(
self, motor, tc_no + 'strt', wait_for, direction, oldRBV, TweakValue)
rbv = capv_lib.capvget(motor + '.RBV')
if movn and not dmov:
return True
time.sleep(polltime)
wait_for -= polltime
return False
def test_TC_2002(self):
motor = self.motor
tc_no = "TC-2002-JOG-_Enable"
capv_lib.capvput(motor + '-PwrAuto', 0)
capv_lib.capvput(motor + '.CNEN', 0)
lib.waitForPowerOff(motor, tc_no, 8.0)
capv_lib.capvput(motor + '.JOGF', 1)
ret_1 = lib.jogDirection(motor, tc_no, 1)
msta_1 = int(capv_lib.capvget(motor + '.MSTA', use_monitor=False))
bError_2 = capv_lib.capvget(motor + '-Err', use_monitor=False)
nErrorId_2 = capv_lib.capvget(motor + '-ErrId', use_monitor=False)
print('%s Error bError_2=%d nErrorId_2=%d' % (tc_no, bError_2, nErrorId_2))
capv_lib.capvput(motor + '-ErrRst',1)
msta_3 = int(capv_lib.capvget(motor + '.MSTA', use_monitor=False))
bError_3 = capv_lib.capvget(motor + '-Err', use_monitor=False)
nErrorId_3 = capv_lib.capvget(motor + '-ErrId', use_monitor=False)
print('%s Clean lib.MSTA_BIT_PROBLEM=%x msta_3=%x bError_3=%d nErrorId=%d' % (tc_no, lib.MSTA_BIT_PROBLEM, msta_3, bError_3, nErrorId_3))
# Loop until moving has stopped and error has been reseted
counter = 7
msta = msta_3
nErrorId = nErrorId_3
bError = bError_3
while (msta & lib.MSTA_BIT_MOVING or bError != 0 or nErrorId != 0):
time.sleep(polltime)
print('%s sleep counter = %d' % (tc_no, counter))
msta = int(capv_lib.capvget(motor + '.MSTA', use_monitor=False))
bError = capv_lib.capvget(motor + '-Err', use_monitor=False)
nErrorId = capv_lib.capvget(motor + '-ErrId', use_monitor=False)
counter = counter - 1
if counter == 0:
break
# Restore the values we had before this test started
capv_lib.capvput(motor + '.CNEN', self.saved_CNEN)
if self.saved_CNEN:
lib.waitForPowerOn(motor, tc_no + "restore", 8.0)
else:
lib.waitForPowerOff(motor, tc_no+ "restore", 3.0)
capv_lib.capvput(motor + '-PwrAuto', self.saved_PwrAuto)
# Run all the asserts after we have restored the original state
self.assertEqual(True, ret_1, 'waitForStop return True')
print('%s Error msta_1=%s' % (tc_no, lib.getMSTAtext(msta_1)))
self.assertNotEqual(0, msta_1 & lib.MSTA_BIT_PROBLEM, 'Error MSTA.Problem should be set)')
self.assertEqual(0, msta_1 & lib.MSTA_BIT_SLIP_STALL, 'Error MSTA.Slip stall Error should not be set)')
self.assertEqual(0, msta_1 & lib.MSTA_BIT_MOVING, 'Error MSTA.Moving)')
self.assertNotEqual(0, bError_2, 'bError')
self.assertNotEqual(0, nErrorId_2, 'nErrorId')
self.assertEqual(0, msta & lib.MSTA_BIT_MOVING, 'Clean MSTA.Moving)')
self.assertEqual(0, bError, 'bError')
self.assertEqual(0, nErrorId, 'nErrorId')
def waitForStop(self, motor, tc_no, wait_for_stop):
while wait_for_stop > 0:
wait_for_stop -= polltime
dmov = int(capv_lib.capvget(motor + '.DMOV', use_monitor=False))
movn = int(capv_lib.capvget(motor + '.MOVN', use_monitor=False))
rbv = capv_lib.capvget(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 test_TC_1322(self):
motor = self.motor
if (self.msta & lib.MSTA_BIT_HOMED):
tc_no = "TC-1322-low-limit-switch"
print('%s' % tc_no)
old_high_limit = capv_lib.capvget(motor + '.HLM')
old_low_limit = capv_lib.capvget(motor + '.LLM')
rdbd = capv_lib.capvget(motor + '.RDBD')
capv_lib.capvput(motor + '.STOP', 1)
#Go away from limit switch
done = lib.moveWait(motor, tc_no, self.jog_start_pos)
destination = capv_lib.capvget(motor + '.HLM')
rbv = capv_lib.capvget(motor + '.RBV')
jvel = capv_lib.capvget(motor + '.JVEL')
timeout = lib.calcTimeOut(motor, destination, jvel) * 2
lib.setSoftLimitsOff(motor)
done1 = lib.jogDirection(motor, tc_no, 0)
# Get values, check them later
lvio = int(capv_lib.capvget(motor + '.LVIO'))
mstaE = int(capv_lib.capvget(motor + '.MSTA'))
#Go away from limit switch
done2 = lib.moveWait(motor, tc_no, old_low_limit + rdbd)
print('%s msta=%x lvio=%d' % (tc_no, mstaE, lvio))
lib.setSoftLimitsOn(motor, old_low_limit, old_high_limit)
self.assertEqual(0, mstaE & lib.MSTA_BIT_PROBLEM, 'MSTA.Problem should not be set')
self.assertNotEqual(0, mstaE & lib.MSTA_BIT_MINUS_LS, 'LLS should be active')
self.assertEqual(0, mstaE & lib.MSTA_BIT_PLUS_LS, 'HLS should not be active')
self.assertEqual(1, done1, 'moveWait1 should return done')
self.assertEqual(1, done2, 'moveWait2 should return done')
def setLimit(tself, motor, tc_no, field, value, expDHLM, expDLLM, expHLM, expLLM, expM3rhlm, expM3rllm):
oldDHLM = capv_lib.capvget(motor + '.DHLM', use_monitor=False)
oldDLLM = capv_lib.capvget(motor + '.DLLM', use_monitor=False)
capv_lib.capvput(motor + '.DHLM', oldDHLM)
capv_lib.capvput(motor + '.DLLM', oldDLLM)
capv_lib.capvput(motor + '.' + field, value)
time.sleep(0.5)
actDHLM = capv_lib.capvget(motor + '.DHLM', use_monitor=False)
actDLLM = capv_lib.capvget(motor + '.DLLM', use_monitor=False)
actHLM = capv_lib.capvget(motor + '.HLM', use_monitor=False)
actLLM = capv_lib.capvget(motor + '.LLM', use_monitor=False)
actM3rhlm = capv_lib.capvget(motor + '-M3RHLM', use_monitor=False)
actM3rllm = capv_lib.capvget(motor + '-M3RLLM', use_monitor=False)
print('%s expDHLM=%g expDLLM=%g expHLM=%g expLLM=%g expM3rhlm=%g expM3rllm=%g' % \
(tc_no, expDHLM, expDLLM, expHLM, expLLM, expM3rhlm, expM3rllm))
print('%s actDHLM=%g actDLLM=%g actHLM=%g actLLM=%g actM3rhlm=%g actM3rllm=%g' % \
(tc_no, actDHLM, actDLLM, actHLM, actLLM, actM3rhlm, actM3rllm))
okDHLM = lib.calcAlmostEqual(motor, tc_no, expDHLM, actDHLM, maxdelta)
okDLLM = lib.calcAlmostEqual(motor, tc_no, expDLLM, actDLLM, maxdelta)
okHLM = lib.calcAlmostEqual(motor, tc_no, expHLM, actHLM, maxdelta)
okLLM = lib.calcAlmostEqual(motor, tc_no, expLLM, actLLM, maxdelta)
okM3rhlm = lib.calcAlmostEqual(motor, tc_no, expM3rhlm, actM3rhlm, maxdelta)
okM3rllm = lib.calcAlmostEqual(motor, tc_no, expM3rllm, actM3rllm, maxdelta)
assert (okDHLM and okDLLM and okHLM and okLLM and okM3rhlm and okM3rllm)
def test_TC_501(self):
motor = str(self.motor)
tc_no = "TC_501-10-percent-dialPosition"
print('%s' % tc_no)
saved_HLM = capv_lib.capvget(motor + '.HLM')
saved_LLM = capv_lib.capvget(motor + '.LLM')
destination = (1 * saved_HLM + 9 * saved_LLM) / 10
capv_lib.capvput(motor + '.VAL', destination, wait=True)
rbv = capv_lib.capvget(motor + '.RBV')
inpos = lib.calcAlmostEqual(motor, tc_no, destination, rbv, 2)
print('%s destination=%f RBV=%f inpos=%d' %
(tc_no, destination, rbv, inpos))
assert inpos
class Test(unittest.TestCase):
motor = os.getenv("TESTEDMOTORAXIS")
capv_lib.capvput(motor + '-DbgStrToLOG',
"Start " + os.path.basename(__file__)[0:20])
saved_CNEN = capv_lib.capvget(motor + '.CNEN')
saved_PwrAuto = capv_lib.capvget(motor + '-PwrAuto')
# Jog, wait for start, power off, check error, reset error
def test_TC_212(self):
motor = self.motor
tc_no = "TC-212-EnabledFailed"
capv_lib.capvput(motor + '.CNEN', 0, wait=True)
setValueOnSimulator(self, motor, tc_no, "bAmplifierLockedToBeOff",
AMPLIFIER_LOCKED_TO_BE_OFF_SILENT)
capv_lib.capvput(motor + '-PwrAuto', 0)
time.sleep(1.0)
capv_lib.capvput(motor + '.CNEN', 1, wait=True)
time.sleep(4.0)
mstaErr = int(capv_lib.capvget(motor + '.MSTA', use_monitor=False))
print('%s Error mstaErr=%s' % (tc_no, lib.getMSTAtext(mstaErr)))
capv_lib.capvput(motor + '-ErrRst', 1)
setValueOnSimulator(self, motor, tc_no, "bAmplifierLockedToBeOff", 0)
mstaOKagain = int(capv_lib.capvget(motor + '.MSTA', use_monitor=False))
bError = capv_lib.capvget(motor + '-Err', use_monitor=False)
nErrorId = capv_lib.capvget(motor + '-ErrId', use_monitor=False)
print(
'%s Clean lib.MSTA_BIT_PROBLEM=%x mstaOKagain=%s bError=%d nErrorId=%d'
% (tc_no, lib.MSTA_BIT_PROBLEM, lib.getMSTAtext(mstaOKagain),
bError, nErrorId))
capv_lib.capvput(motor + '.CNEN', self.saved_CNEN)
capv_lib.capvput(motor + '-PwrAuto', self.saved_PwrAuto)
self.assertNotEqual(0, mstaErr & lib.MSTA_BIT_PROBLEM,
'Error MSTA.Problem should be set)')
self.assertEqual(0, mstaErr & lib.MSTA_BIT_SLIP_STALL,
'Error MSTA.Slip stall Error should not be set)')
self.assertEqual(0, mstaErr & lib.MSTA_BIT_MOVING,
'Error MSTA.Moving)')
self.assertEqual(0, mstaOKagain & lib.MSTA_BIT_MOVING,
'Clean MSTA.Moving)')
self.assertEqual(0, bError, 'bError')
self.assertEqual(0, nErrorId, 'nErrorId')
class XTest(unittest.TestCase):
motor = os.getenv("TESTEDMOTORAXIS")
capv_lib.capvput(motor + '-DbgStrToLOG',
"Start " + os.path.basename(__file__)[0:20])
motor2 = "IOC:m2"
hlm = capv_lib.capvget(motor + '.HLM')
llm = capv_lib.capvget(motor + '.LLM')
msta = int(capv_lib.capvget(motor + '.MSTA'))
per10_UserPosition = round((9 * llm + 1 * hlm) / 10)
per90_UserPosition = round((1 * llm + 9 * hlm) / 10)
# Assert that motor is homed
def Xtest_TC_231(self):
motor = self.motor
tc_no = "TC-231"
if not (self.msta & lib.MSTA_BIT_HOMED):
self.assertNotEqual(0, self.msta & lib.MSTA_BIT_HOMED,
'MSTA.homed (Axis is not homed)')
# Jog, wait for start, power off, check error, reset error
def Xtest_TC_232(self):
motor = self.motor
motor2 = self.motor2
tc_no = "TC-232-NetYetStarted"
print('%s' % tc_no)
if (self.msta & lib.MSTA_BIT_HOMED):
setValueOnSimulator(self, motor2, tc_no, "usleep", 1700000)
destination = self.per90_UserPosition
res1 = lib.move(motor, destination, 60)
UserPosition = capv_lib.capvget(motor + '.RBV', use_monitor=False)
print('%s postion=%f per90_UserPosition=%f' %
(tc_no, UserPosition, self.per90_UserPosition))
destination = self.per10_UserPosition
res2 = lib.move(motor, destination, 60)
UserPosition = capv_lib.capvget(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 == globals.SUCCESS,
'move returned SUCCESS')
self.assertNotEqual(res2 == globals.SUCCESS,
'move returned SUCCESS')
def test_TC_403(self):
tc_no = "TC-403-20-percent"
print('%s' % tc_no)
motor = self.motor
if (self.msta & lib.MSTA_BIT_HOMED):
saved_ACCL = float(capv_lib.capvget(motor + '.ACCL'))
saved_VELO = float(capv_lib.capvget(motor + '.VELO'))
used_ACCL = saved_ACCL + 1.0 # Make sure we have an acceleration != 0
capv_lib.capvput(motor + '.ACCL', used_ACCL)
done = lib.moveWait(motor, tc_no, self.per20_UserPosition)
resacc = self.getAcceleration(motor, tc_no)
expacc = saved_VELO / used_ACCL
capv_lib.capvput(motor + '.ACCL', saved_ACCL)
print('%s ACCL=%f expacc=%f resacc=%f' % (tc_no,used_ACCL,expacc,resacc))
assert lib.calcAlmostEqual(self.motor, tc_no, expacc, resacc, 2)
self.assertEqual(1, done, 'moveWait should return done')
def moveWait(self, motor, tc_no, destination):
timeout = 30
acceleration = capv_lib.capvget(motor + '.ACCL')
velocity = capv_lib.capvget(motor + '.VELO')
timeout += 2 * acceleration + 1.0
if velocity > 0:
distance = math.fabs(
capv_lib.capvget(motor + '.RBV') - destination)
timeout += distance / velocity
capv_lib.capvput(motor + '.VAL', destination)
success_or_failed = self.move(motor, destination, timeout)
if (success_or_failed == self.globals.FAIL):
return False
else:
return True
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 = capv_lib.capvget(_off)
capv_lib.capvput(_set, 1, wait=True, timeout=timeout)
capv_lib.capvput(_dval, position, wait=True, timeout=timeout)
capv_lib.capvput(_off, offset, wait=True, timeout=timeout)
capv_lib.capvput(_set, 0, wait=True, timeout=timeout)
if (self.postMoveCheck(motor) != self.globals.SUCCESS):
return self.globals.FAIL
try:
self.verifyPosition(motor, position + offset)
except Exception as e:
print(str(e))
return self.globals.FAIL
def setSoftLimitsOn(self, motor, low_limit, high_limit):
"""
Set the soft limits
"""
# switch on the controller soft limits
try:
capv_lib.capvput(motor + '-CfgDHLM',
high_limit,
wait=True,
timeout=2)
capv_lib.capvput(motor + '-CfgDLLM',
low_limit,
wait=True,
timeout=2)
capv_lib.capvput(motor + '-CfgDHLM-En', 1, wait=True, timeout=2)
capv_lib.capvput(motor + '-CfgDLLM-En', 1, wait=True, timeout=2)
finally:
oldRBV = capv_lib.capvget(motor + '.RBV')
if oldRBV < 0:
capv_lib.capvput(motor + '.LLM', low_limit)
capv_lib.capvput(motor + '.HLM', high_limit)
else:
capv_lib.capvput(motor + '.HLM', high_limit)
capv_lib.capvput(motor + '.LLM', low_limit)
def doSTUPandSYNC(self, motor, tc_no):
stup = capv_lib.capvget(motor + '.STUP', use_monitor=False)
while stup != 0:
stup = capv_lib.capvget(motor + '.STUP', use_monitor=False)
print('%s .STUP=%s' % (tc_no, stup))
time.sleep(polltime)
capv_lib.capvput(motor + '.STUP', 1)
capv_lib.capvput(motor + '.SYNC', 1)
rbv = capv_lib.capvget(motor + '.RBV', use_monitor=False)
print('%s .RBV=%f .STUP=%s' % (tc_no, rbv, stup))
while stup != 0:
stup = capv_lib.capvget(motor + '.STUP', use_monitor=False)
rbv = capv_lib.capvget(motor + '.RBV', use_monitor=False)
print('%s .RBV=%f .STUP=%s' % (tc_no, rbv, stup))
time.sleep(polltime)
