1404 lines
43 KiB
Python
1404 lines
43 KiB
Python
|
|
# python
|
|
|
|
import time
|
|
import timeit
|
|
import numpy as np
|
|
import array
|
|
import inspect
|
|
import os
|
|
import operator
|
|
import platform
|
|
import sys
|
|
import PyCafe
|
|
|
|
cafe = PyCafe.CyCafe()
|
|
cyca = PyCafe.CyCa()
|
|
|
|
##############################################################
|
|
# (1) Establishing connections to EPICS Process Variables (PVs)
|
|
# (2) Simple single channel operations
|
|
# (3) Waveforms and Arrays
|
|
# (4) Multiple scalar operations, i.e. operations on several PVs with scalar values
|
|
# (5) Multiple compound operations, i.e. operations on several PVS with either scalar values or arrays
|
|
# (6) Synchronous group operations
|
|
# (7) Control system parameters, i.e. operating limits, engineerimg units
|
|
# (8) Monitors, either with or without user supplied callbacks
|
|
# (9) Asynchronous interactions and retrieving data from Cache
|
|
# (10) Synchronous group operations, with externally defined groups
|
|
# (11) Special Methods, match, setAndMatch
|
|
# (END) Gracefully terminate CAFE
|
|
##############################################################
|
|
|
|
PY2 = True
|
|
PY3 = False
|
|
|
|
if sys.version_info >= (3, 0):
|
|
PY3 = True
|
|
PY2 = False
|
|
|
|
print("This is Python Version:\n", sys.version_info)
|
|
|
|
#################################################################
|
|
# Test channels
|
|
#################################################################
|
|
# For use in office network cao
|
|
PV1 = 'ARIDI-BPM-01LE:X-AVG'
|
|
PV2 = 'ARIDI-BPM-01LE:Y-AVG'
|
|
PV3 = 'ARIDI-BPM-01LB:X-AVG'
|
|
PV4 = 'ARIDI-BPM-01LB:Y-AVG'
|
|
PVWF1 = 'ARIDI-BPM-01LE:WF-INT-1'
|
|
PVWF2 = 'ARIDI-BPM-01LB:WF-INT-2'
|
|
PVWF3 = 'ARIDI-BPM-01SE:WF-INT-2'
|
|
PVWF4 = 'ARIDI-BPM-01SB:WF-INT-2'
|
|
|
|
PVS = 'ARIDI-BPM-01SB:SET-ENABLE'
|
|
PV_JOKE = 'PV-DOES-NOT:EXIST'
|
|
PV_REAL = 'SAR-CMON-MAG4531:VOLTAGE-5'
|
|
|
|
pvlist1 = [PV1, PV2, PV3, PV4]
|
|
pvlistWF = [PVWF1, PVWF2, PVWF3, PVWF4]
|
|
pvlistAll = [PV1, PV2, PV3, PV4, PVWF1, PVWF2, PVWF3, PVWF4, PVS, PV_JOKE]
|
|
|
|
#################################################################
|
|
|
|
|
|
def py_connect_callback(handle: int = None, pv_name: str = "", status: int = None):
|
|
try:
|
|
print("pv_name=", pv_name)
|
|
print("CONNECT CALLBACK HANDLER INVOKED FOR HANDLE with status:", handle, status)
|
|
# Usual action is to get the updated value
|
|
print("isConnected?", cafe.isConnected(handle))
|
|
print("Channel=", cafe.getPVNameFromHandle(handle))
|
|
print("Value =", cafe.getCache(handle)) # native format
|
|
# else dt='int', dt='float'
|
|
print("Value =", cafe.getCache(handle, dt='str'))
|
|
|
|
except PyCafe.CafeException as cafeEx:
|
|
|
|
cafeEx.show()
|
|
# or
|
|
cafeEx.reveal()
|
|
# or
|
|
print(cafeEx.name, "(handle=", cafeEx.handle, ")")
|
|
print(cafeEx.error_code, ":", cafeEx.error_text, cafeEx.error_info)
|
|
|
|
except Exception as inst:
|
|
print(inst)
|
|
|
|
print("END: CONNECT CALLBACK HANDLER COMPLETED FOR HANDLE with status:", handle, status)
|
|
print("")
|
|
return
|
|
#################################################################
|
|
# A user supplied callback function to be (optionally) used in (8) Monitors
|
|
# (or puts and gets if required)
|
|
#################################################################
|
|
|
|
|
|
def py_callback(handle: int = None, pvname: str = ""):
|
|
# operations permitted from within handle are getCache, set and close
|
|
# open, get and monitorStart are not permitted
|
|
try:
|
|
print("")
|
|
print("START: MONITOR CALLBACK HANDLER INVOKED FOR HANDLE:", handle)
|
|
# Usual action is to get the updated value
|
|
print("isConnected?", cafe.isConnected(handle))
|
|
print("Channel=", cafe.getPVNameFromHandle(handle))
|
|
print("Value =", cafe.getCache(handle)) # native format
|
|
# else dt='int', dt='float'
|
|
print("Value =", cafe.getCache(handle, dt='str'))
|
|
#print ("DbrDataType =", cafe.getDbrDataTypeInCallback(handle) )
|
|
#print ("DataType =", cafe.getDataTypeInCallback(handle) )
|
|
#print ("DbrBase =", cafe.getDbrBaseInCallback(handle) )
|
|
|
|
# This retrieves all the parameters that acted as input to the monitor
|
|
#Input is handle and monitorId
|
|
monid = cafe.getMonitorIDInCallback(handle)
|
|
print("monid ", monid)
|
|
#mp=cafe.getMonitorPolicyVector(handle, monid)
|
|
# mp.show()
|
|
|
|
# get PVData
|
|
p1 = cafe.getPVCache(handle)
|
|
print("--------")
|
|
p1.showMax(10) # if waveform print only first 10 elements
|
|
print("--------")
|
|
# alternatively:
|
|
print("Value =", p1.value[0])
|
|
print("status = {0}".format(p1.status))
|
|
print("alarmStatus = {0}".format(p1.alarmStatus))
|
|
print("alarmSeverity = {0}".format(p1.alarmSeverity))
|
|
print("ts =", p1.ts[0], p1.ts[1])
|
|
print("tsDate =", p1.tsDate[0], p1.tsDate[1],
|
|
p1.tsDate[2], p1.tsDate[3],
|
|
p1.tsDate[4], p1.tsDate[5], p1.tsDate[6])
|
|
|
|
# Increment value - set to this channel
|
|
# newValue=1+pv.value[0]
|
|
# if newValue < 10:
|
|
# cafe.set(handle, newValue)
|
|
|
|
except PyCafe.CafeException as cafeEx:
|
|
|
|
cafeEx.show()
|
|
# or
|
|
cafeEx.reveal()
|
|
# or
|
|
print(cafeEx.name, "(handle=", cafeEx.handle, ")")
|
|
print(cafeEx.error_code, ":", cafeEx.error_text, cafeEx.error_info)
|
|
|
|
|
|
except Exception as inst:
|
|
print(inst)
|
|
|
|
print("END: MONITOR CALLBACK HANDLER COMPLETED FOR HANDLE:", handle)
|
|
print("")
|
|
return
|
|
##############################################################
|
|
|
|
|
|
#################################################################
|
|
# A user supplied callback function to be (optionally) used in (8) Monitors.
|
|
# This is a variant to the above; it returns a PVData object, handle, and pv name.
|
|
#################################################################
|
|
def py_callback_pvdata(handle: int = None, pvname: str = "", pvdata: PyCafe.pvdata = None ):
|
|
# operations permitted from within handle are getCache, set and close
|
|
# open, get and monitorStart are not permitted
|
|
try:
|
|
print("MonitorID:", cafe.getMonitorIDInCallback(handle), "for handle/pv", handle, pvname)
|
|
print("START: MONITOR CALLBACK PVDATA HANDLER INVOKED FOR HANDLE/PV:", handle, pvname)
|
|
# Usual action is to get the updated value
|
|
print("isConnected?", cafe.isConnected(handle))
|
|
print("Channel=", pvname)
|
|
print("Value (native) =", pvdata.value[0]) # native format
|
|
# else dt='int', dt='float'
|
|
print("Value (str) =", cafe.getCache(handle, dt='str'))
|
|
#print ("DbrDataType =", cafe.getDbrDataTypeInCallback(handle) )
|
|
#print ("DataType =", cafe.getDataTypeInCallback(handle) )
|
|
#print ("DbrBase =", cafe.getDbrBaseInCallback(handle) )
|
|
print("----------")
|
|
pvdata.showMax(10) # if waveform print only first 10 elements
|
|
print("----------")
|
|
# alternatively:
|
|
print("Value =", pvdata.value[0])
|
|
print("status = {0}".format(pvdata.status))
|
|
print("alarmStatus = {0}".format(pvdata.alarmStatus))
|
|
print("alarmSeverity = {0}".format(pvdata.alarmSeverity))
|
|
print("ts =", pvdata.ts[0], pvdata.ts[1])
|
|
print("tsDate =", pvdata.tsDate[0], pvdata.tsDate[1],
|
|
pvdata.tsDate[2], pvdata.tsDate[3],
|
|
pvdata.tsDate[4], pvdata.tsDate[5], pvdata.tsDate[6])
|
|
|
|
except PyCafe.CafeException as cafeEx:
|
|
|
|
cafeEx.show()
|
|
# or
|
|
cafeEx.reveal()
|
|
# or
|
|
print(cafeEx.name, "(handle=", cafeEx.handle, ")")
|
|
print(cafeEx.error_code, ":", cafeEx.error_text, cafeEx.error_info)
|
|
|
|
except Exception as inst:
|
|
print(inst)
|
|
|
|
print("END: MONITOR CALLBACK PVDATA HANDLER COMPLETED FOR HANDLE/PV:", handle, pvname)
|
|
print("")
|
|
return
|
|
##############################################################
|
|
|
|
|
|
#################################################################
|
|
# A user supplied callback function to be (optionally) used in ctrl monitors.
|
|
# This is a variant to the above; it returns a PVCtrl object, handle, and pv name.
|
|
#################################################################
|
|
def py_callback_pvctrl(handle: int = None, pvname: str = "", pvctrl: PyCafe.pvctrl = None):
|
|
# operations permitted from within handle are getCache, set and close
|
|
# open, get and monitorStart are not permitted
|
|
try:
|
|
print("")
|
|
print("START: MONITOR CALLBACK CTRL HANDLER INVOKED FOR HANDLE/PV:", handle, pvname)
|
|
# Usual action is to get the updated value
|
|
print("isConnected?", cafe.isConnected(handle))
|
|
print("Channel=", pvname)
|
|
print("Value (native) =", pvctrl.value[0]) # native format
|
|
# else dt='int', dt='float'
|
|
print("Value (str) =", str(pvctrl.value[0]))
|
|
#print ("DbrDataType =", cafe.getDbrDataTypeInCallback(handle) )
|
|
#print ("DataType =", cafe.getDataTypeInCallback(handle) )
|
|
#print ("DbrBase =", cafe.getDbrBaseInCallback(handle) )
|
|
print("----------")
|
|
pvctrl.showMax(10) # if waveform print only first 10 elements
|
|
print("----------")
|
|
|
|
except PyCafe.CafeException as cafeEx:
|
|
|
|
cafeEx.show()
|
|
# or
|
|
cafeEx.reveal()
|
|
# or
|
|
print(cafeEx.name, "(handle=", cafeEx.handle, ")")
|
|
print(cafeEx.error_code, ":", cafeEx.error_text, cafeEx.error_info)
|
|
|
|
except Exception as inst:
|
|
print(inst)
|
|
|
|
print("END: MONITOR CALLBACK CTRL HANDLER COMPLETED FOR HANDLE/PV:", handle, pvname)
|
|
print("")
|
|
return
|
|
|
|
|
|
#################################################################
|
|
# A user supplied callback function for put operations (optional)
|
|
#################################################################
|
|
def py_callback_put(handle):
|
|
print("Channel=", cafe.getPVNameFromHandle(handle))
|
|
print("Old Value from Cache =", cafe.getCache(handle)) # native format
|
|
print("Put HANDLER COMPLETED FOR HANDLE:", handle)
|
|
return
|
|
|
|
#################################################################
|
|
# A user supplied callback function for get operations (optional)
|
|
#################################################################
|
|
|
|
|
|
def py_callback_get(handle):
|
|
print("Channel=", cafe.getPVNameFromHandle(handle))
|
|
print("Value =", cafe.getCache(handle)) # native format
|
|
print("Get HANDLER COMPLETED FOR HANDLE:", handle)
|
|
return
|
|
##############################################################
|
|
|
|
|
|
##############################################################
|
|
# (1) Establishing connections to EPICS Process Variables (PVs)
|
|
##############################################################
|
|
# Explicitly opening channels is good practice even if only optional
|
|
|
|
|
|
print("CAFE_VERSION:", cafe.CAFE_version())
|
|
print("EPICS_VERSION:", cafe.EPICS_version(), cafe.epics_version_string())
|
|
print("CA_VERSION:", cafe.ca_version())
|
|
|
|
#cafe.monitor("ARIDI-BPM:OFB-YRMS.DESC:EGU", cb=py_callback_pvctrl)
|
|
#time.sleep(1)
|
|
#pvc = cafe.getCache("ARIDI-BPM:OFB-YRMS.EGU")
|
|
#print(pvc)
|
|
|
|
#sys.exit(1)
|
|
|
|
print("INFO: pend time for open", cafe.getOpenDefaultPendTime())
|
|
# open a single channel
|
|
|
|
# Connect callback function is optional
|
|
try:
|
|
handleS = cafe.open("test ", cb=py_connect_callback)
|
|
|
|
except PyCafe.CafeException as cafeEx: # inst:
|
|
print("PyCafe.CafeException")
|
|
# if isinstance(inst.args[0], PyCafe.CyCafeException):
|
|
# cafeEx=inst.args[0]
|
|
cafeEx.show()
|
|
# or
|
|
cafeEx.reveal()
|
|
# or
|
|
print(cafeEx.error_code, ":", cafeEx.error_text, cafeEx.error_info)
|
|
# else:
|
|
# print(inst)
|
|
|
|
except Exception as inst:
|
|
print("Exception")
|
|
print(inst.args)
|
|
print(inst)
|
|
# better practice is to open all channels at once
|
|
|
|
|
|
start = time.time()
|
|
|
|
|
|
# cafe.openPrepare()
|
|
# All Chhanels opened only after openAndWait
|
|
# Otherwise channels will open after each cafe.open method is executed
|
|
|
|
try:
|
|
# return list of handles
|
|
hlist1 = cafe.open(pvlist1, cb=py_connect_callback)
|
|
print(hlist1)
|
|
|
|
hlistWF = cafe.open(pvlistWF, cb=py_connect_callback)
|
|
print(hlistWF)
|
|
|
|
# Note: only one handle per channel is created
|
|
hlistAll = cafe.open(pvlistAll, cb=py_connect_callback)
|
|
print(hlistAll)
|
|
|
|
|
|
except PyCafe.CafeException as cafeEx:
|
|
cafeEx.show()
|
|
|
|
except Exception as inst:
|
|
print(inst.args)
|
|
exit(1)
|
|
|
|
# cafe.openNowAndWait(0.5) #timeout for channels to connect
|
|
|
|
end = time.time()
|
|
print(end-start)
|
|
|
|
# cafe.terminate()
|
|
# exit(1)
|
|
|
|
if cafe.allConnected() == False:
|
|
cafe.printDisconnected()
|
|
|
|
# Alternatively
|
|
if cafe.allConnected() == False:
|
|
h, pv = cafe.getDisconnectedHandles()
|
|
print("---------------------")
|
|
print("DISCONNECTED CHANNELS")
|
|
print("---------------------")
|
|
for i in range(0, len(h)):
|
|
print(h[i], " ", pv[i])
|
|
|
|
# Alternatively - show all handles
|
|
# cafe.printHandles()
|
|
h, pv = cafe.getHandles()
|
|
print("---------------------")
|
|
print("ALL CHANNELS")
|
|
print("---------------------")
|
|
for i in range(0, len(h)):
|
|
print(h[i], " ", pv[i])
|
|
h, pv, state = cafe.getHandleStates()
|
|
print("---------------------")
|
|
print("ALL CHANNELS AND CONNECTION STATE")
|
|
print("---------------------")
|
|
for i in range(0, len(h)):
|
|
print(h[i], " ", pv[i], " ", state[i])
|
|
print("")
|
|
# END (1) Establishing connections to EPICS Process Variables (PVs)
|
|
##############################################################
|
|
|
|
|
|
##############################################################
|
|
# (2) Simple single channel operations
|
|
##############################################################
|
|
# Now perform some get/set operations
|
|
|
|
# input to get method can be the handle to the PV, or the PV name
|
|
|
|
# If you prefer to check on the value (which will return
|
|
# a Python None in the event of a failed operation) rather
|
|
# than catch exceptions then it is possible to turn off exceptions:
|
|
|
|
cafe.withExceptions(False)
|
|
##cafe.enableExceptions = False
|
|
|
|
# get 'ARIDI-BPM-01SB:SET-ENABLE' by handle
|
|
val = cafe.get(hlistAll[8])
|
|
# or
|
|
val = cafe.get(PVS)
|
|
if val == None:
|
|
# print ErrorCode by calling cafe.getStatus with handle or PVName as input argument
|
|
print(cafe.getStatus(hlistAll[8]))
|
|
# or
|
|
print(cafe.getStatus(PVS))
|
|
# print meaning of error message
|
|
cafe.printStatusIfError(hlistAll[8], cafe.getStatus(hlistAll[8]))
|
|
else:
|
|
print("Value=", val)
|
|
|
|
#enumValue=cafe.getEnumFromString(PVS, val)
|
|
#print ("enumValue=",enumValue)
|
|
#enumString=cafe.getStringFromEnum(PVS, enumValue)
|
|
#print ("enumString=",enumString)
|
|
|
|
|
|
# This channel does not exist hence None will be returned
|
|
# The status code and error message will indicate that the channel was never connected
|
|
val = cafe.get(PV_JOKE)
|
|
if val == None:
|
|
cafe.printStatusIfError(PV_JOKE, cafe.getStatus(PV_JOKE))
|
|
else:
|
|
print("Value=", val)
|
|
|
|
# Now use exceptions for single channel get/set operations
|
|
##cafe.enableExceptions = True
|
|
cafe.withExceptions(True)
|
|
|
|
# Now perform some get operations
|
|
try:
|
|
val = cafe.get(hlistAll[8])
|
|
print("Channel: ", cafe.getPVNameFromHandle(hlistAll[8]), " value=", val)
|
|
|
|
except PyCafe.CafeException as cafeEx:
|
|
cafeEx.show()
|
|
|
|
except Exception as inst:
|
|
print(inst.args)
|
|
|
|
|
|
# Retrun pvdata struct, i.e., val, alarms, timestamps
|
|
try:
|
|
pv = cafe.getPV(hlistAll[8])
|
|
pv.show()
|
|
|
|
except PyCafe.CafeException as cafeEx:
|
|
cafeEx.show()
|
|
|
|
except Exception as inst:
|
|
print(inst.args)
|
|
|
|
|
|
# Now perform a get operations on a disconnected channel
|
|
# and catche the exception being thrown
|
|
try:
|
|
val = cafe.get(PV_JOKE) # will throw an exception
|
|
print("Channel: ", PV_JOKE, " value=", val)
|
|
|
|
except PyCafe.CafeException as cafeEx:
|
|
cafeEx.reveal()
|
|
except Exception as inst:
|
|
print(inst)
|
|
|
|
try:
|
|
val = cafe.get(hlistAll[3])
|
|
print("Channel: ", pvlistAll[3], " value=", val)
|
|
# or
|
|
print("Channel: ", cafe.getPVNameFromHandle(hlistAll[3]), " value=", val)
|
|
|
|
except PyCafe.CafeException as cafeEx:
|
|
cafeEx.reveal()
|
|
except Exception as inst:
|
|
print(inst)
|
|
|
|
|
|
# cafe.get on a WF will return first element only (see(3) fro WFs)
|
|
try:
|
|
val = cafe.get('ARIDI-BPM-01SE:WF-INT-2') # will throw an exception
|
|
print('ARIDI-BPM-01SE:WF-INT-2 has val=', val)
|
|
|
|
|
|
except PyCafe.CafeException as cafeEx:
|
|
cafeEx.reveal()
|
|
|
|
# or
|
|
print(cafeEx.name, "(handle=", cafeEx.handle, ")")
|
|
print(cafeEx.error_code, ":", cafeEx.error_text, cafeEx.error_info)
|
|
|
|
|
|
# Now perform a set operation on a waveform
|
|
|
|
try:
|
|
print("set")
|
|
cafe.set(PV1, 1.234) # set by pvname; value can be in any format
|
|
print("get")
|
|
val = cafe.get(PV1, dt='native') # dt='native' (defulat) may be omitted
|
|
print("Value (should be 1.234) =", val) # default dt='native'
|
|
|
|
cafe.set(hlistAll[0], [4.321]) # set by handle
|
|
val = cafe.get(PV1, dt='str') # dt='int', dt='float' are other options
|
|
print("Value (should be 4.321) =", val)
|
|
|
|
# get pvdata struct
|
|
pv = cafe.getPV(PV1)
|
|
pv.show()
|
|
# or
|
|
print("Value =", pv.value[0])
|
|
print("TS =", pv.ts[0], " ", pv.ts[1])
|
|
print("tsDate =", pv.tsDate[0], pv.tsDate[1],
|
|
pv.tsDate[2], pv.tsDate[3],
|
|
pv.tsDate[4], pv.tsDate[5], pv.tsDate[6] )
|
|
print("")
|
|
|
|
|
|
except PyCafe.CafeException as cafeEx:
|
|
cafeEx.reveal()
|
|
# or
|
|
|
|
print(cafeEx.name, "(handle=", cafeEx.handle, ")")
|
|
print(cafeEx.error_code, ":", cafeEx.error_text, cafeEx.error_info)
|
|
|
|
except Exception as inst:
|
|
print(inst)
|
|
|
|
|
|
# Now perform a set/get operation with user supplied callbacks
|
|
try:
|
|
cafe.setCallbackGet(hlist1[0], cb=py_callback_get)
|
|
cafe.setCallbackPut(hlist1[0], cb=py_callback_put)
|
|
cafe.setCallbackPut(hlist1[1], cb=py_callback_put)
|
|
s = cafe.set(hlist1[0], 3.348)
|
|
#cafe.ca_flush_io()
|
|
s = cafe.set(hlist1[1], -3.348)
|
|
#cafe.ca_flush_io()
|
|
s = cafe.set(hlist1[0], 7.777)
|
|
#cafe.ca_flush_io()
|
|
|
|
v = cafe.get(hlist1[0])
|
|
print("Value should be 7.777", v, s)
|
|
#s, sl = cafe.waitForBundledEvents(hlist1[0])
|
|
v = cafe.getCache(hlist1[0])
|
|
s = cafe.getStatus (hlist1[0])
|
|
|
|
print("Can you see if the callback functions were called for set/get?")
|
|
print("Value should be 7.777", v, s)
|
|
|
|
print("Waiting 5 seconds to allow data to be viewed")
|
|
time.sleep(5)
|
|
# return to default callbacks
|
|
cafe.setCallbackGet(hlist1[0], cb=None)
|
|
cafe.setCallbackPut(hlist1[0], cb=None)
|
|
|
|
|
|
except PyCafe.CafeException as cafeEx:
|
|
cafeEx.reveal()
|
|
# or
|
|
print(cafeEx.name, "(handle=", cafeEx.handle, ")")
|
|
print(cafeEx.error_code, ":", cafeEx.error_text, cafeEx.error_info)
|
|
|
|
except Exception as inst:
|
|
print(inst)
|
|
|
|
|
|
# END (2) Simple single channel operations
|
|
##############################################################
|
|
|
|
#cafe.terminate()
|
|
#exit(1)
|
|
|
|
##############################################################
|
|
# (3) Waveforms and Arrays
|
|
##############################################################
|
|
try:
|
|
NWF = 10
|
|
print('setting no of elements for wf to ', cafe.setNelem(PVWF1, 4084))
|
|
# time.sleep(5)
|
|
|
|
# waveform as Python List
|
|
print("Waveform as a Python List and native data type")
|
|
start = time.time()
|
|
for i in range(0, NWF):
|
|
valList = cafe.getList(PVWF1, dt='native')
|
|
end = time.time()
|
|
print(end - start)
|
|
|
|
start = time.time()
|
|
for i in range(0, NWF):
|
|
valList = cafe.getList(PVWF1, dt='int8')
|
|
end = time.time()
|
|
print(end - start)
|
|
|
|
#print (valList)
|
|
# waveform as int and as numpy
|
|
print("Waveform as a numpy and dt='float'")
|
|
start = time.time()
|
|
for i in range(0, NWF):
|
|
valNumpy = cafe.getArray(
|
|
hlistWF[0], dt='native', art='numpy') # PVWF1,
|
|
end = time.time()
|
|
print(end - start)
|
|
#print (valNumpy)
|
|
#
|
|
#cafe.setNelem(PVWF1, 5)
|
|
|
|
# waveform as a float and as a Python array.array
|
|
print("Waveform as a Python array.array and dt='float'")
|
|
start = time.time()
|
|
for i in range(0, NWF):
|
|
valArray = cafe.getArray(
|
|
hlistWF[0], dt='native', art='array') # PVWF1,
|
|
end = time.time()
|
|
print(end - start)
|
|
#print (valArray)
|
|
for i in range(0, min(10, len(valArray))):
|
|
#print (valArray[i], " [",i,"] ", sep='', end="")
|
|
print(valArray[i], " [", i, "] ",)
|
|
print(" ")
|
|
# waveform as a and as a Python memoryview
|
|
print("Waveform as a Python memoryview and dt='native' (default)")
|
|
|
|
start = time.time()
|
|
for i in range(0, NWF):
|
|
mv = cafe.getArray(hlistWF[0], dt='native', art='memoryview')
|
|
end = time.time()
|
|
print(end - start)
|
|
|
|
print(type(mv))
|
|
print(type(mv[0]))
|
|
print(mv[0])
|
|
|
|
time.sleep(5)
|
|
# cafe.terminate()
|
|
# exit(1)
|
|
|
|
# ml=memoryview(mv)
|
|
#print (type(ml))
|
|
#print (type(ml[0]))
|
|
#print (ml[0], ml[1], ml[4])
|
|
#print (ml[2:4].tolist())
|
|
status = cafe.set(hlistWF[0], mv)
|
|
# Did set work? Check on first element
|
|
print("Value (should be what?)=", cafe.get(PVWF1, dt='float'))
|
|
|
|
'''
|
|
#for PY3
|
|
for i in range (0,len(mv)):
|
|
print (mv[i], " ",end="")
|
|
print (" ")
|
|
'''
|
|
|
|
mv_a = np.ndarray(4)
|
|
|
|
# mv_a=mv
|
|
|
|
for i in range(0, 4): # len(mv)):
|
|
mv[i] = 3.456+i
|
|
#print (mv[i], " ", sep="", end="")
|
|
mv_a[i] = mv[i]
|
|
|
|
print(" ")
|
|
|
|
# set first element of wf using memoryview
|
|
# mv_a[0]=4.567
|
|
# mv[0]=4.567
|
|
|
|
status = cafe.set(PVWF1, mv)
|
|
# Did set work? Check on first element
|
|
print("Value (should be 1.23)=", cafe.get(PVWF1, dt='float'))
|
|
|
|
'''
|
|
valArrayI=cafe.getArray(PVWF1, dt='int', art='array')
|
|
print (valArrayI)
|
|
for i in range (0,min(4,len(valArrayI))):
|
|
print (valArrayI[i], " ",)
|
|
print (" ")
|
|
|
|
|
|
valArrayI=cafe.getArray(PVWF1, dt='int', art='array')
|
|
print (valArrayI)
|
|
for i in range (0,min(4,len(valArrayI))):
|
|
print (valArrayI[i], " ",)
|
|
print (" ")
|
|
'''
|
|
|
|
print('nelemCtrl=', cafe.setNelemCtrl(PVWF1, 20))
|
|
|
|
valC = cafe.getCtrl(PVWF1, dt='int')
|
|
print(valC)
|
|
# for i in range (0,min(50,len(valC.value))):
|
|
#print (valC.value[i], " [",i,"] ", sep='', end="")
|
|
#print (valC.value[i], " [",i,"] ",)
|
|
#print (" ")
|
|
|
|
# set wf using array.array
|
|
valArray[0] = 5.678
|
|
status = cafe.set(PVWF1, valArray)
|
|
print("Value (should be 5.678)=", cafe.get(PVWF1, dt='float'))
|
|
|
|
# set wf using numpy array
|
|
valNumpy[0] = 6.543
|
|
status = cafe.set(PVWF1, valNumpy)
|
|
print("Value (should be 6)=", cafe.get(PVWF1, dt='int'))
|
|
|
|
# set wf using Python List
|
|
valList[0] = '1.23'
|
|
valList[1] = '2.10'
|
|
status = cafe.set(PVWF1, valList)
|
|
|
|
vL = cafe.getList(PVWF1, dt='float')
|
|
if vL[0] != None:
|
|
print("Values (should be 1.23, 2.1)=", vL[0], vL[1])
|
|
|
|
|
|
except PyCafe.CafeException as cafeEx:
|
|
cafeEx.reveal()
|
|
# or
|
|
print(cafeEx.name, "(handle=", cafeEx.handle, ")")
|
|
print(cafeEx.error_code, ":", cafeEx.error_text, cafeEx.error_info)
|
|
|
|
except Exception as inst:
|
|
print(inst)
|
|
|
|
|
|
##############################################################
|
|
|
|
# cafe.terminate()
|
|
# exit(1)
|
|
|
|
##############################################################
|
|
# (4) Multiple scalar operations
|
|
##############################################################
|
|
# Now work with multiple scalars - far far more efficient to get multiple data-sets with one call
|
|
# If a channel is not connected (or other error) then it is reported in the !
|
|
# These methods do not throw exceptions
|
|
|
|
valueList, status, statusList = cafe.getScalarList(
|
|
hlist1, 'str') # hlist1 or pvlist1
|
|
|
|
if status != cyca.ICAFE_NORMAL:
|
|
cafe.printStatusIfError(hlist1, statusList)
|
|
|
|
for i in range(0, len(valueList)):
|
|
print(valueList[i], " [", i, "] ",)
|
|
print(" ")
|
|
|
|
if status != cyca.ICAFE_NORMAL:
|
|
for i in range(0, len(statusList)):
|
|
print(cafe.getStatusCodeAsText(statusList[i]), "[", i, "]")
|
|
print(" ")
|
|
|
|
try:
|
|
val = cafe.getPV(hlistAll[8], dt='int')
|
|
print(pvlistAll[8], val)
|
|
val.show()
|
|
|
|
|
|
except PyCafe.CafeException as cafeEx:
|
|
cafeEx.reveal()
|
|
# or
|
|
print(cafeEx.name, "(handle=", cafeEx.handle, ")")
|
|
print(cafeEx.error_code, ":", cafeEx.error_text, cafeEx.error_info)
|
|
|
|
except Exception as inst:
|
|
print(inst)
|
|
|
|
|
|
valueList, status, statusList = cafe.getScalarList(
|
|
hlistAll[0:9], dt='double') # hlistAll or pvlistALL
|
|
print("--------------------------------------------------------")
|
|
print("valueList from cafe.getScalarList(hlistAll,dt='native') ")
|
|
print("Note the different data types appearing in the list ")
|
|
print("If a WF is among the list, only the first element is returned")
|
|
print("--------------------------------------------------------")
|
|
|
|
for i in range(0, len(valueList)):
|
|
print(pvlistAll[i], valueList[i], " [", i, "] ", statusList[i])
|
|
print(" ")
|
|
|
|
|
|
if status != cyca.ICAFE_NORMAL:
|
|
cafe.printStatusIfError(hlistAll, statusList)
|
|
|
|
|
|
'''
|
|
if PY3:
|
|
for i in range (0, len(valueList)):
|
|
print (valueList[i], " [",i,"] ", end="")
|
|
print(" ")
|
|
if status != cyca.ICAFE_NORMAL:
|
|
for i in range (0, len(statusList)):
|
|
print (cafe.getStatusCodeAsText(statusList[i]), " [",i,"] ",end="")
|
|
print(" ")
|
|
'''
|
|
|
|
# if PY2:
|
|
|
|
for i in range(0, len(valueList)):
|
|
print(valueList[i], " [", i, "] ",)
|
|
print(type(valueList[i]))
|
|
print(" ")
|
|
if status != cyca.ICAFE_NORMAL:
|
|
for i in range(0, len(statusList)):
|
|
print(cafe.getStatusCodeAsText(statusList[i]), " [", i, "] ")
|
|
print(" ")
|
|
print("--------------------------------------------------------")
|
|
|
|
print("--------------------------------------------------------")
|
|
print("valueList from cafe.getScalarList(hlist1,dt='float') ")
|
|
print("Values returned should be 5.6, 6.389, 7.7, 22 ")
|
|
print("--------------------------------------------------------")
|
|
# Note that different data types are allowed within the input List
|
|
llist = [5, 6.389, '7.7', 22]
|
|
status, statusList = cafe.setScalarList(hlist1, llist)
|
|
valueList, status, statusList = cafe.getScalarList(
|
|
hlist1, dt='float') # hlist1 or pvlist1
|
|
|
|
if status != cyca.ICAFE_NORMAL:
|
|
cafe.printStatusIfError(hlist1, statusList)
|
|
|
|
for i in range(0, len(valueList)):
|
|
print(valueList[i], " [", i, "] ",)
|
|
print(" ")
|
|
print("--------------------------------------------------------")
|
|
|
|
##############################################################
|
|
|
|
##############################################################
|
|
# (5) Mulitple compound operations
|
|
##############################################################
|
|
print("--------------------------------------------------------")
|
|
print("valueList from cafe.getCompoundList(hlistAll,dt='native') ")
|
|
print("A WF is returned as a List within the List ")
|
|
print("--------------------------------------------------------")
|
|
val, s, sl = cafe.getCompoundList(hlistAll, dt='native')
|
|
|
|
|
|
# print one of the waveforms in above val List
|
|
mval = 10
|
|
if len(val) > 4:
|
|
if isinstance(val[4], (list)):
|
|
mval = len(val[4])
|
|
# print 10 first elements of WF
|
|
for i in range(0, min(10, mval)):
|
|
print(val[4][i], " [", i, "] ")
|
|
print(" ")
|
|
|
|
print("--------------------------------------------------------")
|
|
print("valueList from cafe.getPVList(hlistAll,dt='native') for comparison to above")
|
|
print("A WF is returned as a List within the List ")
|
|
print("--------------------------------------------------------")
|
|
pvl, s = cafe.getPVList(hlistAll, dt='native')
|
|
for i in range(0, len(pvl)):
|
|
print(hlistAll[i], " ", cafe.getPVNameFromHandle(hlistAll[i]))
|
|
pvl[i].show()
|
|
print(" ")
|
|
print(s)
|
|
print("--------------------------------------------------------")
|
|
|
|
|
|
cafe.printStatusIfError(hlistAll, sl)
|
|
|
|
if len(val) > 2:
|
|
|
|
val[2] = 0.7123
|
|
s, sl = cafe.setCompoundList(hlistAll, val)
|
|
if (s != cyca.ICAFE_NORMAL):
|
|
cafe.printStatusIfError(hlistAll, sl)
|
|
|
|
try:
|
|
val2 = cafe.get(hlistAll[2])
|
|
|
|
# readback to check that above set worked
|
|
print("Readback value should be", val[2], " val=", val2)
|
|
print("--------------------------------------------------------")
|
|
print("--------------------------------------------------------")
|
|
|
|
|
|
except PyCafe.CafeException as cafeEx:
|
|
cafeEx.reveal()
|
|
|
|
# or
|
|
print(cafeEx.name, "(handle=", cafeEx.handle, ")")
|
|
print(cafeEx.error_code, ":", cafeEx.error_text, cafeEx.error_info)
|
|
|
|
|
|
except Exception as inst:
|
|
print(inst)
|
|
|
|
|
|
##############################################################
|
|
|
|
|
|
##############################################################
|
|
# (6) Synchronous group operations and like
|
|
##############################################################
|
|
print("--------------------------------------------------------")
|
|
print(" Synchronous group operations ")
|
|
print("--------------------------------------------------------")
|
|
|
|
gh=cafe.grouping('testg', pvlist1)
|
|
|
|
# Return a group of PV structs
|
|
pvg = cafe.getPVGroup(gh)
|
|
pvg.show()
|
|
# or
|
|
pvg.showWithPV(pvlist1)
|
|
|
|
# define a group on the fly
|
|
cafe.defineGroup('gBPM', pvlist1)
|
|
|
|
groupHandle1 = cafe.groupOpen('gBPM')
|
|
glist = cafe.groupMemberList('gBPM')
|
|
|
|
# Return a group of PV structs
|
|
pvg = cafe.getPVGroup(groupHandle1)
|
|
pvg.show()
|
|
# or
|
|
pvg.showWithPV(glist)
|
|
# or
|
|
for i in range(0, pvg.npv):
|
|
print(glist[i], " value=", pvg.pvdata[i].value[0],)
|
|
print(" ")
|
|
print("--------------------------------------------------------")
|
|
|
|
# extract all values from pvgroup into a list
|
|
setList = []
|
|
setList = cafe.PVGroupValuesToList(pvg)
|
|
|
|
# modify values
|
|
setList[0] = setList[0]+0.1234567
|
|
setList[1] = setList[1]+0.9876543
|
|
|
|
# set new values
|
|
s, sL = cafe.setGroup(groupHandle1, setList)
|
|
|
|
# readback new values
|
|
values, s, sl = cafe.getGroup(groupHandle1) # by group handle
|
|
print(values)
|
|
values, s, sl = cafe.getGroup('gBPM') # by group name
|
|
print(values)
|
|
|
|
# Now define another group
|
|
cafe.defineGroup('gAll', pvlistAll[0:9]) #take out PV-JOKE
|
|
|
|
groupHandle2 = cafe.groupOpen('gAll')
|
|
pvg = cafe.getPVGroup(groupHandle2)
|
|
# pvg.show()
|
|
# or
|
|
pvg.showWithPV(pvlistAll[0:9])
|
|
# or
|
|
# for i in range (0, pvg.npv):
|
|
# print(glist[i], " value=", pvg.pvdata[i].value[0],)
|
|
# print(" "
|
|
print("--------------------------------------------------------")
|
|
|
|
values, s, sl = cafe.getGroup(groupHandle2) # by group handle
|
|
print(values)
|
|
if s != cyca.ICAFE_NORMAL:
|
|
cafe.printStatusIfError(pvlistAll, sl)
|
|
else:
|
|
# change some values:
|
|
values[0] = values[0] + 0.234
|
|
values[1] = values[1] + 0.456
|
|
values[8] = "monitor"
|
|
|
|
s, sl = cafe.setGroup(groupHandle2, values)
|
|
if s != cyca.ICAFE_NORMAL:
|
|
cafe.printStatusIfError(pvlistAll, sl)
|
|
|
|
newValues, s, sl = cafe.getGroup(groupHandle2) # by group handle
|
|
print(newValues[0], newValues[1])
|
|
if s != cyca.ICAFE_NORMAL:
|
|
cafe.printStatusIfError(pvlistAll, sl)
|
|
|
|
|
|
print("--------------------------------------------------------")
|
|
print("Note: getCompoundPVGroup does a collective asynchronous get on all group members")
|
|
print("--------------------------------------------------------")
|
|
print("Data from getCompoundPVGroup")
|
|
glist = cafe.groupMemberList('gAll')
|
|
print(glist)
|
|
|
|
pvg = cafe.getCompoundPVGroup('gAll', dt='str')
|
|
pvg.showWithPV(pvlistAll[0:9])
|
|
# or
|
|
pvg.showWithPV(glist[0:9])
|
|
|
|
|
|
print("Values of first element:")
|
|
for i in range(0, pvg.npv):
|
|
print(i, glist[i], " value=", pvg.pvdata[i].value[0],)
|
|
print(" ")
|
|
|
|
print("Data from getCompoundPVGroup by groupHandle")
|
|
pvg = cafe.getCompoundPVGroup(groupHandle2, dt='float')
|
|
|
|
|
|
pvg.showWithPV(pvlistAll[0:9])
|
|
# or
|
|
print("Values of first element:")
|
|
for i in range(0, pvg.npv):
|
|
print(pvlistAll[i], " value=", pvg.pvdata[i].value[0],)
|
|
print(" ")
|
|
|
|
|
|
##############################################################
|
|
|
|
##############################################################
|
|
# (7) Get Ctrl Parameters
|
|
##############################################################
|
|
|
|
try:
|
|
pvctrl = cafe.getCtrl(hlistAll[8])
|
|
# or from Cache would normally suffice as we are not interested in .value
|
|
|
|
pvctrl.show()
|
|
|
|
pvctrl = cafe.getCtrlCache(hlistAll[8])
|
|
|
|
print(pvctrl.enumStrings)
|
|
print(pvctrl.units) # if any
|
|
|
|
|
|
except PyCafe.CafeException as cafeEx:
|
|
cafeEx.reveal()
|
|
# or
|
|
print(cafeEx.name, "(handle=", cafeEx.handle, ")")
|
|
print(cafeEx.error_code, ":", cafeEx.error_text, cafeEx.error_info)
|
|
|
|
except Exception as inst:
|
|
print(inst)
|
|
|
|
|
|
##############################################################
|
|
|
|
#cafe.enableExceptions = False
|
|
cafe.withExceptions(False)
|
|
|
|
##############################################################
|
|
# (8) Monitors
|
|
##############################################################
|
|
cafe.openMonitorPrepare()
|
|
|
|
# user supplied callback
|
|
m0 = cafe.monitorStart(hlist1[0], cb=py_callback_pvdata,
|
|
dbr=cyca.CY_DBR_TIME, mask=cyca.CY_DBE_VALUE | cyca.CY_DBE_ALARM)
|
|
|
|
m2 = cafe.monitorStart(hlist1[0], cb=py_callback_pvdata,
|
|
dbr=cyca.CY_DBR_TIME, mask=cyca.CY_DBE_VALUE | cyca.CY_DBE_ALARM)
|
|
|
|
# default input parameters for dbr and mask
|
|
m1 = cafe.monitorStart(hlist1[1], cb=py_callback_pvctrl, dbr=cyca.CY_DBR_CTRL)
|
|
|
|
|
|
|
|
# optional, getCache methods get from cache without pre-checks, i.e. isChannel Connected
|
|
#cafe.setGetCacheWaitPolicy(hlist[0], cyca.GET_CACHE_NO_CHECK)
|
|
#cafe.setGetCacheWaitPolicy(hlist[1], cyca.GET_CACHE_NO_CHECK)
|
|
|
|
print("Monitor STARTING ------------------------------------------------------------- ", m0, m1)
|
|
|
|
cafe.openMonitorNowAndWait(1.0)
|
|
|
|
val = -2.0
|
|
|
|
# watch the callbacks being invoked
|
|
for i in range(0, 5):
|
|
cafe.set(hlist1[0], val+i)
|
|
cafe.set(hlist1[2], val+i)
|
|
#cafe.set(hlist1[1], val+i+0.373)
|
|
time.sleep(2.0)
|
|
|
|
#print (" ")
|
|
#print ("Latest Value for channel",cafe.getPVNameFromHandle(hlist1[0]), " is", cafe.getCache(hlist1[0], dt='native'))
|
|
#print (" ")
|
|
|
|
|
|
print('getNoMonitors ', cafe.getNoMonitors(hlist1[0]))
|
|
|
|
|
|
# cafe.monitorStop(hlist1[0], mpid=m0) # mpid=m0 is optional and may be omitted
|
|
# cafe.monitorStop(hlist1[0])
|
|
|
|
# optional, getCache methods get from cache with pre-checks (back to default)
|
|
#cafe.setGetCacheWaitPolicy(hlist[0], cyca.GET_CACHE_WAIT)
|
|
#cafe.setGetCacheWaitPolicy(hlist[1], cyca.GET_CACHE_WAIT)
|
|
|
|
##############################################################
|
|
|
|
##############################################################
|
|
# (9) Asynchronous interactions and retrieving data from Cache
|
|
##############################################################
|
|
|
|
|
|
print("--------------------------------------------------------")
|
|
print("Asynchronous interactions and retrieving data from Cache")
|
|
print("--------------------------------------------------------")
|
|
|
|
# Check on return value or status instead of exceptions
|
|
|
|
##print("Exceptions enabled?", cafe.enableExceptions)
|
|
s = cafe.set(hlistAll[0], 1.111789)
|
|
|
|
s, sl = cafe.getAsyn(hlistAll)
|
|
print("status of cafe.getAsyn(hlistAll)", s)
|
|
|
|
if s != cyca.ICAFE_NORMAL:
|
|
print(sl)
|
|
|
|
# optional - may be omitted
|
|
s, sl = cafe.waitForBundledEvents(hlistAll)
|
|
|
|
# will wait for callback to be invoked if above omitted
|
|
v = cafe.getCache(hlistAll[0])
|
|
if v != None:
|
|
print("Value from Cache ", v)
|
|
|
|
# get array
|
|
v = cafe.getArrayCache(hlistAll[4], art='numpy')
|
|
if v[0] != None:
|
|
print("Value from Cache ", v)
|
|
|
|
pv = cafe.getPVCache(hlistAll[4])
|
|
print(cafe.getPVNameFromHandle(hlistAll[4]), ":")
|
|
pv.showMax(4) # show max 4 elements of wf
|
|
|
|
##############################################################
|
|
|
|
#############################################################
|
|
# (10) More on groups
|
|
##############################################################
|
|
# loads groups defined by virtual accelerator (SF network only)
|
|
# SF specific, please delete
|
|
'''
|
|
cafe.loadSFGroups()
|
|
print ("loadSFGroups")
|
|
|
|
ll=cafe.groupList()
|
|
print ("----------------/")
|
|
print (ll )
|
|
print ("----------------/")
|
|
inl=['MQUA080','PS-MODE']
|
|
ll2=cafe.getChannelList(inl) #search for channels containing inl in pc name
|
|
print ("--------------------//")
|
|
print (ll2)
|
|
print ("--------------------//")
|
|
#View members of group ll[3]
|
|
gml=cafe.groupMemberList(ll[3])
|
|
print ("------------------------///")
|
|
print (gml)
|
|
print ("------------------------///")
|
|
|
|
'''
|
|
|
|
# See that a number of groups have been added to the groupList
|
|
ll = cafe.groupList()
|
|
print("----------------------------////")
|
|
print(ll)
|
|
print("----------------------------////")
|
|
|
|
try:
|
|
cafe.openGroupPrepare()
|
|
|
|
gHandle = cafe.groupOpen(ll[0])
|
|
|
|
if (len(ll) > 0):
|
|
gHandle2 = cafe.groupOpen(ll[1])
|
|
|
|
gl = []
|
|
gl.append(gHandle)
|
|
if (len(ll) > 0):
|
|
gl.append(gHandle2)
|
|
cafe.openGroupNowAndWaitForInputGroups(
|
|
3.0, [ll[0], gHandle2]) # maximum timeout
|
|
|
|
pvg = cafe.getPVGroup(gHandle)
|
|
pvg.showWithPV(cafe.groupMemberList(ll[0]))
|
|
|
|
cafe.closeDisconnectedChannelsWithinGroup([ll[0], gHandle2])
|
|
# cafe.closeChannelKeepHandle(pvlist1)
|
|
|
|
pvg = cafe.getPVGroup(gHandle)
|
|
# or
|
|
# pvg = cafe.getPVGroup(ll[1])
|
|
|
|
pvg.showWithPV(cafe.groupMemberList(ll[0])) # 'testg'
|
|
|
|
# cafe.terminate()
|
|
# exit(0)
|
|
|
|
# Start a Collective monitor on all group memebers with the same user supplied cb function
|
|
cbf = []
|
|
for i in range(0, len(cafe.groupMemberList(ll[0]))):
|
|
cbf.append(py_callback) # _pvdata)
|
|
print(len(cafe.groupMemberList(ll[0])), len(cbf))
|
|
s, sV = cafe.groupMonitorStartWithCBList(gHandle, cbf)
|
|
# or
|
|
# s,sV=cafe.groupMonitorStartWithCBList(ll[0],cbf)
|
|
|
|
# Start a monitor on all group members with default callback
|
|
# If a channel is disconnected, then the monitor will start automatically on connection
|
|
s, sV = cafe.groupMonitorStart('gAll')
|
|
|
|
val, s, sl = cafe.getGroupCache(gHandle)
|
|
|
|
# wait a tick for callbacks to complete before sets are done
|
|
time.sleep(0.5)
|
|
print("--------------------------------/")
|
|
print("SET to monitored channels")
|
|
print("--------------------------------/")
|
|
for i in range(0, len(val)):
|
|
val[i] = val[i]+0.9099999
|
|
s, sl = cafe.setGroup(gHandle, val)
|
|
time.sleep(0.5)
|
|
|
|
s, sV = cafe.groupMonitorStop(gHandle)
|
|
s, sV = cafe.groupMonitorStop('gAll')
|
|
|
|
|
|
except PyCafe.CafeException as cafeEx:
|
|
cafeEx.reveal()
|
|
# or
|
|
print(cafeEx.name, "(handle=", cafeEx.handle, ")")
|
|
print(cafeEx.error_code, ":", cafeEx.error_text, cafeEx.error_info)
|
|
|
|
except Exception as inst:
|
|
print(inst)
|
|
|
|
|
|
time.sleep(1)
|
|
|
|
|
|
'''
|
|
|
|
#load collections and groups from external file
|
|
cafe.loadCollectionsFromXML("Collections/collection_swissfel.xml");
|
|
cafe.loadGroupsFromXML("Groups/group_swissfel.xml");
|
|
|
|
cafe.loadCollectionsFromXML ("cNodes.xml")
|
|
cafe.loadGroupsFromXML ("gDBPM.xml")
|
|
|
|
# get static BPM data, i.e., names/positions
|
|
BPMdev, BPMpos=cafe.devicePositionMap("cDBPM")
|
|
|
|
nDBPM=len(BPMdev)
|
|
print ("No. of DBPs devices =", nDBPM)
|
|
for i in range (0, len(BPMdev)):
|
|
print (i, " " + BPMdev[i], " " , BPMpos[i]
|
|
'''
|
|
|
|
|
|
##############################################################
|
|
# (11) Special methods:
|
|
##############################################################
|
|
# int match(valueToReach, handleMatch, tolerance, timeout, printFlag)
|
|
# This method does not do a set, just waits until valueToReach
|
|
# for channel hlist1[0] is reached
|
|
print(" ")
|
|
print("START cafe.match------------------------------------------------------")
|
|
try:
|
|
cafe.set(hlist1[0], 2.001)
|
|
print(hlist1[0], "hlist1[0]", type(hlist1[0]))
|
|
s = cyca.ICAFE_NORMAL
|
|
s = cafe.match(float(2.34), int(hlist1[0]) , float(0.0011), float(10.0), bool(True))
|
|
# s=cafe.match(cafe.getEnumFromString(PVS,"monitor"),hlist1[0],0.0011,10.0,True)
|
|
print("Status of match method: ", cafe.getStatusCodeAsText(s))
|
|
|
|
except PyCafe.CafeException as cafeEx:
|
|
cafeEx.reveal()
|
|
# or
|
|
print(cafeEx.name, "(handle=", cafeEx.handle, ")")
|
|
print(cafeEx.error_code, ":", cafeEx.error_text, cafeEx.error_info)
|
|
|
|
except Exception as inst:
|
|
print(inst)
|
|
print("Exception for cafe match ")
|
|
print("Status of match method: ",
|
|
cafe.getStatusCodeAsText(cafe.getStatus(hlist1[0])))
|
|
print("END cafe.match------------------------------------------------------")
|
|
|
|
|
|
#cafe.terminate()
|
|
#exit()
|
|
|
|
# int setAndMatch(handlePVtoSet, valueToSet, handlePVtoReadback, tolerance, timeout, printFlag)
|
|
# Set Channel1 followed by a readback of Channel 2 \n
|
|
# Method verifies whether or not the 2 values agree within the given tolerance and timeout
|
|
# Method returns with ECA_NORMAL as soon as a match is reached
|
|
print(" ")
|
|
print("START cafe.setAndMatch------------------------------------------------------")
|
|
try:
|
|
cafe.set(hlist1[1], 2.0201)
|
|
s = cafe.setAndMatch(hlist1[0], 2.02, hlist1[1], 0.001, 10.0, True)
|
|
# s=cafe.setAndMatch(hlist1[0],cafe.getEnumFromString(PVS,"monitor"),hlist1[1],0.001,1,True)
|
|
print("Status of set and match method: ", cafe.getStatusCodeAsText(s))
|
|
|
|
except PyCafe.CafeException as cafeEx:
|
|
cafeEx.reveal()
|
|
# or
|
|
print(cafeEx.name, "(handle=", cafeEx.handle, ")")
|
|
print(cafeEx.error_code, ":", cafeEx.error_text, cafeEx.error_info)
|
|
|
|
|
|
except Exception as inst:
|
|
print(inst)
|
|
print("EXCEPTION AT SET AND MATCH")
|
|
print("Status of set and match method: ",
|
|
cafe.getStatusCodeAsText(cafe.getStatus(hlist1[0])))
|
|
|
|
print("END cafe.setAndMatch------------------------------------------------------")
|
|
|
|
# Throw exception
|
|
try:
|
|
cafe.getEnumFromString(PVS, "Monitor")
|
|
|
|
except PyCafe.CafeException as cafeEx:
|
|
cafeEx.reveal()
|
|
# or
|
|
print(cafeEx.name, "(handle=", cafeEx.handle, ")")
|
|
print(cafeEx.error_code, ":", cafeEx.error_text, cafeEx.error_info)
|
|
|
|
except Exception as inst:
|
|
print(inst)
|
|
|
|
|
|
# Set Channels followed by a corresponding readback of Channels \n
|
|
# Method verifies whether or not the set/readback values agree within the given tolerance and timeout \n
|
|
# Method returns with ECA_NORMAL as soon as a match is reached
|
|
|
|
magnetSetList = ['ARIMA-CV-12LB:I-SET', 'ARIMA-CV-12LE:I-SET']
|
|
magnetReadList = ['ARIMA-CV-12LB:I-READ', 'ARIMA-CV-12LE:I-READ']
|
|
cafe.openPrepare()
|
|
mSetHandleList = cafe.open(magnetSetList)
|
|
mReadHandleList = cafe.open(magnetReadList)
|
|
cafe.openNowAndWait(0.4)
|
|
valInput = []
|
|
valInput.append(3.5)
|
|
valInput.append(3.6)
|
|
|
|
|
|
# int setAndMatchMany(handlePVArraytoSet, valueArrayToSet, handlePVArraytoReadback, tolerance, timeout, printFlag)
|
|
print(" ")
|
|
print("START cafe.setAndMatchMany------------------------------------------------------")
|
|
try:
|
|
s, sL = cafe.setScalarList(mSetHandleList, valInput)
|
|
s, sL = cafe.setScalarList(mReadHandleList, [3.501, 3.599])
|
|
s = cafe.setAndMatchMany(mSetHandleList, valInput,
|
|
mReadHandleList, 0.002, 10.0, True)
|
|
print("Status of set and match method: ", cafe.getStatusCodeAsText(s))
|
|
|
|
|
|
except PyCafe.CafeException as cafeEx:
|
|
cafeEx.reveal()
|
|
# or
|
|
print(cafeEx.name, "(handle=", cafeEx.handle, ")")
|
|
print(cafeEx.error_code, ":", cafeEx.error_text, cafeEx.error_info)
|
|
|
|
except Exception as inst:
|
|
print(inst)
|
|
|
|
|
|
print("END cafe.setAndMatch------------------------------------------------------")
|
|
|
|
|
|
# int gameSetAndMatch(handlePVArraytoSet, valueArrayToSet, handlePVActiontoSet, valueActionToSet, handlePVArraytoReadback, tolerance, timeout, printFlag)
|
|
print(" ")
|
|
print("START cafe.gameSetAndMatch------------------------------------------------------")
|
|
try:
|
|
s, sL = cafe.setScalarList(mSetHandleList, valInput)
|
|
s, sL = cafe.setScalarList(mReadHandleList, [3.501, 3.599])
|
|
s = cafe.gameSetAndMatch(
|
|
mSetHandleList, valInput, mReadHandleList[0], "1", mReadHandleList, 0.002, 20.0, True)
|
|
print("Status of set and match method: ", cafe.getStatusCodeAsText(s))
|
|
|
|
except PyCafe.CafeException as cafeEx:
|
|
cafeEx.reveal()
|
|
|
|
except Exception as inst:
|
|
print(inst)
|
|
|
|
print("END cafe.gameSetAndMatch------------------------------------------------------")
|
|
|
|
|
|
##############################################################
|
|
|
|
|
|
# Test with attaching context (would do this from another thread)
|
|
#print(cafe.getStatusCodeAsText(cafe.attachContext(1)))
|
|
#print(cafe.getStatusCodeAsText(cafe.attachContext(999)))
|
|
|
|
if (cafe.attachContext(1) == cyca.CY_ECA_ISATTACHED):
|
|
print("TEST: Should be attached",
|
|
cafe.getStatusCodeAsText(cyca.CY_ECA_ISATTACHED))
|
|
|
|
if (cafe.attachContext(999) == cyca.ECAFE_NULLCONTEXT):
|
|
print("TEST: Should not be attached",
|
|
cafe.getStatusCodeAsText(cyca.ECAFE_NULLCONTEXT))
|
|
|
|
|
|
##############################################################
|
|
# END Gracefully terminate CAFE
|
|
##############################################################
|
|
cafe.terminate()
|
|
exit(0)
|
|
##############################################################
|