epicsdev 1.0.1__tar.gz → 2.0.1__tar.gz

epicsdev-2.0.1/.github/copilot-instructions.md

@@ -0,0 +1,28 @@
+# Copilot instructions for epicsdev
+
+## Big picture
+- Core EPICS PVAccess helpers are in [epicsdev/epicsdev.py](epicsdev/epicsdev.py). It keeps global server state in `C_` (prefix, PV map, verbosity, server state) and exposes `SPV()`, `publish()`, `pvv()`, `serverState()`.
+- Server startup flow: `init_epicsdev(prefix, pvDefs, verbose=0, serverStateChanged=None, listDir=None)` builds PVs, then `Server(providers=[PVs])` runs a polling loop that checks `serverState()`; see [epicsdev/epicsdev.py](epicsdev/epicsdev.py) and [epicsdev/multiadc.py](epicsdev/multiadc.py).
+- `create_PVs()` adds mandatory PVs (`host`, `version`, `status`, `server`, `verbose`, `polling`, `cycle`) before app-specific PVs; see [epicsdev/epicsdev.py](epicsdev/epicsdev.py).
+- GUI pages for pypeto live in [config/epicsdev_pp.py](config/epicsdev_pp.py), [config/multiadc_pp.py](config/multiadc_pp.py), and [config/epicsSimscope_pp.py](config/epicsSimscope_pp.py); they assume the PV names/prefixes defined by the servers.
+
+## Project-specific patterns & conventions
+- PV definitions are `[name, description, SPV, extra]` and passed to `create_PVs()`; examples: `myPVDefs()` in [epicsdev/epicsdev.py](epicsdev/epicsdev.py) and [epicsdev/multiadc.py](epicsdev/multiadc.py).
+- `SPV(initial, meta, vtype)` uses compact `meta`: `W` (writable), `R` (readable), `A` (alarm), `D` (discrete enum). `D` creates an `NTEnum` with `{choices,index}`.
+- Writable PVs set `control.limitLow/High` to `0` as a PVA writability workaround (see `_create_PVs()` in [epicsdev/epicsdev.py](epicsdev/epicsdev.py)).
+- `extra` dict keys commonly used: `setter`, `units`, `limitLow`, `limitHigh`, `format`, `valueAlarm`. `setter` receives `(value, spv)`.
+- Use `publish()`/`pvv()` instead of direct `SharedPV` access; logging goes through `printi/printw/printe`, which also posts to `status`.
+- In multi-channel templates, don’t pre-create `SPV` objects; use tuples and convert per-channel (see `ChannelTemplates` in [epicsdev/multiadc.py](epicsdev/multiadc.py)).
+
+## External deps & integration points
+- Requires `p4p` (see [pyproject.toml](pyproject.toml)). Optional runtime tools: `pypeto`, `pvplot` for GUI/plotting (see [README.md](README.md)).
+
+## Common workflows (from README)
+- Install and run demo server:
+  - `python -m epicsdev.epicsdev`
+- Control/plot demo (requires `pypeto`, `pvplot`):
+  - `python -m pypeto -c config -f epicsdev`
+- Run multi-channel waveform generator:
+  - `python -m epicsdev.multiadc -c100 -n1000`
+- Launch multiadc GUI:
+  - `python -m pypeto -c config -f multiadc`

{epicsdev-1.0.1 → epicsdev-2.0.1}/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,30 @@
+# epicsdev
+Helper module for creating EPICS PVAccess servers.
+
+Demo:
+```
+python pip install epicsdev
+python -m epicsdev.epicsdev
+```
+
+To control and plot:
+```
+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-1.0.1 → epicsdev-2.0.1}/config/epicsdev_pp.py

@@ -16,18 +16,17 @@ def slider(minValue,maxValue):
 
 LargeFont = {'color':'light gray', **font(18), 'fgColor':'dark green'}
 ButtonFont = {'font':['Open Sans Extrabold',14]}# Comic Sans MS
-# Attributes for gray row, it should be in the first cell:
-#GrayRow = {'ATTRIBUTES':{'color':'light gray', **font(12)}}
 LYRow = {'ATTRIBUTES':{'color':'light yellow'}}
 lColor = color('lightGreen')
 
 # definition for plotting cell
 PyPath = 'python -m'
-PaneP2P = ' '.join([f'ch{i+1:01d}Mean' for i in range(1)])
+PaneP2P = ' '.join([f'ch{i+1:01d}Mean ch{i+1:01d}Peak2Peak' for i in range(1)])
 PaneWF = ' '.join([f'ch{i+1:01d}Waveform' for i in range(1)])
 #PaneT = 'timing[1] timing[3]'
-Plot = {'Plot':{'launch':f'{PyPath} pvplot -aV:epicsDev0: -#0"{PaneP2P}" -#1"{PaneWF}"',# -#2"{PaneT}"',
-            **lColor, **ButtonFont}}
+Plot = {'Plot':{'launch':
+  f'{PyPath} pvplot Y-5:5 -aV:epicsDev0: -#0"{PaneP2P}" -#1"{PaneWF}"',# -#2"{PaneT}"',
+  **lColor, **ButtonFont}}
 print(f'Plot command: {Plot}')
 #``````````````````PyPage Object``````````````````````````````````````````````
 class PyPage():
@@ -43,16 +42,16 @@ class PyPage():
         self.title = title
 
         #``````````Page attributes, optional`````````````````````````
-        self.page = {**color(240,240,240)}# Does not work
+        self.page = {**color(240,240,240)}
         #self.page['editable'] = False
 
         #``````````Definition of columns`````````````````````````````
         self.columns = {
             1: {'width': 120, 'justify': 'right'},
             2: {'width': 80},
-            3: {'width': 80},
+            3: {'width': 80, 'justify': 'right'},
             4: {'width': 80},
-            5: {'width': 80},
+            5: {'width': 80, 'justify': 'right'},
             6: {'width': 80},
             7: {'width': 80},
             8: {'width': 80},
@@ -74,42 +73,14 @@ string or device:parameter and the value is dictionary of the features.
         #FOption = ' -file '+logreqMap.get(D,'')
         #``````````mandatory member```````````````````````````````````````````
         self.rows = [
-['Device:', D, {D+'version':span(2,1)}],#_, 'scope time:', #{D+'dateTime':span(2,1)},_],
-['State:', D+'server','cycle:',D+'cycle',_,_,Plot], # 'Recall:', D+'setup',],
+['Device:', D, {D+'version':span(2,1)},_, 'host:', D+'host',_],
+['State:', D+'server', 'cycle:', D+'cycle',_,_, Plot], # 'Recall:', D+'setup',],
 ['Status:', {D+'status': span(8,1)}],
-['Polling Interval:', D+'polling','RecLength:',D+'recordLength',
-'V/Div:',D+'ch1VoltsPerDiv'],
-['Noise level:',D+'noiseLevel'],
-#['Triggers recorded:', D+'acqCount', 'Lost:', D+'lostTrigs',
-#  'Acquisitions:',D+'scopeAcqCount'], 
-# ['Horizontal scale:', D+'timePerDiv', '     samples:', D+'recLength',
-#     'SamplRate:', {D+'samplingRate':span(2,1)},_],
-# #['Trigger:', D+'trigSourceS', D+'trigCouplingS', D+'trigSlopeS', 'level:', D+'trigLevelS', 'delay:', {D+'trigDelay':span(2,1)},''],
-# ['Trigger state:',D+'trigState','   trigMode:',D+'trigMode',
-#   'TrigLevel','TrigDelay'],
-# [{D+'trigger':color('lightCyan')}, D+'trigSource', D+'trigCoupling',
-#   D+'trigSlope', D+'trigLevel', D+'trigDelay'],
-[{'ATTRIBUTES':color('lightGreen')}, 'Channels:','CH1','CH2','CH3','CH4','CH5','CH6'],
-# ['Gain:']+ChLine('VoltsPerDiv'),
-# ['Offset:']+ChLine('Position'),
-# ['Coupling:']+ChLine('Coupling'),
-# ['Termination:']+ChLine('Termination'),
-# ['On/Off:']+ChLine('OnOff'),
-#['Delay:']+ChLine('DelayFromTriggerM'),
-#['Waveform:']+ChLine('WaveforM'),
+['Polling Interval:', D+'polling', 'nPoints:', D+'recordLength',
+	'Noise:', D+'noiseLevel',_],
+[{'ATTRIBUTES':{**color('lightCyan'),**just(1)}},
+	'Channels:', 'CH1', 'CH2', 'CH3', 'CH4', 'CH5', 'CH6'],
+['V/div:']+ChLine('VoltsPerDiv'),
 ['Mean:']+ChLine('Mean'),
 ['Peak2Peak:']+ChLine('Peak2Peak'),
-#[''],
-# ["Trigger",D+'trigSourceS',D+'trigLevelS',D+'trigSlopeS',D+'trigModeS'],
-# ['',"Setup"],
-# ["Repair:",D+'updateDataA',D+'deviceClearA',D+'resetScopeA',D+'forceTrigA'],
-# ["Session",D+'SaveSession',D+'RecallSession',"folder:",D+'folderS'],
-# [D+'currentSessionS',"<-current",D+'nextSessionS',"out off",D+'sessionsM'],
-#[{'ATTRIBUTES':{'color':'yellow'}},
-#['tAxis:',D+'tAxis'],
-# [LYRow,'',{'For Experts only!':{**span(6,1),**font(14)}}],
-# [LYRow,'Scope command:', {D+'instrCmdS':span(2,1)},_,{D+'instrCmdR':span(4,1)}],
-# [LYRow,'Special commands', {D+'instrCtrl':span(2,1)},_,_,_,_,_,],
-# [LYRow,'Timing:',{D+'timing':span(6,1)}],
-# [LYRow,'ActOnEvent',D+'actOnEvent','AOE_Limit',D+'aOE_Limit',_,_,_],
         ]

epicsdev-2.0.1/config/multiadc_pp.py

@@ -0,0 +1,87 @@
+"""Pypet page for epicdev.multiadc module"""
+# format: pypeto 1.2+
+__version__ = 'v0.0.1 2026-01-23'#
+print(f'epicsScope {__version__}')
+
+#``````````````````Definitions````````````````````````````````````````````````
+# python expressions and functions, used in the spreadsheet
+_ = ''
+def span(x,y=1): return {'span':[x,y]}
+def color(*v): return {'color':v[0]} if len(v)==1 else {'color':list(v)}
+def font(size): return {'font':['Arial',size]}
+def just(i): return {'justify':{0:'left',1:'center',2:'right'}[i]}
+def slider(minValue,maxValue):
+    """Definition of the GUI element: horizontal slider with flexible range"""
+    return {'widget':'hslider','opLimits':[minValue,maxValue],'span':[2,1]}
+
+LargeFont = {'color':'light gray', **font(18), 'fgColor':'dark green'}
+ButtonFont = {'font':['Open Sans Extrabold',14]}# Comic Sans MS
+LYRow = {'ATTRIBUTES':{'color':'light yellow'}}
+lColor = color('lightGreen')
+
+# definition for plotting cell
+PyPath = 'python -m'
+PaneP2P = ' '.join([f'c{i+1:02d}Mean c{i+1:02d}Peak2Peak' for i in range(1)])
+PaneWF = ' '.join([f'c{i+1:02d}Waveform' for i in range(1)])
+#PaneT = 'timing[1] timing[3]'
+Plot = {'Plot':{'launch':
+  f'{PyPath} pvplot Y-5:5 -aV:multiadc0: -#0"{PaneP2P}" -#1"{PaneWF}"',# -#2"{PaneT}"',
+  **lColor, **ButtonFont}}
+print(f'Plot command: {Plot}')
+#``````````````````PyPage Object``````````````````````````````````````````````
+class PyPage():
+    def __init__(self, instance='multiadc0:',
+            title="Simulated oscilloscope", channels=6):
+        """instance: unique name of the page.
+        For EPICS it is usually device prefix 
+        """
+        print(f'Instantiating Page {instance,title} with {channels} channels')
+
+        #``````````Mandatory class members starts here````````````````````````
+        self.namespace = 'PVA'
+        self.title = title
+
+        #``````````Page attributes, optional`````````````````````````
+        self.page = {**color(240,240,240)}
+        #self.page['editable'] = False
+
+        #``````````Definition of columns`````````````````````````````
+        self.columns = {
+            1: {'width': 120, 'justify': 'right'},
+            2: {'width': 80},
+            3: {'width': 80, 'justify': 'right'},
+            4: {'width': 80},
+            5: {'width': 80, 'justify': 'right'},
+            6: {'width': 80},
+            7: {'width': 80},
+            8: {'width': 80},
+            9: {'width': 80},
+        }
+        """`````````````````Configuration of rows`````````````````````````````
+A row is a list of comma-separated cell definitions.
+The cell definition is one of the following: 
+  1)string, 2)device:parameters, 3)dictionary.
+The dictionary is used when the cell requires extra features like color, width,
+description etc. The dictionary is single-entry {key:value}, where the key is a 
+string or device:parameter and the value is dictionary of the features.
+        """
+        D = instance
+
+        #``````````Abbreviations, used in cell definitions
+        def ChLine(suffix):
+            return [f'{D}c{ch+1:02d}{suffix}' for ch in range(channels)]
+        #FOption = ' -file '+logreqMap.get(D,'')
+        #``````````mandatory member```````````````````````````````````````````
+        self.rows = [
+['Device:', D, {D+'version':span(2,1)},_, 'host:', D+'host',_],
+['State:', D+'server','cycle:', D+'cycle',_,_,Plot], # 'Recall:', D+'setup',],
+['Status:', {D+'status': span(8,1)}],
+['Polling Interval:', D+'polling', 'nPoints:', D+'recordLength',
+	'Noise:', D+'noiseLevel',_],
+[{'ATTRIBUTES':{**color('lightCyan'),**just(1)}},
+	'Channels:','CH1','CH2','CH3','CH4','CH5','CH6'],
+['V/div:']+ChLine('VoltsPerDiv'),
+['Mean:']+ChLine('Mean'),
+['Peak2Peak:']+ChLine('Peak2Peak'),
+#['Waveform:']+ChLine('Waveform'),
+        ]

{epicsdev-1.0.1 → epicsdev-2.0.1}/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-2.0.1/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-2.0.1/fallback/multiadc.py

@@ -0,0 +1,151 @@
+"""Simulated multi-channel ADC device server using epicsdev module."""
+# pylint: disable=invalid-name
+__version__= 'v0.0.1 26-01-18'# 
+
+import sys
+import time
+from copy import copy
+from time import perf_counter as timer
+from .epicsdev import  Server, Context, init_epicsdev, serverState, publish
+from .epicsdev import  pvv, printi, printv, SPV, set_server
+
+if True: # to enable code folding in some editors
+    import numpy as np
+    import argparse
+
+    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(), 'WE'), {}], 
+['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
+
+    nPatterns = 100 # number of waveform patterns.
+    rng = np.random.default_rng(nPatterns)
+
+    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
+
+    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 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.list, pargs.verbose)
+    # 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 → epicsdev-2.0.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "epicsdev"
-version = "1.0.1"
+version = "2.0.1"
 authors = [
   { name="Andrey Sukhanov", email="sukhanov@bnl.gov" },
 ]

epicsdev-1.0.1/README.md

@@ -1,16 +0,0 @@
-# epicsdev
-Helper module for creating EPICS PVAccess servers.
-
-Demo:
-```
-python pip install epicsdev
-python -m epicsdev.epicsdev -l
-```
-
-To control and plot:
-```
-python pip install pypeto,pvplot
-python -m pypeto -c config -f epicsdev
-```
-
-