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

epicsdev/epicsdev.py

@@ -1,12 +1,12 @@
 """Skeleton and helper functions for creating EPICS PVAccess server"""
 # pylint: disable=invalid-name
-__version__= 'v2.0.1 26-01-30'# added mandatory host PV
-#TODO add mandatory PV: host, to identify the server host.
+__version__= 'v2.1.1 26-02-05'# sleep() returns False if a periodic update occurred. Simplified waveform randomization.
 #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
-from time import time, sleep, strftime, perf_counter as timer
+import time
+from time import perf_counter as timer
 import os
 from socket import gethostname
 from p4p.nt import NTScalar, NTEnum
@@ -15,6 +15,8 @@ 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"""
@@ -28,6 +30,10 @@ class C_():
     PVs = {}
     PVDefs = [] 
     serverStateChanged = _serverStateChanged
+    lastCycleTime = timer()
+    lastUpdateTime = 0.
+    cycleTimeSum = 0.
+    cyclesAfterUpdate = 0
 
 #```````````````````Helper methods````````````````````````````````````````````
 def serverState():
@@ -35,7 +41,7 @@ def serverState():
     cached in C_ to avoid unnecessary get() calls."""
     return C_.serverState
 def _printTime():
-    return strftime("%m%d:%H%M%S")
+    return time.strftime("%m%d:%H%M%S")
 def printi(msg):
     """Print info message and publish it to status PV."""
     print(f'inf_@{_printTime()}: {msg}')
@@ -81,7 +87,7 @@ def publish(pvName:str, value, ifChanged=False, t=None):
         print(f'WARNING: PV {pvName} not found. Cannot publish value.')
         return
     if t is None:
-        t = time()
+        t = time.time()
     if not ifChanged or pv.current() != value:
         pv.post(value, timestamp=t)
 
@@ -127,7 +133,7 @@ def SPV(initial, meta='', vtype=None):
 
 #``````````````````create_PVs()```````````````````````````````````````````````
 def _create_PVs(pvDefs):
-    ts = time()
+    ts = time.time()
     for defs in pvDefs:
         try:
             pname,desc,spv,extra = defs
@@ -174,7 +180,7 @@ def _create_PVs(pvDefs):
         if spv.writable:
             @spv.put
             def handle(spv, op):
-                ct = time()
+                ct = time.time()
                 vv = op.value()
                 vr = vv.raw.value
                 current = spv._wrap(spv.current())
@@ -259,8 +265,12 @@ def create_PVs(pvDefs=None):
         {'setter':set_server}],
 ['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'), {}],
+['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
@@ -301,7 +311,8 @@ def init_epicsdev(prefix:str, pvDefs:list, verbose=0,
         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)
@@ -315,8 +326,33 @@ def init_epicsdev(prefix:str, pvDefs:list, verbose=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.
+    Returns False if a periodic update occurred.
+    """
+    time.sleep(pvv('sleep'))
+    tnow = timer()
+    C_.cycleTimeSum += tnow - C_.lastCycleTime
+    C_.lastCycleTime = tnow
+    C_.cyclesAfterUpdate += 1
+    C_.cycle += 1
+    printv(f'cycle {C_.cycle}')
+    sleeping = True
+    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
+        sleeping = False
+    return sleeping
+
 #``````````````````Demo````````````````````````````````````````````````````````
 if __name__ == "__main__":
     import numpy as np
@@ -327,20 +363,20 @@ if __name__ == "__main__":
         SET,U,LL,LH = 'setter','units','limitLow','limitHigh'
         alarm = {'valueAlarm':{'lowAlarmLimit':-9., 'highAlarmLimit':9.}}
         return [    # device-specific PVs
-['noiseLevel',  'Noise amplitude',  SPV(1.E-6,'W'), {SET:set_noise, U:'V'}],
+['noiseLevel',  'Noise amplitude',  SPV(1.,'W'), {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'}],
-['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}],
+['throughput', 'Performance metrics, points per second', SPV(0.), {U:'Mpts/s'}],
+['c01Offset',   'Offset',  SPV(0.,'W'), {U:'du'}],
+['c01VoltsPerDiv',  'Vertical scale',       SPV(0.1,'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.
     pargs = None
-    rng = np.random.default_rng(nPatterns)
+    rng = np.random.default_rng()
     nPoints = 100
 
     def set_recordLength(value, *_):
@@ -349,37 +385,23 @@ if __name__ == "__main__":
         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 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"""
-        #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))
+        """Example of polling function. Called every cycle when server is running."""
+        #ts = timer()
+        wf = rng.random(pvv('recordLength'))*pvv('noiseLevel')# it takes 5ms for 1M points
+        wf /= pvv('c01VoltsPerDiv')
+        wf += pvv('c01Offset')
+        #print(f'Waveform updated in {timer()-ts:.6g} S.')
+        publish('c01Waveform', wf)
+        publish('c01Peak2Peak', np.ptp(wf))
+        publish('c01Mean', np.mean(wf))
+        #print(f'Polling completed in {timer()-ts:.6g} S.')
 
     # Argument parsing
     parser = argparse.ArgumentParser(description = __doc__,
@@ -389,7 +411,7 @@ if __name__ == "__main__":
 '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=(
+    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.
@@ -413,12 +435,16 @@ 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()
-        sleep(pvv("polling"))
+        if not sleep():# Sleep and update performance metrics periodically
+            if not state.startswith('Stop'):
+                pointsPerSecond = len(pvv('c01Waveform'))/(pvv('cycleTime')-pvv('sleep'))/1.E6
+                publish('throughput', round(pointsPerSecond,6))
+                printv(f'periodic update. Performance: {pointsPerSecond:.3g} Mpts/s')
     printi('Server is exited')

epicsdev/multiadc.py

@@ -1,15 +1,14 @@
 """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
+__version__= 'v2.1.1 26-02-04'# added timing, throughput and c0$VoltOffset PVs
 
 import sys
-import time
 from time import perf_counter as timer
-import numpy as np
 import argparse
+import numpy as np
 
 from .epicsdev import  Server, Context, init_epicsdev, serverState, publish
-from .epicsdev import  pvv, printi, printv, SPV, set_server
+from .epicsdev import  pvv, printi, printv, SPV, set_server, sleep
 
 
 def myPVDefs():
@@ -17,19 +16,23 @@ def myPVDefs():
     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'}],
+['noiseLevel',  'Noise amplitude',  SPV(0.05,'W'), {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}],
+#``````````````````Auxiliary PVs
+['timing',  'Elapsed time for waveform generation, publishing, total]', SPV([0.]), {U:'S'}],
+['throughput', 'Total number of points processed per second', SPV(0.), {U:'Mpts/s'}],
     ]
 
     # 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$VoltsPerDiv',  'Vertical scale',       (0.1,'W'), {U:'V/du'}],
+['c0$VoltOffset',  'Vertical offset',       (0.,'W'), {U:'V'}],
 ['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}],
@@ -43,30 +46,20 @@ def myPVDefs():
             pvDefs.append(newpvdef)
     return pvDefs
 
-#``````````````````Module constants
-nPatterns = 100 # number of waveform patterns.
-rng = np.random.default_rng(nPatterns)
+#``````````````````Module attributes
+rng = np.random.default_rng()
+ElapsedTime = {'waveform': 0., 'publish': 0., 'poll': 0.}
+class C_():
+    cyclesSinceUpdate = 0
 
 #``````````````````Setter functions for PVs```````````````````````````````````
-def set_recordLength(value):
+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):
+def set_externalControl(value, *_):
     """External control PV have changed. Control the server accordingly."""
     pvname = str(value)
     if pvname in (None,'0'):
@@ -91,27 +84,45 @@ def serverStateChanged(newState:str):
         publish('cycle', 0)
 
 def init(recordLength):
-    """Testing function. Do not use in production code."""
+    """Device initialization function"""
     set_recordLength(recordLength)
+    # Set offset of each channel = channel index
+    for ch in range(pargs.channels):
+        publish(f'c{ch+1:02}VoltOffset', ch)
     #set_externalControl(pargs.prefix + pargs.external)
+    publish('sleep', pargs.sleep)
 
 def poll():
-    """Example of polling function"""
-    #pattern = C_.cycle % nPatterns# produces sliding
-    cycle = pvv('cycle')
-    printv(f'cycle {repr(cycle)}')
-    publish('cycle', cycle + 1)
+    """Device polling function, called every cycle when server is running"""
+    C_.cyclesSinceUpdate += 1
+    ts0 = timer()
     for ch in range(pargs.channels):
-        pattern = rng.integers(0, nPatterns)
+        ts1 = timer()
         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))
+        rwf = rng.random(pvv('recordLength'))*pvv('noiseLevel')
+        wf = rwf/pvv(f'{chstr}VoltsPerDiv') + pvv(f'{chstr}VoltOffset')# the time is comparable with rng.random
+        ts2 = timer()
+        ElapsedTime['waveform'] += ts2 - ts1
+        #print(f'ElapsedTime: {C_.cyclesSinceUpdate, ElapsedTime["waveform"]}')
+        publish(f'{chstr}Waveform', wf)
         publish(f'{chstr}Peak2Peak', np.ptp(wf))
         publish(f'{chstr}Mean', np.mean(wf))
+        ElapsedTime['publish'] += timer() - ts2
+    ElapsedTime['poll'] += timer() - ts0
+
+def periodic_update():
+    """Perform periodic update"""
+    #printi(f'periodic update for {C_.cyclesSinceUpdate} cycles: {ElapsedTime}')
+    times = [(round(i/C_.cyclesSinceUpdate,6)) for i in ElapsedTime.values()]
+    publish('timing', times)
+    C_.cyclesSinceUpdate = 0
+    for key in ElapsedTime:
+        ElapsedTime[key] = 0.
+    pointsPerSecond = len(pvv('tAxis'))/(pvv('cycleTime')-pvv('sleep'))/1.E6
+    pointsPerSecond *= pvv('channels')
+    publish('throughput', round(pointsPerSecond,6))
+    printv(f'periodic update. Performance: {pointsPerSecond:.3g} Mpts/s')
+
 
 # Argument parsing
 parser = argparse.ArgumentParser(description = __doc__,
@@ -130,6 +141,8 @@ parser.add_argument('-i', '--index', default='0', help=
 # 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('-s', '--sleep', type=float, default=1.0, help=
+'Sleep time per cycle')
 parser.add_argument('-v', '--verbose', action='count', default=0, help=
 'Show more log messages (-vv: show even more)') 
 pargs = parser.parse_args()
@@ -139,11 +152,6 @@ print(f'pargs: {pargs}')
 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.
@@ -154,12 +162,13 @@ set_server('Start')
 
 #``````````````````Main loop``````````````````````````````````````````````````
 server = Server(providers=[PVs])
-printi(f'Server started with polling interval {repr(pvv("polling"))} S.')
+printi(f'Server started. Sleeping per cycle: {float(pvv("sleep")):.3f} S.')
 while True:
     state = serverState()
     if state.startswith('Exit'):
         break
     if not state.startswith('Stop'):
         poll()
-    time.sleep(pvv("polling"))
-printi('Server is exited')
+    if not sleep():
+        periodic_update()
+printi('Server has exited')

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: epicsdev
-Version: 2.0.1
+Version: 2.1.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
@@ -30,10 +30,10 @@ 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.
+the EPICS environment. For example the following command will generate 10000 of 
+100-pont noisy waveforms and 40000 of scalar parameters per second.
 ```
-python -m epicsdev.multiadc -c100 -n1000
+python -m epicsdev.multiadc -s0.1 -c10000 -n100
 ```
 The GUI for monitoring:<br>
 ```python -m pypeto -c config -f multiadc```
@@ -42,4 +42,4 @@ The graphs should look like this:
 [control page](docs/epicsdev_pypet.png),
 [plots](docs/epicsdev_pvplot.jpg).
 
-
+Example of [Phoebus display](docs/phoebus_epicsdev.jpg), as defined in config/epicsdev.bob.

epicsdev-2.1.1.dist-info/RECORD

@@ -0,0 +1,7 @@
+epicsdev/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+epicsdev/epicsdev.py,sha256=dVPuuQ0xXF8ibw28DpvxQfkG_9k7WubNp_9rWXRvTVw,17970
+epicsdev/multiadc.py,sha256=2sg_VmIfylG5XHJzx5bgi_Bb9VPiX2TtyI-8JuAiBmQ,7219
+epicsdev-2.1.1.dist-info/METADATA,sha256=2tMnntNmRcksDUO0fAH9PCrmICCWS4ad7GRcGwnnAtc,1382
+epicsdev-2.1.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+epicsdev-2.1.1.dist-info/licenses/LICENSE,sha256=qj3cUKUrX4oXTb0NwuJQ44ThYDEMUfOeIjw9kkT6Qck,1072
+epicsdev-2.1.1.dist-info/RECORD,,

epicsdev-2.0.1.dist-info/RECORD

@@ -1,7 +0,0 @@
-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,,