コード例 #1
0
ファイル: ca_unittest.py プロジェクト: thzfelcg/pyepics
    def test_type_converions_1(self):
        write("CA type conversions scalars")
        pvlist = (pvnames.str_pv, pvnames.int_pv, pvnames.float_pv,
                  pvnames.enum_pv,  pvnames.long_pv,  pvnames.double_pv2)
        chids = []
        with no_simulator_updates():
            for name in pvlist:
                chid = ca.create_channel(name)
                ca.connect_channel(chid)
                chids.append((chid, name))
                ca.poll(evt=0.025, iot=5.0)
            ca.poll(evt=0.05, iot=10.0)

            values = {}
            for chid, name in chids:
                values[name] = ca.get(chid, as_string=True)

            for promotion in ('ctrl', 'time'):
                for chid, pvname in chids:
                    write('=== %s  chid=%s as %s' % (ca.name(chid), repr(chid),
                                                     promotion))
                    time.sleep(0.01)
                    if promotion == 'ctrl':
                        ntype = ca.promote_type(chid, use_ctrl=True)
                    else:
                        ntype = ca.promote_type(chid, use_time=True)

                    val  = ca.get(chid, ftype=ntype)
                    cval = ca.get(chid, as_string=True)
                    if ca.element_count(chid) > 1:
                        val = val[:12]
                    self.assertEqual(cval, values[pvname])
コード例 #2
0
ファイル: ca_unittest.py プロジェクト: thzfelcg/pyepics
    def test_type_converions_2(self):
        write("CA type conversions arrays")
        pvlist = (pvnames.char_arr_pv,
                  pvnames.long_arr_pv,
                  pvnames.double_arr_pv)
        with no_simulator_updates():
            chids = []
            for name in pvlist:
                chid = ca.create_channel(name)
                ca.connect_channel(chid)
                chids.append((chid, name))
                ca.poll(evt=0.025, iot=5.0)
            ca.poll(evt=0.05, iot=10.0)

            values = {}
            for chid, name in chids:
                values[name] = ca.get(chid)
            for promotion in ('ctrl', 'time'):
                for chid, pvname in chids:
                    write('=== %s  chid=%s as %s' % (ca.name(chid), repr(chid),
                                                     promotion))
                    time.sleep(0.01)
                    if promotion == 'ctrl':
                        ntype = ca.promote_type(chid, use_ctrl=True)
                    else:
                        ntype = ca.promote_type(chid, use_time=True)

                    val  = ca.get(chid, ftype=ntype)
                    cval = ca.get(chid, as_string=True)
                    for a, b in zip(val, values[pvname]):
                        self.assertEqual(a, b)
コード例 #3
0
ファイル: pv_unittest.py プロジェクト: danielballan/pyepics
    def test_type_converions_2(self):
        write("CA type conversions arrays\n")
        pvlist = (pvnames.char_arr_pv,
                  pvnames.long_arr_pv,
                  pvnames.double_arr_pv)
        with no_simulator_updates():
            chids = []
            for name in pvlist:
                chid = ca.create_channel(name)
                ca.connect_channel(chid)
                chids.append((chid, name))
                ca.poll(evt=0.025, iot=5.0)
            ca.poll(evt=0.05, iot=10.0)

            values = {}
            for chid, name in chids:
                values[name] = ca.get(chid)
            for promotion in ('ctrl', 'time'):
                for chid, pvname in chids:
                    write('=== %s  chid=%s as %s\n' % (ca.name(chid),
                                                       repr(chid), promotion))
                    time.sleep(0.01)
                    if promotion == 'ctrl':
                        ntype = ca.promote_type(chid, use_ctrl=True)
                    else:
                        ntype = ca.promote_type(chid, use_time=True)

                    val  = ca.get(chid, ftype=ntype)
                    cval = ca.get(chid, as_string=True)
                    for a, b in zip(val, values[pvname]):
                        self.assertEqual(a, b)
コード例 #4
0
ファイル: ca_unittest.py プロジェクト: peteut/pyepics
    def test_type_converions_1(self):
        write("CA type conversions scalars")
        pvlist = (pvnames.str_pv, pvnames.int_pv, pvnames.float_pv,
                  pvnames.enum_pv,  pvnames.long_pv,  pvnames.double_pv2)
        chids = []
        pause_updating()
        for name in pvlist:
            chid = ca.create_channel(name)
            ca.connect_channel(chid)
            chids.append((chid, name))
            ca.poll(evt=0.025, iot=5.0)
        ca.poll(evt=0.05, iot=10.0)

        values = {}
        for chid, name in chids:
            values[name] = ca.get(chid, as_string=True)

        for promotion in ('ctrl', 'time'):
            for chid, pvname in chids:
                write('=== %s  chid=%s as %s' % (ca.name(chid),
                                                   repr(chid), promotion))
                time.sleep(0.01)
                if promotion == 'ctrl':
                    ntype = ca.promote_type(chid, use_ctrl=True)
                else:
                    ntype = ca.promote_type(chid, use_time=True)

                val  = ca.get(chid, ftype=ntype)
                cval = ca.get(chid, as_string=True)
                if ca.element_count(chid) > 1:
                    val = val[:12]
                self.assertEqual(cval, values[pvname])
        resume_updating()
コード例 #5
0
    def testCtrlStruct_ValueMonitor(self):
        '''Monitor PV (value events) through GW - change value and properties directly - check CTRL structure consistency'''
        diffs = []

        # gwcachetest is an ai record with full set of alarm limits: -100 -10 10 100
        gw = ca.create_channel("gateway:gwcachetest")
        connected = ca.connect_channel(gw, timeout=.5)
        self.assertTrue(connected,
                        "Could not connect to gateway channel " + ca.name(gw))
        (gw_cbref, gw_uaref,
         gw_eventid) = ca.create_subscription(gw,
                                              mask=dbr.DBE_VALUE,
                                              use_ctrl=True,
                                              callback=self.onChangeGW)
        ioc = ca.create_channel("ioc:gwcachetest")
        connected = ca.connect_channel(ioc, timeout=.5)
        self.assertTrue(connected,
                        "Could not connect to ioc channel " + ca.name(ioc))
        (ioc_cbref, ioc_uaref,
         ioc_eventid) = ca.create_subscription(ioc,
                                               mask=dbr.DBE_VALUE,
                                               use_ctrl=True,
                                               callback=self.onChangeIOC)

        # set value on IOC
        ioc_value = ca.create_channel("ioc:gwcachetest")
        ca.put(ioc_value, 10.0, wait=True)
        gwtests.wait_until(
            lambda: self.eventsReceivedIOC == self.eventsReceivedGW, 5.0)

        self.assertTrue(
            self.eventsReceivedIOC == self.eventsReceivedGW,
            "After setting value, no. of received updates differ: GW {0}, IOC {1}"
            .format(str(self.eventsReceivedGW), str(self.eventsReceivedIOC)))

        (are_diff, diffs) = self.compareStructures()
        self.assertTrue(
            are_diff == False,
            "At update {0} (change value), received structure updates differ:\n\t{1}"
            .format(str(self.eventsReceivedIOC), "\n\t".join(diffs)))

        # set property on IOC
        ioc_hihi = ca.create_channel("ioc:gwcachetest.HIHI")
        ca.put(ioc_hihi, 123.0, wait=True)
        ca.put(ioc_value, 11.0, wait=True)  # trigger update
        gwtests.wait_until(
            lambda: self.eventsReceivedIOC == self.eventsReceivedGW, 5.0)

        self.assertTrue(
            self.eventsReceivedIOC == self.eventsReceivedGW,
            "After setting property, no. of received updates differ: GW {0}, IOC {1}"
            .format(str(self.eventsReceivedGW), str(self.eventsReceivedIOC)))

        (are_diff, diffs) = self.compareStructures()
        self.assertTrue(
            are_diff == False,
            "At update {0} (change property), received structure updates differ:\n\t{1}"
            .format(str(self.eventsReceivedIOC), "\n\t".join(diffs)))
コード例 #6
0
 def connectGwStats(self):
     self.gw_vctotal = ca.create_channel("gwtest:vctotal")
     ca.connect_channel(self.gw_vctotal, timeout=.5)
     self.gw_pvtotal = ca.create_channel("gwtest:pvtotal")
     ca.connect_channel(self.gw_pvtotal, timeout=.5)
     self.gw_connected = ca.create_channel("gwtest:connected")
     ca.connect_channel(self.gw_connected, timeout=.5)
     self.gw_active = ca.create_channel("gwtest:active")
     ca.connect_channel(self.gw_active, timeout=.5)
     self.gw_inactive = ca.create_channel("gwtest:inactive")
     ca.connect_channel(self.gw_inactive, timeout=.5)
コード例 #7
0
    def testEnumPropCache_ValueMonitorCTRLget(self):
        '''Monitor PV (value events) through GW - change ENUM string directly - get the DBR_CTRL of the PV through GW'''
        # gateway should show no VC (client side connection) and no PV (IOC side connection)
        self.updateGwStats()
        self.assertTrue(self.vctotal == 0, "Expected GW VC total count: 0, actual: " + str(self.vctotal))
        self.assertTrue(self.pvtotal == 0, "Expected GW PV total count: 0, actual: " + str(self.pvtotal))
        self.assertTrue(self.connected == 0, "Expected GW connected PV count: 0, actual: " + str(self.connected))
        self.assertTrue(self.active == 0, "Expected GW active PV count: 0, actual: " + str(self.active))
        self.assertTrue(self.inactive == 0, "Expected GW inactive PV count: 0, actual: " + str(self.inactive))

        # enumtest is an mbbi record with three strings defined: zero one two
        gw = ca.create_channel("gateway:enumtest")
        connected = ca.connect_channel(gw, timeout=.5)
        self.assertTrue(connected, "Could not connect to gateway channel " + ca.name(gw))
        (gw_cbref, gw_uaref, gw_eventid) = ca.create_subscription(gw, mask=dbr.DBE_VALUE, callback=self.onChange)
        ioc = ca.create_channel("ioc:enumtest")
        connected = ca.connect_channel(ioc, timeout=.5)
        self.assertTrue(connected, "Could not connect to ioc channel " + ca.name(gw))
        (ioc_cbref, ioc_uaref, ioc_eventid) = ca.create_subscription(ioc, mask=dbr.DBE_VALUE, callback=self.onChange)

        # gateway should show one VC and one connected active PV
        self.updateGwStats()
        self.assertTrue(self.vctotal == 1, "Expected GW VC total count: 1, actual: " + str(self.vctotal))
        self.assertTrue(self.pvtotal == 1, "Expected GW PV total count: 1, actual: " + str(self.pvtotal))
        self.assertTrue(self.connected == 1, "Expected GW connected PV count: 1, actual: " + str(self.connected))
        self.assertTrue(self.active == 1, "Expected GW active PV count: 1, actual: " + str(self.active))
        self.assertTrue(self.inactive == 0, "Expected GW inactive PV count: 0, actual: " + str(self.inactive))

        # enum string should not have been updated
        ioc_ctrl = ca.get_ctrlvars(ioc)
        oneStr = ioc_ctrl['enum_strs'][1]
        self.assertTrue(oneStr == 'one', "Expected IOC enum[1]: one; actual enum[1]: "+ oneStr)
        gw_ctrl = ca.get_ctrlvars(gw)
        oneStr = gw_ctrl['enum_strs'][1]
        self.assertTrue(oneStr == 'one', "Expected GW enum[1]: one; actual enum[1]: "+ oneStr)

        # set enum string on IOC
        ioc_enum1 = ca.create_channel("ioc:enumtest.ONST")
        ca.put(ioc_enum1, 'uno', wait=True)
        time.sleep(.1)

        # Now the enum string should have been updated (if IOC supports DBE_PROPERTY)
        ioc_ctrl = ca.get_ctrlvars(ioc)
        oneStr = ioc_ctrl['enum_strs'][1]
        self.assertTrue(oneStr == 'uno', "Expected IOC enum[1]: uno; actual enum[1]: "+ oneStr)
        if self.propSupported:
            gw_expected = 'uno'
        else:
            gw_expected = 'one'
        gw_ctrl = ca.get_ctrlvars(gw)
        oneStr = gw_ctrl['enum_strs'][1]
        self.assertTrue(oneStr == gw_expected, "Expected GW enum[1]: {0}; actual enum[1]: {1}".format(gw_expected, oneStr))
コード例 #8
0
def generate_live_data(duration, period, pvnames):
    pvnamelist = tuple(pvnames)
    cols = list(pvnamelist)
    cols.insert(0, 'timestamp')
    pvconn = {}
    alldata = []
    ca.initialize_libca()
    for name in pvnamelist:
        chid = ca.create_channel(name, connect=False, auto_cb=False)
        pvconn[name] = (chid, None)
    for key in list(pvconn):
        state = ca.connect_channel(pvconn.get(key)[0])
        if not state:
            print('PV:', key, 'not connected')
            pvconn.pop(key)
    ca.poll()
    while duration > 0 and pvconn:
        pvdata = []
        for name, data in pvconn.items():
            ca.get(data[0], wait=False)
        ca.poll()
        pvdata.append(datetime.datetime.now())
        for name, data in pvconn.items():
            val = ca.get_complete(data[0])
            pvdata.append(val)
        alldata.append(pvdata)
        time.sleep(period)
        duration = duration - period
    ca.finalize_libca(maxtime=1.0)
    df = pd.DataFrame(alldata, columns=cols)
    return df
コード例 #9
0
def batch_get(pv_list):
	chids = {}
	pvdata = {}
	for name in pv_list:
		chid = ca.create_channel(name, connect=False, auto_cb=False)
		chids[name] = chid
	for name, chid in chids.items():
		ca.connect_channel(chid)
	ca.poll()
	for name, chid in chids.items():
		ca.get(chid, wait=False)
	ca.poll()
	for name, chid in chids.items():
		val = ca.get_complete(chid)
		pvdata[name] = val
	return pvdata
コード例 #10
0
ファイル: ca_unittest.py プロジェクト: Crayzero/pyepics
 def test_Values(self):
     write("CA test Values (compare 5 values with caget)")
     os.system("rm ./caget.tst")
     vals = {}
     pause_updating()
     for pvn in (pvnames.str_pv, pvnames.int_pv, pvnames.float_pv, pvnames.enum_pv, pvnames.long_pv):
         os.system("caget  -n -f5 %s >> ./caget.tst" % pvn)
         chid = ca.create_channel(pvn)
         ca.connect_channel(chid)
         vals[pvn] = ca.get(chid)
     rlines = open("./caget.tst", "r").readlines()
     for line in rlines:
         pvn, sval = [i.strip() for i in line[:-1].split(" ", 1)]
         tval = str(vals[pvn])
         if pvn in (pvnames.float_pv, pvnames.double_pv):  # use float precision!
             tval = "%.5f" % vals[pvn]
         self.assertEqual(tval, sval)
     resume_updating()
コード例 #11
0
ファイル: snapshot_ca_threading.py プロジェクト: dongliu/rsc
def get(d, pv_name, size, start, pid):
    ch = ca.create_channel(pv_name, connect=False, auto_cb=False)
    if ca.connect_channel(ch, timeout=1.0):
        d[pv_name] = ca.get(ch, wait=True)
    else:
        d[pv_name] = 'not connected'
    if len(d) == size:
        print int(round((time.time() - start) * 1000))
        os.kill(pid, signal.SIGTERM)
コード例 #12
0
def main():

    parser = argparse.ArgumentParser()        # parser for the inputs - must keep the 2 lines below.
    parser.add_argument("-f", "--setupfile",  help="setup file (default = monitor.dat)",nargs='?', const=0, default="monitor.dat")   
    parser.add_argument("-v", "--verbosity",  help="increase verbosity", nargs='?', const=0, default=0)

    args = parser.parse_args()                 #get the input args from the parser
    
    global verbose
    verbose = args.verbosity
    setup_file = args.setupfile
    
    global pvdata
    global mon_line
    global pvf

    global pvfull

    #read the setup file, which has the form 
    #index    TOP        PVname  Period(s)

    for line in file(setup_file):                             #read the lines in the setup file to pvdata monitor list
        if not (line.startswith("#") or len(line.split())<3): #skip comments and require 3 fields
            s=line.split()                                    #split input into fields
            wf=PV(s[pvf.TOP]+":"+s[pvf.NAME]+"_wf")            #wf, en are PVs for waveform and enable
            en=PV(s[pvf.TOP]+":"+s[pvf.NAME]+"_en")  
            pvdata.append([s[0],s[pvf.TOP],s[pvf.NAME],s[pvf.PERIOD],wf,en,[]]) #add to list, with list for IDS
            
            #Call doNode() which works recursively through the tree and calls do_node()
            #which you may overwrite by calling your own function (eg my_node() shown here)
            #In this case, it calls my_node() for every element - see below.
            doNode.doNode(pvdata[mon_line][pvf.TOP],do_node=my_node, v=verbose)
            
            #now the pvf.ID array has been filled, try to connect to all the elements
            for n,chid in enumerate(pvdata[mon_line][pvf.ID]):
                if not ca.connect_channel(chid,timeout=0.001):
                    if verbose:
                        print pvfull[n], "... Not connected, chid = 0"
                    pvdata[mon_line][pvf.ID][n]=0
                else:
                    if verbose:
                        print pvfull[n], "... Connected, chid = ",chid
            pvdata[mon_line].append(numpy.zeros(len(pvdata[mon_line][pvf.ID]))) #create a zero numpy array for the data
            
            pvfull = [] #reset the list of names
            mon_line+=1 #increment the current line number 
      
    #start a monitor thread for each
    for l in range(mon_line):
        t = Thread(target=monitor, args=(l,))
        t.start()
      
    #do the poll loop here, to cover all monitor threads 
    while mon_line > 0:
        ca.poll()
        time.sleep(1.0)
        print "poll"
コード例 #13
0
ファイル: ca_unittest.py プロジェクト: yifans/pyepics
 def test_Values(self):
     write('CA test Values (compare 5 values with caget)')
     os.system('rm ./caget.tst')
     vals = {}
     with no_simulator_updates():
         for pvn in (pvnames.str_pv, pvnames.int_pv, pvnames.float_pv,
                     pvnames.enum_pv, pvnames.long_pv):
             os.system('caget  -n -f5 %s >> ./caget.tst' % pvn)
             chid = ca.create_channel(pvn)
             ca.connect_channel(chid)
             vals[pvn] = ca.get(chid)
         rlines = open('./caget.tst', 'r').readlines()
         for line in rlines:
             pvn, sval = [i.strip() for i in line[:-1].split(' ', 1)]
             tval = str(vals[pvn])
             if pvn in (pvnames.float_pv, pvnames.double_pv):
                 # use float precision!
                 tval = "%.5f" % vals[pvn]
             self.assertEqual(tval, sval)
コード例 #14
0
def run_synchronous_get_optimized(pvs):
    """Run synchronous optimized get test."""
    pvschid = []
    for pvn in pvs:
        chid = ca.create_channel(pvn, connect=False, auto_cb=False)
        pvschid.append(chid)

    for chid in pvschid:
        ca.connect_channel(chid)

    ca.poll()
    for i in range(600):
        t0 = time.time()
        for chid in pvschid:
            ca.get(chid, wait=False)
        out = []
        for chid in pvschid:
            out.append(ca.get_complete(chid))
        print(f'dtime {(time.time()-t0)*1000:.1f}ms   pos {out[0]:.0f}nm')
コード例 #15
0
ファイル: ca_unittest.py プロジェクト: RobbieClarken/pyepics
 def test_Values(self):
     write( 'CA test Values (compare 5 values with caget)')
     os.system('rm ./caget.tst')
     vals = {}
     with no_simulator_updates():
         for pvn in (pvnames.str_pv,  pvnames.int_pv,
                     pvnames.float_pv, pvnames.enum_pv,
                     pvnames.long_pv):
             os.system('caget  -n -f5 %s >> ./caget.tst' % pvn)
             chid = ca.create_channel(pvn)
             ca.connect_channel(chid)
             vals[pvn] = ca.get(chid)
         rlines = open('./caget.tst', 'r').readlines()
         for line in rlines:
             pvn, sval = [i.strip() for i in line[:-1].split(' ', 1)]
             tval = str(vals[pvn])
             if pvn in (pvnames.float_pv,pvnames.double_pv):
                 # use float precision!
                 tval = "%.5f" % vals[pvn]
             self.assertEqual(tval, sval)
コード例 #16
0
 def _set_params2(self):
     """Set run params..."""
     functionName = '_set_params'
     pvdata = {}
     for name in self._pvnamelist:
         chid = ca.create_channel(name, connect=False,
                                  auto_cb=False)  # note 1
         pvdata[name] = [chid, None]
     for name, data in pvdata.items():
         ca.connect_channel(data[0])
     ca.poll()
     for name, data in pvdata.items():
         ca.get(data[0], wait=False)  # note 2
     ca.poll()
     for name, data in pvdata.items():
         val = ca.get_complete(data[0])
         pvdata[name][1] = val
     #return { name: data[1] for name, data in pvdata.items()}
     ret = dict((name, data[1]) for name, data in pvdata.items())
     print(ret)
     return ret
コード例 #17
0
    def run_subprocess(pvs, pipe):
        pvschid = []
        for pv in pvs:
            chid = ca.create_channel(pv, connect=False, auto_cb=False)
            pvschid.append(chid)

        for chid in pvschid:
            ca.connect_channel(chid)
        time.sleep(5)
        for chid in pvschid:
            ftype = ca.promote_type(chid, use_time=True, use_ctrl=False)

        ca.poll()
        while pipe.recv():
            for chid in pvschid:
                ca.get_with_metadata(chid, ftype=ftype, wait=False)
            out = []
            for chid in pvschid:
                data = ca.get_complete_with_metadata(chid, ftype=ftype)
                out.append(data['timestamp'])
            pipe.send(out)
コード例 #18
0
    def testCtrlStruct_ValueMonitor(self):
        '''Monitor PV (value events) through GW - change value and properties directly - check CTRL structure consistency'''
        diffs = []

        # gwcachetest is an ai record with full set of alarm limits: -100 -10 10 100
        gw = ca.create_channel("gateway:gwcachetest")
        connected = ca.connect_channel(gw, timeout=.5)
        self.assertTrue(connected, "Could not connect to gateway channel " + ca.name(gw))
        (gw_cbref, gw_uaref, gw_eventid) = ca.create_subscription(gw, mask=dbr.DBE_VALUE, use_ctrl=True, callback=self.onChangeGW)
        ioc = ca.create_channel("ioc:gwcachetest")
        connected = ca.connect_channel(ioc, timeout=.5)
        self.assertTrue(connected, "Could not connect to ioc channel " + ca.name(ioc))
        (ioc_cbref, ioc_uaref, ioc_eventid) = ca.create_subscription(ioc, mask=dbr.DBE_VALUE, use_ctrl=True, callback=self.onChangeIOC)

        # set value on IOC
        ioc_value = ca.create_channel("ioc:gwcachetest")
        ca.put(ioc_value, 10.0, wait=True)
        time.sleep(.1)

        self.assertTrue(self.eventsReceivedIOC == self.eventsReceivedGW,
        "After setting value, no. of received updates differ: GW {0}, IOC {1}"
        .format(str(self.eventsReceivedGW), str(self.eventsReceivedIOC)))
        (are_diff, diffs) = self.compareStructures()
        self.assertTrue(are_diff == False,
        "At update {0} (change value), received structure updates differ:\n\t{1}"
        .format(str(self.eventsReceivedIOC), "\n\t".join(diffs)))

        # set property on IOC
        ioc_hihi = ca.create_channel("ioc:gwcachetest.HIHI")
        ca.put(ioc_hihi, 123.0, wait=True)
        ca.put(ioc_value, 11.0, wait=True) # trigger update
        time.sleep(.1)

        self.assertTrue(self.eventsReceivedIOC == self.eventsReceivedGW,
        "After setting property, no. of received updates differ: GW {0}, IOC {1}"
        .format(str(self.eventsReceivedGW), str(self.eventsReceivedIOC)))
        (are_diff, diffs) = self.compareStructures()
        self.assertTrue(are_diff == False,
        "At update {0} (change property), received structure updates differ:\n\t{1}"
        .format(str(self.eventsReceivedIOC), "\n\t".join(diffs)))
コード例 #19
0
def test_CreateChid_CheckTypeCount():
    write('Simple Test: create chid, check count, type, host, and access')
    chid = ca.create_channel(pvnames.double_pv)
    ret = ca.connect_channel(chid)
    ca.pend_event(1.e-3)

    ftype = ca.field_type(chid)
    count = ca.element_count(chid)
    host = ca.host_name(chid)
    rwacc = ca.access(chid)

    assert chid is not None
    assert host is not None
    assert count == 1
    assert ftype == 6
    assert rwacc == 'read/write'
コード例 #20
0
ファイル: ca_unittest.py プロジェクト: thzfelcg/pyepics
    def testA_CreateChid_CheckTypeCount(self):
        write('Simple Test: create chid, check count, type, host, and access')
        chid = ca.create_channel(pvnames.double_pv)
        ret = ca.connect_channel(chid)
        ca.pend_event(1.e-3)

        ftype  = ca.field_type(chid)
        count  = ca.element_count(chid)
        host    = ca.host_name(chid)
        rwacc = ca.access(chid)

        self.assertIsNot(chid, None)
        self.assertIsNot(host, None)
        self.assertEqual(count, 1)
        self.assertEqual(ftype, 6)
        self.assertEqual(rwacc,'read/write')
コード例 #21
0
ファイル: ca_unittest.py プロジェクト: peteut/pyepics
    def testA_CreateChid_CheckTypeCount(self):
        write('Simple Test: create chid, check count, type, host, and access')
        chid = ca.create_channel(pvnames.double_pv)
        ret = ca.connect_channel(chid)
        ca.pend_event(1.e-3)

        ftype  = ca.field_type(chid)
        count  = ca.element_count(chid)
        host    = ca.host_name(chid)
        rwacc = ca.access(chid)

        self.assertNotEqual(chid, None)
        self.assertNotEqual(host, None)
        self.assertEqual(count, 1)
        self.assertEqual(ftype, 6)
        self.assertEqual(rwacc,'read/write')
コード例 #22
0
    def testPropCache_ValueMonitorCTRLget(self):
        '''Monitor PV (value events) through GW - change HIGH directly - get the DBR_CTRL of the PV through GW'''
        gw_vctotal = ca.create_channel("gwtest:vctotal")
        gw_pvtotal = ca.create_channel("gwtest:pvtotal")
        gw_connected = ca.create_channel("gwtest:connected")
        gw_active = ca.create_channel("gwtest:active")
        gw_inactive = ca.create_channel("gwtest:inactive")

        # gateway should show no VC (client side connection) and no PV (IOC side connection)
        count = ca.get(gw_vctotal)
        self.assertTrue(count == 0, "Expected GW VC total count: 0, actual: " + str(count))
        count = ca.get(gw_pvtotal)
        self.assertTrue(count == 0, "Expected GW PV total count: 0, actual: " + str(count))
        count = ca.get(gw_connected)
        self.assertTrue(count == 0, "Expected GW connected PV count: 0, actual: " + str(count))
        count = ca.get(gw_active)
        self.assertTrue(count == 0, "Expected GW active PV count: 0, actual: " + str(count))
        count = ca.get(gw_inactive)
        self.assertTrue(count == 0, "Expected GW inactive PV count: 0, actual: " + str(count))

        # gwcachetest is an ai record with full set of alarm limits: -100 -10 10 100
        gw = ca.create_channel("gateway:gwcachetest")
        connected = ca.connect_channel(gw, timeout=.5)
        self.assertTrue(connected, "Could not connect to gateway channel " + ca.name(gw))
        (gw_cbref, gw_uaref, gw_eventid) = ca.create_subscription(gw, mask=dbr.DBE_VALUE, callback=self.onChange)
        ioc = ca.create_channel("ioc:gwcachetest")
        connected = ca.connect_channel(ioc, timeout=.5)
        self.assertTrue(connected, "Could not connect to ioc channel " + ca.name(gw))
        (ioc_cbref, ioc_uaref, ioc_eventid) = ca.create_subscription(ioc, mask=dbr.DBE_VALUE, callback=self.onChange)

        # gateway should show one VC and one connected active PV
        count = ca.get(gw_vctotal)
        self.assertTrue(count == 1, "Expected GW VC total count: 1, actual: " + str(count))
        count = ca.get(gw_pvtotal)
        self.assertTrue(count == 1, "Expected GW PV total count: 1, actual: " + str(count))
        count = ca.get(gw_connected)
        self.assertTrue(count == 1, "Expected GW connected PV count: 1, actual: " + str(count))
        count = ca.get(gw_active)
        self.assertTrue(count == 1, "Expected GW active PV count: 1, actual: " + str(count))
        count = ca.get(gw_inactive)
        self.assertTrue(count == 0, "Expected GW inactive PV count: 0, actual: " + str(count))

        # limit should not have been updated
        ioc_ctrl = ca.get_ctrlvars(ioc)
        highVal = ioc_ctrl['upper_warning_limit']
        self.assertTrue(highVal == 10.0, "Expected IOC warning_limit: 10; actual limit: "+ str(highVal))
        gw_ctrl = ca.get_ctrlvars(gw)
        highVal = gw_ctrl['upper_warning_limit']
        self.assertTrue(highVal == 10.0, "Expected GW warning_limit: 10; actual limit: "+ str(highVal))

        # set warning limit on IOC
        ioc_high = ca.create_channel("ioc:gwcachetest.HIGH")
        ca.put(ioc_high, 20.0, wait=True)
        time.sleep(.1)

        # Now the limit should have been updated (if IOC supports DBE_PROPERTY)
        ioc_ctrl = ca.get_ctrlvars(ioc)
        highVal = ioc_ctrl['upper_warning_limit']
        self.assertTrue(highVal == 20.0, "Expected IOC warning_limit: 20; actual limit: "+ str(highVal))
        if self.propSupported:
            gw_expected = 20.0
        else:
            gw_expected = 10.0
        gw_ctrl = ca.get_ctrlvars(gw)
        highVal = gw_ctrl['upper_warning_limit']
        self.assertTrue(highVal == gw_expected, "Expected GW warning_limit: {0}; actual limit: {1}".format(gw_expected, highVal))
コード例 #23
0
ファイル: ca_fastconn.py プロジェクト: epicsdeb/pyepics
    pvnames = pvnames[:MAX_PVS]


add('Read PV list:  Will connect to %i PVs' % len(pvnames))
libca = ca.initialize_libca()

for name in pvnames:
    chid = ca.create_channel(name, connect=False, auto_cb=False)
    results[name] = {'chid': chid}

time.sleep(0.001)

add("created PVs with ca_create_channel")

for name in pvnames:
    ca.connect_channel(results[name]['chid'])

time.sleep(0.001)

add("connected to PVs with connect_channel")

ca.pend_event(1.e-2)

for name in pvnames:
    chid = results[name]['chid']
    val = ca.get(chid, wait=False)
    results[name]['value'] =  val

add("did ca.get(wait=False)")
ca.poll(2.e-3, 1.0)
add("ca.poll() complete")
コード例 #24
0
ファイル: snapshot_ca.py プロジェクト: dongliu/rsc
elif len(sys.argv) == 2:
    if str(sys.argv[1]) == 'clean':
        config = open('./config/pv_list_clean.json', 'r')
    else:
        config = open('./config/pv_list.json', 'r')
else:
    sys.exit('at most two arguments allowed.')

result = {}
pv_list = json.loads(config.read())
start = time.time()
for pv_name in pv_list:
    ch = ca.create_channel(pv_name, connect=False, auto_cb=False)
    result[pv_name] = [ch, None, None]
for pv_name, data in result.items():
    result[pv_name][1] = ca.connect_channel(data[0], timeout=1.0)
ca.poll()
for pv_name, data in result.items():
    if result[pv_name][1]:
        ca.get(data[0], wait=False)

ca.poll()
for pv_name, data in result.items():
    if result[pv_name][1]:
        val = ca.get_complete(data[0])
        result[pv_name][2] = val
    else:
        result[pv_name][2] = 'not connected'

duration = time.time() - start
print int(round(duration * 1000))
コード例 #25
0
ファイル: ca_fastconn.py プロジェクト: gvanriessen/pyepics
    pvnames = pvnames[:MAX_PVS]


dt.add('Read PV list:  Will connect to %i PVs' % len(pvnames))
libca = ca.initialize_libca()

for name in pvnames:
    chid = ca.create_channel(name, connect=False, auto_cb=False)
    results[name] = {'chid': chid}

time.sleep(0.001)

dt.add("created PVs with ca_create_channel")

for name in pvnames:
    ca.connect_channel(results[name]['chid'])

time.sleep(0.001)

dt.add("connected to PVs with connect_channel")

ca.pend_event(1.e-2)

for name in pvnames:
    chid = results[name]['chid']
    val = ca.get(chid, wait=False)
    results[name]['value'] =  val

dt.add("did ca.get(wait=False)")
ca.pend_event(1.e-2)
dt.add("pend complete")
コード例 #26
0
ファイル: TestCSStudio.py プロジェクト: slac-epics/ca-gateway
    def testCSStudio_ValueAndPropMonitor(self):
        '''Monitor PV (imitating CS-Studio) through GW - change value and properties directly - check CTRL structure consistency'''
        diffs = []

        if gwtests.verbose:
            print()
        # gwcachetest is an ai record with full set of alarm limits: -100 -10 10 100
        gw = ca.create_channel("gateway:gwcachetest")
        connected = ca.connect_channel(gw, timeout=.5)
        self.assertTrue(connected,
                        "Could not connect to gateway channel " + ca.name(gw))
        (gw_cbref, gw_uaref, gw_eventid) = ca.create_subscription(
            gw,
            mask=dbr.DBE_VALUE | dbr.DBE_ALARM,
            use_time=True,
            callback=self.onChangeGW)
        (gw_cbref2, gw_uaref2,
         gw_eventid2) = ca.create_subscription(gw,
                                               mask=dbr.DBE_PROPERTY,
                                               use_ctrl=True,
                                               callback=self.onChangeGW)
        ioc = ca.create_channel("ioc:gwcachetest")
        connected = ca.connect_channel(ioc, timeout=.5)
        self.assertTrue(connected,
                        "Could not connect to ioc channel " + ca.name(ioc))
        (ioc_cbref, ioc_uaref, ioc_eventid) = ca.create_subscription(
            ioc,
            mask=dbr.DBE_VALUE | dbr.DBE_ALARM,
            use_time=True,
            callback=self.onChangeIOC)
        (ioc_cbref2, ioc_uaref2,
         ioc_eventid2) = ca.create_subscription(ioc,
                                                mask=dbr.DBE_PROPERTY,
                                                use_ctrl=True,
                                                callback=self.onChangeIOC)

        time.sleep(.1)

        # set value on IOC
        ioc_value = ca.create_channel("ioc:gwcachetest")
        ca.put(ioc_value, 10.0, wait=True)
        time.sleep(.1)
        if gwtests.verbose:
            print()

        self.assertTrue(
            self.eventsReceivedIOC == self.eventsReceivedGW,
            "After setting value, no. of received updates differ: GW {0}, IOC {1}"
            .format(str(self.eventsReceivedGW), str(self.eventsReceivedIOC)))

        (are_diff, diffs) = self.compareStructures()
        self.assertTrue(
            are_diff == False,
            "At update {0} (change value), received structure updates differ:\n\t{1}"
            .format(str(self.eventsReceivedIOC), "\n\t".join(diffs)))

        # set property on IOC
        ioc_hihi = ca.create_channel("ioc:gwcachetest.HIHI")
        ca.put(ioc_hihi, 123.0, wait=True)
        time.sleep(.1)
        if gwtests.verbose:
            print()
        ca.put(ioc_value, 11.0, wait=True)
        time.sleep(.1)
        if gwtests.verbose:
            print()

        self.assertTrue(
            self.eventsReceivedIOC == self.eventsReceivedGW,
            "After setting property, no. of received updates differ: GW {0}, IOC {1}"
            .format(str(self.eventsReceivedGW), str(self.eventsReceivedIOC)))

        (are_diff, diffs) = self.compareStructures()
        self.assertTrue(
            are_diff == False,
            "At update {0} (change property), received structure updates differ:\n\t{1}"
            .format(str(self.eventsReceivedIOC), "\n\t".join(diffs)))
コード例 #27
0
def main():
    parser = argparse.ArgumentParser()                            # parser for the inputs - must keep the 2 lines below.
    parser.add_argument("top",                 help="top node")   # must have a top node, -v VERBOSITY is an opion  
    parser.add_argument("-v", "--verbosity",   help="increase verbosity", nargs='?', const=0, default=0)
    #add extra args and opts here
    parser.add_argument("pv",                  help="pvname")   

    args = parser.parse_args()                 #get the input args from the parser
    
    global verbose
    verbose = args.verbosity

    global pvname
    global nChid

    
    pvname = args.pv
    
    #This calls the doNode() (bottom of this file) that works recursively through the tree and calls do_node()
    #which you may overwrite by calling your own function (eg my_node() shown here
    #In this case, it calls my_node() for every element - see below.
    doNode.doNode(args.top,do_node=my_node, v=verbose)

    
    wave=numpy.zeros(nChid)             #create an array for all the values

    pvname_wf = args.top+":"+pvname+"_wf"    #make the names of the PVs for waveform and enable switch
    pvname_en = args.top+":"+pvname+"_en"

    print pvname_wf,pvname_en
    
    pvwf = PV(pvname_wf)          #set the PV
    pven = PV(pvname_en)          #set the PV

    pven.put(1)

    for i in range(len(allids)):        #connect call the channels
        if not ca.connect_channel(allids[i],timeout=0.001):
            allids[i]=0
            print "Warning didn't connect to PV =", allnames[i], "ignoring this one"
            
    ca.poll()                           #Not sure exactly what this does!
    n=0
    while n < 100000:
        for i in range(len(allids)):
            #print i, allids[i]
            if allids[i] > 0:
                ca.get(allids[i], wait=False) #Tell them all to start getting but don't wait
        ca.poll() 
        
        for i in range(len(allids)):           #now finish getting
            if allids[i] > 0:
                val = ca.get_complete(allids[i])
                wave[i]=val
                if verbose:
                    #print allnames[i],val
        pvwf.put(wave)
        time.sleep(0.5)

        if not pven.get():
            exit()
        #print n,pven.get()
        n+=1
コード例 #28
0
    def testPropCache_ValueGetDisconnectCTRLGet(self):
        '''Get PV (value) through GW - disconnect client - change properties (HIGH, EGU) directly - get the DBR_CTRL of the PV through GW'''
        # gateway should show no VC (client side connection) and no PV (IOC side connection)
        self.updateGwStats()
        self.assertTrue(
            self.vctotal == 0,
            "Expected GW VC total count: 0, actual: " + str(self.vctotal))
        self.assertTrue(
            self.pvtotal == 0,
            "Expected GW PV total count: 0, actual: " + str(self.pvtotal))
        self.assertTrue(
            self.connected == 0,
            "Expected GW connected PV count: 0, actual: " +
            str(self.connected))
        self.assertTrue(
            self.active == 0,
            "Expected GW active PV count: 0, actual: " + str(self.active))
        self.assertTrue(
            self.inactive == 0,
            "Expected GW inactive PV count: 0, actual: " + str(self.inactive))

        # gwcachetest is an ai record with full set of alarm limits: -100 -10 10 100
        gw = ca.create_channel("gateway:gwcachetest")
        connected = ca.connect_channel(gw, timeout=.5)
        self.assertTrue(connected,
                        "Could not connect to gateway channel " + ca.name(gw))
        ioc = ca.create_channel("ioc:gwcachetest")
        connected = ca.connect_channel(ioc, timeout=.5)
        self.assertTrue(connected,
                        "Could not connect to ioc channel " + ca.name(gw))

        # gateway should show one VC and one connected active PV
        self.updateGwStats()
        self.assertTrue(
            self.vctotal == 1,
            "Expected GW VC total count: 1, actual: " + str(self.vctotal))
        self.assertTrue(
            self.pvtotal == 1,
            "Expected GW PV total count: 1, actual: " + str(self.pvtotal))
        self.assertTrue(
            self.connected == 1,
            "Expected GW connected PV count: 1, actual: " +
            str(self.connected))
        self.assertTrue(
            self.active == 1,
            "Expected GW active PV count: 1, actual: " + str(self.active))
        self.assertTrue(
            self.inactive == 0,
            "Expected GW inactive PV count: 0, actual: " + str(self.inactive))

        # limit should not have been updated
        ioc_ctrl = ca.get_ctrlvars(ioc)
        highVal = ioc_ctrl['upper_warning_limit']
        self.assertTrue(
            highVal == 10.0,
            "Expected IOC warning_limit: 10; actual limit: " + str(highVal))
        eguVal = ioc_ctrl['units']
        self.assertTrue(
            eguVal == "wobbles",
            "Expected IOC units string: wobbles; actual units string: " +
            eguVal)
        gw_ctrl = ca.get_ctrlvars(gw)
        highVal = gw_ctrl['upper_warning_limit']
        self.assertTrue(
            highVal == 10.0,
            "Expected GW warning_limit: 10; actual limit: " + str(highVal))
        eguVal = gw_ctrl['units']
        self.assertTrue(
            eguVal == "wobbles",
            "Expected GW units string: wobbles; actual units string: " +
            eguVal)

        # disconnect Channel Access, reconnect Gateway stats
        ca.finalize_libca()
        ca.initialize_libca()
        self.connectGwStats()

        # gateway should show no VC and 1 connected inactive PV
        self.updateGwStats()
        self.assertTrue(
            self.vctotal == 0,
            "Expected GW VC total count: 0, actual: " + str(self.vctotal))
        self.assertTrue(
            self.pvtotal == 1,
            "Expected GW PV total count: 1, actual: " + str(self.pvtotal))
        self.assertTrue(
            self.connected == 1,
            "Expected GW connected PV count: 1, actual: " +
            str(self.connected))
        self.assertTrue(
            self.active == 0,
            "Expected GW active PV count: 0, actual: " + str(self.active))
        self.assertTrue(
            self.inactive == 1,
            "Expected GW inactive PV count: 1, actual: " + str(self.inactive))

        # set warning limit on IOC
        ioc_high = ca.create_channel("ioc:gwcachetest.HIGH")
        ca.put(ioc_high, 20.0, wait=True)
        # set unit string on IOC
        ioc_egu = ca.create_channel("ioc:gwcachetest.EGU")
        ca.put(ioc_egu, "foo", wait=True)
        time.sleep(.1)

        # reconnect Gateway and IOC
        gw = ca.create_channel("gateway:gwcachetest")
        connected = ca.connect_channel(gw, timeout=.5)
        self.assertTrue(connected,
                        "Could not connect to gateway channel " + ca.name(gw))
        ioc = ca.create_channel("ioc:gwcachetest")
        connected = ca.connect_channel(ioc, timeout=.5)
        self.assertTrue(connected,
                        "Could not connect to ioc channel " + ca.name(gw))

        # gateway should show one VC and one connected active PV
        self.updateGwStats()
        self.assertTrue(
            self.vctotal == 1,
            "Expected GW VC total count: 1, actual: " + str(self.vctotal))
        self.assertTrue(
            self.pvtotal == 1,
            "Expected GW PV total count: 1, actual: " + str(self.pvtotal))
        self.assertTrue(
            self.connected == 1,
            "Expected GW connected PV count: 1, actual: " +
            str(self.connected))
        self.assertTrue(
            self.active == 1,
            "Expected GW active PV count: 1, actual: " + str(self.active))
        self.assertTrue(
            self.inactive == 0,
            "Expected GW inactive PV count: 0, actual: " + str(self.inactive))

        # now the limit should have been updated
        ioc_ctrl = ca.get_ctrlvars(ioc)
        highVal = ioc_ctrl['upper_warning_limit']
        self.assertTrue(
            highVal == 20.0,
            "Expected IOC warning_limit: 20; actual limit: " + str(highVal))
        eguVal = ioc_ctrl['units']
        self.assertTrue(
            eguVal == "foo",
            "Expected IOC units string: foo; actual units string: " + eguVal)
        gw_ctrl = ca.get_ctrlvars(gw)
        highVal = gw_ctrl['upper_warning_limit']
        self.assertTrue(
            highVal == 20.0,
            "Expected GW warning_limit: 20; actual limit: " + str(highVal))
        eguVal = gw_ctrl['units']
        self.assertTrue(
            eguVal == "foo",
            "Expected GW units string: wobbles; actual units string: " +
            eguVal)
コード例 #29
0
    def testEnumPropCache_ValueGetDisconnectCTRLGet(self):
        '''Get PV (value) through GW - disconnect client - change ENUM string directly - get the DBR_CTRL of the PV through GW'''
        # gateway should show no VC (client side connection) and no PV (IOC side connection)
        self.updateGwStats()
        self.assertTrue(self.vctotal == 0, "Expected GW VC total count: 0, actual: " + str(self.vctotal))
        self.assertTrue(self.pvtotal == 0, "Expected GW PV total count: 0, actual: " + str(self.pvtotal))
        self.assertTrue(self.connected == 0, "Expected GW connected PV count: 0, actual: " + str(self.connected))
        self.assertTrue(self.active == 0, "Expected GW active PV count: 0, actual: " + str(self.active))
        self.assertTrue(self.inactive == 0, "Expected GW inactive PV count: 0, actual: " + str(self.inactive))

        # enumtest is an mbbi record with three strings defined: zero one two
        gw = ca.create_channel("gateway:enumtest")
        connected = ca.connect_channel(gw, timeout=.5)
        self.assertTrue(connected, "Could not connect to gateway channel " + ca.name(gw))
        ioc = ca.create_channel("ioc:enumtest")
        connected = ca.connect_channel(ioc, timeout=.5)
        self.assertTrue(connected, "Could not connect to ioc channel " + ca.name(gw))

        # gateway should show one VC and one connected active PV
        self.updateGwStats()
        self.assertTrue(self.vctotal == 1, "Expected GW VC total count: 1, actual: " + str(self.vctotal))
        self.assertTrue(self.pvtotal == 1, "Expected GW PV total count: 1, actual: " + str(self.pvtotal))
        self.assertTrue(self.connected == 1, "Expected GW connected PV count: 1, actual: " + str(self.connected))
        self.assertTrue(self.active == 1, "Expected GW active PV count: 1, actual: " + str(self.active))
        self.assertTrue(self.inactive == 0, "Expected GW inactive PV count: 0, actual: " + str(self.inactive))

        # enum string should not have been updated
        ioc_ctrl = ca.get_ctrlvars(ioc)
        oneStr = ioc_ctrl['enum_strs'][1]
        self.assertTrue(oneStr == 'one', "Expected IOC enum[1]: one; actual enum[1]: "+ oneStr)
        gw_ctrl = ca.get_ctrlvars(gw)
        oneStr = gw_ctrl['enum_strs'][1]
        self.assertTrue(oneStr == 'one', "Expected GW enum[1]: one; actual enum[1]: "+ oneStr)

        # disconnect Channel Access, reconnect Gateway stats
        ca.finalize_libca()
        ca.initialize_libca()
        self.connectGwStats()

        # gateway should show no VC and 1 connected inactive PV
        self.updateGwStats()
        self.assertTrue(self.vctotal == 0, "Expected GW VC total count: 0, actual: " + str(self.vctotal))
        self.assertTrue(self.pvtotal == 1, "Expected GW PV total count: 1, actual: " + str(self.pvtotal))
        self.assertTrue(self.connected == 1, "Expected GW connected PV count: 1, actual: " + str(self.connected))
        self.assertTrue(self.active == 0, "Expected GW active PV count: 0, actual: " + str(self.active))
        self.assertTrue(self.inactive == 1, "Expected GW inactive PV count: 1, actual: " + str(self.inactive))

        # set enum string on IOC
        ioc_enum1 = ca.create_channel("ioc:enumtest.ONST")
        ca.put(ioc_enum1, 'uno', wait=True)
        time.sleep(.1)

        # reconnect Gateway and IOC
        gw = ca.create_channel("gateway:enumtest")
        connected = ca.connect_channel(gw, timeout=.5)
        self.assertTrue(connected, "Could not connect to gateway channel " + ca.name(gw))
        ioc = ca.create_channel("ioc:enumtest")
        connected = ca.connect_channel(ioc, timeout=.5)
        self.assertTrue(connected, "Could not connect to ioc channel " + ca.name(gw))

        # gateway should show one VC and one connected active PV
        self.updateGwStats()
        self.assertTrue(self.vctotal == 1, "Expected GW VC total count: 1, actual: " + str(self.vctotal))
        self.assertTrue(self.pvtotal == 1, "Expected GW PV total count: 1, actual: " + str(self.pvtotal))
        self.assertTrue(self.connected == 1, "Expected GW connected PV count: 1, actual: " + str(self.connected))
        self.assertTrue(self.active == 1, "Expected GW active PV count: 1, actual: " + str(self.active))
        self.assertTrue(self.inactive == 0, "Expected GW inactive PV count: 0, actual: " + str(self.inactive))

        # Now the enum string should have been updated
        ioc_ctrl = ca.get_ctrlvars(ioc)
        oneStr = ioc_ctrl['enum_strs'][1]
        self.assertTrue(oneStr == 'uno', "Expected IOC enum[1]: uno; actual enum[1]: "+ oneStr)
        gw_ctrl = ca.get_ctrlvars(gw)
        oneStr = gw_ctrl['enum_strs'][1]
        self.assertTrue(oneStr == 'uno', "Expected GW enum[1]: uno; actual enum[1]: "+ oneStr)
コード例 #30
0
import time
import sys
from epics import ca

import pvnames

pvname = pvnames.double_pv
host = pvnames.double_pv_host

chid = ca.create_channel(pvname)
ret = ca.connect_channel(chid)
ca.pend_event(1.e-3)

ftype = ca.field_type(chid)
count = ca.element_count(chid)
host = ca.host_name(chid)
rwacc = ca.access(chid)

if ftype == 6 and count == 1 and host.startswith(host) and rwacc.startswith(
        'read'):
    sys.stdout.write('OK!\n')
else:
    sys.stdout.write("Error\n")
コード例 #31
0
    def testEnumPropCache_ValueGetDisconnectCTRLGet(self):
        '''Get PV (value) through GW - disconnect client - change ENUM string directly - get the DBR_CTRL of the PV through GW'''
        # gateway should show no VC (client side connection) and no PV (IOC side connection)
        self.updateGwStats()
        self.assertTrue(
            self.vctotal == 0,
            "Expected GW VC total count: 0, actual: " + str(self.vctotal))
        self.assertTrue(
            self.pvtotal == 0,
            "Expected GW PV total count: 0, actual: " + str(self.pvtotal))
        self.assertTrue(
            self.connected == 0,
            "Expected GW connected PV count: 0, actual: " +
            str(self.connected))
        self.assertTrue(
            self.active == 0,
            "Expected GW active PV count: 0, actual: " + str(self.active))
        self.assertTrue(
            self.inactive == 0,
            "Expected GW inactive PV count: 0, actual: " + str(self.inactive))

        # enumtest is an mbbi record with three strings defined: zero one two
        gw = ca.create_channel("gateway:enumtest")
        connected = ca.connect_channel(gw, timeout=.5)
        self.assertTrue(connected,
                        "Could not connect to gateway channel " + ca.name(gw))
        ioc = ca.create_channel("ioc:enumtest")
        connected = ca.connect_channel(ioc, timeout=.5)
        self.assertTrue(connected,
                        "Could not connect to ioc channel " + ca.name(gw))

        # gateway should show one VC and one connected active PV
        self.updateGwStats()
        self.assertTrue(
            self.vctotal == 1,
            "Expected GW VC total count: 1, actual: " + str(self.vctotal))
        self.assertTrue(
            self.pvtotal == 1,
            "Expected GW PV total count: 1, actual: " + str(self.pvtotal))
        self.assertTrue(
            self.connected == 1,
            "Expected GW connected PV count: 1, actual: " +
            str(self.connected))
        self.assertTrue(
            self.active == 1,
            "Expected GW active PV count: 1, actual: " + str(self.active))
        self.assertTrue(
            self.inactive == 0,
            "Expected GW inactive PV count: 0, actual: " + str(self.inactive))

        # enum string should not have been updated
        ioc_ctrl = ca.get_ctrlvars(ioc)
        oneStr = ioc_ctrl['enum_strs'][1]
        self.assertTrue(oneStr == 'one',
                        "Expected IOC enum[1]: one; actual enum[1]: " + oneStr)
        gw_ctrl = ca.get_ctrlvars(gw)
        oneStr = gw_ctrl['enum_strs'][1]
        self.assertTrue(oneStr == 'one',
                        "Expected GW enum[1]: one; actual enum[1]: " + oneStr)

        # disconnect Channel Access, reconnect Gateway stats
        ca.finalize_libca()
        ca.initialize_libca()
        self.connectGwStats()

        # gateway should show no VC and 1 connected inactive PV
        self.updateGwStats()
        self.assertTrue(
            self.vctotal == 0,
            "Expected GW VC total count: 0, actual: " + str(self.vctotal))
        self.assertTrue(
            self.pvtotal == 1,
            "Expected GW PV total count: 1, actual: " + str(self.pvtotal))
        self.assertTrue(
            self.connected == 1,
            "Expected GW connected PV count: 1, actual: " +
            str(self.connected))
        self.assertTrue(
            self.active == 0,
            "Expected GW active PV count: 0, actual: " + str(self.active))
        self.assertTrue(
            self.inactive == 1,
            "Expected GW inactive PV count: 1, actual: " + str(self.inactive))

        # set enum string on IOC
        ioc_enum1 = ca.create_channel("ioc:enumtest.ONST")
        ca.put(ioc_enum1, 'uno', wait=True)
        time.sleep(.1)

        # reconnect Gateway and IOC
        gw = ca.create_channel("gateway:enumtest")
        connected = ca.connect_channel(gw, timeout=.5)
        self.assertTrue(connected,
                        "Could not connect to gateway channel " + ca.name(gw))
        ioc = ca.create_channel("ioc:enumtest")
        connected = ca.connect_channel(ioc, timeout=.5)
        self.assertTrue(connected,
                        "Could not connect to ioc channel " + ca.name(gw))

        # gateway should show one VC and one connected active PV
        self.updateGwStats()
        self.assertTrue(
            self.vctotal == 1,
            "Expected GW VC total count: 1, actual: " + str(self.vctotal))
        self.assertTrue(
            self.pvtotal == 1,
            "Expected GW PV total count: 1, actual: " + str(self.pvtotal))
        self.assertTrue(
            self.connected == 1,
            "Expected GW connected PV count: 1, actual: " +
            str(self.connected))
        self.assertTrue(
            self.active == 1,
            "Expected GW active PV count: 1, actual: " + str(self.active))
        self.assertTrue(
            self.inactive == 0,
            "Expected GW inactive PV count: 0, actual: " + str(self.inactive))

        # Now the enum string should have been updated
        ioc_ctrl = ca.get_ctrlvars(ioc)
        oneStr = ioc_ctrl['enum_strs'][1]
        self.assertTrue(oneStr == 'uno',
                        "Expected IOC enum[1]: uno; actual enum[1]: " + oneStr)
        gw_ctrl = ca.get_ctrlvars(gw)
        oneStr = gw_ctrl['enum_strs'][1]
        self.assertTrue(oneStr == 'uno',
                        "Expected GW enum[1]: uno; actual enum[1]: " + oneStr)
コード例 #32
0
ファイル: ca_simpletest.py プロジェクト: vigder/pyepics
import time
import sys
from epics import ca

import pvnames

pvname = pvnames.double_pv
host      = pvnames.double_pv_host


chid = ca.create_channel(pvname)
ret   = ca.connect_channel(chid)
ca.pend_event(1.e-3)
 
ftype  = ca.field_type(chid)
count  = ca.element_count(chid)
host    = ca.host_name(chid)
rwacc = ca.access(chid)
 
if  ftype ==6 and count == 1 and host.startswith(host) and rwacc.startswith('read'):
    sys.stdout.write('OK!\n')
else:
    sys.stdout.write("Error\n")

コード例 #33
0
def main():

    parser = argparse.ArgumentParser(
    )  # parser for the inputs - must keep the 2 lines below.
    parser.add_argument("-f",
                        "--setupfile",
                        help="setup file (default = monitor.dat)",
                        nargs='?',
                        const=0,
                        default="monitor.dat")
    parser.add_argument("-v",
                        "--verbosity",
                        help="increase verbosity",
                        nargs='?',
                        const=0,
                        default=0)

    args = parser.parse_args()  #get the input args from the parser

    global verbose
    verbose = args.verbosity
    setup_file = args.setupfile

    global pvdata
    global mon_line
    global pvf

    global pvfull

    #read the setup file, which has the form
    #index    TOP        PVname  Period(s)

    for line in file(
            setup_file
    ):  #read the lines in the setup file to pvdata monitor list
        if not (line.startswith("#")
                or len(line.split()) < 3):  #skip comments and require 3 fields
            s = line.split()  #split input into fields
            wf = PV(s[pvf.TOP] + ":" + s[pvf.NAME] +
                    "_wf")  #wf, en are PVs for waveform and enable
            en = PV(s[pvf.TOP] + ":" + s[pvf.NAME] + "_en")
            pvdata.append(
                [s[0], s[pvf.TOP], s[pvf.NAME], s[pvf.PERIOD], wf, en,
                 []])  #add to list, with list for IDS

            #Call doNode() which works recursively through the tree and calls do_node()
            #which you may overwrite by calling your own function (eg my_node() shown here)
            #In this case, it calls my_node() for every element - see below.
            doNode.doNode(pvdata[mon_line][pvf.TOP],
                          do_node=my_node,
                          v=verbose)

            #now the pvf.ID array has been filled, try to connect to all the elements
            for n, chid in enumerate(pvdata[mon_line][pvf.ID]):
                if not ca.connect_channel(chid, timeout=0.001):
                    if verbose:
                        print pvfull[n], "... Not connected, chid = 0"
                    pvdata[mon_line][pvf.ID][n] = 0
                else:
                    if verbose:
                        print pvfull[n], "... Connected, chid = ", chid
            pvdata[mon_line].append(numpy.zeros(len(pvdata[mon_line][
                pvf.ID])))  #create a zero numpy array for the data

            pvfull = []  #reset the list of names
            mon_line += 1  #increment the current line number

    #start a monitor thread for each
    for l in range(mon_line):
        t = Thread(target=monitor, args=(l, ))
        t.start()

    #do the poll loop here, to cover all monitor threads
    while mon_line > 0:
        ca.poll()
        time.sleep(1.0)
コード例 #34
0
    def testPropCache_ValueMonitorCTRLget(self):
        '''Monitor PV (value events) through GW - change properties (HIGH, EGU) directly - get the DBR_CTRL of the PV through GW'''
        # gateway should show no VC (client side connection) and no PV (IOC side connection)
        self.updateGwStats()
        self.assertTrue(
            self.vctotal == 0,
            "Expected GW VC total count: 0, actual: " + str(self.vctotal))
        self.assertTrue(
            self.pvtotal == 0,
            "Expected GW PV total count: 0, actual: " + str(self.pvtotal))
        self.assertTrue(
            self.connected == 0,
            "Expected GW connected PV count: 0, actual: " +
            str(self.connected))
        self.assertTrue(
            self.active == 0,
            "Expected GW active PV count: 0, actual: " + str(self.active))
        self.assertTrue(
            self.inactive == 0,
            "Expected GW inactive PV count: 0, actual: " + str(self.inactive))

        # gwcachetest is an ai record with full set of alarm limits: -100 -10 10 100
        gw = ca.create_channel("gateway:gwcachetest")
        connected = ca.connect_channel(gw, timeout=.5)
        self.assertTrue(connected,
                        "Could not connect to gateway channel " + ca.name(gw))
        (gw_cbref, gw_uaref,
         gw_eventid) = ca.create_subscription(gw,
                                              mask=dbr.DBE_VALUE,
                                              callback=self.onChange)
        ioc = ca.create_channel("ioc:gwcachetest")
        connected = ca.connect_channel(ioc, timeout=.5)
        self.assertTrue(connected,
                        "Could not connect to ioc channel " + ca.name(ioc))
        (ioc_cbref, ioc_uaref,
         ioc_eventid) = ca.create_subscription(ioc,
                                               mask=dbr.DBE_VALUE,
                                               callback=self.onChange)

        # gateway should show one VC and one connected active PV
        self.updateGwStats()
        self.assertTrue(
            self.vctotal == 1,
            "Expected GW VC total count: 1, actual: " + str(self.vctotal))
        self.assertTrue(
            self.pvtotal == 1,
            "Expected GW PV total count: 1, actual: " + str(self.pvtotal))
        self.assertTrue(
            self.connected == 1,
            "Expected GW connected PV count: 1, actual: " +
            str(self.connected))
        self.assertTrue(
            self.active == 1,
            "Expected GW active PV count: 1, actual: " + str(self.active))
        self.assertTrue(
            self.inactive == 0,
            "Expected GW inactive PV count: 0, actual: " + str(self.inactive))

        # limit should not have been updated
        ioc_ctrl = ca.get_ctrlvars(ioc)
        highVal = ioc_ctrl['upper_warning_limit']
        self.assertTrue(
            highVal == 10.0,
            "Expected IOC warning_limit: 10; actual limit: " + str(highVal))
        gw_ctrl = ca.get_ctrlvars(gw)
        highVal = gw_ctrl['upper_warning_limit']
        self.assertTrue(
            highVal == 10.0,
            "Expected GW warning_limit: 10; actual limit: " + str(highVal))

        # set warning limit on IOC
        ioc_high = ca.create_channel("ioc:gwcachetest.HIGH")
        ca.put(ioc_high, 20.0, wait=True)
        time.sleep(.1)

        # Now the limit should have been updated (if IOC supports DBE_PROPERTY)
        ioc_ctrl = ca.get_ctrlvars(ioc)
        highVal = ioc_ctrl['upper_warning_limit']
        self.assertTrue(
            highVal == 20.0,
            "Expected IOC warning_limit: 20; actual limit: " + str(highVal))
        if self.propSupported:
            gw_expected = 20.0
        else:
            gw_expected = 10.0
        gw_ctrl = ca.get_ctrlvars(gw)
        highVal = gw_ctrl['upper_warning_limit']
        self.assertTrue(
            highVal == gw_expected,
            "Expected GW warning_limit: {0}; actual limit: {1}".format(
                gw_expected, highVal))

        # set unit string on IOC
        ioc_egu = ca.create_channel("ioc:gwcachetest.EGU")
        old_egu = ca.get(ioc_egu)
        ca.put(ioc_egu, "foo", wait=True)
        time.sleep(.1)

        # Now the unit string should have been updated (if IOC supports DBE_PROPERTY)
        ioc_ctrl = ca.get_ctrlvars(ioc)
        eguVal = ioc_ctrl['units']
        self.assertTrue(
            eguVal == "foo",
            "Expected IOC units string: foo; actual units string: " + eguVal)
        if self.propSupported:
            gw_expected = "foo"
        else:
            gw_expected = old_egu
        gw_ctrl = ca.get_ctrlvars(gw)
        eguVal = gw_ctrl['units']
        self.assertTrue(
            eguVal == gw_expected,
            "Expected GW units string: {0}; actual units string: {1}".format(
                gw_expected, eguVal))
コード例 #35
0
    def testPropCache_ValueGetDisconnectCTRLGet(self):
        '''Get PV (value) through GW - disconnect client - change HIGH directly - get the DBR_CTRL of the PV through GW'''
        gw_vctotal = ca.create_channel("gwtest:vctotal")
        gw_pvtotal = ca.create_channel("gwtest:pvtotal")
        gw_connected = ca.create_channel("gwtest:connected")
        gw_active = ca.create_channel("gwtest:active")
        gw_inactive = ca.create_channel("gwtest:inactive")

        # gateway should show no VC (client side connection) and no PV (IOC side connection)
        count = ca.get(gw_vctotal)
        self.assertTrue(count == 0, "Expected GW VC total count: 0, actual: " + str(count))
        count = ca.get(gw_pvtotal)
        self.assertTrue(count == 0, "Expected GW PV total count: 0, actual: " + str(count))
        count = ca.get(gw_connected)
        self.assertTrue(count == 0, "Expected GW connected PV count: 0, actual: " + str(count))
        count = ca.get(gw_active)
        self.assertTrue(count == 0, "Expected GW active PV count: 0, actual: " + str(count))
        count = ca.get(gw_inactive)
        self.assertTrue(count == 0, "Expected GW inactive PV count: 0, actual: " + str(count))

        # gwcachetest is an ai record with full set of alarm limits: -100 -10 10 100
        gw = ca.create_channel("gateway:gwcachetest")
        connected = ca.connect_channel(gw, timeout=.5)
        self.assertTrue(connected, "Could not connect to gateway channel " + ca.name(gw))
        ioc = ca.create_channel("ioc:gwcachetest")
        connected = ca.connect_channel(ioc, timeout=.5)
        self.assertTrue(connected, "Could not connect to ioc channel " + ca.name(gw))

        # gateway should show one VC and one connected active PV
        count = ca.get(gw_vctotal)
        self.assertTrue(count == 1, "Expected GW VC total count: 1, actual: " + str(count))
        count = ca.get(gw_pvtotal)
        self.assertTrue(count == 1, "Expected GW PV total count: 1, actual: " + str(count))
        count = ca.get(gw_connected)
        self.assertTrue(count == 1, "Expected GW connected PV count: 1, actual: " + str(count))
        count = ca.get(gw_active)
        self.assertTrue(count == 1, "Expected GW active PV count: 1, actual: " + str(count))
        count = ca.get(gw_inactive)
        self.assertTrue(count == 0, "Expected GW inactive PV count: 0, actual: " + str(count))

        # limit should not have been updated
        ioc_ctrl = ca.get_ctrlvars(ioc)
        highVal = ioc_ctrl['upper_warning_limit']
        self.assertTrue(highVal == 10.0, "Expected IOC warning_limit: 10; actual limit: "+ str(highVal))
        gw_ctrl = ca.get_ctrlvars(gw)
        highVal = gw_ctrl['upper_warning_limit']
        self.assertTrue(highVal == 10.0, "Expected GW warning_limit: 10; actual limit: "+ str(highVal))

        # disconnect Channel Access, reconnect Gateway stats
        ca.finalize_libca()
        ca.initialize_libca()
        gw_vctotal = ca.create_channel("gwtest:vctotal")
        gw_pvtotal = ca.create_channel("gwtest:pvtotal")
        gw_connected = ca.create_channel("gwtest:connected")
        gw_active = ca.create_channel("gwtest:active")
        gw_inactive = ca.create_channel("gwtest:inactive")

        # gateway should show no VC and 1 connected inactive PV
        count = ca.get(gw_vctotal)
        self.assertTrue(count == 0, "Expected GW VC total count: 0, actual: " + str(count))
        count = ca.get(gw_pvtotal)
        self.assertTrue(count == 1, "Expected GW PV total count: 1, actual: " + str(count))
        count = ca.get(gw_connected)
        self.assertTrue(count == 1, "Expected GW connected PV count: 1, actual: " + str(count))
        count = ca.get(gw_active)
        self.assertTrue(count == 0, "Expected GW active PV count: 0, actual: " + str(count))
        count = ca.get(gw_inactive)
        self.assertTrue(count == 1, "Expected GW inactive PV count: 1, actual: " + str(count))

        # set warning limit on IOC
        ioc_high = ca.create_channel("ioc:gwcachetest.HIGH")
        ca.put(ioc_high, 20.0, wait=True)
        time.sleep(.1)

        # reconnect Gateway and IOC
        gw = ca.create_channel("gateway:gwcachetest")
        connected = ca.connect_channel(gw, timeout=.5)
        self.assertTrue(connected, "Could not connect to gateway channel " + ca.name(gw))
        ioc = ca.create_channel("ioc:gwcachetest")
        connected = ca.connect_channel(ioc, timeout=.5)
        self.assertTrue(connected, "Could not connect to ioc channel " + ca.name(gw))

        # gateway should show one VC and one connected active PV
        count = ca.get(gw_vctotal)
        self.assertTrue(count == 1, "Expected GW VC total count: 1, actual: " + str(count))
        count = ca.get(gw_pvtotal)
        self.assertTrue(count == 1, "Expected GW PV total count: 1, actual: " + str(count))
        count = ca.get(gw_connected)
        self.assertTrue(count == 1, "Expected GW connected PV count: 1, actual: " + str(count))
        count = ca.get(gw_active)
        self.assertTrue(count == 1, "Expected GW active PV count: 1, actual: " + str(count))
        count = ca.get(gw_inactive)
        self.assertTrue(count == 0, "Expected GW inactive PV count: 0, actual: " + str(count))

        # now the limit should have been updated
        ioc_ctrl = ca.get_ctrlvars(ioc)
        highVal = ioc_ctrl['upper_warning_limit']
        self.assertTrue(highVal == 20.0, "Expected IOC warning_limit: 20; actual limit: "+ str(highVal))
        gw_ctrl = ca.get_ctrlvars(gw)
        highVal = gw_ctrl['upper_warning_limit']
        self.assertTrue(highVal == 20.0, "Expected GW warning_limit: 20; actual limit: "+ str(highVal))
コード例 #36
0
def main():
    parser = argparse.ArgumentParser()                            # parser for the inputs - must keep the 2 lines below.
    parser.add_argument("top",                 help="top node")   # must have a top node, -v VERBOSITY is an opion  
    parser.add_argument("-v", "--verbosity",   help="increase verbosity", nargs='?', const=0, default=0)
    #add extra args and opts here
    parser.add_argument("pv",                  help="pvname")   

    args = parser.parse_args()                 #get the input args from the parser
    
    global verbose
    verbose = args.verbosity

    global pvname
    global nChid

    
    pvname = args.pv
    
    #This calls the doNode() (bottom of this file) that works recursively through the tree and calls do_node()
    #which you may overwrite by calling your own function (eg my_node() shown here
    #In this case, it calls my_node() for every element - see below.
    doNode.doNode(args.top,do_node=my_node, v=verbose)

    
    wave=numpy.zeros(nChid)             #create an array for all the values

    pvname_wf = args.top+":"+pvname+"_wf"    #make the names of the PVs for waveform and enable switch
    pvname_en = args.top+":"+pvname+"_en"

    print pvname_wf,pvname_en
    
    pvwf = PV(pvname_wf)          #set the PV
    pven = PV(pvname_en)          #set the PV

    pven.put(1)

    for i in range(len(allids)):        #connect call the channels
        if not ca.connect_channel(allids[i],timeout=0.001):
            allids[i]=0
            print "Warning didn't connect to PV =", allnames[i], "ignoring this one"
            
    ca.poll()                           #Not sure exactly what this does!
    n=0
    while n < 100000:
        for i in range(len(allids)):
            #print i, allids[i]
            if allids[i] > 0:
                ca.get(allids[i], wait=False) #Tell them all to start getting but don't wait
        ca.poll() 
        
        for i in range(len(allids)):           #now finish getting
            if allids[i] > 0:
                val = ca.get_complete(allids[i])
                wave[i]=val
                #if verbose:
                #print allnames[i],val
        pvwf.put(wave)
        time.sleep(0.5)

        if not pven.get():
            exit()
        #print n,pven.get()
        n+=1
コード例 #37
0
    def testEnumPropCache_ValueMonitorCTRLget(self):
        '''Monitor PV (value events) through GW - change ENUM string directly - get the DBR_CTRL of the PV through GW'''
        # gateway should show no VC (client side connection) and no PV (IOC side connection)
        self.updateGwStats()
        self.assertTrue(
            self.vctotal == 0,
            "Expected GW VC total count: 0, actual: " + str(self.vctotal))
        self.assertTrue(
            self.pvtotal == 0,
            "Expected GW PV total count: 0, actual: " + str(self.pvtotal))
        self.assertTrue(
            self.connected == 0,
            "Expected GW connected PV count: 0, actual: " +
            str(self.connected))
        self.assertTrue(
            self.active == 0,
            "Expected GW active PV count: 0, actual: " + str(self.active))
        self.assertTrue(
            self.inactive == 0,
            "Expected GW inactive PV count: 0, actual: " + str(self.inactive))

        # enumtest is an mbbi record with three strings defined: zero one two
        gw = ca.create_channel("gateway:enumtest")
        connected = ca.connect_channel(gw, timeout=.5)
        self.assertTrue(connected,
                        "Could not connect to gateway channel " + ca.name(gw))
        (gw_cbref, gw_uaref,
         gw_eventid) = ca.create_subscription(gw,
                                              mask=dbr.DBE_VALUE,
                                              callback=self.onChange)
        ioc = ca.create_channel("ioc:enumtest")
        connected = ca.connect_channel(ioc)
        self.assertTrue(connected,
                        "Could not connect to ioc channel " + ca.name(gw))
        (ioc_cbref, ioc_uaref,
         ioc_eventid) = ca.create_subscription(ioc,
                                               mask=dbr.DBE_VALUE,
                                               callback=self.onChange)

        # gateway should show one VC and one connected active PV
        self.updateGwStats()
        self.assertTrue(
            self.vctotal == 1,
            "Expected GW VC total count: 1, actual: " + str(self.vctotal))
        self.assertTrue(
            self.pvtotal == 1,
            "Expected GW PV total count: 1, actual: " + str(self.pvtotal))
        self.assertTrue(
            self.connected == 1,
            "Expected GW connected PV count: 1, actual: " +
            str(self.connected))
        self.assertTrue(
            self.active == 1,
            "Expected GW active PV count: 1, actual: " + str(self.active))
        self.assertTrue(
            self.inactive == 0,
            "Expected GW inactive PV count: 0, actual: " + str(self.inactive))

        # enum string should not have been updated
        ioc_ctrl = ca.get_ctrlvars(ioc)
        oneStr = ioc_ctrl['enum_strs'][1]
        self.assertTrue(oneStr == 'one',
                        "Expected IOC enum[1]: one; actual enum[1]: " + oneStr)
        gw_ctrl = ca.get_ctrlvars(gw)
        oneStr = gw_ctrl['enum_strs'][1]
        self.assertTrue(oneStr == 'one',
                        "Expected GW enum[1]: one; actual enum[1]: " + oneStr)

        # set enum string on IOC
        ioc_enum1 = ca.create_channel("ioc:enumtest.ONST")
        ca.put(ioc_enum1, 'uno', wait=True)
        time.sleep(.1)

        # Now the enum string should have been updated (if IOC supports DBE_PROPERTY)
        ioc_ctrl = ca.get_ctrlvars(ioc)
        oneStr = ioc_ctrl['enum_strs'][1]
        self.assertTrue(oneStr == 'uno',
                        "Expected IOC enum[1]: uno; actual enum[1]: " + oneStr)
        if self.propSupported:
            gw_expected = 'uno'
        else:
            gw_expected = 'one'
        gw_ctrl = ca.get_ctrlvars(gw)
        oneStr = gw_ctrl['enum_strs'][1]
        self.assertTrue(
            oneStr == gw_expected,
            "Expected GW enum[1]: {0}; actual enum[1]: {1}".format(
                gw_expected, oneStr))