epicsdev 1.0.2__py3-none-any.whl → 2.1.0__py3-none-any.whl

epicsdev/epicsdev.py

@@ -1,8 +1,7 @@
 """Skeleton and helper functions for creating EPICS PVAccess server"""
 # pylint: disable=invalid-name
-__version__= 'v1.0.2 26-01-18'# --list define directory to save list of PVs.
-#TODO: NTEnums do not have structure display
-#TODO: Add performance counters to demo.
+__version__= 'v2.1.0 26-01-31'# polling renamed to sleep. Sleep function added.
+#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.
 
@@ -10,13 +9,19 @@ import sys
 import time
 from time import 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
 from p4p.server.thread import SharedPV
 from p4p.client.thread import Context
 
+PeriodicUpdateInterval = 10. # seconds
+
 #``````````````````Module Storage`````````````````````````````````````````````
+def _serverStateChanged(newState:str):
+    """Dummy serverStateChanged function"""
+    return
 class C_():
     """Storage for module members"""
     prefix = ''
@@ -24,10 +29,17 @@ class C_():
     cycle = 0
     serverState = ''
     PVs = {}
-    PVDefs = []
+    PVDefs = [] 
+    serverStateChanged = _serverStateChanged
+    lastCycleTime = time.time()
+    lastUpdateTime = 0.
+    cycleTimeSum = 0.
+    cyclesAfterUpdate = 0
+
 #```````````````````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")
@@ -66,11 +78,14 @@ 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()
@@ -79,11 +94,15 @@ def publish(pvName:str, value, ifChanged=False, t=None):
 
 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',
     }
@@ -93,20 +112,28 @@ 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()
     for defs in pvDefs:
         try:
@@ -115,15 +142,22 @@ def _create_PVs(pvDefs):
             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)):
@@ -140,7 +174,7 @@ 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')
 
@@ -151,7 +185,8 @@ def _create_PVs(pvDefs):
                 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']
@@ -162,65 +197,84 @@ 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. Features: RWE',    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}],
-['polling', 'Polling interval', SPV(1.0,'W'), {U:'S', LL:0.001, LH:10.1}],
-['cycle',   'Cycle number',         SPV(0,'','u32'), {}],
+['verbose', 'Debugging verbosity', SPV(C_.verbose,'W','u8'),
+        {'setter':set_verbose, LL:0,LH:3}],
+['sleep', 'Pause in the main loop, it could be useful for throttling the data output',
+    SPV(1.0,'W'), {U:'S', LL:0.001, LH:10.1}],
+['cycle',   'Cycle number, published every {PeriodicUpdateInterval} S.',
+    SPV(0,'','u32'), {}],
+['cycleTime','Average cycle time including sleep, published every {PeriodicUpdateInterval} S',
+    SPV(0.), {U:'S'}],
     ]
-    # 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)
@@ -232,20 +286,36 @@ def get_externalPV(pvName:str, timeout=0.5):
     ctxt = Context('pva')
     return ctxt.get(pvName, timeout=timeout)
 
-def init_epicsdev(prefix:str, pvDefs:list, listDir:str, verbose:str=0):
+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'ERROR: 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
+
+    # No existing server found. Creating PVs.
     pvs = create_PVs(pvDefs)
     # Save list of PVs to a file, if requested
     if listDir != '':
@@ -257,11 +327,30 @@ def init_epicsdev(prefix:str, pvDefs:list, listDir:str, verbose:str=0):
         with open(filepath, 'w', encoding="utf-8") as f:
             for _pvname in pvs:
                 f.write(_pvname + '\n')
+    printi(f'Hosting {len(pvs)} PVs')
     return pvs
 
+def sleep():
+    """Sleep function to be called in the main loop. It updates cycleTime PV
+    and sleeps for the time specified in sleep PV."""
+    tnow = time.time()
+    C_.cycleTimeSum += tnow - C_.lastCycleTime
+    C_.lastCycleTime = tnow
+    C_.cyclesAfterUpdate += 1
+    C_.cycle += 1
+    printv(f'cycle {C_.cycle}')
+    if tnow - C_.lastUpdateTime > PeriodicUpdateInterval:
+        avgCycleTime = C_.cycleTimeSum / C_.cyclesAfterUpdate
+        printv(f'Average cycle time: {avgCycleTime:.6f} S.')
+        publish('cycle', C_.cycle)
+        publish('cycleTime', avgCycleTime)
+        C_.lastUpdateTime = tnow
+        C_.cycleTimeSum = 0.
+        C_.cyclesAfterUpdate = 0
+    time.sleep(pvv('sleep'))
+
 #``````````````````Demo````````````````````````````````````````````````````````
 if __name__ == "__main__":
-    print(f'epicsdev multiadc demo server {__version__}')
     import numpy as np
     import argparse
 
@@ -274,11 +363,11 @@ if __name__ == "__main__":
 ['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'}],
-['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}],
+['c01Offset',   'Offset',  SPV(0.,'W'), {U:'du'}],
+['c01VoltsPerDiv',  'Vertical scale',       SPV(1E-3,'W'), {U:'V/du'}],
+['c01Waveform', 'Waveform array',           SPV([0.]), {U:'du'}],
+['c01Mean',     'Mean of the waveform',     SPV(0.,'A'), {U:'du'}],
+['c01Peak2Peak','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.
@@ -286,49 +375,52 @@ if __name__ == "__main__":
     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)*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."""
         v = float(level)
         recordLength = pvv('recordLength')
         ts = timer()
-        pargs.noise = np.random.normal(scale=0.5*level, size=recordLength+nPatterns)# 45ms/1e6 points
+        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."""
+        """Example of device initialization function"""
         set_recordLength(recordLength)
         #set_noise(pvv('noiseLevel')) # already called from set_recordLength
 
     def poll():
-        """Example of polling function"""
+        """Example of polling function. Called every cycle when server is running."""
         #pattern = C_.cycle % nPatterns# produces sliding
         pattern = rng.integers(0, nPatterns)
-        cycle = pvv('cycle')
-        printv(f'cycle {repr(cycle)}')
-        publish('cycle', cycle + 1)
         wf = pargs.noise[pattern:pattern+pvv('recordLength')].copy()
-        wf /= pvv('ch1VoltsPerDiv')
-        wf += pvv('ch1Offset')
-        publish('ch1Waveform', wf)
-        publish('ch1Peak2Peak', np.ptp(wf))
-        publish('ch1Mean', np.mean(wf))
+        wf /= pvv('c01VoltsPerDiv')
+        wf += pvv('c01Offset')
+        publish('c01Waveform', wf)
+        publish('c01Peak2Peak', np.ptp(wf))
+        publish('c01Mean', np.mean(wf))
 
     # Argument parsing
     parser = argparse.ArgumentParser(description = __doc__,
     formatter_class=argparse.ArgumentDefaultsHelpFormatter,
     epilog=f'{__version__}')
-    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.')
-    parser.add_argument('-p', '--prefix', default='epicsDev0:', help=
-'Prefix to be prepended to all PVs')
+    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', 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')
@@ -338,9 +430,11 @@ if __name__ == "__main__":
     print(pargs)
 
     # Initialize epicsdev and PVs
-    PVs = init_epicsdev(pargs.prefix, myPVDefs(), pargs.list, pargs.verbose)
+    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.
@@ -348,12 +442,12 @@ if __name__ == "__main__":
 
     # Main loop
     server = Server(providers=[PVs])
-    printi(f'Server started with polling interval {repr(pvv("polling"))} S.')
+    printi(f'Server started. Sleeping per cycle: {repr(pvv("sleep"))} S.')
     while True:
         state = serverState()
         if state.startswith('Exit'):
             break
         if not state.startswith('Stop'):
             poll()
-        time.sleep(pvv("polling"))
+        sleep()
     printi('Server is exited')

epicsdev/multiadc.py

@@ -0,0 +1,161 @@
+"""Simulated multi-channel ADC device server using epicsdev module."""
+# pylint: disable=invalid-name
+__version__= 'v2.1.0 26-01-31'# updated for epicsdev v2.1.0
+
+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, sleep
+
+
+def myPVDefs():
+    """Example of PV definitions"""
+    SET,U,LL,LH = 'setter','units','limitLow','limitHigh'
+    alarm = {'valueAlarm':{'lowAlarmLimit':-9., 'highAlarmLimit':9.}}
+    pvDefs = [    # device-specific PVs
+['channels',    'Number of device channels',    SPV(pargs.channels), {}],
+['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):
+    """Device initialization function"""
+    set_recordLength(recordLength)
+    #set_externalControl(pargs.prefix + pargs.external)
+
+def poll():
+    """Device polling function, called every cycle when server is running"""
+    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)
+
+# 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. Sleeping per cycle: {repr(pvv("sleep"))} S.')
+while True:
+    state = serverState()
+    if state.startswith('Exit'):
+        break
+    if not state.startswith('Stop'):
+        poll()
+    sleep()
+printi('Server is exited')

{epicsdev-1.0.2.dist-info → epicsdev-2.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: epicsdev
-Version: 1.0.2
+Version: 2.1.0
 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.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+epicsdev/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+epicsdev/epicsdev.py,sha256=aOiVWY8sIrEGqxHJ9niyRtGl3z2Qg0ep5MFbnZskWxg,18017
+epicsdev/multiadc.py,sha256=ZVsA1wzl4GfOepC_zQdjisNKQFcpJuEMV6vt1y3zBnw,6520
+epicsdev-2.1.0.dist-info/METADATA,sha256=8bFFHdc7SnDooPlzHZsnzYAy9QnpqkYoZX7VGmVtfrE,1270
+epicsdev-2.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+epicsdev-2.1.0.dist-info/licenses/LICENSE,sha256=qj3cUKUrX4oXTb0NwuJQ44ThYDEMUfOeIjw9kkT6Qck,1072
+epicsdev-2.1.0.dist-info/RECORD,,

epicsdev-1.0.2.dist-info/RECORD

@@ -1,6 +0,0 @@
-epicsdev/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-epicsdev/epicsdev.py,sha256=Cr4yUBCcCJVQiREgiultFJlUqWIHWVlewtzI45hHyNs,14598
-epicsdev-1.0.2.dist-info/METADATA,sha256=LZvfLp-nbvHZso5JxY_w76cNcjh-1sZaHU8oGEoDcbE,786
-epicsdev-1.0.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-epicsdev-1.0.2.dist-info/licenses/LICENSE,sha256=qj3cUKUrX4oXTb0NwuJQ44ThYDEMUfOeIjw9kkT6Qck,1072
-epicsdev-1.0.2.dist-info/RECORD,,