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')
def test_TC_091(self): tc_no = "TC-091-Tweak" print('%s' % tc_no) motor = self.motor resetAxis(motor, tc_no) print('%s:%d .CNEN=1' % (tc_no, lineno())) lib.setCNENandWait(motor, tc_no, 1) oldRBV = capv_lib.capvget(motor + '.RBV', use_monitor=False) old_high_limit = capv_lib.capvget(motor + '.HLM') old_low_limit = capv_lib.capvget(motor + '.LLM') # Switch off soft limits lib.setSoftLimitsOff(motor) msta = int(capv_lib.capvget(motor + '.MSTA')) direction = 0 if (msta & lib.MSTA_BIT_PLUS_LS): direction = -1 destination = oldRBV - self.TweakValue else: direction = +1 destination = oldRBV + self.TweakValue print('%s:%d Tweak the motor oldRBV=%f destination=%f' % (tc_no, lineno(), oldRBV, destination)) capv_lib.capvput(motor + '.VAL', destination) ret1 = waitForStart(self, motor, tc_no, 0.4, direction, oldRBV) ret2 = waitForStop(self, motor, tc_no, 10.0, direction, oldRBV, self.TweakValue) msta = int(capv_lib.capvget(motor + '.MSTA')) print('%s STOP=1 start=%d stop=%d' % (tc_no, ret1, ret2)) capv_lib.capvput(motor + '.STOP', 1) capv_lib.capvput(motor + '.LLM', old_low_limit) capv_lib.capvput(motor + '.HLM', old_high_limit) ReadBackValue = capv_lib.capvget(motor + '.RBV', use_monitor=False) print('%s destination=%d postion=%f' % ( tc_no, destination, ReadBackValue)) #self.assertEqual(True, ret1, 'waitForStart return True') self.assertEqual(True, ret2, 'waitForStop return True') maxdelta = self.TweakValue * 2 print('%s destination=%f ReadBackValue=%f, maxdelta=%f' % (tc_no, destination, ReadBackValue, maxdelta)) assert calcAlmostEqual(motor, tc_no, destination, ReadBackValue, maxdelta)
def test_TC_1335(self): motor = self.motor if (self.msta & lib.MSTA_BIT_HOMED): tc_no = "TC-1235-low-soft-limit Moveabs" print('%s' % tc_no) drvUseEGU = capv_lib.capvget(motor + '-DrvUseEGU-RB') if drvUseEGU == 1: mres = 1.0 else: mres = capv_lib.capvget(motor + '.MRES') rbv = capv_lib.capvget(motor + '.RBV') jar = capv_lib.capvget(motor + '.JAR') capv_lib.capvput(motor + '-ACCS', jar / mres) jvel = capv_lib.capvget(motor + '.JVEL') capv_lib.capvput(motor + '-VELO', jvel / mres) destination = self.llm - 1 timeout = lib.calcTimeOut(motor, destination, jvel) print('%s rbv=%f destination=%f timeout=%f' % (tc_no, rbv, destination, timeout)) res = capv_lib.capvput(motor + '-MoveAbs', (destination) / 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') done = lib.waitForStartAndDone(motor, tc_no, timeout) msta = int(capv_lib.capvget(motor + '.MSTA')) miss = int(capv_lib.capvget(motor + '.MISS')) success = lib.verifyPosition(motor, rbv) if (msta & lib.MSTA_BIT_PROBLEM): capv_lib.capvput(motor + '-ErrRst', 1) self.assertEqual(success, globals.SUCCESS, 'verifyPosition returned SUCCESS') self.assertEqual(0, msta & lib.MSTA_BIT_MINUS_LS, 'DLY Minus hard limit not reached Moveabs') self.assertEqual(0, msta & lib.MSTA_BIT_PLUS_LS, 'DLY Plus hard limit not reached Moveabs') self.assertEqual(0, miss, 'DLY MISS not set Moveabs')
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')
class Test(unittest.TestCase): motor = os.getenv("TESTEDMOTORAXIS") capv_lib.capvput(motor + '-DbgStrToLOG', "Start " + os.path.basename(__file__)[0:20]) # Set and readback Vel def test_TC_9301(self): motor = self.motor tc_no = "TC-9301" setAndReadBackParam(self, motor, tc_no, '-Vel-RB', 'fVelocity') # Set and readback Acc def test_TC_9302(self): motor = self.motor tc_no = "TC-9302" setAndReadBackParam(self, motor, tc_no, '-Acc-RB', 'fAcceleration') # Set and readback high soft limit value def test_TC_9303(self): motor = self.motor tc_no = "TC-9303" setAndReadBackParam(self, motor, tc_no, '-CfgDHLM-RB', 'fHighSoftLimitPos') ## Set and readback high soft limit enable # Cant run those, PILS has no enable bit #def test_TC_9304(self): # motor = self.motor # tc_no = "TC-9304" # setAndReadBackParam(self, motor, tc_no, '-CfgDHLM-En-RB', 'bEnableHighSoftLimit') # Set and readback low soft limit value def test_TC_9305(self): motor = self.motor tc_no = "TC-9305" setAndReadBackParam(self, motor, tc_no, '-CfgDLLM-RB', 'fLowSoftLimitPos')
def test_TC_404(self): tc_no = "TC-404-JOGR" print('%s' % tc_no) motor = self.motor if (self.msta & lib.MSTA_BIT_HOMED): accl = float(capv_lib.capvget(motor + '.ACCL')) jvel = float(capv_lib.capvget(motor + '.JVEL')) saved_JAR = float(capv_lib.capvget(motor + '.JAR')) used_JAR = jvel / (accl + 2.0) capv_lib.capvput(motor + '.JAR', used_JAR) capv_lib.capvput(motor + '.JOGR', 1, wait=True) resacc = self.getAcceleration(motor, tc_no) expacc = used_JAR capv_lib.capvput(motor + '.JAR', saved_JAR) print('%s JAR=%f expacc=%f resacc=%f' % (tc_no, used_JAR, expacc, resacc)) assert lib.calcAlmostEqual(self.motor, tc_no, expacc, resacc, 2)
def test_TC_90010(self): tc_no = 90010 encRel = 0 capv_lib.capvput(self.motor + '-DbgStrToLOG', "Start " + str(tc_no)) #vers = float(capv_lib.capvget(self.motor + '.VERS')) #print('%s vers=%g' % (tc_no, vers)) #self.assertEqual(0, 1, '1 != 0') testPassed = readBackParamVerify(self, self.motor, tc_no, '-DrvUseEGU-RB', 0) motorInitVeloAcc(self, self.motor, tc_no, encRel) mres = 0.1 dir = 0 off = 0.5 setMresDirOff(self, self.motor, tc_no, mres, dir, off) motorInitLimitsNoC(self, self.motor, tc_no) if testPassed: capv_lib.capvput(self.motor + '-DbgStrToLOG', "Passed " + str(tc_no)) else: capv_lib.capvput(self.motor + '-DbgStrToLOG', "Failed " + str(tc_no)) assert (testPassed)
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')
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) destination = self.saved_LLM + 10 + 2*autopower done = lib.moveWait(motor, tc_no, destination) #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) lib.setCNENandWait(motor, tc_no, self.saved_CNEN) self.assertEqual(1, done, 'moveWait should return done') assert(power1 == 1) assert(power2 == 0)
def motorInitLimitsWithC(self, motor, tc_no): capv_lib.capvput(motor + '-CfgDLLM-En', 0, wait=True) capv_lib.capvput(motor + '-CfgDHLM-En', 0, wait=True) capv_lib.capvput(motor + '-CfgDHLM', myCfgDHLM) capv_lib.capvput(motor + '-CfgDLLM', myCfgDLLM) capv_lib.capvput(motor + '-CfgDLLM-En', 1, wait=True) capv_lib.capvput(motor + '-CfgDHLM-En', 1, wait=True) capv_lib.capvput(motor + '.DHLM', myDHLM) capv_lib.capvput(motor + '.DLLM', myDLLM)
def restorePwrSettings(self, motor, tc_no, pwrAuto, pwrOnDly, pwrOffDly): capv_lib.capvput(motor + '-PwrAuto', pwrAuto) capv_lib.capvput(motor + '-PwrOnDly', pwrOnDly) capv_lib.capvput(motor + '-PwrOffDly', pwrOffDly)
def test_TC_900999(self): if self.drvUseEGU_RB == 1: capv_lib.capvput(self.motor + '-DrvUseEGU', 1)
def motorInitVeloAcc(self, motor, tc_no, encRel): msta = int(capv_lib.capvget(motor + '.MSTA')) assert (msta & lib.MSTA_BIT_HOMED) #, 'MSTA.homed (Axis has been homed)') # Prepare parameters for jogging and backlash capv_lib.capvput(motor + '.VELO', myVELO) capv_lib.capvput(motor + '.ACCL', myACCL) capv_lib.capvput(motor + '.JVEL', myJVEL) capv_lib.capvput(motor + '.JAR', myJAR) capv_lib.capvput(motor + '.BVEL', myBVEL) capv_lib.capvput(motor + '.BACC', myBACC) capv_lib.capvput(motor + '.BDST', myBDST) capv_lib.capvput(motor + '.UEIP', encRel) # Move the motor to 0, to avoid limit swicth activation capv_lib.capvput(motor + '.DVAL', myStartposDial) # Bit speed it up, by setting the position in the simulator lib.setValueOnSimulator(motor, tc_no, "fActPosition", myStartposDial) # and wait for the movement to finish ret3 = lib.waitForStop(motor, tc_no, 2.0)
def test_TC_90000(self): tc_no = 90010 capv_lib.capvput(self.motor + '-DbgStrToLOG', "Start " + str(tc_no)) lib.motorInitAllForBDST(self.motor, 90000) capv_lib.capvput(self.motor + '-DbgStrToLOG', "End " + str(tc_no))
class Test(unittest.TestCase): motor = os.getenv("TESTEDMOTORAXIS") capv_lib.capvput(motor + '-DbgStrToLOG', "Start " + os.path.basename(__file__)[0:20]) myPOSlow = lib.myPOSlow myPOSmid = lib.myPOSmid myPOShig = lib.myPOShig def test_TC_14400(self): lib.motorInitAllForBDST(self.motor, 14400) capv_lib.capvput(self.motor + '.FRAC', myFRAC) # motorRMOD_D = 0 # "Default" # position forward & backlash compensation, absolute def test_TC_14401(self): positionAndBacklash(self, self.motor, 14401, motorRMOD_D, use_abs, self.myPOSlow, self.myPOShig) # position forward & backlash compensation, relative def test_TC_14402(self): positionAndBacklash(self, self.motor, 14402, motorRMOD_D, use_rel, self.myPOSlow, self.myPOShig) # position backward & backlash compensation, absolute def test_TC_14403(self): positionAndBacklash(self, self.motor, 14403, motorRMOD_D, use_abs, self.myPOShig, self.myPOSlow) # position backward & backlash compensation, relative def test_TC_14404(self): positionAndBacklash(self, self.motor, 14404, motorRMOD_D, use_rel, self.myPOShig, self.myPOSlow) # position forward inside backlash range, absolute def test_TC_14405(self): positionAndBacklash(self, self.motor, 14405, motorRMOD_D, use_abs, self.myPOSmid, self.myPOSlow) # position forward inside backlash range, relative def test_TC_14406(self): positionAndBacklash(self, self.motor, 14406, motorRMOD_D, use_rel, self.myPOSmid, self.myPOSlow) # position forward inside backlash range, absolute def test_TC_14407(self): positionAndBacklash(self, self.motor, 14407, motorRMOD_D, use_abs, self.myPOSlow, self.myPOSmid) # position forward inside backlash range, relative def test_TC_14408(self): positionAndBacklash(self, self.motor, 14408, motorRMOD_D, use_rel, self.myPOSlow, self.myPOSmid) ############################################################################### # motorRMOD_A # position forward & backlash compensation, absolute def test_TC_14411(self): positionAndBacklash(self, self.motor, 14411, motorRMOD_A, use_abs, self.myPOSlow, self.myPOShig) # position forward & backlash compensation, relative def test_TC_14412(self): positionAndBacklash(self, self.motor, 14412, motorRMOD_A, use_rel, self.myPOSlow, self.myPOShig) # position backward & backlash compensation, absolute def test_TC_14413(self): positionAndBacklash(self, self.motor, 14413, motorRMOD_A, use_abs, self.myPOShig, self.myPOSlow) # position backward & backlash compensation, relative def test_TC_14414(self): positionAndBacklash(self, self.motor, 14414, motorRMOD_A, use_rel, self.myPOShig, self.myPOSlow) # position forward inside backlash range, absolute def test_TC_14415(self): positionAndBacklash(self, self.motor, 14415, motorRMOD_A, use_abs, self.myPOSmid, self.myPOSlow) # position forward inside backlash range, relative def test_TC_14416(self): positionAndBacklash(self, self.motor, 14416, motorRMOD_A, use_rel, self.myPOSmid, self.myPOSlow) # position forward inside backlash range, absolute def test_TC_14417(self): positionAndBacklash(self, self.motor, 14417, motorRMOD_A, use_abs, self.myPOSlow, self.myPOSmid) # position forward inside backlash range, relative def test_TC_14418(self): positionAndBacklash(self, self.motor, 14418, motorRMOD_A, use_rel, self.myPOSlow, self.myPOSmid) ############################################################################### # motorRMOD_G # position forward & backlash compensation, absolute def test_TC_14421(self): positionAndBacklash(self, self.motor, 14421, motorRMOD_G, use_abs, self.myPOSlow, self.myPOShig) # position forward & backlash compensation, relative def test_TC_14422(self): positionAndBacklash(self, self.motor, 14422, motorRMOD_G, use_rel, self.myPOSlow, self.myPOShig) # position backward & backlash compensation, absolute def test_TC_14423(self): positionAndBacklash(self, self.motor, 14423, motorRMOD_G, use_abs, self.myPOShig, self.myPOSlow) # position backward & backlash compensation, relative def test_TC_14424(self): positionAndBacklash(self, self.motor, 14424, motorRMOD_G, use_rel, self.myPOShig, self.myPOSlow) # position forward inside backlash range, absolute def test_TC_14425(self): positionAndBacklash(self, self.motor, 14425, motorRMOD_G, use_abs, self.myPOSmid, self.myPOSlow) # position forward inside backlash range, relative def test_TC_14426(self): positionAndBacklash(self, self.motor, 14426, motorRMOD_G, use_rel, self.myPOSmid, self.myPOSlow) # position forward inside backlash range, absolute def test_TC_14427(self): positionAndBacklash(self, self.motor, 14427, motorRMOD_G, use_abs, self.myPOSlow, self.myPOSmid) # position forward inside backlash range, relative def test_TC_14428(self): positionAndBacklash(self, self.motor, 14428, motorRMOD_G, use_rel, self.myPOSlow, self.myPOSmid) ############################################################################### # motorRMOD_I # position forward & backlash compensation, absolute def test_TC_14431(self): positionAndBacklash(self, self.motor, 14431, motorRMOD_I, use_abs, self.myPOSlow, self.myPOShig) # position forward & backlash compensation, relative def test_TC_14432(self): positionAndBacklash(self, self.motor, 14432, motorRMOD_I, use_rel, self.myPOSlow, self.myPOShig) # position backward & backlash compensation, absolute def test_TC_14433(self): positionAndBacklash(self, self.motor, 14433, motorRMOD_I, use_abs, self.myPOShig, self.myPOSlow) # position backward & backlash compensation, relative def test_TC_14434(self): positionAndBacklash(self, self.motor, 14434, motorRMOD_I, use_rel, self.myPOShig, self.myPOSlow) # position forward inside backlash range, absolute def test_TC_14435(self): positionAndBacklash(self, self.motor, 14435, motorRMOD_I, use_abs, self.myPOSmid, self.myPOSlow) # position forward inside backlash range, relative def test_TC_14436(self): positionAndBacklash(self, self.motor, 14436, motorRMOD_I, use_rel, self.myPOSmid, self.myPOSlow) # position forward inside backlash range, absolute def test_TC_14437(self): positionAndBacklash(self, self.motor, 14437, motorRMOD_I, use_abs, self.myPOSlow, self.myPOSmid) # position forward inside backlash range, relative def test_TC_14438(self): positionAndBacklash(self, self.motor, 14438, motorRMOD_I, use_rel, self.myPOSlow, self.myPOSmid)
def setLimit(self, motor, tc_no, field, value, expDHLM, expDLLM, expHLM, expLLM, expM3rhlm, expM3rllm): capv_lib.capvput(self.motor + '-DbgStrToLOG', "Start " + str(tc_no)) 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) okDHLM = readBackParamVerify(self, motor, tc_no, '.DHLM', expDHLM) okDLLM = readBackParamVerify(self, motor, tc_no, '.DLLM', expDLLM) okHLM = readBackParamVerify(self, motor, tc_no, '.HLM', expHLM) okLLM = readBackParamVerify(self, motor, tc_no, '.LLM', expLLM) okM3rhlm = readBackParamVerify(self, motor, tc_no, '-M3RHLM', expM3rhlm) okM3rllm = readBackParamVerify(self, motor, tc_no, '-M3RLLM', expM3rllm) testPassed = okDHLM and okDLLM and okHLM and okLLM and okM3rhlm and okM3rllm if testPassed: capv_lib.capvput(self.motor + '-DbgStrToLOG', "Passed " + str(tc_no)) else: capv_lib.capvput(self.motor + '-DbgStrToLOG', "Failed " + str(tc_no)) assert (testPassed)
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 test_TC_14400(self): lib.motorInitAllForBDST(self.motor, 14400) capv_lib.capvput(self.motor + '.FRAC', myFRAC)
def motorInitTC(tself, motor, tc_no, rmod, encRel): capv_lib.capvput(motor + '.RMOD', rmod) capv_lib.capvput(motor + '.UEIP', encRel)
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')) accs = capv_lib.capvget(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 & lib.MSTA_BIT_HOMED, 0, 'Axis has been homed') self.assertNotEqual(self.msta & lib.MSTA_BIT_AMPON, 0, 'Amplifier is on') self.assertNotEqual(self.accs, None, 'ACCS field in record') # 10% dialPosition def test_TC_412(self): tc_no = "TC-412-10-percent" print('%s' % tc_no) motor = self.motor if (self.msta & lib.MSTA_BIT_HOMED): ret = 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)
def test_TC_502(self): motor = self.motor tc_no = "TC_502-10-percent-plus-1" print('%s' % tc_no) rbv = capv_lib.capvget(motor + '.RBV') saved_DLY = capv_lib.capvget(motor + '.DLY') saved_VELO = capv_lib.capvget(motor + '.VELO') saved_ACCL = capv_lib.capvget(motor + '.ACCL') capv_lib.capvput(motor + '.DLY', 5.2) capv_lib.capvput(motor + '.VELO', 1) capv_lib.capvput(motor + '.ACCL', 1) capv_lib.capvput(motor + '.VAL', rbv + 1.0, wait=False) time.sleep(4.0) movn1 = capv_lib.capvget(motor + '.MOVN') capv_lib.capvput(motor + '.STOP', 1) time.sleep(7.0) capv_lib.capvput(motor + '.SPMG', 0) capv_lib.capvput(motor + '.SPMG', 3) time.sleep(4.0) dmov = capv_lib.capvget(motor + '.DMOV') print('%s: movn1=%d dmov=%d' % (tc_no, movn1, dmov)) capv_lib.capvput(motor + '.DLY', saved_DLY) capv_lib.capvput(motor + '.VELO', saved_VELO) capv_lib.capvput(motor + '.ACCL', saved_ACCL)
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') jvel = capv_lib.capvget(motor + '.JVEL') margin = 1.1 # motorRecord stops jogging 1 second before reaching HLM jog_start_pos = llm + jvel + margin msta = int(capv_lib.capvget(motor + '.MSTA')) print('llm=%f hlm=%f jog_start_pos=%f' % (llm, hlm, jog_start_pos)) # Assert that motor is homed def test_TC_1331(self): motor = self.motor tc_no = "TC-1331" 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_1332(self): motor = self.motor if (self.msta & lib.MSTA_BIT_HOMED): tc_no = "TC-1332-10-percent-UserPosition" print('%s' % tc_no) done = lib.moveWait(motor, tc_no, self.jog_start_pos) UserPosition = capv_lib.capvget(motor + '.RBV', use_monitor=False) print('%s postion=%f jog_start_pos=%f done=%s' % (tc_no, UserPosition, self.jog_start_pos, done)) self.assertEqual(1, done, 'moveWait should return done') # Low soft limit in controller when using MoveVel def test_TC_1333(self): motor = self.motor if (self.msta & lib.MSTA_BIT_HOMED): tc_no = "TC-1333-low-soft-limit MoveVel" print('%s' % tc_no) jar = capv_lib.capvget(motor + '.JAR') capv_lib.capvput(motor + '-ACCS', jar) rbv = capv_lib.capvget(motor + '.RBV') destination = capv_lib.capvget(motor + '.LLM') - 1 jvel = capv_lib.capvget(motor + '.JVEL') timeout = lib.calcTimeOut(motor, destination, jvel) print('%s rbv=%f destination=%f timeout=%f' % (tc_no, rbv, destination, timeout)) res = capv_lib.capvput(motor + '-MoveVel', 0 - jvel) # TODO: The -MoveVel PV is not always there ? # Investigations needed #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') done = lib.waitForStartAndDone(motor, tc_no, timeout) msta = int(capv_lib.capvget(motor + '.MSTA')) miss = int(capv_lib.capvget(motor + '.MISS')) if (msta & lib.MSTA_BIT_PROBLEM): capv_lib.capvput(motor + '-ErrRst', 1) self.assertEqual(0, msta & lib.MSTA_BIT_MINUS_LS, 'DLY Minus hard limit not reached MoveVel') self.assertEqual(0, msta & lib.MSTA_BIT_PLUS_LS, 'DLY Plus hard limit not reached MoveVel') self.assertEqual(0, miss, 'DLY MISS not set MoveVel') # per10 UserPosition def test_TC_1334(self): motor = self.motor if (self.msta & lib.MSTA_BIT_HOMED): tc_no = "TC-1234-q0-percent-UserPosition" print('%s' % tc_no) done = lib.moveWait(motor, tc_no, self.jog_start_pos) UserPosition = capv_lib.capvget(motor + '.RBV', use_monitor=False) print('%s postion=%f jog_start_pos=%f done=%s' % (tc_no, UserPosition, self.jog_start_pos, done)) self.assertEqual(1, done, 'moveWait should return done') # Low soft limit in controller when using MoveAbs def test_TC_1335(self): motor = self.motor if (self.msta & lib.MSTA_BIT_HOMED): tc_no = "TC-1235-low-soft-limit Moveabs" print('%s' % tc_no) drvUseEGU = capv_lib.capvget(motor + '-DrvUseEGU-RB') if drvUseEGU == 1: mres = 1.0 else: mres = capv_lib.capvget(motor + '.MRES') rbv = capv_lib.capvget(motor + '.RBV') jar = capv_lib.capvget(motor + '.JAR') capv_lib.capvput(motor + '-ACCS', jar / mres) jvel = capv_lib.capvget(motor + '.JVEL') capv_lib.capvput(motor + '-VELO', jvel / mres) destination = self.llm - 1 timeout = lib.calcTimeOut(motor, destination, jvel) print('%s rbv=%f destination=%f timeout=%f' % (tc_no, rbv, destination, timeout)) res = capv_lib.capvput(motor + '-MoveAbs', (destination) / 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') done = lib.waitForStartAndDone(motor, tc_no, timeout) msta = int(capv_lib.capvget(motor + '.MSTA')) miss = int(capv_lib.capvget(motor + '.MISS')) success = lib.verifyPosition(motor, rbv) if (msta & lib.MSTA_BIT_PROBLEM): capv_lib.capvput(motor + '-ErrRst', 1) self.assertEqual(success, globals.SUCCESS, 'verifyPosition returned SUCCESS') self.assertEqual(0, msta & lib.MSTA_BIT_MINUS_LS, 'DLY Minus hard limit not reached Moveabs') self.assertEqual(0, msta & lib.MSTA_BIT_PLUS_LS, 'DLY Plus hard limit not reached Moveabs') self.assertEqual(0, miss, 'DLY MISS not set Moveabs')
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) capv_lib.capvput(motor + '-ErrRst', 1) # Prepare parameters for jogging and backlash self.setSoftLimitsOff(motor) capv_lib.capvput(motor + '.VELO', self.myVELO) capv_lib.capvput(motor + '.ACCL', self.myACCL) capv_lib.capvput(motor + '.JVEL', self.myJVEL) capv_lib.capvput(motor + '.JAR', self.myJAR) capv_lib.capvput(motor + '.BVEL', self.myBVEL) capv_lib.capvput(motor + '.BACC', self.myBACC) capv_lib.capvput(motor + '.BDST', self.myBDST) capv_lib.capvput(motor + '.FRAC', self.myFRAC) capv_lib.capvput(motor + '.RTRY', self.myRTRY) capv_lib.capvput(motor + '.RMOD', motorRMOD_D) capv_lib.capvput(motor + '.DLY', self.myDLY)
class Test(unittest.TestCase): hasROlimit = 0 drvUseEGU_RB = None drvUseEGU = 0 motor = os.getenv("TESTEDMOTORAXIS") capv_lib.capvput(motor + '-DbgStrToLOG', "Start " + os.path.basename(__file__)[0:20]) vers = float(capv_lib.capvget(motor + '.VERS')) if vers >= 6.94 and vers <= 7.09 : hasROlimit = 1 drvUseEGU_RB = capv_lib.capvget(motor + '-DrvUseEGU-RB') drvUseEGU = 0 if drvUseEGU_RB == 1: capv_lib.capvput(motor + '-DrvUseEGU', drvUseEGU) #drvUseEGU = capv_lib.capvget(motor + '-DrvUseEGU-RB') def test_TC_90000(self): tc_no = 90010 capv_lib.capvput(self.motor + '-DbgStrToLOG', "Start " + str(tc_no)) lib.motorInitAllForBDST(self.motor, 90000) capv_lib.capvput(self.motor + '-DbgStrToLOG', "End " + str(tc_no)) def test_TC_90010(self): tc_no = 90010 encRel = 0 capv_lib.capvput(self.motor + '-DbgStrToLOG', "Start " + str(tc_no)) #vers = float(capv_lib.capvget(self.motor + '.VERS')) #print('%s vers=%g' % (tc_no, vers)) #self.assertEqual(0, 1, '1 != 0') testPassed = readBackParamVerify(self, self.motor, tc_no, '-DrvUseEGU-RB', 0) motorInitVeloAcc(self, self.motor, tc_no, encRel) mres = 0.1 dir = 0 off = 0.5 setMresDirOff(self, self.motor, tc_no, mres, dir, off) motorInitLimitsNoC(self, self.motor, tc_no) if testPassed: capv_lib.capvput(self.motor + '-DbgStrToLOG', "Passed " + str(tc_no)) else: capv_lib.capvput(self.motor + '-DbgStrToLOG', "Failed " + str(tc_no)) assert (testPassed) def test_TC_90011(self): tc_no = 90011 #setLimit(self, motor, tc_no, field, val, expDHLM, expDLLM, expHLM, expLLM, expM3rhlm, expM3rllm): setLimit(self, self.motor, tc_no, "DHLM", 4.1, 4.1, -5.0, 4.6, -4.5, 41.0, -50.0) def test_TC_90012(self): tc_no = 90012 #setLimit(self, motor, tc_no, field, val, expDHLM, expDLLM, expHLM, expLLM, expM3rhlm, expM3rllm): setLimit(self, self.motor, tc_no, "HLM", 4.7, 4.2, -5.0, 4.7, -4.5, 42.0, -50.0) def test_TC_90013(self): tc_no = 90013 #setLimit(self, motor, tc_no, field, val, expDHLM, expDLLM, expHLM, expLLM, expM3rhlm, expM3rllm): setLimit(self, self.motor, tc_no, "DLLM", -5.3, 4.2, -5.3, 4.7, -4.8, 42.0, -53.0) def test_TC_90014(self): tc_no = 90014 #setLimit(self, motor, tc_no, field, val, expDHLM, expDLLM, expHLM, expLLM, expM3rhlm, expM3rllm): setLimit(self, self.motor, tc_no, "LLM", -5.4, 4.2, -5.9, 4.7, -5.4, 42.0, -59.0) ################################################################################################################### #Invert mres def test_TC_90020(self): tc_no = 90020 capv_lib.capvput(self.motor + '-DbgStrToLOG', "Start " + str(tc_no)) encRel = 0 # mres, dir,off, hlm, expHLM, expM3rhlm, expLLM, expM3rllm) motorInitVeloAcc(self, self.motor, tc_no, encRel) mres = -0.1 dir = 0 off = 0.5 setMresDirOff(self, self.motor, tc_no, mres, dir, off) motorInitLimitsNoC(self, self.motor, tc_no) capv_lib.capvput(self.motor + '-DbgStrToLOG', "End " + str(tc_no)) def test_TC_90021(self): tc_no = 90021 #setLimit(self, motor, tc_no, field, val, expDHLM, expDLLM, expHLM, expLLM, expM3rhlm, expM3rllm): setLimit(self, self.motor, tc_no, "DHLM", 4.1, 4.1, -5.0, 4.6, -4.5, 50.0, -41.0) def test_TC_90022(self): tc_no = 90022 #setLimit(self, motor, tc_no, field, val, expDHLM, expDLLM, expHLM, expLLM, expM3rhlm, expM3rllm): setLimit(self, self.motor, tc_no, "HLM", 4.7, 4.2, -5.0, 4.7, -4.5, 50.0, -42.0) def test_TC_90023(self): tc_no = 90023 #setLimit(self, motor, tc_no, field, val, expDHLM, expDLLM, expHLM, expLLM, expM3rhlm, expM3rllm): setLimit(self, self.motor, tc_no, "DLLM", -5.3, 4.2, -5.3, 4.7, -4.8, 53.0, -42.0) def test_TC_90024(self): tc_no = 90024 #setLimit(self, motor, tc_no, field, val, expDHLM, expDLLM, expHLM, expLLM, expM3rhlm, expM3rllm): setLimit(self, self.motor, tc_no, "LLM", -5.4, 4.2, -5.9, 4.7, -5.4, 59.0, -42.0) ################################################################################################################### #Invert dir def test_TC_90030(self): tc_no = 90030 encRel = 0 capv_lib.capvput(self.motor + '-DbgStrToLOG', "Start " + str(tc_no)) # mres, dir,off, hlm, expHLM, expM3rhlm, expLLM, expM3rllm) motorInitVeloAcc(self, self.motor, tc_no, encRel) mres = 0.1 dir = 1 off = 0.5 setMresDirOff(self, self.motor, tc_no, mres, dir, off) motorInitLimitsNoC(self, self.motor, tc_no) capv_lib.capvput(self.motor + '-DbgStrToLOG', "End " + str(tc_no)) def test_TC_90031(self): tc_no = 90031 #setLimit(self, motor, tc_no, field, val, expDHLM, expDLLM, expHLM, expLLM, expM3rhlm, expM3rllm): setLimit(self, self.motor, tc_no, "DHLM", 4.1, 4.1, -5.0, 5.5, -3.6, 41.0, -50.0) def test_TC_90032(self): tc_no = 90032 #setLimit(self, motor, tc_no, field, val, expDHLM, expDLLM, expHLM, expLLM, expM3rhlm, expM3rllm): setLimit(self, self.motor, tc_no, "HLM", 4.7, 4.1, -4.2, 4.7, -3.6, 41.0, -42.0) def test_TC_90033(self): tc_no = 90033 #setLimit(self, motor, tc_no, field, val, expDHLM, expDLLM, expHLM, expLLM, expM3rhlm, expM3rllm): setLimit(self, self.motor, tc_no, "DLLM", -5.3, 4.1, -5.3, 5.8, -3.6, 41.0, -53.0) def test_TC_90034(self): tc_no = 90034 #setLimit(self, motor, tc_no, field, val, expDHLM, expDLLM, expHLM, expLLM, expM3rhlm, expM3rllm): setLimit(self, self.motor, tc_no, "LLM", -5.4, 5.9, -5.3, 5.8, -5.4, 59.0, -53.0) ################################################################################################################### #Invert mres, invert dir def test_TC_90040(self): tc_no = 90040 encRel = 0 capv_lib.capvput(self.motor + '-DbgStrToLOG', "Start " + str(tc_no)) # mres, dir,off, hlm, expHLM, expM3rhlm, expLLM, expM3rllm) motorInitVeloAcc(self, self.motor, tc_no, encRel) mres = -0.1 dir = 1 off = 0.5 setMresDirOff(self, self.motor, tc_no, mres, dir, off) motorInitLimitsNoC(self, self.motor, tc_no) capv_lib.capvput(self.motor + '-DbgStrToLOG', "End " + str(tc_no)) def test_TC_90041(self): tc_no = 90041 #setLimit(self, motor, tc_no, field, val, expDHLM, expDLLM, expHLM, expLLM, expM3rhlm, expM3rllm): setLimit(self, self.motor, tc_no, "DHLM", 4.1, 4.1, -5.0, 5.5, -3.6, 50.0, -41.0) def test_TC_90042(self): tc_no = 90042 #setLimit(self, motor, tc_no, field, val, expDHLM, expDLLM, expHLM, expLLM, expM3rhlm, expM3rllm): setLimit(self, self.motor, tc_no, "HLM", 4.7, 4.1, -4.2, 4.7, -3.6, 42.0, -41.0) def test_TC_90043(self): tc_no = 90043 #setLimit(self, motor, tc_no, field, val, expDHLM, expDLLM, expHLM, expLLM, expM3rhlm, expM3rllm): setLimit(self, self.motor, tc_no, "DLLM", -5.3, 4.1, -5.3, 5.8, -3.6, 53.0, -41.0) def test_TC_90044(self): tc_no = 90044 #setLimit(self, motor, tc_no, field, val, expDHLM, expDLLM, expHLM, expLLM, expM3rhlm, expM3rllm): setLimit(self, self.motor, tc_no, "LLM", -5.4, 5.9, -5.3, 5.8, -5.4, 53.0, -59.0) ######################################################################################################### # Test clipping def test_TC_90050(self): tc_no = 90050 encRel = 0 capv_lib.capvput(self.motor + '-DbgStrToLOG', "Start " + str(tc_no)) print('%s vers=%g hasROlimit=%d' % (tc_no, self.vers, self.hasROlimit)) self.assertEqual(1, self.hasROlimit, 'motorRecord supports RO soft limits') # mres, dir,off, hlm, expHLM, expM3rhlm, expLLM, expM3rllm) motorInitVeloAcc(self, self.motor, tc_no, encRel) mres = 0.1 dir = 0 off = 0.5 setMresDirOff(self, self.motor, tc_no, mres, dir, off) motorInitLimitsWithC(self, self.motor, tc_no) capv_lib.capvput(self.motor + '-DbgStrToLOG', "End " + str(tc_no)) def test_TC_90051(self): self.assertEqual(1, self.hasROlimit, 'motorRecord supports RO soft limits') tc_no = 90051 #setLimit(self, motor, tc_no, field, val, expDHLM, expDLLM, expHLM, expLLM, expM3rhlm, expM3rllm): setLimit(self, self.motor, tc_no, "DHLM", 10, 0.6, -0.7, 1.1, -0.2, 6.0, -7.0) def test_TC_90052(self): self.assertEqual(1, self.hasROlimit, 'motorRecord supports RO soft limits') tc_no = 90052 #setLimit(self, motor, tc_no, field, val, expDHLM, expDLLM, expHLM, expLLM, expM3rhlm, expM3rllm): setLimit(self, self.motor, tc_no, "HLM", 10, 0.6, -0.7, 1.1, -0.2, 6.0, -7.0) def test_TC_90053(self): self.assertEqual(1, self.hasROlimit, 'motorRecord supports RO soft limits') tc_no = 90053 #setLimit(self, motor, tc_no, field, val, expDHLM, expDLLM, expHLM, expLLM, expM3rhlm, expM3rllm): setLimit(self, self.motor, tc_no, "DLLM", -10.0, 0.6, -0.7, 1.1, -0.2, 6.0, -7.0) def test_TC_90054(self): self.assertEqual(1, self.hasROlimit, 'motorRecord supports RO soft limits') tc_no = 90054 #setLimit(self, motor, tc_no, field, val, expDHLM, expDLLM, expHLM, expLLM, expM3rhlm, expM3rllm): setLimit(self, self.motor, tc_no, "LLM", -10.0, 0.6, -0.7, 1.1, -0.2, 6.0, -7.0) #Invert mres def test_TC_90060(self): self.assertEqual(1, self.hasROlimit, 'motorRecord supports RO soft limits') tc_no = 90060 capv_lib.capvput(self.motor + '-DbgStrToLOG', "Start " + str(tc_no)) encRel = 0 # mres, dir,off, hlm, expHLM, expM3rhlm, expLLM, expM3rllm) motorInitVeloAcc(self, self.motor, tc_no, encRel) mres = -0.1 dir = 0 off = 0.5 setMresDirOff(self, self.motor, tc_no, mres, dir, off) motorInitLimitsWithC(self, self.motor, tc_no) capv_lib.capvput(self.motor + '-DbgStrToLOG', "End " + str(tc_no)) def test_TC_90061(self): self.assertEqual(1, self.hasROlimit, 'motorRecord supports RO soft limits') tc_no = 90061 #setLimit(self, motor, tc_no, field, val, expDHLM, expDLLM, expHLM, expLLM, expM3rhlm, expM3rllm): setLimit(self, self.motor, tc_no, "DHLM", 10, 0.7, -0.6, 1.2, -0.1, 6.0, -7.0) def test_TC_90062(self): self.assertEqual(1, self.hasROlimit, 'motorRecord supports RO soft limits') tc_no = 90062 #setLimit(self, motor, tc_no, field, val, expDHLM, expDLLM, expHLM, expLLM, expM3rhlm, expM3rllm): setLimit(self, self.motor, tc_no, "HLM", 10, 0.7, -0.6, 1.2, -0.1, 6.0, -7.0) def test_TC_90063(self): self.assertEqual(1, self.hasROlimit, 'motorRecord supports RO soft limits') tc_no = 90063 #setLimit(self, motor, tc_no, field, val, expDHLM, expDLLM, expHLM, expLLM, expM3rhlm, expM3rllm): setLimit(self, self.motor, tc_no, "DLLM", -10.0, 0.7, -0.6, 1.2, -0.1, 6.0, -7.0) def test_TC_90064(self): self.assertEqual(1, self.hasROlimit, 'motorRecord supports RO soft limits') tc_no = 90064 #setLimit(self, motor, tc_no, field, val, expDHLM, expDLLM, expHLM, expLLM, expM3rhlm, expM3rllm): setLimit(self, self.motor, tc_no, "LLM", -10.0, 0.7, -0.6, 1.2, -0.1, 6.0, -7.0) #Invert dir def test_TC_90070(self): self.assertEqual(1, self.hasROlimit, 'motorRecord supports RO soft limits') tc_no = 90070 encRel = 0 capv_lib.capvput(self.motor + '-DbgStrToLOG', "Start " + str(tc_no)) # mres, dir,off, hlm, expHLM, expM3rhlm, expLLM, expM3rllm) motorInitVeloAcc(self, self.motor, tc_no, encRel) mres = 0.1 dir = 1 off = 0.5 setMresDirOff(self, self.motor, tc_no, mres, dir, off) motorInitLimitsWithC(self, self.motor, tc_no) capv_lib.capvput(self.motor + '-DbgStrToLOG', "End " + str(tc_no)) def test_TC_90071(self): self.assertEqual(1, self.hasROlimit, 'motorRecord supports RO soft limits') tc_no = 90071 #setLimit(self, motor, tc_no, field, val, expDHLM, expDLLM, expHLM, expLLM, expM3rhlm, expM3rllm): setLimit(self, self.motor, tc_no, "DHLM", 10, 0.6, -0.7, 1.2, -0.1, 6.0, -7.0) def test_TC_90072(self): self.assertEqual(1, self.hasROlimit, 'motorRecord supports RO soft limits') tc_no = 90072 #setLimit(self, motor, tc_no, field, val, expDHLM, expDLLM, expHLM, expLLM, expM3rhlm, expM3rllm): setLimit(self, self.motor, tc_no, "HLM", 10, 0.6, -0.7, 1.2, -0.1, 6.0, -7.0) def test_TC_90073(self): self.assertEqual(1, self.hasROlimit, 'motorRecord supports RO soft limits') tc_no = 90073 #setLimit(self, motor, tc_no, field, val, expDHLM, expDLLM, expHLM, expLLM, expM3rhlm, expM3rllm): setLimit(self, self.motor, tc_no, "DLLM", -10.0, 0.6, -0.7, 1.2, -0.1, 6.0, -7.0) def test_TC_90074(self): self.assertEqual(1, self.hasROlimit, 'motorRecord supports RO soft limits') tc_no = 90074 #setLimit(self, motor, tc_no, field, val, expDHLM, expDLLM, expHLM, expLLM, expM3rhlm, expM3rllm): setLimit(self, self.motor, tc_no, "LLM", -10.0, 0.6, -0.7, 1.2, -0.1, 6.0, -7.0) #Invert MRES and dir def test_TC_90080(self): self.assertEqual(1, self.hasROlimit, 'motorRecord supports RO soft limits') tc_no = 90080 capv_lib.capvput(self.motor + '-DbgStrToLOG', "Start " + str(tc_no)) encRel = 0 # mres, dir,off, hlm, expHLM, expM3rhlm, expLLM, expM3rllm) motorInitVeloAcc(self, self.motor, tc_no, encRel) mres = -0.1 dir = 1 off = 0.5 setMresDirOff(self, self.motor, tc_no, mres, dir, off) motorInitLimitsWithC(self, self.motor, tc_no) capv_lib.capvput(self.motor + '-DbgStrToLOG', "End " + str(tc_no)) def test_TC_90081(self): self.assertEqual(1, self.hasROlimit, 'motorRecord supports RO soft limits') tc_no = 90081 #setLimit(self, motor, tc_no, field, val, expDHLM, expDLLM, expHLM, expLLM, expM3rhlm, expM3rllm): setLimit(self, self.motor, tc_no, "DHLM", 10, 0.7, -0.6, 1.1, -0.2, 6.0, -7.0) def test_TC_90082(self): self.assertEqual(1, self.hasROlimit, 'motorRecord supports RO soft limits') tc_no = 90082 #setLimit(self, motor, tc_no, field, val, expDHLM, expDLLM, expHLM, expLLM, expM3rhlm, expM3rllm): setLimit(self, self.motor, tc_no, "HLM", 10, 0.7, -0.6, 1.1, -0.2, 6.0, -7.0) def test_TC_90083(self): self.assertEqual(1, self.hasROlimit, 'motorRecord supports RO soft limits') tc_no = 90083 #setLimit(self, motor, tc_no, field, val, expDHLM, expDLLM, expHLM, expLLM, expM3rhlm, expM3rllm): setLimit(self, self.motor, tc_no, "DLLM", -10, 0.7, -0.6, 1.1, -0.2, 6.0, -7.0) def test_TC_90084(self): self.assertEqual(1, self.hasROlimit, 'motorRecord supports RO soft limits') tc_no = 90084 #setLimit(self, motor, tc_no, field, val, expDHLM, expDLLM, expHLM, expLLM, expM3rhlm, expM3rllm): setLimit(self, self.motor, tc_no, "LLM", -10, 0.7, -0.6, 1.1, -0.2, 6.0, -7.0) def test_TC_900999(self): if self.drvUseEGU_RB == 1: capv_lib.capvput(self.motor + '-DrvUseEGU', 1)
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 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')
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): print('%s: getAcceleration %s' % (tc_no, motor)) res = capv_lib.capvget(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 & lib.MSTA_BIT_HOMED): self.assertNotEqual(0, self.msta & lib.MSTA_BIT_HOMED, 'MSTA.homed (Axis is not homed)') # 10% dialPosition def test_TC_402(self): tc_no = "TC-402-10-percent" print('%s' % tc_no) motor = self.motor if (self.msta & lib.MSTA_BIT_HOMED): ret = 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 & 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) ret = lib.move(self.motor, self.per20_UserPosition, 60) 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) assert (ret == 0) # JOGR def test_TC_404(self): tc_no = "TC-404-JOGR" print('%s' % tc_no) motor = self.motor if (self.msta & lib.MSTA_BIT_HOMED): accl = float(capv_lib.capvget(motor + '.ACCL')) jvel = float(capv_lib.capvget(motor + '.JVEL')) saved_JAR = float(capv_lib.capvget(motor + '.JAR')) used_JAR = jvel / (accl + 2.0) capv_lib.capvput(motor + '.JAR', used_JAR) capv_lib.capvput(motor + '.JOGR', 1, wait=True) resacc = self.getAcceleration(motor, tc_no) expacc = used_JAR capv_lib.capvput(motor + '.JAR', saved_JAR) print('%s JAR=%f expacc=%f resacc=%f' % (tc_no, used_JAR, expacc, resacc)) assert lib.calcAlmostEqual(self.motor, tc_no, expacc, resacc, 2)
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 motorInitTC(tself, motor, tc_no, frac, encRel): capv_lib.capvput(motor + '.FRAC', frac) capv_lib.capvput(motor + '.UEIP', encRel) msta = int(capv_lib.capvget(motor + '.MSTA', use_monitor=False)) print('%s:%d motorInitTC msta=%s' % (tc_no, lineno(), lib.getMSTAtext(msta)))
def setMresDirOff(self, motor, tc_no, mres, dir, off): capv_lib.capvput(motor + '.MRES', mres) capv_lib.capvput(motor + '.DIR', dir) capv_lib.capvput(motor + '.OFF', off)