epicsdev 1.0.1__py3-none-any.whl → 2.0.1__py3-none-any.whl

epicsdev/epicsdev.py

@@ -1,11 +1,14 @@
 """Skeleton and helper functions for creating EPICS PVAccess server"""
 # pylint: disable=invalid-name
-__version__= 'v1.0.1 26-01-16'# rng range = nPatterns
-#TODO: NTEnums do not have structure display
-#TODO: Add performance counters to demo.
+__version__= 'v2.0.1 26-01-30'# added mandatory host PV
+#TODO add mandatory PV: host, to identify the server host.
+#Issue: There is no way in PVAccess to specify if string PV is writable.
+# As a workaround we append description with suffix ' Features: W' to indicate that.
 
 import sys
-import time
+from time import time, sleep, strftime, perf_counter as timer
+import os
+from socket import gethostname
 from p4p.nt import NTScalar, NTEnum
 from p4p.nt.enum import ntenum
 from p4p.server import Server
@@ -13,6 +16,9 @@ from p4p.server.thread import SharedPV
 from p4p.client.thread import Context
 
 #``````````````````Module Storage`````````````````````````````````````````````
+def _serverStateChanged(newState:str):
+    """Dummy serverStateChanged function"""
+    return
 class C_():
     """Storage for module members"""
     prefix = ''
@@ -20,13 +26,16 @@ class C_():
     cycle = 0
     serverState = ''
     PVs = {}
-    PVDefs = []
+    PVDefs = [] 
+    serverStateChanged = _serverStateChanged
+
 #```````````````````Helper methods````````````````````````````````````````````
 def serverState():
-    """Return current server state. That is the value of the server PV, but cached in C_ to avoid unnecessary get() calls."""
+    """Return current server state. That is the value of the server PV, but
+    cached in C_ to avoid unnecessary get() calls."""
     return C_.serverState
 def _printTime():
-    return time.strftime("%m%d:%H%M%S")
+    return strftime("%m%d:%H%M%S")
 def printi(msg):
     """Print info message and publish it to status PV."""
     print(f'inf_@{_printTime()}: {msg}')
@@ -62,24 +71,31 @@ def pvv(pvName:str):
     return pvobj(pvName).current()
 
 def publish(pvName:str, value, ifChanged=False, t=None):
-    """Publish value to PV. If ifChanged is True, then publish only if the value is different from the current value. If t is not None, then use it as timestamp, otherwise use current time."""
+    """Publish value to PV. If ifChanged is True, then publish only if the 
+    value is different from the current value. If t is not None, then use
+    it as timestamp, otherwise use current time."""
+    #print(f'Publishing {pvName}')
     try:
         pv = pvobj(pvName)
     except KeyError:
-        printw(f'PV {pvName} not found. Cannot publish value.')
+        print(f'WARNING: PV {pvName} not found. Cannot publish value.')
         return
     if t is None:
-        t = time.time()
+        t = time()
     if not ifChanged or pv.current() != value:
         pv.post(value, timestamp=t)
 
 def SPV(initial, meta='', vtype=None):
     """Construct SharedPV.
-    meta is a string with characters W,A,E indicating if the PV is writable, has alarm or it is NTEnum.
-    vtype should be one of the p4p.nt type definitions (see https://epics-base.github.io/p4p/values.html).
+    meta is a string with characters W,R,A,D indicating if the PV is writable,
+    has alarm or it is discrete (ENUM).
+    vtype should be one of the p4p.nt type definitions 
+    (see https://epics-base.github.io/p4p/values.html).
     if vtype is None then the nominal type will be determined automatically.
+    initial is the initial value of the PV. It can be a single value or
+    a list/array of values (for array PVs).
     """
-    typeCode = {
+    typeCode = {# mapping from vtype to p4p type code
     's8':'b', 'u8':'B', 's16':'h', 'u16':'H', 'i32':'i', 'u32':'I', 'i64':'l',
     'u64':'L', 'f32':'f', 'f64':'d', str:'s',
     }
@@ -89,33 +105,52 @@ def SPV(initial, meta='', vtype=None):
         itype = type(firstItem)
         vtype = {int: 'i32', float: 'f32'}.get(itype,itype)
     tcode = typeCode[vtype]
-    if 'E' in meta:
+    allowed_chars = 'WRAD'
+    discrete = False
+    for ch in meta:
+        if ch not in allowed_chars:
+            printe(f'Unknown meta character {ch} in SPV definition')
+            sys.exit(1)
+    if 'D' in meta:
+        discrete = True
         initial = {'choices': initial, 'index': 0}
         nt = NTEnum(display=True, control='W' in meta)
     else:
         prefix = 'a' if iterable else ''
-        nt = NTScalar(prefix+tcode, display=True, control='W' in meta, valueAlarm='A' in meta)
+        nt = NTScalar(prefix+tcode, display=True, control='W' in meta,
+                      valueAlarm='A' in meta)
     pv = SharedPV(nt=nt, initial=initial)
+    # add new attributes.
     pv.writable = 'W' in meta
+    pv.discrete = discrete
     return pv
 
 #``````````````````create_PVs()```````````````````````````````````````````````
 def _create_PVs(pvDefs):
-    """Create PVs, using definitions from pvDEfs list. Each definition is a list of the form:
-[pvname, description, SPV object, extra], where extra is a dictionary of extra parameters, like setter, units, limits etc. Setter is a function, that will be called when"""
-    ts = time.time()
+    ts = time()
     for defs in pvDefs:
-        pname,desc,spv,extra = defs
+        try:
+            pname,desc,spv,extra = defs
+        except ValueError:
+            printe(f'Invalid PV definition of {defs[0]}')
+            sys.exit(1)
         ivalue = spv.current()
-        printv(f'created pv {pname}, initial: {type(ivalue),ivalue}, extra: {extra}')
+        printv((f'created pv {pname}, initial: {type(ivalue),ivalue},'
+               f'extra: {extra}'))
+        key = C_.prefix + pname
+        if key in C_.PVs:
+            printe(f'Duplicate PV name: {pname}')
+            sys.exit(1)
         C_.PVs[C_.prefix+pname] = spv
         v = spv._wrap(ivalue, timestamp=ts)
         if spv.writable:
             try:
-                # To indicate that the PV is writable, set control limits to (0,0). Not very elegant, but it works for numerics and enums, not for strings.
+                # To indicate that the PV is writable, set control limits to
+                # (0,0). Not very elegant, but it works for numerics and enums,
+                #  not for strings.
                 v['control.limitLow'] = 0
                 v['control.limitHigh'] = 0
-            except KeyError as e:
+            except KeyError:
                 #print(f'control not set for {pname}: {e}')
                 pass
         if 'ntenum' in str(type(ivalue)):
@@ -132,18 +167,19 @@ def _create_PVs(pvDefs):
                         v[f'valueAlarm.{key}'] = value
             spv.post(v)
 
-        # add new attributes. To my surprise that works!
+        # add new attributes.
         spv.name = pname
         spv.setter = extra.get('setter')
 
         if spv.writable:
             @spv.put
             def handle(spv, op):
-                ct = time.time()
+                ct = time()
                 vv = op.value()
                 vr = vv.raw.value
                 current = spv._wrap(spv.current())
-                # check limits, if they are defined. That will be a good example of using control structure and valueAlarm.
+                # check limits, if they are defined. That will be a good
+                # example of using control structure and valueAlarm.
                 try:
                     limitLow = current['control.limitLow']
                     limitHigh = current['control.limitHigh']
@@ -154,86 +190,131 @@ def _create_PVs(pvDefs):
                 except KeyError:
                     pass
                 if isinstance(vv, ntenum):
-                    vr = vv
+                    vr = str(vv)
                 if spv.setter:
-                    spv.setter(vr)
+                    spv.setter(vr, spv)
                     # value will be updated by the setter, so get it again
                     vr = pvv(spv.name)
                 printv(f'putting {spv.name} = {vr}')
                 spv.post(vr, timestamp=ct) # update subscribers
                 op.done()
-        #print(f'PV {pv.name} created: {spv}')
 #,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
 #``````````````````Setters
-def set_verbosity(level):
+def set_verbose(level, *_):
     """Set verbosity level for debugging"""
     C_.verbose = level
-    publish('verbosity',level)
+    printi(f'Setting verbose to {level}')
+    publish('verbose',level)
 
-def set_server(state=None):
-    """Example of the setter for the server PV."""
-    #printv(f'>set_server({state}), {type(state)}')
-    if state is None:
-        state = pvv('server')
-        printi(f'Setting server state to {state}')
-    state = str(state)
-    if state == 'Start':
+def set_server(servState, *_):
+    """Example of the setter for the server PV.
+    servState can be 'Start', 'Stop', 'Exit' or 'Clear'. If servState is None,
+    then get the desired state from the server PV."""
+    #printv(f'>set_server({servState}), {type(servState)}')
+    if servState is None:
+        servState = pvv('server')
+        printi(f'Setting server state to {servState}')
+    servState = str(servState)
+    C_.serverStateChanged(servState)
+    if servState == 'Start':
         printi('Starting the server')
-        # configure_instrument()
-        # adopt_local_setting()
         publish('server','Started')
         publish('status','Started')
-    elif state == 'Stop':
+    elif servState == 'Stop':
         printi('server stopped')
         publish('server','Stopped')
         publish('status','Stopped')
-    elif state == 'Exit':
+    elif servState == 'Exit':
         printi('server is exiting')
         publish('server','Exited')
         publish('status','Exited')
-    elif state == 'Clear':
-        publish('acqCount', 0)
+    elif servState == 'Clear':
         publish('status','Cleared')
-        # set server to previous state
+        # set server to previous servState
         set_server(C_.serverState)
-    C_.serverState = state
+        return
+    C_.serverState = servState
 
 def create_PVs(pvDefs=None):
-    """Creates manadatory PVs and adds PVs specified in pvDefs list"""
+    """Creates manadatory PVs and adds PVs specified in pvDefs list.
+    Returns dictionary of created PVs.
+    Each definition is a list of the form:
+    [pvname, description, SPV object, extra], where extra is a dictionary of
+    extra parameters.
+    Extra parameters can include:
+    'setter' : function to be called on put
+    'units'  : string with units
+    'limitLow'  : low control limit
+    'limitHigh' : high control limit
+    'format'    : format string
+    'valueAlarm': dictionary with valueAlarm parameters, like
+        'lowAlarmLimit', 'highAlarmLimit', etc."""
     U,LL,LH = 'units','limitLow','limitHigh'
     C_.PVDefs = [
+['host',    'Server host name',  SPV(gethostname()), {}],
 ['version', 'Program version',  SPV(__version__), {}],
-['status',  'Server status',    SPV('?','W'), {}],
-['server',  'Server control',   
-    SPV('Start Stop Clear Exit Started Stopped Exited'.split(), 'WE'),
+['status',  'Server status. Features: RWE',    SPV('','W'), {}],
+['server',  'Server control',
+    SPV('Start Stop Clear Exit Started Stopped Exited'.split(), 'WD'),
         {'setter':set_server}],
-['verbosity', 'Debugging verbosity', SPV(0,'W','u8'),
-        {'setter':set_verbosity}],
+['verbose', 'Debugging verbosity', SPV(C_.verbose,'W','u8'),
+        {'setter':set_verbose, LL:0,LH:3}],
 ['polling', 'Polling interval', SPV(1.0,'W'), {U:'S', LL:0.001, LH:10.1}],
 ['cycle',   'Cycle number',         SPV(0,'','u32'), {}],
     ]
-    # append application's PVs, defined in the pvDefs and create map of providers
+    # append application's PVs, defined in the pvDefs and create map of
+    #  providers
     if pvDefs is not None:
         C_.PVDefs += pvDefs
     _create_PVs(C_.PVDefs)
     return C_.PVs
 
-def get_externalPV(pvName, timeout=0.5):
-    """Get value of PV from another server. That can be used to check if the server is already running, or to get values from other servers."""
+def get_externalPV(pvName:str, timeout=0.5):
+    """Get value of PV from another server. That can be used to check if the
+    server is already running, or to get values from other servers."""
     ctxt = Context('pva')
     return ctxt.get(pvName, timeout=timeout)
 
-def init_epicsdev(prefix, pvDefs, verbose=0):
-    """Check if no other server is running with the same prefix, create PVs and return them as a dictionary."""
+def init_epicsdev(prefix:str, pvDefs:list, verbose=0,
+                serverStateChanged=None, listDir=None):
+    """Check if no other server is running with the same prefix.
+    Create PVs and return them as a dictionary.
+    prefix is a string to be prepended to all PV names.
+    pvDefs is a list of PV definitions (see create_PVs()).
+    verbose is the verbosity level for debug messages.
+    serverStateChanged is a function to be called when the server PV changes.
+    The function should have the signature:
+        def serverStateChanged(newStatus:str):
+    If serverStateChanged is None, then a dummy function is used.
+    The listDir is a directory to save list of all generated PVs,
+    if no directory is given, then </tmp/pvlist/><prefix> is assumed.
+    """
+    if not isinstance(verbose, int) or verbose < 0:
+        printe('init_epicsdev arguments should be (prefix:str, pvDefs:list, verbose:int, listDir:str)')
+        sys.exit(1)
+    printi(f'Initializing epicsdev with prefix {prefix}')
     C_.prefix = prefix
     C_.verbose = verbose
-    try:
-        get_externalPV(prefix+'version')
-        print(f'Server for {prefix} already running. Exiting.')
+    if serverStateChanged is not None:# set custom serverStateChanged function
+        C_.serverStateChanged = serverStateChanged
+    try: # check if server is already running
+        host = repr(get_externalPV(prefix+'host')).replace("'",'')
+        print(f'ERROR: Server for {prefix} already running at {host}. Exiting.')
         sys.exit(1)
-    except TimeoutError:
-        pass
+    except TimeoutError:    pass
+
+    # No existing server found. Creating PVs.
     pvs = create_PVs(pvDefs)
+    # Save list of PVs to a file, if requested
+    if listDir != '':
+        listDir = '/tmp/pvlist/' if listDir is None else listDir
+        if not os.path.exists(listDir):
+            os.makedirs(listDir)
+        filepath = f'{listDir}{prefix[:-1]}.txt'
+        print(f'Writing list of PVs to {filepath}')
+        with open(filepath, 'w', encoding="utf-8") as f:
+            for _pvname in pvs:
+                f.write(_pvname + '\n')
     return pvs
 
 #``````````````````Demo````````````````````````````````````````````````````````
@@ -244,54 +325,57 @@ if __name__ == "__main__":
     def myPVDefs():
         """Example of PV definitions"""
         SET,U,LL,LH = 'setter','units','limitLow','limitHigh'
-        alarm = {'valueAlarm':{'lowAlarmLimit':0, 'highAlarmLimit':100}}
+        alarm = {'valueAlarm':{'lowAlarmLimit':-9., 'highAlarmLimit':9.}}
         return [    # device-specific PVs
-['noiseLevel',  'Noise amplitude',  SPV(1.E-6,'W'), {SET:set_noise}],
+['noiseLevel',  'Noise amplitude',  SPV(1.E-6,'W'), {SET:set_noise, U:'V'}],
 ['tAxis',       'Full scale of horizontal axis', SPV([0.]), {U:'S'}],
 ['recordLength','Max number of points',     SPV(100,'W','u32'),
     {LL:4,LH:1000000, SET:set_recordLength}],
 ['ch1Offset',   'Offset',  SPV(0.,'W'), {U:'du'}],
 ['ch1VoltsPerDiv',  'Vertical scale',       SPV(1E-3,'W'), {U:'V/du'}],
-['timePerDiv',  'Horizontal scale',         SPV(1.E-6,'W'), {U:'S/du'}],
-['ch1Waveform', 'Waveform array',           SPV([0.]), {}],
-['ch1Mean',     'Mean of the waveform',     SPV(0.,'A'), {}],
-['ch1Peak2Peak','Peak-to-peak amplitude',   SPV(0.,'A'), {}],
-['alarm',       'PV with alarm',            SPV(0,'WA'), alarm],
+['ch1Waveform', 'Waveform array',           SPV([0.]), {U:'du'}],
+['ch1Mean',     'Mean of the waveform',     SPV(0.,'A'), {U:'du'}],
+['ch1Peak2Peak','Peak-to-peak amplitude',   SPV(0.,'A'), {U:'du',**alarm}],
+['alarm',       'PV with alarm',            SPV(0,'WA'), {U:'du',**alarm}],
         ]
     nPatterns = 100 # number of waveform patterns.
     pargs = None
-    nDivs = 10 # number of divisions on the oscilloscope screen. That is needed to set tAxis when recordLength is changed.                          
     rng = np.random.default_rng(nPatterns)
+    nPoints = 100
 
-    def set_recordLength(value):
-        """Record length have changed. The tAxis should be updated accordingly."""
+    def set_recordLength(value, *_):
+        """Record length have changed. The tAxis should be updated
+        accordingly."""
         printi(f'Setting tAxis to {value}')
-        publish('tAxis', np.arange(value)*pvv('timePerDiv')/nDivs)
+        publish('tAxis', np.arange(value)*1.E-6)
         publish('recordLength', value)
-        set_noise(pvv('noiseLevel')) # Re-initialize noise array, because its size depends on recordLength
+        # Re-initialize noise array, because its size depends on recordLength
+        set_noise(pvv('noiseLevel'))
 
-    def set_noise(level):
+    def set_noise(level, *_):
         """Noise level have changed. Update noise array."""
-        printi(f'Setting noise level to {repr(level)}')
+        v = float(level)
         recordLength = pvv('recordLength')
-        pargs.noise = np.random.normal(scale=0.5*level, size=recordLength+nPatterns)
-        print(f'Noise array {len(pargs.noise)} updated with level {repr(level)}')
+        ts = timer()
+        pargs.noise = np.random.normal(scale=0.5*level,
+            size=recordLength+nPatterns)# 45ms/1e6 points
+        printi(f'Noise array[{len(pargs.noise)}] updated with level {v:.4g} V. in {timer()-ts:.4g} S.')
         publish('noiseLevel', level)
 
     def init(recordLength):
         """Testing function. Do not use in production code."""
         set_recordLength(recordLength)
-        set_noise(pvv('noiseLevel'))
+        #set_noise(pvv('noiseLevel')) # already called from set_recordLength
 
     def poll():
         """Example of polling function"""
         #pattern = C_.cycle % nPatterns# produces sliding
         pattern = rng.integers(0, nPatterns)
-        C_.cycle += 1
-        printv(f'cycle {C_.cycle}')
-        publish('cycle', C_.cycle)
+        cycle = pvv('cycle')
+        printv(f'cycle {repr(cycle)}')
+        publish('cycle', cycle + 1)
         wf = pargs.noise[pattern:pattern+pvv('recordLength')].copy()
-        wf *= pvv('ch1VoltsPerDiv')*nDivs
+        wf /= pvv('ch1VoltsPerDiv')
         wf += pvv('ch1Offset')
         publish('ch1Waveform', wf)
         publish('ch1Peak2Peak', np.ptp(wf))
@@ -301,24 +385,27 @@ if __name__ == "__main__":
     parser = argparse.ArgumentParser(description = __doc__,
     formatter_class=argparse.ArgumentDefaultsHelpFormatter,
     epilog=f'{__version__}')
-    parser.add_argument('-l', '--listPVs', action='store_true', help=
-'List all generated PVs')
-    parser.add_argument('-p', '--prefix', default='epicsDev0:', help=
-'Prefix to be prepended to all PVs')
-    parser.add_argument('-n', '--npoints', type=int, default=100, help=
+    parser.add_argument('-d', '--device', default='epicsDev', help=
+'Device name, the PV name will be <device><index>:')
+    parser.add_argument('-i', '--index', default='0', help=
+'Device index, the PV name will be <device><index>:') 
+    parser.add_argument('-l', '--list', default='', nargs='?', help=(
+'Directory to save list of all generated PVs, if no directory is given, '
+'then </tmp/pvlist/><prefix> is assumed.'))
+    # The rest of options are not essential, they can be controlled at runtime using PVs.
+    parser.add_argument('-n', '--npoints', type=int, default=nPoints, help=
 'Number of points in the waveform')
     parser.add_argument('-v', '--verbose', action='count', default=0, help=
-'Show more log messages (-vv: show even more)')
+'Show more log messages (-vv: show even more)') 
     pargs = parser.parse_args()
+    print(pargs)
 
     # Initialize epicsdev and PVs
-    PVs = init_epicsdev(pargs.prefix, myPVDefs(), pargs.verbose)
-    if pargs.listPVs:
-        print('List of PVs:')
-        for _pvname in PVs:
-            print(_pvname)
+    pargs.prefix = f'{pargs.device}{pargs.index}:'
+    PVs = init_epicsdev(pargs.prefix, myPVDefs(), pargs.verbose, None, pargs.list)
 
-    # Initialize the device, using pargs if needed. That can be used to set the number of points in the waveform, for example.
+    # Initialize the device using pargs if needed. That can be used to set 
+    # the number of points in the waveform, for example.
     init(pargs.npoints)
 
     # Start the Server. Use your set_server, if needed.
@@ -333,5 +420,5 @@ if __name__ == "__main__":
             break
         if not state.startswith('Stop'):
             poll()
-        time.sleep(pvv("polling"))
+        sleep(pvv("polling"))
     printi('Server is exited')

epicsdev/multiadc.py

@@ -0,0 +1,165 @@
+"""Simulated multi-channel ADC device server using epicsdev module."""
+# pylint: disable=invalid-name
+__version__= 'v0.0.2 26-01-23'# refactored, adjusted for epicdev 2.0.1
+
+import sys
+import time
+from time import perf_counter as timer
+import numpy as np
+import argparse
+
+from .epicsdev import  Server, Context, init_epicsdev, serverState, publish
+from .epicsdev import  pvv, printi, printv, SPV, set_server
+
+
+def myPVDefs():
+    """Example of PV definitions"""
+    SET,U,LL,LH = 'setter','units','limitLow','limitHigh'
+    alarm = {'valueAlarm':{'lowAlarmLimit':-9., 'highAlarmLimit':9.}}
+    pvDefs = [    # device-specific PVs
+['externalControl', 'Name of external PV, which controls the server',
+    SPV('Start Stop Clear Exit Started Stopped Exited'.split(), 'WD'), {}], 
+['noiseLevel',  'Noise amplitude',  SPV(1.E-4,'W'), {SET:set_noise, U:'V'}],
+['tAxis',       'Full scale of horizontal axis', SPV([0.]), {U:'S'}],
+['recordLength','Max number of points',     SPV(100,'W','u32'),
+    {LL:4,LH:1000000, SET:set_recordLength}],
+['alarm',       'PV with alarm',            SPV(0,'WA'), {U:'du',**alarm}],
+    ]
+
+    # Templates for channel-related PVs. Important: SPV cannot be used in this list!
+    ChannelTemplates = [
+['c0$VoltsPerDiv',  'Vertical scale',       (1E-3,'W'), {U:'V/du'}],
+#['c0$VoltOffset',  'Vertical offset',       (1E-3,), {U:'V/du'}],
+['c0$Waveform', 'Waveform array',           ([0.],), {U:'du'}],
+['c0$Mean',     'Mean of the waveform',     (0.,'A'), {U:'du'}],
+['c0$Peak2Peak','Peak-to-peak amplitude',   (0.,'A'), {U:'du',**alarm}],
+    ]
+    # extend PvDefs with channel-related PVs
+    for ch in range(pargs.channels):
+        for pvdef in ChannelTemplates:
+            newpvdef = pvdef.copy()
+            newpvdef[0] = pvdef[0].replace('0$',f'{ch+1:02}')
+            newpvdef[2] = SPV(*pvdef[2])
+            pvDefs.append(newpvdef)
+    return pvDefs
+
+#``````````````````Module constants
+nPatterns = 100 # number of waveform patterns.
+rng = np.random.default_rng(nPatterns)
+
+#``````````````````Setter functions for PVs```````````````````````````````````
+def set_recordLength(value):
+    """Record length have changed. The tAxis should be updated accordingly."""
+    printi(f'Setting tAxis to {value}')
+    publish('tAxis', np.arange(value)*1.E-6)
+    publish('recordLength', value)
+    # Re-initialize noise array, because its size depends on recordLength
+    set_noise(pvv('noiseLevel'))
+
+def set_noise(level):
+    """Noise level have changed. Update noise array."""
+    v = float(level)
+    recordLength = pvv('recordLength')
+    ts = timer()
+
+    pargs.noise = np.random.normal(scale=0.5*level, size=recordLength+nPatterns)# 45ms/1e6 points
+    printi(f'Noise array[{len(pargs.noise)}] updated with level {v:.4g} V. in {timer()-ts:.4g} S.')
+    publish('noiseLevel', level)
+
+def set_externalControl(value):
+    """External control PV have changed. Control the server accordingly."""
+    pvname = str(value)
+    if pvname in (None,'0'):
+        print('External control is not activated.')
+        return
+    printi(f'External control PV: {pvname}')
+    ctxt = Context('pva')
+    try:
+        r = ctxt.get(pvname, timeout=0.5)
+    except TimeoutError:
+        printi(f'Cannot connect to external control PV {pvname}.')
+        sys.exit(1)
+#,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+def serverStateChanged(newState:str):
+    """Start device function called when server is started"""
+    if newState == 'Start':
+        printi('start_device called')
+    elif newState == 'Stop':
+        printi('stop_device called')
+    elif newState == 'Clear':
+        printi('clear_device called')
+        publish('cycle', 0)
+
+def init(recordLength):
+    """Testing function. Do not use in production code."""
+    set_recordLength(recordLength)
+    #set_externalControl(pargs.prefix + pargs.external)
+
+def poll():
+    """Example of polling function"""
+    #pattern = C_.cycle % nPatterns# produces sliding
+    cycle = pvv('cycle')
+    printv(f'cycle {repr(cycle)}')
+    publish('cycle', cycle + 1)
+    for ch in range(pargs.channels):
+        pattern = rng.integers(0, nPatterns)
+        chstr = f'c{ch+1:02}'
+        wf = pargs.noise[pattern:pattern+pvv('recordLength')].copy()
+        #print(f'ch{ch}, {pattern}: {wf[0], wf.sum(), wf.mean(), np.mean(wf)}')
+        wf /= pvv(f'{chstr}VoltsPerDiv')
+        #wf += pvv(f'{chstr}Offset')
+        wf += ch
+        publish(f'{chstr}Waveform', list(wf))
+        publish(f'{chstr}Peak2Peak', np.ptp(wf))
+        publish(f'{chstr}Mean', np.mean(wf))
+
+# Argument parsing
+parser = argparse.ArgumentParser(description = __doc__,
+formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+epilog=f'{__version__}')
+parser.add_argument('-c', '--channels', type=int, default=6, help=
+'Number of channels per device')
+parser.add_argument('-e', '--external', help=
+'Name of external PV, which controls the server, if 0 then it will be <device>0:')
+parser.add_argument('-l', '--list', default=None, nargs='?', help=
+'Directory to save list of all generated PVs, if None, then </tmp/pvlist/><prefix> is assumed.')
+parser.add_argument('-d', '--device', default='multiadc', help=
+'Device name, the PV name will be <device><index>:')
+parser.add_argument('-i', '--index', default='0', help=
+'Device index, the PV name will be <device><index>:') 
+# The rest of arguments are not essential, they can be changed at runtime using PVs.
+parser.add_argument('-n', '--npoints', type=int, default=100, help=
+'Number of points in the waveform')
+parser.add_argument('-v', '--verbose', action='count', default=0, help=
+'Show more log messages (-vv: show even more)') 
+pargs = parser.parse_args()
+print(f'pargs: {pargs}')
+
+# Initialize epicsdev and PVs
+pargs.prefix = f'{pargs.device}{pargs.index}:'
+PVs = init_epicsdev(pargs.prefix, myPVDefs(), pargs.verbose,
+                    serverStateChanged, pargs.list)
+# if pargs.list != '':
+#     print('List of PVs:')
+#     for _pvname in PVs:
+#         print(_pvname)
+printi(f'Hosting {len(PVs)} PVs')
+
+# Initialize the device, using pargs if needed. 
+# That can be used to set the number of points in the waveform, for example.
+init(pargs.npoints)
+
+# Start the Server. Use your set_server, if needed.
+set_server('Start')
+
+#``````````````````Main loop``````````````````````````````````````````````````
+server = Server(providers=[PVs])
+printi(f'Server started with polling interval {repr(pvv("polling"))} S.')
+while True:
+    state = serverState()
+    if state.startswith('Exit'):
+        break
+    if not state.startswith('Stop'):
+        poll()
+    time.sleep(pvv("polling"))
+printi('Server is exited')

{epicsdev-1.0.1.dist-info → epicsdev-2.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: epicsdev
-Version: 1.0.1
+Version: 2.0.1
 Summary: Helper module for creating EPICS PVAccess servers using p4p
 Project-URL: Homepage, https://github.com/ASukhanov/epicsdev
 Project-URL: Bug Tracker, https://github.com/ASukhanov/epicsdev
@@ -19,7 +19,7 @@ Helper module for creating EPICS PVAccess servers.
 Demo:
 ```
 python pip install epicsdev
-python -m epicsdev.epicsdev -l
+python -m epicsdev.epicsdev
 ```
 
 To control and plot:
@@ -28,4 +28,18 @@ python pip install pypeto,pvplot
 python -m pypeto -c config -f epicsdev
 ```
 
+## Multi-channel waveform generator
+Module **epicdev.multiadc** can generate large amount of data for stress-testing
+the EPICS environment. For example the following command will generate 100 of 
+1000-pont noisy waveforms and 300 of scalar parameters.
+```
+python -m epicsdev.multiadc -c100 -n1000
+```
+The GUI for monitoring:<br>
+```python -m pypeto -c config -f multiadc```
+
+The graphs should look like this: 
+[control page](docs/epicsdev_pypet.png),
+[plots](docs/epicsdev_pvplot.jpg).
+
 

epicsdev-2.0.1.dist-info/RECORD

@@ -0,0 +1,7 @@
+epicsdev/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+epicsdev/epicsdev.py,sha256=2hNtiqiD491XwudLpwy8fg85UO7etzttIY3SZs_FMQ4,16969
+epicsdev/multiadc.py,sha256=r7vC9eG9CRRlW9WyJEy3h7A435WqrDn7KqpQXNUC6xA,6619
+epicsdev-2.0.1.dist-info/METADATA,sha256=2_tD2YFalnTHU5D_Y7JM9PZIOqxPIv8GIQ-R2IQKkFA,1270
+epicsdev-2.0.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+epicsdev-2.0.1.dist-info/licenses/LICENSE,sha256=qj3cUKUrX4oXTb0NwuJQ44ThYDEMUfOeIjw9kkT6Qck,1072
+epicsdev-2.0.1.dist-info/RECORD,,

epicsdev-1.0.1.dist-info/RECORD

@@ -1,6 +0,0 @@
-epicsdev/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-epicsdev/epicsdev.py,sha256=-mOvv9iGpUqtyX8IsO_dkcY8K52vVlJ_ZR1rMYI7CSY,13545
-epicsdev-1.0.1.dist-info/METADATA,sha256=n4Lz5H4NMJRCDAEFbyj0CHe7K0Cz2ERa5tFJW58F9hI,786
-epicsdev-1.0.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-epicsdev-1.0.1.dist-info/licenses/LICENSE,sha256=qj3cUKUrX4oXTb0NwuJQ44ThYDEMUfOeIjw9kkT6Qck,1072
-epicsdev-1.0.1.dist-info/RECORD,,