849 lines
32 KiB
Cython
849 lines
32 KiB
Cython
|
|
def show():
|
|
print "cafe=PyCafe.CyCafe()"
|
|
print "cyca=PyCafe.CyCa()"
|
|
print "cafe.init()"
|
|
print "cafe.openNoWait()"
|
|
print "<handle/handleList>=cafe.open(<pv/pvList>)"
|
|
print "cafe.openNowAndWait(timeout)"
|
|
print "cafe.openNow()"
|
|
print "cafe.close(handlePV=<handle/pv>)"
|
|
print "cafe.closeChannels()"
|
|
print "cafe.allConnected()"
|
|
print "cafe.isConnected(handlePV=<handle/pv>)"
|
|
print "cafe.printDisconnected()"
|
|
print "cafe.printHandles()"
|
|
print "cafe.printHandle(handlePV=<handle/pv>)"
|
|
|
|
print "cafe.getStatus(handlePV=<handle/pv>)"
|
|
print "cafe.getAlarmStatusSeverity(handlePV=<handle/pv>)"
|
|
print "cafe.getTimeStamp(handlePV=<handle/pv>)"
|
|
print "cafe.getTimeStampDate(handlePV=<handle/pv>)"
|
|
print "cafe.checkForHandle(<pv>)"
|
|
print "cafe.checkForHandleList(<pvList>)"
|
|
print "cafe.checkForGroupHandle(<groupName>)"
|
|
print "cafe.getPVNameFromHandle(int)"
|
|
print "cafe.getHandleFromPVName(str)"
|
|
print "cafe.getChannelInfo(handlePV=<handle/pv>)"
|
|
print "cafe.setDbrBase(handlePV=<handle/pv>, unsigned int) #dbrBase.DBR_XXX"
|
|
print "cafe.getDbrBase(handlePV=<handle/pv>)"
|
|
|
|
print "cafe.getNonBlocking(handlePV=<handle/pv>)" #followed by getCache
|
|
print "cafe.get(handlePV=<handle/pv>)" # return in native type
|
|
print "cafe.get(handlePV=<handle/pv>, dt='native' (default) else <'int','float','str'>)"
|
|
print "cafe.getInt(handlePV=<handle/pv>)"
|
|
print "cafe.getFloathandlePV=<handle/pv>)"
|
|
print "cafe.getStr(handlePV=<handle/pv>)"
|
|
|
|
print "cafe.getList(handlePV=<handle/pv>)" # return List in native type
|
|
print "cafe.getList(handlePV=<handle/pv>, dt='native' (default) else <'int','float','str'>)"
|
|
print "cafe.getIntList(handlePV=<handle/pv>)"
|
|
print "cafe.getFloatList(handlePV=<handle/pv>)"
|
|
print "cafe.getStrList(handlePV=<handle/pv>)"
|
|
|
|
# returns Memoryview in native type, except for when dt='str' which returns a List
|
|
# returns np.array if asnumpy=True
|
|
print "cafe.getArray(handlePV=<handle/pv>)"
|
|
print "cafe.getArray(handlePV=<handle/pv>, dt=<'int','float','str','native'(default)>)"
|
|
print "cafe.getIntArray(handlePV=<handle/pv>,asnumpy=<True,False(default)>)"
|
|
print "cafe.getFloatArray(handlePV=<handle/pv>,asnumpy=<True,False(default)>)"
|
|
|
|
|
|
print "cafe.getPV(handlePV=<handle/pv>)" # return PVData in native type
|
|
print "cafe.getPV(handlePV=<handle/pv>, dt='native' (default) else <'int','float','str'>)"
|
|
print "cafe.getPVInt(handlePV=<handle/pv>)"
|
|
print "cafe.getPVFloat(handlePV=<handle/pv>)"
|
|
print "cafe.getPVStr(handlePV=<handle/pv>)"
|
|
|
|
print "cafe.getPVList(handleList=<handleList/pvList>)" # return Array of PVData in native type
|
|
print "cafe.getPVList(handleList=<handleList/pvList>, dt='native' (default) else <'int','float','str'>)"
|
|
print "cafe.getPVIntList(handleList=<handleList/pvList>)"
|
|
print "cafe.getPVFloatList(handleList=<handleList/pvList>)"
|
|
print "cafe.getPVStrList(handleList=<handleList/pvList>)"
|
|
|
|
print "cafe.getScalarList(handleList=<handleList/pvList>)" # return List in native type
|
|
print "cafe.getScalarList(handleList=<handleList/pvList>, dt='native' (default) else <'int','float','str'>)"
|
|
print "cafe.getIntScalarList(handleList=<handleList/pvList>)"
|
|
print "cafe.getFloatScalarList(handleList=<handleList/pvList>)"
|
|
print "cafe.getStrScalarList(handleList=<handleList/pvList>)"
|
|
|
|
print "cafe.getPVCache(handlePV=<handle/pv>)" # return PVData in native type
|
|
print "cafe.getPVCache(handlePV=<handle/pv>, dt='native' (default) else <'int','float','str'>)"
|
|
print "cafe.getPVIntCache(handlePV=<handle/pv>)"
|
|
print "cafe.getPVFloatCache(handlePV=<handle/pv>)"
|
|
print "cafe.getPVStrCache(handlePV=<handle/pv>)"
|
|
|
|
|
|
# returns Memoryview in native type, except for when dt='str' which returns a List
|
|
# returns np.array if asnumpy=True
|
|
print "cafe.getArrayCache(handlePV=<handle/pv>)"
|
|
print "cafe.getArrayCache(handlePV=<handle/pv>, dt=<'int','float','str','native'(default)>)"
|
|
print "cafe.getIntArrayCache(handlePV=<handle/pv>,asnumpy=<True,False(default)>)"
|
|
print "cafe.getFloatArrayCache(handlePV=<handle/pv>,asnumpy=<True,False(default)>)"
|
|
|
|
print "cafe.getCtrl(handlePV=<handle/pv>)"
|
|
print "cafe.getCtrl(handlePV=<handle/pv>, dt='native' (default) else <'int','float','str'>)"
|
|
print "cafe.getCtrlCache(handlePV=<handle/pv>)"
|
|
print "cafe.getCtrlCache(handlePV=<handle/pv>, dt='native' (default) else <'int','float','str'>)"
|
|
|
|
print "mpid=cafe.monitorStart(handlePV=<handle/pv>), cb=None, dbr=None, mask=DBE_VALUE|DBE_LOG|DBE_ALARM)"
|
|
print "cafe.monitorStop(handlePV=<handle/pv>, mpID=None)"
|
|
print "cafe.monitorStopAll(handlePV=<handle/pv>)"
|
|
|
|
print "cafe.getNoMonitors(handlePV=<handle/pv>)"
|
|
|
|
print "cafe.set(handlePV=<handle/pv>, valSet)"
|
|
print "cafe.setScalarList(handleList=<handleList/pvList>, valList)"
|
|
print "cafe.setAndMatch(handlePVSet=<handle/pv>, valSet=<int,float,str>, handlePVMatch=<handle/pv>, \
|
|
tolerance=<int,float,str> , timeout=<float>, printFlag=<bint>)"
|
|
#Synchronous groups
|
|
print "handleList[]=cafe.defineGroup(gname, pvList)"
|
|
print "list[]=cafe.PVGroupValuesToList(pvgroup)"
|
|
print "vectorList,status,statusList = cafe.getGroup(self, ghandleName, dt='native')"
|
|
print "pvdataList[],status = cafe.getPVGroup(self, ghandleName, dt='native')"
|
|
print "cafe.setGroup(ghandleName, vectorList)"
|
|
|
|
return
|
|
|
|
|
|
cdef int PYCAFE_PRINT_HIGH=9
|
|
cdef int PYCAFE_PRINT_MED=5
|
|
cdef int PYCAFE_PRINT_LOW=1
|
|
|
|
cdef int PYCAFE_PRINT_LEVEL=PYCAFE_PRINT_MED
|
|
|
|
ctypedef shared_ptr[vector [double]] vdouble_ptr
|
|
ctypedef shared_ptr[vector [float]] vfloat_ptr
|
|
|
|
cdef object py_cb = None
|
|
cdef object py_cb_handle = None
|
|
cdef object py_cb_ctrl = None
|
|
|
|
|
|
'''
|
|
def py_cb(pvdata pv1, unsigned int handle, str pvname):
|
|
print "PV:", pvname, " Handle:", handle
|
|
pv1.showMax(10)
|
|
return
|
|
|
|
def py_cb_handle(unsigned int handle):
|
|
print " Handle:", handle
|
|
return
|
|
|
|
#Add control callback!
|
|
|
|
def py_cb_ctrl(pvctrl c1, unsigned int handle, str pvname):
|
|
print "PV:", pvname, " Handle:", handle
|
|
c1.showMax(10)
|
|
return
|
|
'''
|
|
|
|
#***********api***************
|
|
|
|
cdef public void py_cb_wrapper(PVDataHolder pvd, unsigned int handle, string pvname) with gil:
|
|
cdef pvdata pv1 = PVDataHolderToStruct(pvd)
|
|
py_cb(pv1, handle, pvname)
|
|
with nogil:
|
|
return
|
|
|
|
cdef public void py_cb_ctrl_wrapper(PVCtrlHolder pvc, unsigned int handle, string pvname) with gil:
|
|
cdef pvctrl c1 = PVCtrlHolderToStruct(pvc)
|
|
py_cb_ctrl(c1, handle, pvname)
|
|
with nogil:
|
|
return
|
|
|
|
cdef public void py_cb_handle_wrapper(unsigned int handle) with gil:
|
|
|
|
py_cb_handle(handle)
|
|
|
|
with nogil:
|
|
return
|
|
|
|
|
|
cdef public void py_cb_handle_monid_wrapper(unsigned int handle, unsigned long monid) with gil:
|
|
|
|
|
|
cbobjt=monDictGlobal[monid]
|
|
|
|
cbobjt(handle)
|
|
|
|
with nogil:
|
|
return
|
|
|
|
|
|
#***********api***************
|
|
'''
|
|
cdef object callbackHandlerMonitor = None
|
|
|
|
|
|
cdef void callbackHandlerMonitor_wrapper(event_handler_args args) with gil:
|
|
handle=<unsigned long> args.usr
|
|
py_cb_handle(handle)
|
|
with nogil:
|
|
return
|
|
'''
|
|
#Correct memory management a la KWSmith p.190
|
|
cdef class _finalizer:
|
|
cdef void *_data
|
|
def __dealloc__(self):
|
|
if self._data is not NULL:
|
|
free(self._data)
|
|
return
|
|
|
|
cdef void set_base(cnp.ndarray arr, void * carr):
|
|
cdef _finalizer fin = _finalizer()
|
|
fin._data = <void *> carr
|
|
cnp.set_array_base(arr, fin)
|
|
return
|
|
|
|
cdef class CyCa:
|
|
cpdef readonly unsigned int CY_DBE_VALUE
|
|
cpdef readonly unsigned int CY_DBE_LOG
|
|
cpdef readonly unsigned int CY_DBE_ARCHIVE
|
|
cpdef readonly unsigned int CY_DBE_ALARM
|
|
cpdef readonly unsigned int CY_DBE_PROPERTY
|
|
cpdef readonly unsigned int CY_DBR_PRIMITIVE
|
|
cpdef readonly unsigned int CY_DBR_PLAIN
|
|
cpdef readonly unsigned int CY_DBR_STS
|
|
cpdef readonly unsigned int CY_DBR_TIME
|
|
cpdef readonly unsigned int CY_DBR_GR
|
|
cpdef readonly unsigned int CY_DBR_CTRL
|
|
cpdef readonly unsigned int CY_DBR_PUT
|
|
cpdef readonly unsigned int CY_DBR_STSACK
|
|
cpdef readonly unsigned int CY_DBR_CLASS
|
|
cpdef readonly unsigned int CY_DBR_NONE
|
|
cpdef readonly unsigned int CY_DBR_STRING #returns a NULL terminated string
|
|
cpdef readonly unsigned int CY_DBR_SHORT #returns an unsigned short
|
|
cpdef readonly unsigned int CY_DBR_INT #returns an unsigned short
|
|
cpdef readonly unsigned int CY_DBR_FLOAT #returns an IEEE floating point value
|
|
cpdef readonly unsigned int CY_DBR_ENUM #returns an unsigned short which is the enum item
|
|
cpdef readonly unsigned int CY_DBR_CHAR #returns an unsigned char
|
|
cpdef readonly unsigned int CY_DBR_LONG #returns an unsigned long
|
|
cpdef readonly unsigned int CY_DBR_DOUBLE #returns a double precision floating point number
|
|
cpdef readonly unsigned int CY_DBR_STS_STRING #returns a string status structure (dbr_sts_string)
|
|
cpdef readonly unsigned int CY_DBR_STS_SHORT #returns a short status structure (dbr_sts_short)
|
|
cpdef readonly unsigned int CY_DBR_STS_INT #returns a short status structure (dbr_sts_int)
|
|
cpdef readonly unsigned int CY_DBR_STS_FLOAT #returns a float status structure (dbr_sts_float)
|
|
cpdef readonly unsigned int CY_DBR_STS_ENUM #returns an enum status structure (dbr_sts_enum)
|
|
cpdef readonly unsigned int CY_DBR_STS_CHAR #returns a char status structure (dbr_sts_char)
|
|
cpdef readonly unsigned int CY_DBR_STS_LONG #returns a long status structure (dbr_sts_long)
|
|
cpdef readonly unsigned int CY_DBR_STS_DOUBLE #returns a double status structure (dbr_sts_double)
|
|
cpdef readonly unsigned int CY_DBR_TIME_STRING #returns a string time structure (dbr_time_string)
|
|
cpdef readonly unsigned int CY_DBR_TIME_SHORT #returns a short time structure (dbr_time_short)
|
|
cpdef readonly unsigned int CY_DBR_TIME_INT #returns a short time structure (dbr_time_short)
|
|
cpdef readonly unsigned int CY_DBR_TIME_FLOAT #returns a float time structure (dbr_time_float)
|
|
cpdef readonly unsigned int CY_DBR_TIME_ENUM #returns an enum time structure (dbr_time_enum)
|
|
cpdef readonly unsigned int CY_DBR_TIME_CHAR #returns a char time structure (dbr_time_char)
|
|
cpdef readonly unsigned int CY_DBR_TIME_LONG #returns a long time structure (dbr_time_long)
|
|
cpdef readonly unsigned int CY_DBR_TIME_DOUBLE #returns a double time structure (dbr_time_double)
|
|
cpdef readonly unsigned int CY_DBR_GR_STRING #returns a graphic string structure (dbr_gr_string)
|
|
cpdef readonly unsigned int CY_DBR_GR_SHORT #returns a graphic short structure (dbr_gr_short)
|
|
cpdef readonly unsigned int CY_DBR_GR_INT #returns a graphic short structure (dbr_gr_int)
|
|
cpdef readonly unsigned int CY_DBR_GR_FLOAT #returns a graphic float structure (dbr_gr_float)
|
|
cpdef readonly unsigned int CY_DBR_GR_ENUM #returns a graphic enum structure (dbr_gr_enum)
|
|
cpdef readonly unsigned int CY_DBR_GR_CHAR #returns a graphic char structure (dbr_gr_char)
|
|
cpdef readonly unsigned int CY_DBR_GR_LONG #returns a graphic long structure (dbr_gr_long)
|
|
cpdef readonly unsigned int CY_DBR_GR_DOUBLE #returns a graphic double structure (dbr_gr_double)
|
|
cpdef readonly unsigned int CY_DBR_CTRL_STRING #returns a control string structure (dbr_ctrl_int)
|
|
cpdef readonly unsigned int CY_DBR_CTRL_SHORT #returns a control short structure (dbr_ctrl_short)
|
|
cpdef readonly unsigned int CY_DBR_CTRL_INT #returns a control short structure (dbr_ctrl_int)
|
|
cpdef readonly unsigned int CY_DBR_CTRL_FLOAT #returns a control float structure (dbr_ctrl_float)
|
|
cpdef readonly unsigned int CY_DBR_CTRL_ENUM #returns a control enum structure (dbr_ctrl_enum)
|
|
cpdef readonly unsigned int CY_DBR_CTRL_CHAR #returns a control char structure (dbr_ctrl_char)
|
|
cpdef readonly unsigned int CY_DBR_CTRL_LONG #returns a control long structure (dbr_ctrl_long)
|
|
cpdef readonly unsigned int CY_DBR_CTRL_DOUBLE #returns a control double structure (dbr_ctrl_double)
|
|
|
|
def __cinit__(self):
|
|
self.CY_DBE_VALUE =DBE_VALUE
|
|
self.CY_DBE_LOG =DBE_LOG
|
|
self.CY_DBE_ARCHIVE =DBE_ARCHIVE
|
|
self.CY_DBE_ALARM =DBE_ALARM
|
|
self.CY_DBE_PROPERTY =DBE_PROPERTY
|
|
self.CY_DBR_PRIMITIVE =DBR_PRIMITIVE
|
|
self.CY_DBR_PLAIN =DBR_PLAIN
|
|
self.CY_DBR_STS =DBR_STS
|
|
self.CY_DBR_TIME =DBR_TIME
|
|
self.CY_DBR_GR =DBR_GR
|
|
self.CY_DBR_CTRL =DBR_CTRL
|
|
self.CY_DBR_PUT =DBR_PUT # DBR_PUT_ACKT and DBR_PUT_ACKS Write only - used from global alarm acknowledge.
|
|
self.CY_DBR_STSACK =DBR_STSACK # is DBR_STSACK_STRING
|
|
self.CY_DBR_CLASS =DBR_CLASS # is DBR_CLASS_NAME,
|
|
self.CY_DBR_NONE =DBR_NONE
|
|
self.CY_DBR_STRING =DBR_STRING
|
|
self.CY_DBR_SHORT =DBR_SHORT #returns an unsigned short
|
|
self.CY_DBR_INT =DBR_INT #returns an unsigned short
|
|
self.CY_DBR_FLOAT =DBR_FLOAT #returns an IEEE floating point value
|
|
self.CY_DBR_ENUM =DBR_ENUM #returns an unsigned short which is the enum item
|
|
self.CY_DBR_CHAR =DBR_CHAR #returns an unsigned char
|
|
self.CY_DBR_LONG =DBR_LONG #returns an unsigned long
|
|
self.CY_DBR_DOUBLE =DBR_DOUBLE #returns a double precision floating point number
|
|
self.CY_DBR_STS_STRING=DBR_STS_STRING #returns a string status structure (dbr_sts_string)
|
|
self.CY_DBR_STS_SHORT =DBR_STS_SHORT #returns a short status structure (dbr_sts_short)
|
|
self.CY_DBR_STS_INT =DBR_STS_INT #returns a short status structure (dbr_sts_int)
|
|
self.CY_DBR_STS_FLOAT =DBR_STS_FLOAT #returns a float status structure (dbr_sts_float)
|
|
self.CY_DBR_STS_ENUM =DBR_STS_ENUM #returns an enum status structure (dbr_sts_enum)
|
|
self.CY_DBR_STS_CHAR =DBR_STS_CHAR #returns a char status structure (dbr_sts_char)
|
|
self.CY_DBR_STS_LONG =DBR_STS_LONG #returns a long status structure (dbr_sts_long)
|
|
self.CY_DBR_STS_DOUBLE=DBR_STS_DOUBLE #returns a double status structure (dbr_sts_double)
|
|
self.CY_DBR_TIME_STRING=DBR_TIME_STRING #returns a string time structure (dbr_time_string)
|
|
self.CY_DBR_TIME_SHORT =DBR_TIME_SHORT #returns a short time structure (dbr_time_short)
|
|
self.CY_DBR_TIME_INT =DBR_TIME_INT #returns a short time structure (dbr_time_short)
|
|
self.CY_DBR_TIME_FLOAT =DBR_TIME_FLOAT #returns a float time structure (dbr_time_float)
|
|
self.CY_DBR_TIME_ENUM =DBR_TIME_ENUM #returns an enum time structure (dbr_time_enum)
|
|
self.CY_DBR_TIME_CHAR =DBR_TIME_CHAR #returns a char time structure (dbr_time_char)
|
|
self.CY_DBR_TIME_LONG =DBR_TIME_LONG #returns a long time structure (dbr_time_long)
|
|
self.CY_DBR_TIME_DOUBLE=DBR_TIME_DOUBLE #returns a double time structure (dbr_time_double)
|
|
self.CY_DBR_GR_STRING =DBR_GR_STRING #returns a graphic string structure (dbr_gr_string)
|
|
self.CY_DBR_GR_SHORT =DBR_GR_SHORT #returns a graphic short structure (dbr_gr_short)
|
|
self.CY_DBR_GR_INT =DBR_GR_INT #returns a graphic short structure (dbr_gr_int)
|
|
self.CY_DBR_GR_FLOAT =DBR_GR_FLOAT #returns a graphic float structure (dbr_gr_float)
|
|
self.CY_DBR_GR_ENUM =DBR_GR_ENUM #returns a graphic enum structure (dbr_gr_enum)
|
|
self.CY_DBR_GR_CHAR =DBR_GR_CHAR #returns a graphic char structure (dbr_gr_char)
|
|
self.CY_DBR_GR_LONG =DBR_GR_LONG #returns a graphic long structure (dbr_gr_long)
|
|
self.CY_DBR_GR_DOUBLE =DBR_GR_DOUBLE #returns a graphic double structure (dbr_gr_double)
|
|
self.CY_DBR_CTRL_STRING=DBR_CTRL_STRING #returns a control string structure (dbr_ctrl_int)
|
|
self.CY_DBR_CTRL_SHORT =DBR_CTRL_SHORT #returns a control short structure (dbr_ctrl_short)
|
|
self.CY_DBR_CTRL_INT =DBR_CTRL_INT #returns a control short structure (dbr_ctrl_int)
|
|
self.CY_DBR_CTRL_FLOAT =DBR_CTRL_FLOAT #returns a control float structure (dbr_ctrl_float)
|
|
self.CY_DBR_CTRL_ENUM =DBR_CTRL_ENUM #returns a control enum structure (dbr_ctrl_enum)
|
|
self.CY_DBR_CTRL_CHAR =DBR_CTRL_CHAR #returns a control char structure (dbr_ctrl_char)
|
|
self.CY_DBR_CTRL_LONG =DBR_CTRL_LONG #returns a control long structure (dbr_ctrl_long)
|
|
self.CY_DBR_CTRL_DOUBLE=DBR_CTRL_DOUBLE #returns a control double structure (dbr_ctrl_double)
|
|
return
|
|
|
|
|
|
|
|
cdef class channelInfo:
|
|
cdef readonly long channelID
|
|
cdef readonly bint connectFlag
|
|
cdef readonly string hostName
|
|
cdef readonly unsigned int nelem #native
|
|
cdef readonly int dataType; #native
|
|
cdef readonly unsigned short accessRead; #0 or 1
|
|
cdef readonly unsigned short accessWrite; #0 or 1
|
|
cdef readonly string className; #dbr_class_name_t
|
|
cdef readonly int connectionState; #as given by CA_OP_
|
|
cdef readonly int cafeConnectionState; #as given by cafe_cs_state
|
|
cdef readonly string connectionStateAsString; #as given by CA_OP_
|
|
cdef readonly string cafeConnectionStateAsString; #as given by cafe_cs_state
|
|
cdef CAFEDataTypeCode cdt
|
|
cdef CAFEStatusCode csc
|
|
cdef CAOPCodes caop
|
|
|
|
def __cinit__(self):
|
|
self.channelID=0
|
|
self.connectFlag=False
|
|
self.hostName=''
|
|
self.nelem=0
|
|
self.dataType=ICAFE_TYPENOTCONN
|
|
self.accessRead=0
|
|
self.accessWrite=0
|
|
self.className=''
|
|
self.connectionState=ICAFE_CA_OP_CONN_DOWN
|
|
self.cafeConnectionState=ICAFE_CS_NEVER_CONN
|
|
self.connectionStateAsString='ICAFE_CA_OP_CONN_DOWN'
|
|
self.cafeConnectionStateAsString='ICAFE_CS_NEVER_CONN'
|
|
|
|
def show(self):
|
|
print ("channelID = %x" % self.channelID)
|
|
print ("connectFlag = %d" % self.connectFlag)
|
|
print ("hostName = %s" % self.hostName)
|
|
print ("nelem = %d" % self.nelem)
|
|
print ("dataType = %s (%d)" % (self.cdt.message(self.dataType), self.dataType))
|
|
print ("accessRead = %d" % self.accessRead)
|
|
print ("accessWrite = %d" % self.accessWrite)
|
|
print ("className = %s" % self.className)
|
|
#print ("connectionState = %s (%d)" % (self.connectionStateAsString, self.connectionState))
|
|
#print ("cafeConnectionState = %s (%d)" % (self.cafeConnectionStateAsString,self.cafeConnectionState))
|
|
print ("connectionState = %s (%d)" % (self.caop.message(self.connectionState),self.connectionState))
|
|
print ("cafeConnectionState = %s (%d)" % (self.csc.message(self.cafeConnectionState),self.cafeConnectionState))
|
|
return
|
|
|
|
|
|
|
|
##################################################################################
|
|
cdef class _epicsTimeStampAsDate:
|
|
cdef epicsTime *_time
|
|
cdef local_tm_nano_sec local
|
|
cdef list etsDate
|
|
def __cinit__(self, epicsTimeStamp ts):
|
|
self._time = new epicsTime(ts)
|
|
self.local = <local_tm_nano_sec &> (self._time)
|
|
|
|
print "ts====== ", ts.secPastEpoch, ts.nsec
|
|
|
|
print "year=== ", ( ( (&(&self.local).ansi_tm).tm_year) + 1900)
|
|
|
|
self.etsDate=[]
|
|
self.etsDate.append( (self.local.ansi_tm.tm_year + 1900))
|
|
self.etsDate.append( (self.local.ansi_tm.tm_mon + 1))
|
|
self.etsDate.append( self.local.ansi_tm.tm_mday)
|
|
self.etsDate.append( self.local.ansi_tm.tm_hour)
|
|
self.etsDate.append( self.local.ansi_tm.tm_min)
|
|
self.etsDate.append( self.local.ansi_tm.tm_sec)
|
|
self.etsDate.append( <unsigned int> ts.nsec)
|
|
self.etsDate.append( self.local.nSec)
|
|
def get(self):
|
|
return self.etsDate
|
|
|
|
|
|
##################################################################################
|
|
|
|
##################################################################################
|
|
cdef class pvctrl:
|
|
cdef readonly unsigned int nelem
|
|
cdef readonly int alarmStatus
|
|
cdef readonly int alarmSeverity
|
|
cdef readonly unsigned short precision
|
|
cdef readonly string units
|
|
cdef readonly unsigned short noEnumStrings
|
|
cdef readonly list enumStrings
|
|
cdef readonly upperDisplayLimit
|
|
cdef readonly lowerDisplayLimit
|
|
cdef readonly upperAlarmLimit
|
|
cdef readonly upperWarningLimit
|
|
cdef readonly lowerWarningLimit
|
|
cdef readonly lowerAlarmLimit
|
|
cdef readonly upperControlLimit
|
|
cdef readonly lowerControlLimit
|
|
cdef readonly list value
|
|
cdef readonly int status
|
|
|
|
def __cinit__(self):
|
|
self.nelem= 1
|
|
self.alarmStatus=-1
|
|
self.alarmSeverity=-1
|
|
self.precision=0
|
|
self.units=""
|
|
self.noEnumStrings=0
|
|
self.enumStrings=[]
|
|
self.upperDisplayLimit=0
|
|
self.lowerDisplayLimit=0
|
|
self.upperAlarmLimit=0
|
|
self.lowerAlarmLimit=0
|
|
self.upperControlLimit=0
|
|
self.lowerControlLimit=0
|
|
self.value=[]
|
|
self.status=1
|
|
|
|
|
|
def show(self):
|
|
self.showPrint(self.nelem)
|
|
return
|
|
|
|
def showMax(self, nelem):
|
|
if nelem > self.nelem:
|
|
#print "----------------------"
|
|
#print "Note: Max. Nelem =", self.nelem
|
|
#print "----------------------"
|
|
nelem=self.nelem
|
|
self.showPrint(nelem)
|
|
return
|
|
|
|
cdef showPrint(self, nelem):
|
|
cdef unsigned int i
|
|
#is self.value[0] a list
|
|
if nelem==1:
|
|
if isinstance (self.value[0], list):
|
|
print "value =", self.value[0][0],
|
|
else:
|
|
print "value =", self.value[0],
|
|
else:
|
|
print "values =",
|
|
if isinstance (self.value[0], list):
|
|
for i in range(0, nelem):
|
|
print self.value[0][i],"[%d]" %i,
|
|
else:
|
|
for i in range(0, nelem):
|
|
print self.value[i],"[%d]" %i,
|
|
print ""
|
|
print ("status = %d" % self.status)
|
|
print ("alarmStatus = %d" % self.alarmStatus)
|
|
print ("alarmSeverity = %d" % self.alarmSeverity)
|
|
print ("precision = %d" % self.precision)
|
|
print ("units = %s" % self.units)
|
|
print ("noEnumStrings = %d" % self.noEnumStrings)
|
|
|
|
if self.noEnumStrings > 0:
|
|
print "enumStrings =",
|
|
for i in range(0, self.noEnumStrings):
|
|
print self.enumStrings[i],"[%s]" %i,
|
|
print ""
|
|
|
|
print ("upperDisplayLimit = %f" % self.upperDisplayLimit)
|
|
print ("lowerDisplayLimit = %f" % self.lowerDisplayLimit)
|
|
print ("upperAlarmLimit = %f" % self.upperAlarmLimit)
|
|
print ("lowerAlarmLimit = %f" % self.lowerAlarmLimit)
|
|
print ("upperWarningLimit = %f" % self.upperWarningLimit)
|
|
print ("lowerWarningLimit = %f" % self.lowerWarningLimit)
|
|
print ("upperControlLimit = %f" % self.upperControlLimit)
|
|
print ("lowerControlLimit = %f" % self.lowerControlLimit)
|
|
|
|
return
|
|
##################################################################################
|
|
|
|
|
|
##################################################################################
|
|
cdef class pvdata:
|
|
cdef readonly unsigned int nelem
|
|
cdef readonly int alarmStatus
|
|
cdef readonly int alarmSeverity
|
|
cdef readonly list ts
|
|
cdef readonly list tsDate
|
|
cdef readonly list value
|
|
cdef readonly int status
|
|
|
|
|
|
def __cinit__(self):
|
|
self.nelem= 1
|
|
|
|
self.alarmStatus=-1
|
|
self.alarmSeverity=-1
|
|
self.ts=[]
|
|
self.tsDate=[]
|
|
self.value=[]
|
|
self.status=1
|
|
|
|
|
|
def show(self):
|
|
self.showPrint(self.nelem)
|
|
return
|
|
|
|
def showMax(self, nelem):
|
|
if nelem > self.nelem:
|
|
#print "----------------------"
|
|
#print "Note: Max. Nelem =", self.nelem
|
|
#print "----------------------"
|
|
nelem=self.nelem
|
|
self.showPrint(nelem)
|
|
return
|
|
|
|
cdef showPrint(self, nelem):
|
|
cdef unsigned int i
|
|
#is self.value[0] a list
|
|
|
|
if nelem==1:
|
|
if isinstance (self.value[0], list):
|
|
print "value =", self.value[0][0],
|
|
else:
|
|
print "value =", self.value[0],
|
|
else:
|
|
print "values =",
|
|
if isinstance (self.value[0], list):
|
|
for i in range(0, nelem):
|
|
print self.value[0][i],"[%d]" %i,
|
|
else:
|
|
for i in range(0, nelem):
|
|
print self.value[i],"[%d]" %i,
|
|
print ""
|
|
print ("status = %d" % self.status)
|
|
#if self.alarmStatus != -1:
|
|
print ("alarmStatus = %d" % self.alarmStatus)
|
|
print ("alarmSeverity = %d" % self.alarmSeverity)
|
|
#if self.ts[0] != 0:
|
|
print "ts =", self.ts[0], self.ts[1]
|
|
print "tsDate =", self.tsDate[0], self.tsDate[1], \
|
|
self.tsDate[2], self.tsDate[3],\
|
|
self.tsDate[4], self.tsDate[5], self.tsDate[6]
|
|
return
|
|
|
|
##################################################################################
|
|
|
|
|
|
|
|
|
|
##################################################################################
|
|
cdef class pvgroup:
|
|
cdef readonly list pvdata
|
|
cdef readonly unsigned int npv
|
|
cdef readonly string name
|
|
cdef readonly int groupStatus
|
|
cdef readonly unsigned int groupHandle
|
|
|
|
def __cinit__(self):
|
|
self.groupStatus=ICAFE_NORMAL
|
|
return
|
|
|
|
def show(self):
|
|
self.showPrint(npv=self.npv, grouplist=None)
|
|
return
|
|
|
|
def showWithPV(self,glist):
|
|
if len(glist) != self.npv:
|
|
print "ERROR: GROUP MEMBER MISMATCH!!"
|
|
print glist, "has", len(glist), "members while group has", self.npv,"!!"
|
|
return
|
|
self.showPrint(self.npv, grouplist=glist)
|
|
return
|
|
|
|
|
|
def showMax(self, _npv):
|
|
if _npv > self.npv:
|
|
#print "----------------------"
|
|
#print "Note: Max. Npv =", self.npv
|
|
#print "----------------------"
|
|
_npv=self.npv
|
|
self.showPrint(npv=_npv, grouplist=None)
|
|
return
|
|
|
|
cdef showPrint(self, npv, grouplist):
|
|
print "GROUP NAME = ", self.name
|
|
print "GROUP HANDLE = ", self.groupHandle
|
|
print "GROUP STATUS = ", self.groupStatus
|
|
cdef unsigned int i,j
|
|
#if nelem==1:
|
|
# print "value =", self.value[0],
|
|
#else:
|
|
|
|
|
|
for i in range(0, npv):
|
|
print "Member: ", i, "---------------------------------"
|
|
if grouplist:
|
|
print "PV =", grouplist[i]
|
|
|
|
print "values =",
|
|
for j in range(0, len(self.pvdata[i].value)):
|
|
print self.pvdata[i].value[j],"[%d]" %j,
|
|
print ""
|
|
print ("status = %d" % self.pvdata[i].status)
|
|
print ("alarmStatus = %d" % self.pvdata[i].alarmStatus)
|
|
print ("alarmSeverity = %d" % self.pvdata[i].alarmSeverity)
|
|
print "ts =", self.pvdata[i].ts[0], self.pvdata[i].tsDate[1]
|
|
print "tsDate =", self.pvdata[i].tsDate[0], self.pvdata[i].tsDate[1], \
|
|
self.pvdata[i].tsDate[2], self.pvdata[i].tsDate[3],\
|
|
self.pvdata[i].tsDate[4], self.pvdata[i].tsDate[5], self.pvdata[i].tsDate[6]
|
|
print "--------------------------------------------"
|
|
return
|
|
|
|
|
|
'''
|
|
cdef showPrintWithPVName(self, npv, pvlist):
|
|
print "GROUP NAME = ", self.name
|
|
print "GROUP HANDLE = ", self.groupHandle
|
|
print "GROUP STATUS = ", self.groupStatus
|
|
cdef unsigned int i,j
|
|
|
|
for i in range(0, npv):
|
|
print "pv =", pvlist[i]
|
|
for j in range(0, len(self.pvdata[i].value)):
|
|
print self.pvdata[i].value[j],"[%d]" %j,
|
|
print ""
|
|
print ("status = %d" % self.pvdata[i].status)
|
|
print ("alarmStatus = %d" % self.pvdata[i].alarmStatus)
|
|
print ("alarmSeverity = %d" % self.pvdata[i].alarmSeverity)
|
|
print "ts =", self.pvdata[i].ts[0], self.pvdata[i].tsDate[1]
|
|
print "tsDate =", self.pvdata[i].tsDate[0], self.pvdata[i].tsDate[1], \
|
|
self.pvdata[i].tsDate[2], self.pvdata[i].tsDate[3],\
|
|
self.pvdata[i].tsDate[4], self.pvdata[i].tsDate[5], self.pvdata[i].tsDate[6]
|
|
return
|
|
'''
|
|
##################################################################################
|
|
|
|
|
|
|
|
##################################################################################
|
|
cdef getMatchedDataType(dt, dtn):
|
|
#dt: input from user
|
|
#dtn: native type
|
|
#dtcheck: matching data type for pvd convert method
|
|
|
|
cdef unsigned int dtcheck=dtn;
|
|
|
|
if dt in ['int','long','short','uint','ulong','ushort','int32','int64','uint32','uint64']:
|
|
dtcheck=CAFE_LONG
|
|
elif dt=='double':
|
|
dtcheck=CAFE_DOUBLE
|
|
elif dt=='float':
|
|
dtcheck=CAFE_DOUBLE
|
|
elif dt in ['string','str']:
|
|
dtcheck=CAFE_STRING
|
|
elif dt in ['native','']:
|
|
dtcheck=dtn #need a line here
|
|
else:
|
|
print "Valid input parameters for data type are: 'int', 'float', 'str', or 'native'"
|
|
print "Data to be presented in native data type"
|
|
|
|
return dtcheck
|
|
##################################################################################
|
|
|
|
|
|
|
|
#################################################################################
|
|
|
|
#cdef pvdata p1 = pvdata()
|
|
#cdef pvctrl c1 = pvctrl()
|
|
|
|
|
|
#################################################################################
|
|
|
|
cdef pvdata PVDataHolderToStruct(PVDataHolder pvd, dt=None):
|
|
|
|
#global p1
|
|
cdef pvdata p1 = pvdata()
|
|
|
|
cdef unsigned int dtn = pvd.getDataType();
|
|
cdef unsigned int dtcheck=dtn
|
|
cdef localList=[]
|
|
|
|
if dt:
|
|
dtcheck=getMatchedDataType(dt, dtn)
|
|
|
|
if dtcheck==CAFE_STRING:
|
|
for i in range(0, pvd.getNelem()):
|
|
localList.append(pvd.getAsString(i))
|
|
elif dtcheck==CAFE_SHORT:
|
|
for i in range(0, pvd.getNelem()):
|
|
localList.append(pvd.getAsLong(i)) #getAsShort(i)
|
|
elif dtcheck==CAFE_FLOAT:
|
|
for i in range(0, pvd.getNelem()):
|
|
localList.append(pvd.getAsDouble(i)) #getAsFloat(i)
|
|
elif dtcheck==CAFE_ENUM:
|
|
#if enum, string taken as native
|
|
#if self._c_cafe.isEnum(handle)==1:
|
|
for i in range(0, pvd.getNelem()):
|
|
localList.append(pvd.getAsString(i))
|
|
#else:
|
|
# for i in range(0, pvd.getNelem()):
|
|
# localList.append(pvd.getAsLong(i)) #getAsUShort(i)
|
|
elif dtcheck==CAFE_CHAR:
|
|
for i in range(0, pvd.getNelem()):
|
|
localList.append(pvd.getAsLong(i)) # <unsigned char> pvd.getAsChar(i)
|
|
elif dtcheck==CAFE_LONG:
|
|
for i in range(0, pvd.getNelem()):
|
|
localList.append(pvd.getAsLong(i))
|
|
elif dtcheck==CAFE_DOUBLE:
|
|
for i in range(0, pvd.getNelem()):
|
|
localList.append(pvd.getAsDouble(i))
|
|
else:
|
|
localList.append(0)
|
|
#print "This line in PyCafe def getDataHolderToStruct should never appear!"
|
|
#print "No Data! Error. Is channel connected?"
|
|
|
|
p1.value=localList
|
|
p1.status=pvd.getStatus()
|
|
p1.nelem=pvd.getNelem()
|
|
p1.alarmStatus=pvd.getAlarmStatus()
|
|
p1.alarmSeverity=pvd.getAlarmSeverity()
|
|
|
|
pvd._etsNorm=pvd.getEpicsTimeStampAsUInt32()
|
|
|
|
cpdef ll=[]
|
|
ll.append((pvd._etsNorm).secPastEpoch)
|
|
ll.append((pvd._etsNorm).nsec)
|
|
p1.ts=ll
|
|
|
|
pvd._etsDate=pvd.getEpicsTimeStampAsDate()
|
|
|
|
cpdef ld=[]
|
|
ld.append( (pvd._etsDate).year )
|
|
ld.append( (pvd._etsDate).mon )
|
|
ld.append( (pvd._etsDate).day )
|
|
ld.append( (pvd._etsDate).hour )
|
|
ld.append( (pvd._etsDate).min )
|
|
ld.append( (pvd._etsDate).sec )
|
|
ld.append( (pvd._etsDate).nsec )
|
|
p1.tsDate=ld
|
|
|
|
return p1
|
|
##################################################################################
|
|
|
|
|
|
|
|
#################################################################################
|
|
|
|
cdef pvctrl PVCtrlHolderToStruct(PVCtrlHolder pvc, dt=None):
|
|
|
|
#global c1
|
|
cdef pvctrl c1 = pvctrl()
|
|
|
|
cdef unsigned int dtn = pvc.getDataType();
|
|
|
|
cdef unsigned int dtcheck=dtn
|
|
|
|
cdef localList=[]
|
|
|
|
if dt:
|
|
dtcheck=getMatchedDataType(dt, dtn)
|
|
|
|
if dtcheck==CAFE_STRING:
|
|
for i in range(0, pvc.getNelem()):
|
|
localList.append(pvc.getAsString(i))
|
|
elif dtcheck==CAFE_SHORT:
|
|
for i in range(0, pvc.getNelem()):
|
|
localList.append(pvc.getAsLong(i)) #getAsShort(i)
|
|
elif dtcheck==CAFE_FLOAT:
|
|
for i in range(0, pvc.getNelem()):
|
|
localList.append(pvc.getAsDouble(i)) #getAsFloat(i)
|
|
elif dtcheck==CAFE_ENUM:
|
|
#if enum, string taken as native
|
|
#if self._c_cafe.isEnum(handle)==1:
|
|
for i in range(0, pvc.getNelem()):
|
|
localList.append(pvc.getAsString(i))
|
|
#else:
|
|
# for i in range(0, pvd.getNelem()):
|
|
# localList.append(pvd.getAsLong(i)) #getAsUShort(i)
|
|
elif dtcheck==CAFE_CHAR:
|
|
for i in range(0, pvc.getNelem()):
|
|
localList.append(pvc.getAsLong(i)) # <unsigned char> pvd.getAsChar(i)
|
|
elif dtcheck==CAFE_LONG:
|
|
for i in range(0, pvc.getNelem()):
|
|
localList.append(pvc.getAsLong(i))
|
|
elif dtcheck==CAFE_DOUBLE:
|
|
for i in range(0, pvc.getNelem()):
|
|
localList.append(pvc.getAsDouble(i))
|
|
else:
|
|
localList.append(0)
|
|
#print "This line in PyCafe def getDataHolderToStruct should never appear!"
|
|
#print "No Data! Error. Is channel connected?"
|
|
c1.value=localList
|
|
c1.status=pvc.getStatus()
|
|
c1.nelem=pvc.getNelem()
|
|
c1.alarmStatus=pvc.getAlarmStatus()
|
|
c1.alarmSeverity=pvc.getAlarmSeverity()
|
|
|
|
c1.precision=pvc.getPrecision()
|
|
c1.noEnumStrings=pvc.getNoEnumStrings()
|
|
|
|
enumList=[]
|
|
for i in range(0, pvc.getNoEnumStrings()):
|
|
enumList.append(pvc.getEnumStrings()[i])
|
|
|
|
c1.enumStrings=enumList
|
|
|
|
c1.units=pvc.getUnitsAsString()
|
|
|
|
c1.upperDisplayLimit=pvc.getUpperDispLimit_AsDouble()
|
|
c1.lowerDisplayLimit=pvc.getLowerDispLimit_AsDouble()
|
|
c1.upperAlarmLimit =pvc.getUpperAlarmLimit_AsDouble()
|
|
c1.upperWarningLimit=pvc.getUpperWarningLimit_AsDouble()
|
|
c1.lowerWarningLimit=pvc.getLowerWarningLimit_AsDouble()
|
|
c1.lowerAlarmLimit =pvc.getLowerAlarmLimit_AsDouble()
|
|
c1.upperControlLimit=pvc.getUpperCtrlLimit_AsDouble()
|
|
c1.lowerControlLimit=pvc.getLowerCtrlLimit_AsDouble()
|
|
|
|
return c1
|
|
##################################################################################
|
|
|
|
|
|
#################################################################################
|
|
|
|
cdef channelInfo channelRegaliaToStruct(ChannelRegalia cr):
|
|
|
|
cdef channelInfo ci = channelInfo()
|
|
|
|
ci.channelID = (<long> cr.getChannelID())
|
|
ci.connectFlag=cr.getConnectFlag()
|
|
ci.hostName =cr.getHostNameAsString()
|
|
ci.dataType =cr.getDataType()
|
|
ci.className =cr.getClassNameAsString()
|
|
ci.accessRead =cr.getAccessRead()
|
|
ci.accessWrite=cr.getAccessWrite()
|
|
ci.nelem =cr.getNelem()
|
|
ci.connectionState =cr.getConnectionState()
|
|
ci.cafeConnectionState=cr.getCafeConnectionState()
|
|
ci.connectionStateAsString =cr.getConnectionStateAsString()
|
|
ci.cafeConnectionStateAsString =cr.getCafeConnectionStateAsString()
|
|
return ci
|
|
#################################################################################
|
|
|