def testInvokeOtherClient(self):
class Target:
def v8(self): return "V8 great!"
def v9(self): raise ProtocolException("V9 not good.")
def v10(self): raise IOError("V10 have problems.")
def v(self, i, b): return "OK"
mc1 = Session((MessageTransportTest.addr, MessageTransportTest.port), Target(), name="T1-Benz")
mc1.start()
checker = Session.newSession((MessageTransportTest.addr, MessageTransportTest.port), None, "T1-Checher")
benzChecker = checker.blockingInvoker(u"T1-Benz", 10)
v8r = benzChecker.v8()
self.assertEqual(v8r, "V8 great!")
try:
benzChecker.v9()
self.assertTrue(False)
except ProtocolException as e:
self.assertEqual(e.__str__(), "V9 not good.")
try:
benzChecker.v10()
self.assertTrue(False)
except ProtocolException as e:
self.assertEqual(e.__str__(), "V10 have problems.")
self.assertEqual(benzChecker.v(1, False), "OK")
try:
benzChecker.v11()
self.assertTrue(False)
except ProtocolException as e:
self.assertEqual(e.__str__(), "InvokeError: Command v11 not found.")
mc1.stop()
checker.stop()
def __init__(self, adapter, port, address, serviceName):
self.adapterServer = AdapterServer(port)
if adapter is None:
self.adapter = SimulatedAdapter(port)
else:
self.adapter = ExecutableAdapter(adapter, port)
self.adapterServer.accept()
class PXIFrequencyDividerService:
def __init__(self, handler):
self.handler = handler
def getDivide(self):
raise RuntimeError('')
def setDivide(self, divide):
self.handler.adapterServer.sendCommand(self.__createFrequancyCommand(divide))
def setDelay(self, channel, course, fine):
self.handler.adapterServer.sendCommand(self.__createDelayCommand(channel, course, fine))
def __createFrequancyCommand(self, divide):
if divide < 1 or divide > 255:
raise RuntimeError('Divide out of range.')
addr = b'0x28c\0' + b'0x'
data = format(divide, '2X').replace(' ', '0').encode('utf-8')
cmd = addr + data + b'\0\0\0\0\0\0\0'
return cmd
def __createDelayCommand(self, channel, courseDelay, fineDelay):
if channel < 0 or channel >= 40:
raise RuntimeError('Channel out of range.')
if courseDelay < 0 or courseDelay >= 60000:
raise RuntimeError('Course Delay out of range.')
if fineDelay < 0 or fineDelay >= 256:
raise RuntimeError('Fine Delay out of range.')
addr = b'0x288\0' + b'0x'
cn = format(channel, '2X').replace(' ', '0').encode('utf-8')
cD = format(courseDelay, '4X').replace(' ', '0').encode('utf-8')
fD = format(fineDelay, '2X').replace(' ', '0').encode('utf-8')
cmd = addr + cn + cD + fD + b'\0'
return cmd
time.sleep(1)
self.service = PXIFrequencyDividerService(self)
self.session = Session.newSession(address, self.service, serviceName)
self.service.setDivide(99)
for c in range(0, 40):
self.service.setDelay(c, 0, 0)
from Pydra import Session
import time
if __name__ == '__main__':
session = Session.newSession(('192.168.25.27', 20102), None,
"PolarizationControlTestLocal")
try:
invoker = session.blockingInvoker("PolarizationControlService")
print(invoker.hello("23"))
time.sleep(3)
except Exception:
print('e')
pass
session.stop()
temperature = temperatures[i]
pids[i].Kp = pidPara[i][0]
pids[i].Ki = pidPara[i][1]
pids[i].Kd = pidPara[i][2]
vs[i] += pids[i].update(temperature)
pids[i].setPoint(pidPara[i][3] + tempSetDelta(t, i))
if (vs[i] > 1.5):
vs[i] = 1.5
if (vs[i] < 0):
vs[i] = 0
dc.setVoltages(vs)
print(
'{:.1f}\t{:.3f}\t{:.3f}\t{:.1f}\t{:.1f}\t{:.1f}\t{:.3f}\t{:.3f}\t{:.3f}\t{:.3f}\t{:.3f}\t{:.3f}\t{:.3f}'
.format(t, r1, r2, ppm1, ppm2, ratioPPM, roomTemp,
temperatures[0], vs[0], temperatures[1], vs[1],
temperatures[2], vs[2]))
file.write(
'{}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}\n'.format(
t, r1, r2, ppm1, ppm2, ratioPPM, roomTemp, temperatures[0],
vs[0], temperatures[1], vs[1], temperatures[2], vs[2]))
file.flush()
if __name__ == '__main__':
tc = Control()
tc.setSession(
Session.newSession(('192.168.25.27', 20102), tc,
'Temperature Control For BS and PDs'))
tc.start()
from Pydra import Session
import time
import threading
import random
print('In Try.')
session = Session.newSession(("localhost", 20102))
bi = session.blockingInvoker(timeout=1)
while True:
time.sleep(5)
try:
si = bi.sessionsInformation()
print(si)
except BaseException as e:
print("EXCEPTION!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
from Pydra import Session
if __name__ == '__main__':
session = Session.newSession(('192.168.25.27', 20102))
invoker = session.blockingInvoker('HMC7044EvalTest')
print(invoker.deviceConnected())
for i in range(0, 14):
invoker.setDivider(i, 200)
import time
time.sleep(1)
session.stop()
from Services.MultiMeter.KeySightMultiMeter import KeySight_MultiMeter_34465A, KeySight_MultiMeter_34470A, \
MeasureQuantity
from Pydra import Session
from Services.Storage import StorageService, HBTFileElement
import time
if __name__ == '__main__':
session = Session.newSession(('192.168.25.27', 20102), None,
"LaserStabilityTest")
dmm1 = session.asynchronousInvoker('KeySightMultiMeter_34470A_1')
dmm2 = session.asynchronousInvoker('KeySightMultiMeter_34470A_2')
dmm1.setDCVoltageMeasurement(range=1, autoRange=False,
aperture=0.001).sync()
dmm2.setDCVoltageMeasurement(range=1, autoRange=False,
aperture=0.001).sync()
def measure(count=1000):
f1 = dmm1.directMeasure(count)
f2 = dmm2.directMeasure(count)
r1 = f1.sync()
r2 = f2.sync()
ar1 = sum(r1) / len(r1)
ar2 = sum(r2) / len(r2)
return [ar1, ar2]
ref = measure(400)
while True:
r = measure(400)
ratio = r[0] / r[1]
refRatio = ref[0] / ref[1]
ppm = 1e6 * (ratio / refRatio - 1)
from Pydra import Session
import time
if __name__ == '__main__':
session = Session.newSession(('192.168.25.27', 20102), None, "ServiceTest")
try:
invoker = session.blockingInvoker("GroundTDCServer")
# invoker.turnOnAnalyser("Counter", {"StorageElement": "/Hwaipy/Hydra/20180906/test.counts"})
print(invoker.fetchResults("Counter"))
time.sleep(3)
except Exception as e:
print('e')
print(e)
pass
session.stop()
