718 lines
23 KiB
Plaintext
718 lines
23 KiB
Plaintext
44c44
|
|
< _pymodule = "PyCafe.pyx"
|
|
---
|
|
> _pymodule = "PyCafe.pyx" # os.path.basename(__file__)
|
|
49a50,52
|
|
> cdef object py_cb
|
|
>
|
|
> cdef dict openCallbackDictGlobal = {}
|
|
50a54,59
|
|
> cdef dict handleMonDictGlobal = {}
|
|
> cdef dict monDictGlobal = {}
|
|
> cdef dict openDictGlobal = {}
|
|
>
|
|
> cdef dict getDictGlobal = {}
|
|
> cdef dict putDictGlobal = {}
|
|
52c61,64
|
|
< include "PyCafeDefs_sf.pxi"
|
|
---
|
|
> #cdef ccafe.CAFE * _c_cafe
|
|
> #_c_cafe = new ccafe.CAFE()
|
|
>
|
|
> include "PyCafeDefs.pxi"
|
|
83a96
|
|
>
|
|
172,179c185
|
|
<
|
|
< DBPMKeeper dbpm
|
|
<
|
|
< bint dbpmInitialized
|
|
< bint BSInitialized
|
|
< bint isBSinCAOnly
|
|
< BSDataHolder bsd
|
|
<
|
|
---
|
|
>
|
|
213,216c219
|
|
< self.dbpmInitialized = False
|
|
< self.BSInitialized = False
|
|
< self.isBSinCAOnly = False
|
|
<
|
|
---
|
|
>
|
|
235,240c238
|
|
< def CAFE_version(self):
|
|
< return CAFE_VERSION
|
|
<
|
|
< def EPICS_version(self):
|
|
< return EPICS_VERSION
|
|
<
|
|
---
|
|
>
|
|
245c243,250
|
|
< pv_name = handlePV
|
|
---
|
|
> pv_name = handlePV
|
|
> #global openCallbackDictGlobal
|
|
> #openCallbackDictGlobal[cb] = handlePV
|
|
> #september 21 2021
|
|
> global openDictGlobal
|
|
> openDictGlobal[pv_name] = cb
|
|
>
|
|
> #handle = self.hh.getHandleFromPV(pv_name)
|
|
247a253,264
|
|
> #self._c_cafe.channelCreatePolicy.setPyCallbackFlag(True)
|
|
> #self._c_cafe.channelCreatePolicy.setPyConnectHandler(<void *>cb)
|
|
> #open
|
|
> #false
|
|
>
|
|
> def setPyCallbackConnect(self, pv: str = None, cb: object = None):
|
|
> if None in (pv, cb):
|
|
> return
|
|
> global openDictGlobal
|
|
> openDictGlobal[pv] = cb
|
|
>
|
|
> ##self.hh.setPyConnectCallbackFn(handle, <void *>cb)
|
|
274c291,299
|
|
< self.cs.info(ECA_ALLOCMEM)))
|
|
---
|
|
> self.cs.info(ECA_ALLOCMEM)))
|
|
> '''
|
|
> _cafeException = CafeException(
|
|
> _type='CafeError', _source=_METHOD,
|
|
> _error_code=ECA_ALLOCMEM,
|
|
> _error_text=self.cs.code(ECA_ALLOCMEM),
|
|
> _error_info=self.cs.info(ECA_ALLOCMEM))
|
|
> raise _cafeException
|
|
> '''
|
|
422,424c447,448
|
|
< ##for i in range(0, len(pvV)):
|
|
< ##self.setPyCallbackConnect(pvV[i], cb)
|
|
< #self.setPyConnectCallbackFn(pvV[i], cb)
|
|
---
|
|
> for i in range(0, len(pvV)):
|
|
> self.setPyCallbackConnect(pvV[i], cb)
|
|
473c497
|
|
< ####self.setPyCallbackConnect(pv, cb)
|
|
---
|
|
> self.setPyCallbackConnect(pv, cb)
|
|
481c505
|
|
< #print("OPEN WITH NO GIL//==>", pvStr, handle)
|
|
---
|
|
> #print("OPEN WITH NO GIL//==>", pvStr)
|
|
486c510
|
|
< except RuntimeError as e:
|
|
---
|
|
> except RuntimeError as e:
|
|
501c525
|
|
< raise Exception("{} {} \n{}".format(self._exception_text, _METHOD, e))
|
|
---
|
|
> raise Exception("{} {} \n{}".format(self._exception_text, _METHOD, e))
|
|
791c815,816
|
|
<
|
|
---
|
|
> global getDictGlobal
|
|
>
|
|
800,801c825,827
|
|
< if cb is not None:
|
|
< crp.setPyHandlerGet(<void *> cb) # forces when=WITH_CALLBACK_USER_SUPPLIED
|
|
---
|
|
> if cb is not None:
|
|
> getDictGlobal[handle] = cb
|
|
> crp.setPyHandlerGet() # forces when=WITH_CALLBACK_USER_SUPPLIED
|
|
859,861c885,888
|
|
<
|
|
< if cb is not None:
|
|
< crp.setPyHandlerGet(<void *>cb) # forces when=WITH_CALLBACK_USER_SUPPLIED
|
|
---
|
|
> global getDictGlobal
|
|
> if cb is not None:
|
|
> getDictGlobal[handle] = cb
|
|
> crp.setPyHandlerGet() # forces when=WITH_CALLBACK_USER_SUPPLIED
|
|
886,888c913,917
|
|
<
|
|
< if cb is not None:
|
|
< crp.setPyHandlerPut(<void *>cb) # forces when=WITH_CALLBACK_USER_SUPPLIED
|
|
---
|
|
>
|
|
> global putDictGlobal
|
|
> if cb is not None:
|
|
> putDictGlobal[handle] = cb
|
|
> crp.setPyHandlerPut() # forces when=WITH_CALLBACK_USER_SUPPLIED
|
|
1402c1431
|
|
< #decorator casts handlePV to int
|
|
---
|
|
> #decorator casts to handlePV to int
|
|
4021c4050
|
|
< return pvdict, statusOverall, status
|
|
---
|
|
> return pvdict
|
|
5148a5178,5180
|
|
> global monDictGlobal
|
|
> global handleMonDictGlobal
|
|
>
|
|
5158c5190
|
|
<
|
|
---
|
|
> #global py_cb
|
|
5185,5189d5216
|
|
< mp.setUserArgs(< void * > mpid)
|
|
< mp.setNoCyCallbackParameters(len(sig.parameters))
|
|
< mp.setPyCyHandler(<void *> cb)
|
|
<
|
|
<
|
|
5198c5225,5245
|
|
<
|
|
---
|
|
>
|
|
> mp[i].setUserArgs( < void*> mpid)
|
|
>
|
|
> if len(sig.parameters) == 1:
|
|
> monDictGlobal[mpid] = cb
|
|
> mp[i].setPyHandler()
|
|
>
|
|
> elif len(sig.parameters) == 2:
|
|
> mp[i].setPyCyHandler(<void *> cb)
|
|
>
|
|
> elif len(sig.parameters) == 3:
|
|
> handleMonDictGlobal[cb] = handleList[i]
|
|
> mp[i].setPyCyHandlerData(<void *> cb)
|
|
>
|
|
> else:
|
|
> _cafeException = CafeException(_type='CafeError', _source=_METHOD,
|
|
> _error_info="The signature of the monitor callback function is not supported. \
|
|
> Supported fns are: \
|
|
> 1) callback(handle) or 2) callback(pvdata, handle, pv_name) ")
|
|
> raise _cafeException
|
|
>
|
|
5236a5284,5285
|
|
> global monDictGlobal
|
|
> global handleMonDictGlobal
|
|
5251c5300,5301
|
|
<
|
|
---
|
|
> # April 2020 Legacy
|
|
> #global py_cb
|
|
5286,5290c5336
|
|
< sig = inspect.signature(cb[i])
|
|
<
|
|
< mp[i].setUserArgs(< void * > mpid) # (<unsigned long *> ptr_mpid)[0])
|
|
< mp[i].setNoCyCallbackParameters(len(sig.parameters))
|
|
< mp[i].setPyCyHandler(<void *> cb[i])
|
|
---
|
|
> sig = inspect.signature(cb[i])
|
|
5301c5347,5366
|
|
<
|
|
---
|
|
> mp[i].setUserArgs( < void * > mpid) # (<unsigned long *> ptr_mpid)[0])
|
|
>
|
|
> if len(sig.parameters) == 1:
|
|
> monDictGlobal[mpid] = cb[i]
|
|
> mp[i].setPyHandler()
|
|
>
|
|
> elif len(sig.parameters) == 2:
|
|
> mp[i].setPyCyHandler(<void *> cb[i])
|
|
>
|
|
> elif len(sig.parameters) == 3:
|
|
> handleMonDictGlobal[cb[i]] = handleList[i]
|
|
> mp[i].setPyCyHandlerData(<void *> cb[i])
|
|
>
|
|
> else:
|
|
> _cafeException = CafeException(_type='CafeError', _source=_METHOD,
|
|
> _error_info="The signature of the monitor callback function is not supported. \
|
|
> Supported fns are: \
|
|
> 1) callback(handle) or 2) callback(pvdata, handle, pv_name) ")
|
|
> raise _cafeException
|
|
>
|
|
5940a6006
|
|
>
|
|
5948c6014
|
|
<
|
|
---
|
|
>
|
|
5969c6035,6036
|
|
<
|
|
---
|
|
>
|
|
>
|
|
6044a6112,6114
|
|
> global monDictGlobal
|
|
> global handleMonDictGlobal
|
|
> global py_cb
|
|
6046c6116,6117
|
|
<
|
|
---
|
|
>
|
|
> py_cb = cb
|
|
6049,6050c6120,6121
|
|
< hmd[cb] = mpid ##otherwise cb gets ovewritten when casting to an object
|
|
<
|
|
---
|
|
> hmd[cb] = handle ##otherwise cb gets ovewritten when casting to an object
|
|
> #print(hmd)
|
|
6052c6123,6133
|
|
<
|
|
---
|
|
> '''
|
|
> print('SIGNATURE//3//:')
|
|
> print(str(sig))
|
|
> for param in sig.parameters.values():
|
|
> print('Parameter:', param, type(param))
|
|
> print('len1', len(sig.parameters.values()))
|
|
> print('len2', len(sig.parameters))
|
|
>
|
|
> print('monitorid', mpid)
|
|
> '''
|
|
>
|
|
6056,6057c6137,6165
|
|
< mp.setNoCyCallbackParameters(len(sig.parameters))
|
|
< mp.setPyCyHandler(<void *> cb)
|
|
---
|
|
>
|
|
>
|
|
> if len(sig.parameters) == 1:
|
|
> ###monDictGlobal[mpid] = cb
|
|
>
|
|
> mp.setPyHandler()
|
|
> # print (<long>mp.getUserArgs())
|
|
>
|
|
> elif len(sig.parameters) == 2:
|
|
> mp.setPyCyHandler(<void *> cb)
|
|
> #mp.setPyHandler()
|
|
> #mp.setCyCallback(<void *> cb)
|
|
>
|
|
> elif len(sig.parameters) == 3:
|
|
> #py_cb=cb
|
|
> #self.hh.addWidget(handle, <void *> cb)
|
|
>
|
|
> mp.setPyCyHandlerData(<void *> ( py_cb))
|
|
> #handleMonDictGlobal[cb] = handle
|
|
>
|
|
> #mp.setPyHandlerData()
|
|
> #mp.setCyCallback(<void *> cb)
|
|
> else:
|
|
> _cafeException = CafeException(
|
|
> _type='CafeError', _source=_METHOD,
|
|
> _error_info="The signature of the monitor callback function \
|
|
> given by the user is not supported. Valid fns are: \
|
|
> 1) callback(handle) or 2) callback(pvdata, handle, pv_name) ")
|
|
> raise _cafeException
|
|
6096c6204
|
|
< cdef unsigned int mpid_no_coercion
|
|
---
|
|
> cdef unsigned int mpidUI
|
|
6097a6206,6207
|
|
> global monDictGlobal
|
|
> #global handleMonDictGlobal
|
|
6099c6209,6210
|
|
<
|
|
---
|
|
>
|
|
>
|
|
6101d6211
|
|
< mpid_no_coercion = mpid
|
|
6103c6213
|
|
< mpid_no_coercion = mpid
|
|
---
|
|
> mpidUI = mpid
|
|
6105,6113c6215,6226
|
|
< status = self._c_cafe.monitorStopWithID(handle, mpid_no_coercion)
|
|
< time.sleep(0.001)
|
|
< l = None
|
|
< if mpid not in list(hmd.values()):
|
|
< pass #happens when is direct mode in table widget
|
|
< else:
|
|
< l = list(hmd.keys())[list(hmd.values()).index(mpid)]
|
|
< if l is not None:
|
|
< del hmd[l]
|
|
---
|
|
> status = self._c_cafe.monitorStopWithID(handle, mpidUI)
|
|
> time.sleep(0.01)
|
|
>
|
|
> if (status == ICAFE_NORMAL):
|
|
> #pass
|
|
> #print (monDictGlobal)
|
|
> # DELETE ENTRY ONLY IF IT EXISTS!
|
|
> # if monDictGlobal.has_key(mpidUI):
|
|
> # Sep 2020 - try without del for testing!
|
|
> if mpidUI in monDictGlobal.keys():
|
|
> del monDictGlobal[mpidUI]
|
|
>
|
|
6118d6230
|
|
< mids = self.hh.getMonitorIDs(handle)
|
|
6121,6129c6233,6265
|
|
< time.sleep(0.001)
|
|
<
|
|
< for monid in mids:
|
|
< if monid not in list(hmd.values()):
|
|
< continue
|
|
< l = list(hmd.keys())[list(hmd.values()).index(monid)]
|
|
< if l is not None:
|
|
< del hmd[l]
|
|
<
|
|
---
|
|
> time.sleep(0.01)
|
|
>
|
|
> _ncount = 0
|
|
> for key, value in hmd.items():
|
|
> if value == handle:
|
|
> _ncount += 1
|
|
>
|
|
> for i in range (0, _ncount):
|
|
> try:
|
|
> l = list(hmd.keys())[list(hmd.values()).index(handle)]
|
|
> #print (l)
|
|
> if l is not None:
|
|
> del hmd[l]
|
|
> except ValueError:
|
|
> print("List does not contain handle {0}".format(handle))
|
|
> #{k:v for k,v in hmd.items() if v != handle}
|
|
> ##for a, v in hmd.items():
|
|
> ##print(a, v)
|
|
> ##print ("DEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEELLLLLLLETE")
|
|
> # Find handle with monitor ID and STOP thst one monitor!
|
|
>
|
|
> if (status == ICAFE_NORMAL):
|
|
>
|
|
> # print "size", self.hh.getNmonitor(handle)
|
|
> mpidUIV = self.hh.getMonitorIDs(handle)
|
|
> # print "size", mpidUIV.size()
|
|
>
|
|
> for i in range(0, mpidUIV.size()):
|
|
>
|
|
> # if monDictGlobal.has_key(mpidUIV[i]):
|
|
> if mpidUIV[i] in monDictGlobal.keys():
|
|
> del monDictGlobal[mpidUIV[i]]
|
|
>
|
|
6137a6274
|
|
> # 3
|
|
6143d6279
|
|
< cdef int status
|
|
6144a6281,6282
|
|
> global monDictGlobal
|
|
> global handleMonDictGlobal
|
|
6145a6284
|
|
> cdef int status
|
|
6152c6291,6292
|
|
< hmd.clear()
|
|
---
|
|
> monDictGlobal.clear()
|
|
> handleMonDictGlobal.clear()
|
|
6181a6322
|
|
>
|
|
7232,7545d7372
|
|
<
|
|
< #if HAVE_BSREAD==1:
|
|
<
|
|
< ################################################################################
|
|
<
|
|
< def prepareSFdbpm(self):
|
|
< cdef:
|
|
< vector[string] bpmList
|
|
< vector[unsigned int] bpmHandles
|
|
< vector[string] bpmDev
|
|
< vector[float] bpmPos
|
|
<
|
|
< self._c_cafe.prepareDBPM(bpmList, bpmHandles, bpmDev, bpmPos)
|
|
<
|
|
< # for i in range(0, self.bpmDev.size()):
|
|
< #print (bpmPos[i], bpmDev[i] )
|
|
<
|
|
< if not self.dbpmInitialized:
|
|
< self.dbpm = DBPMKeeper(
|
|
< bpmList, bpmHandles, bpmDev, bpmPos)
|
|
< self.dbpmInitialized = True
|
|
< return
|
|
<
|
|
< ##################################################################################
|
|
< # END def prepareSFdbpm(self)
|
|
< ##################################################################################
|
|
<
|
|
< def setSFdbpmBS(self, bint bsFlag=True):
|
|
< return self.dbpm.setBS(bsFlag)
|
|
<
|
|
< def resetSFdbpmBS(self):
|
|
< return self.dbpm.resetBS()
|
|
<
|
|
< def closeSFdbpmBS(self):
|
|
< return self.dbpm.closeBS()
|
|
<
|
|
< def readSFdbpmOffsets(self):
|
|
< return self._c_cafe.readDBPMOffsets(self.dbpm)
|
|
<
|
|
< def getSFdbpm(self):
|
|
<
|
|
< cdef str _METHOD = "getSFdbpm"
|
|
<
|
|
< cdef int status
|
|
< cdef vector[unsigned int] handleV
|
|
< with nogil:
|
|
< status = self._c_cafe.getDBPM(self.dbpm)
|
|
<
|
|
< if status >= ICAFE_ERRNO_BASE:
|
|
< self._c_cafe.printStatusMessage(status)
|
|
< elif status != ICAFE_NORMAL:
|
|
< if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW:
|
|
< # self._c_cafe.printStatusMessage(status)
|
|
<
|
|
< handleV = self.dbpm.getHandle()
|
|
< # for i in range(0, self.dbpm.getNDBPM()):
|
|
< # if x[i].getStatus !=
|
|
< #print (self.bpmPos[i], self.bpmDev[i] )
|
|
< for i in range(0, self.dbpm.getNPV()):
|
|
< if (self.dbpm.pvd[i].getStatus() != ICAFE_NORMAL):
|
|
< self._c_cafe.printStatus(handleV[i], status)
|
|
<
|
|
< return dbpmHolderToStruct(self.dbpm)
|
|
<
|
|
< ##################################################################################
|
|
< # END def getSFdbpm(self):
|
|
< ##################################################################################
|
|
<
|
|
<
|
|
< def getSFdbpmOffs_x(self):
|
|
< return self.dbpm.getOffsetX()
|
|
<
|
|
< def getSFdbpmOffs_y(self):
|
|
< return self.dbpm.getOffsetY()
|
|
<
|
|
< ################################################################################
|
|
<
|
|
< def setBS(self, list pv=None, modulo=None, offset=None, int timeoutMS=0):
|
|
<
|
|
< cdef str _METHOD = "setBS"
|
|
< cdef int status = ICAFE_NORMAL
|
|
< cdef unsigned int i
|
|
< cdef bint pFlag = False
|
|
<
|
|
< if isinstance(modulo, numbers.Number):
|
|
< if int(modulo) <= 0:
|
|
< raise ValueError("{} {} \n{}".format(
|
|
< self._exception_text, _METHOD,
|
|
< "modulo input argument must be positive!"))
|
|
< elif not TypeError(modulo, dict):
|
|
< raise Exception("{} {} \n{}".format(
|
|
< self._exception_text, _METHOD,
|
|
< ("modulo input arg, should be of type <class 'numbers.Number'>, "
|
|
< "else <class 'dict'> {pv_name : modulo}")))
|
|
<
|
|
< if isinstance(offset, (numbers.Number)):
|
|
< if int(offset) < 0:
|
|
< raise ValueError("{} {} \n{}".format(
|
|
< self._exception_text, _METHOD,
|
|
< "offset input argument cannot be negative!"))
|
|
< elif not isinstance(offset, (dict)):
|
|
< raise TypeError("{} {} \n{}".format(
|
|
< self._exception_text, _METHOD,
|
|
< ("offset input arg, should be of type <class 'numbers.Number'>, "
|
|
< "else <class 'dict'> {pv_name : offset} ")))
|
|
<
|
|
< if self.BSInitialized == True:
|
|
< print("Message from setBS: ONLY A SINGLE STREAM IS ALLOWED")
|
|
< return status
|
|
<
|
|
< cdef vector[string] v
|
|
<
|
|
< if timeoutMS > 0:
|
|
< self.bsd.setTimeout(timeoutMS)
|
|
<
|
|
< if pv is not None:
|
|
< # do this to avoid compiler warning messages
|
|
< for i in range(0, len(pv)):
|
|
< v.push_back(pv[i])
|
|
< self.bsd.init(v)
|
|
<
|
|
< if isinstance(modulo, (numbers.Number)):
|
|
< modulo = dict([(pv[i], int(modulo))
|
|
< for i in range(0, len(pv))])
|
|
<
|
|
< if isinstance(offset, (numbers.Number)):
|
|
< offset = dict([(pv[i], int(offset))
|
|
< for i in range(0, len(pv))])
|
|
<
|
|
< if modulo is not None:
|
|
< for eachKey in modulo:
|
|
< self.bsd.setBSModulo(eachKey, modulo[eachKey])
|
|
< if offset is not None:
|
|
< for eachKey in offset:
|
|
< self.bsd.setBSOffset(eachKey, offset[eachKey])
|
|
<
|
|
< # self.initBSwithCA()
|
|
< with nogil:
|
|
< self._c_cafe.initBSwithCA(self.bsd)
|
|
<
|
|
< with nogil:
|
|
< self._c_cafe.getBS(self.bsd)
|
|
<
|
|
< with nogil:
|
|
< # status=self._c_cafe.setBS_Step1(self.bsd)
|
|
< status = self._c_cafe.setBS(self.bsd)
|
|
<
|
|
< if status == ICAFE_NORMAL:
|
|
< self.BSInitialized = True
|
|
< self.isBSinCAOnly = False
|
|
<
|
|
< return status
|
|
<
|
|
< ################################################################################
|
|
<
|
|
< def initBSwithCA(self):
|
|
<
|
|
< # self.openPrepare()
|
|
< with nogil:
|
|
< self._c_cafe.initBSwithCA(self.bsd)
|
|
<
|
|
< # self.openNowAndWait(0.4)
|
|
<
|
|
<
|
|
< ################################################################################
|
|
< def setBS2CA(self, list pv=None):
|
|
<
|
|
< cdef vector[string] v
|
|
< if pv is not None:
|
|
< # do this to avoid compiler warning messages
|
|
< for i in range(0, len(pv)):
|
|
< v.push_back(pv[i])
|
|
< self.bsd.init(v)
|
|
<
|
|
< with nogil:
|
|
< self._c_cafe.setBS2CAGroup(self.bsd)
|
|
< self.isBSinCAOnly = True
|
|
<
|
|
<
|
|
< def getBSSlim(self):
|
|
< if self.BSInitialized == False:
|
|
< if self.isBSinCAOnly == False:
|
|
< print(("Message from getBS: BS stream not initialized;"
|
|
< "cafe.setBS(pvList) has first to be called."))
|
|
< return None
|
|
<
|
|
< with nogil:
|
|
< self._c_cafe.getBS(self.bsd)
|
|
<
|
|
<
|
|
< t1= time.time()
|
|
< PVDataV = self.bsd.getPVDataV()
|
|
<
|
|
< pvlist = [None] * <int>self.bsd.getNPV()
|
|
< #cdef pvdata p1
|
|
<
|
|
< for i in range (0, self.bsd.getNPV()):
|
|
< #p1 = pvdata()
|
|
< #p1 = PVDataHolderToStruct(self.bsd.pvdata[i])
|
|
< pvlist[i]=PVDataHolderToStruct(PVDataV[i])
|
|
<
|
|
<
|
|
< bs_slim = {}
|
|
<
|
|
< for data, handle in zip(pvlist, self.bsd.getHandles()): # self.bsd.getIsBS()):
|
|
< bs_slim[handle] = data
|
|
<
|
|
< t2= time.time()
|
|
< print("diff in reading BSDataHolderToStruc", t2 - t1)
|
|
<
|
|
<
|
|
< return bs_slim
|
|
<
|
|
< ################################################################################
|
|
< def getBS(self):
|
|
<
|
|
< if self.BSInitialized == False:
|
|
< if self.isBSinCAOnly == False:
|
|
< print(("Message from getBS: BS stream not initialized;"
|
|
< "cafe.setBS(pvList) has first to be called."))
|
|
<
|
|
< return None
|
|
< # CHECK STATUS!!!!
|
|
< #print("getBS in cycafe"
|
|
< #start = time.time()
|
|
<
|
|
< with nogil:
|
|
< self._c_cafe.getBS(self.bsd)
|
|
<
|
|
< _bsd = BSDataHolderToStruct(self.bsd)
|
|
< #_bsd.show()
|
|
< return _bsd #BSDataHolderToStruct(self.bsd)
|
|
<
|
|
< '''
|
|
< cdef double _pid = 0
|
|
< _handle = self._c_cafe.getHandleFromPV(str('SIN-TIMAST-EVG0:TX-PULSEID'))
|
|
< _stat = self._c_cafe.getCacheDouble(_handle, _pid)
|
|
< print("cython/cafe/diff in cython ", self.bsd.getPulse_id(), _pid, _pid - self.bsd.getPulse_id())
|
|
< t1= time.time()
|
|
< print("diff in cython", t1 - start)
|
|
< #print("pulse_id in cycafe", self.bsd.getPulse_id())
|
|
<
|
|
< BSd = BSDataHolderToStruct(self.bsd)
|
|
< t2= time.time()
|
|
< print("diff totol in reading BSDataHolderToStruc", t2 - start)
|
|
<
|
|
< return BSd
|
|
< '''
|
|
<
|
|
< ################################################################################
|
|
<
|
|
< def closeBS(self):
|
|
< with nogil:
|
|
< self._c_cafe.closeBS(self.bsd)
|
|
< self.BSInitialized = False
|
|
< self.isBSinCAOnly = False
|
|
<
|
|
<
|
|
< def getTimeoutMSBS(self):
|
|
< return self.bsd.getTimeout()
|
|
<
|
|
< def setTimeoutMSBS(self, int timeoutMS):
|
|
< self.bsd.setTimeout(timeoutMS)
|
|
<
|
|
<
|
|
< def reconnectBS(self):
|
|
< self.bsd.reconnect()
|
|
<
|
|
<
|
|
< def flushBS(self):
|
|
< self.bsd.reconnect()
|
|
<
|
|
<
|
|
< def monitorPulseID(self):
|
|
< with nogil:
|
|
< self._c_cafe.monitorPulseID()
|
|
<
|
|
<
|
|
< def monitorStopPulseID(self):
|
|
< with nogil:
|
|
< self._c_cafe.monitorStopPulseID()
|
|
<
|
|
<
|
|
< def setPulseIDBufferSize(self, handlePV, int bufferSize = 10):
|
|
< cdef str _METHOD = "setPulseIDBufferSize"
|
|
<
|
|
< cdef unsigned int handle = 0
|
|
< if isinstance(handlePV, (int, long)):
|
|
< handle = handlePV
|
|
< elif isinstance(handlePV, (str)):
|
|
< handle = self.checkForHandle(handlePV)
|
|
< else:
|
|
< raise Exception("{} {} \n{}".format(
|
|
< self._exception_text, _METHOD,
|
|
< ("First Input argument should be of type <class 'int'> if handle "
|
|
< "else <class 'str'> if PV.")))
|
|
<
|
|
< self._c_cafe.setPulseIDBufferSize(handle, bufferSize)
|
|
<
|
|
<
|
|
< def setPulseIDBufferSizeAll(self, int bufferSize = 10):
|
|
< self._c_cafe.setPulseIDBufferSizeAll(bufferSize)
|
|
<
|
|
<
|
|
< ###################################################################################
|
|
<
|
|
< def setBSInit(self, list pv):
|
|
< self.bsd.init(pv)
|
|
<
|
|
<
|
|
<
|
|
< ##################################################################################
|
|
< #END: cdef CAFE###################################################################
|
|
< ##################################################################################
|