epicsdev 0.0.0__tar.gz → 1.0.0__tar.gz

{epicsdev-0.0.0 → epicsdev-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: epicsdev
-Version: 0.0.0
+Version: 1.0.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
@@ -15,3 +15,17 @@ Description-Content-Type: text/markdown
 
 # 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
+```
+
+

epicsdev-1.0.0/README.md

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

epicsdev-1.0.0/config/epicsSimscope_pp.py

@@ -0,0 +1,112 @@
+"""Pypet page for simulated oscilloscopes epicsScope"""
+# format: pypeto 1.2+
+__version__ = 'v0.0.0 2026-01-15'# 
+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
+# 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 = '~sukhanov/venv/bin/python -m'
+PaneP2P = ' '.join([f'c{i:02d}Peak2Peak' for i in range(1)])
+PaneWF = ' '.join([f'c{i:02d}Waveform' for i in range(1)])
+#PaneT = 'timing[1] timing[3]'
+Plot = {'Plot':{'launch':f'{PyPath} pvplot -aV:simScope0: -#0"{PaneP2P}" -#1"{PaneWF}"',# -#2"{PaneT}"',
+            **lColor, **ButtonFont}}
+print(f'Plot command: {Plot}')
+#``````````````````PyPage Object``````````````````````````````````````````````
+class PyPage():
+    def __init__(self, instance='simScope0:',
+            title="Simulated oscilloscope", channels=1):
+        """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)}# Does not work
+        #self.page['editable'] = False
+
+        #``````````Definition of columns`````````````````````````````
+        self.columns = {
+            1: {'width': 120, 'justify': 'right'},
+            2: {'width': 80},
+            3: {'width': 80},
+            4: {'width': 80},
+            5: {'width': 80},
+            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:02d}{suffix}' for ch in range(channels)]
+        #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',],
+['Status:', {D+'status': span(8,1)}],
+['Polling Interval:', D+'polling',_,_,_,],
+#['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'),
+['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-1.0.0/config/epicsdev_pp.py

@@ -0,0 +1,113 @@
+"""Pypet page for epicdev.epicsdev module"""
+# format: pypeto 1.2+
+__version__ = 'v0.0.1 2026-01-16'# 
+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
+# 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)])
+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}}
+print(f'Plot command: {Plot}')
+#``````````````````PyPage Object``````````````````````````````````````````````
+class PyPage():
+    def __init__(self, instance='epicsDev0:',
+            title="Simulated oscilloscope", channels=1):
+        """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)}# Does not work
+        #self.page['editable'] = False
+
+        #``````````Definition of columns`````````````````````````````
+        self.columns = {
+            1: {'width': 120, 'justify': 'right'},
+            2: {'width': 80},
+            3: {'width': 80},
+            4: {'width': 80},
+            5: {'width': 80},
+            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}ch{ch+1:01d}{suffix}' for ch in range(channels)]
+        #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',],
+['Status:', {D+'status': span(8,1)}],
+['Polling Interval:', D+'polling',_,_,_,],
+#['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'),
+['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-1.0.0/epicsdev/epicsdev.py

@@ -0,0 +1,332 @@
+"""Skeleton and helper functions for creating EPICS PVAccess server"""
+# pylint: disable=invalid-name
+__version__= 'v1.0.0 26-01-16'# re-factored and simplified, comments added. Main() re-writtedn.
+#TODO: NTEnums do not have structure display
+
+import sys
+import time
+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
+
+#``````````````````Module Storage`````````````````````````````````````````````
+class C_():
+    """Storage for module members"""
+    prefix = ''
+    verbose = 0
+    cycle = 0
+    serverState = ''
+    PVs = {}
+    PVDefs = []
+#```````````````````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 C_.serverState
+def _printTime():
+    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}')
+def printw(msg):
+    """Print warning message and publish it to status PV."""
+    txt = f'WAR_@{_printTime()}: {msg}'
+    print(txt)
+    publish('status',txt)
+def printe(msg):
+    """Print error message and publish it to status PV."""
+    txt = f'ERR_{_printTime()}: {msg}'
+    print(txt)
+    publish('status',txt)
+def _printv(msg, level):
+    if C_.verbose >= level: 
+        print(f'DBG{level}: {msg}')
+def printv(msg):
+    """Print debug message if verbosity level >=1."""
+    _printv(msg, 1)
+def printvv(msg):
+    """Print debug message if verbosity level >=2."""
+    _printv(msg, 2)
+def printv3(msg):
+    """Print debug message if verbosity level >=3."""
+    _printv(msg, 3)
+
+def pvobj(pvName):
+    """Return PV with given name"""
+    return C_.PVs[C_.prefix+pvName]
+
+def pvv(pvName:str):
+    """Return PV value"""
+    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."""
+    try:
+        pv = pvobj(pvName)
+    except KeyError:
+        printw(f'PV {pvName} not found. Cannot publish value.')
+        return
+    if t is None:
+        t = time.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).
+    if vtype is None then the nominal type will be determined automatically.
+    """
+    typeCode = {
+    's8':'b', 'u8':'B', 's16':'h', 'u16':'H', 'i32':'i', 'u32':'I', 'i64':'l',
+    'u64':'L', 'f32':'f', 'f64':'d', str:'s',
+    }
+    iterable  = type(initial) not in (int,float,str)
+    if vtype is None:
+        firstItem = initial[0] if iterable else initial
+        itype = type(firstItem)
+        vtype = {int: 'i32', float: 'f32'}.get(itype,itype)
+    tcode = typeCode[vtype]
+    if 'E' in meta:
+        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)
+    pv = SharedPV(nt=nt, initial=initial)
+    pv.writable = 'W' in meta
+    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:
+        pname,desc,spv,extra = defs
+        ivalue = spv.current()
+        printv(f'created pv {pname}, initial: {type(ivalue),ivalue}, extra: {extra}')
+        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.
+                v['control.limitLow'] = 0
+                v['control.limitHigh'] = 0
+            except KeyError as e:
+                #print(f'control not set for {pname}: {e}')
+                pass
+        if 'ntenum' in str(type(ivalue)):
+            spv.post(ivalue, timestamp=ts)
+        else:
+            v['display.description'] = desc
+            for field in extra.keys():              
+                if field in ['limitLow','limitHigh','format','units']:
+                    v[f'display.{field}'] = extra[field]
+                    if field.startswith('limit'):
+                        v[f'control.{field}'] = extra[field]
+                if field == 'valueAlarm':
+                    for key,value in extra[field].items():
+                        v[f'valueAlarm.{key}'] = value
+            spv.post(v)
+
+        # add new attributes. To my surprise that works!
+        spv.name = pname
+        spv.setter = extra.get('setter')
+
+        if spv.writable:
+            @spv.put
+            def handle(spv, op):
+                ct = time.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.
+                try:
+                    limitLow = current['control.limitLow']
+                    limitHigh = current['control.limitHigh']
+                    if limitLow != limitHigh and not (limitLow <= vr <= limitHigh):
+                        printw(f'Value {vr} is out of limits [{limitLow}, {limitHigh}]. Ignoring.')
+                        op.done(error=f'Value out of limits [{limitLow}, {limitHigh}]')
+                        return
+                except KeyError:
+                    pass
+                if isinstance(vv, ntenum):
+                    vr = vv
+                if spv.setter:
+                    spv.setter(vr)
+                    # 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):
+    """Set verbosity level for debugging"""
+    C_.verbose = level
+    publish('verbosity',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':
+        printi('Starting the server')
+        # configure_instrument()
+        # adopt_local_setting()
+        publish('server','Started')
+        publish('status','Started')
+    elif state == 'Stop':
+        printi('server stopped')
+        publish('server','Stopped')
+        publish('status','Stopped')
+    elif state == 'Exit':
+        printi('server is exiting')
+        publish('server','Exited')
+        publish('status','Exited')
+    elif state == 'Clear':
+        publish('acqCount', 0)
+        publish('status','Cleared')
+        # set server to previous state
+        set_server(C_.serverState)
+    C_.serverState = state
+
+def create_PVs(pvDefs=None):
+    """Creates manadatory PVs and adds PVs specified in pvDefs list"""
+    U,LL,LH = 'units','limitLow','limitHigh'
+    C_.PVDefs = [
+['version', 'Program version',  SPV(__version__), {}],
+['status',  'Server status',    SPV('?','W'), {}],
+['server',  'Server control',   
+    SPV('Start Stop Clear Exit Started Stopped Exited'.split(), 'WE'),
+        {'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'), {}],
+    ]
+    # 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."""
+    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."""
+    C_.prefix = prefix
+    C_.verbose = verbose
+    try:
+        get_externalPV(prefix+'version')
+        print(f'Server for {prefix} already running. Exiting.')
+        sys.exit(1)
+    except TimeoutError:
+        pass
+    pvs = create_PVs(pvDefs)
+    return pvs
+
+#``````````````````Testing stuff``````````````````````````````````````````````
+if __name__ == "__main__":
+    import numpy as np
+    import argparse
+
+    def myPVDefs():
+        """Example of PV definitions"""
+        SET,U,LL,LH = 'setter','units','limitLow','limitHigh'
+        alarm = {'valueAlarm':{'lowAlarmLimit':0, 'highAlarmLimit':100}}
+        return [    # device-specific PVs
+['noiseLevel',  'Noise amplitude',  SPV(1.E-6,'W'), {SET:set_noise}],
+['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],
+        ]
+    nPatterns = 100 # number of patterns in the waveform.
+    pargs = None
+    nDivs = 10 # number of divisions on the oscilloscope screen. That is needed to set tAxis when recordLength is changed.                          
+
+    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('recordLength', value)
+
+    def set_noise(level):
+        """Noise level have changed. Update noise array."""
+        printi(f'Setting noise level to {level}')
+        pargs.noise = np.random.normal(scale=0.5*level, size=pargs.npoints+nPatterns)
+        #printv(f'Noise array updated with level {level}: {pargs.noise}')
+        publish('noiseLevel', level)
+    
+    def init(recordLength):
+        """Testing function. Do not use in production code."""
+        set_recordLength(recordLength)
+        set_noise(pvv('noiseLevel'))
+
+    def poll():
+        """Example of polling function"""
+        pattern = C_.cycle % nPatterns
+        C_.cycle += 1
+        printv(f'cycle {C_.cycle}')
+        publish('cycle', C_.cycle)
+        wf = pargs.noise[pattern:pattern+pvv('recordLength')].copy()
+        wf *= pvv('ch1VoltsPerDiv')*nDivs
+        wf += pvv('ch1Offset')
+        publish('ch1Waveform', wf)
+        publish('ch1Peak2Peak', np.ptp(wf))
+        publish('ch1Mean', np.mean(wf))
+
+    # Argument parsing
+    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=
+'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()
+
+    # 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)
+
+    # 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-0.0.0 → epicsdev-1.0.0}/pyproject.toml

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

epicsdev-0.0.0/README.md

@@ -1,2 +0,0 @@
-# epicsdev
-Helper module for creating EPICS PVAccess servers.

epicsdev-0.0.0/epicsdev/epicsdev.py

@@ -1,244 +0,0 @@
-"""Skeleton and helper functions for creating EPICS PVAccess server"""
-# pylint: disable=invalid-name
-__version__= 'v0.0.0 26-01-14'# Created
-#TODO: Do not start if another device is already running
-#TODO: NTEnums do not have structure display
-#TODO: Find a way to indicate that a PV is writable.
-# Options:
-# 1) add structure control with (0,0) limits as indication of Writable.
-# 2) use an extra field of the NTScalar.
-
-import argparse
-import time
-from p4p.nt import NTScalar, NTEnum
-from p4p.nt.enum import ntenum
-from p4p.server import Server
-from p4p.server.thread import SharedPV
-
-#``````````````````Module Storage`````````````````````````````````````````````
-class C_():
-    """Storage for module members"""
-    AppName = 'epicsDevLecroyScope'
-    cycle = 0
-    lastRareUpdate = 0.
-    server = None
-    serverState = ''
-    PVs = {}
-    PVDefs = []
-#```````````````````Helper methods````````````````````````````````````````````
-def printTime(): return time.strftime("%m%d:%H%M%S")
-def printi(msg): print(f'inf_@{printTime()}: {msg}')
-def printw(msg):
-    txt = f'WAR_@{printTime()}: {msg}'
-    print(txt)
-    #publish('status',txt)
-def printe(msg):
-    txt = f'ERR_{printTime()}: {msg}'
-    print(txt)
-    #publish('status',txt)
-def _printv(msg, level):
-    if pargs.verbose >= level: print(f'DBG{level}: {msg}')
-def printv(msg): _printv(msg, 1)
-def printvv(msg): _printv(msg, 2)
-def printv3(msg): _printv(msg, 3)
-
-def pvobj(pvname):
-    """Return PV with given name"""
-    return C_.PVs[pargs.prefix+pvname]
-
-def pvv(pvname:str):
-    """Return PV value"""
-    return pvobj(pvname).current()
-
-def publish(pvname:str, value, ifChanged=False, t=None):
-    """Post PV with new value"""
-    try:
-        pv = pvobj(pvname)
-    except KeyError:
-        return
-    if t is None:
-        t = time.time()
-    if not ifChanged or pv.current() != value:
-        pv.post(value, timestamp=t)
-
-def SPV(initial, vtype=None):
-    """Construct SharedPV, vtype should be one of typeCode keys,
-    if vtype is None then the nominal type will be determined automatically
-    """
-    typeCode = {
-    'F64':'d',  'F32':'f',  'I64':'l',  'I8':'b',   'U8':'B',   'I16':'h',
-    'U16':'H',  'I32':'i',  'U32':'I', str:'s', 'enum':'enum',
-    }
-    iterable  = type(initial) not in (int,float,str)
-    if vtype is None:
-        firstItem = initial[0] if iterable else initial
-        itype = type(firstItem)
-        vtype = {int: 'I32', float: 'F32'}.get(itype,itype)
-    tcode = typeCode[vtype]
-    if tcode == 'enum':
-        initial = {'choices': initial, 'index': 0}
-        nt = NTEnum(display=True)#TODO: that does not work
-    else:
-        prefix = 'a' if iterable else ''
-        nt = NTScalar(prefix+tcode, display=True, control=True, valueAlarm=True)
-    return SharedPV(nt=nt, initial=initial)
-
-#``````````````````Definition of PVs``````````````````````````````````````````
-def _define_PVs():
-    """Example of PV definitions"""
-    R,W,SET,U,ENUM,LL,LH = 'R','W','setter','units','enum','limitLow','limitHigh'
-    alarm = {'valueAlarm':{'lowAlarmLimit':0, 'highAlarmLimit':100}}
-    return [
-# device-specific PVs
-['VoltOffset',  'Offset',  SPV(0.), W, {U:'V'}],
-['VoltPerDiv',  'Vertical scale',   SPV(0.), W, {U:'V/du'}],
-['TimePerDiv',  'Horizontal scale', SPV('0.01 0.02 0.05 0.1 0.2 0.5 1 2 5'.split(),ENUM), W, {U:'S/du'}],
-['trigDelay',   'Trigger delay',    SPV(0.), W, {U:'S'}],
-['Waveform',    'Waveform array',   SPV([0.]), R, {}],
-['tAxis',       'Full scale of horizontal axis', SPV([0.]), R,  {}],
-['recordLength','Max number of points',     SPV(100,'U32'), W, {}],
-['peak2peak',   'Peak-to-peak amplitude',   SPV(0.), R,     {}],
-['alarm',       'PV with alarm',    SPV(0), 'WA', alarm],
-    ]
-
-#``````````````````create_PVs()```````````````````````````````````````````````
-def _create_PVs():
-    """Create PVs"""
-    ts = time.time()
-    for defs in C_.PVDefs:
-        pname,desc,spv,features,extra = defs
-        pv = spv
-        ivalue = pv.current()
-        printv(f'created pv {pname}, initial: {type(ivalue),ivalue}, extra: {extra}')
-        C_.PVs[pargs.prefix+pname] = pv
-        #if isinstance(ivalue,dict):# NTEnum
-        if 'ntenum' in str(type(ivalue)):
-            pv.post(ivalue, timestamp=ts)
-        else:
-            v = pv._wrap(ivalue, timestamp=ts)
-            v['display.description'] = desc
-            for field in extra.keys():
-                if field in ['limitLow','limitHigh','format','units']:
-                    v[f'display.{field}'] = extra[field]
-                    if field.startswith('limit'):
-                        v[f'control.{field}'] = extra[field]
-                if field == 'valueAlarm':
-                    for key,value in extra[field].items():
-                        v[f'valueAlarm.{key}'] = value
-            pv.post(v)
-
-        # add new attributes. To my surprise that works!
-        pv.name = pname
-        pv.setter = extra.get('setter')
-
-        writable = 'W' in features
-        if writable:
-            @pv.put
-            def handle(pv, op):
-                ct = time.time()
-                vv = op.value()
-                vr = vv.raw.value
-                if isinstance(vv, ntenum):
-                    vr = vv
-                if pv.setter:
-                    pv.setter(vr)
-                    # value could change by the setter
-                    vr = pvv(pv.name)
-                printv(f'putting {pv.name} = {vr}')
-                pv.post(vr, timestamp=ct) # update subscribers
-                op.done()
-        #print(f'PV {pv.name} created: {pv}')
-#,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
-#``````````````````Setters
-def set_verbosity(level):
-    """Set verbosity level for debugging"""
-    pargs.verbose = level
-    publish('verbosity',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':
-        printi('Starting the server')
-        #configure_scope()
-        #adopt_local_setting()
-        publish('server','Started')
-    elif state == 'Stop':
-        printi('server stopped')
-        publish('server','Stopped')
-    elif state == 'Exit':
-        printi('server is exiting')
-        publish('server','Exited')
-    elif state == 'Clear':
-        publish('acqCount', 0)
-        #publish('lostTrigs', 0)
-        #C_.triggersLost = 0
-        publish('status','Cleared')
-        # set server to previous state
-        set_server(C_.serverState)
-    C_.serverState = state
-
-def poll():
-    """Example of polling function"""
-    C_.cycle += 1
-    printv(f'cycle {C_.cycle}')
-    publish('cycle', C_.cycle)
-
-def create_PVs(pvDefs:list):
-    """Creates manadatory PVs and adds PVs, using definitions from pvDEfs list"""
-    U,LL,LH = 'units','limitLow','limitHigh'
-    C_.PVDefs = [
-['version', 'Program version',  SPV(__version__),    'R', {}],
-['status',  'Server status',    SPV('?'),   'W', {}],
-['server',  'Server control',   
-    SPV('Start Stop Clear Exit Started Stopped Exited'.split(), 'enum'), 
-    'W', {'setter':set_server}],
-['verbosity', 'Debugging verbosity', SPV(0,'U8'), 'W',
-    {'setter':set_verbosity}],
-['polling', 'Polling interval', SPV(1.0), 'W', {U:'S', LL:0.001, LH:10.1}],
-['cycle',   'Cycle number',         SPV(0,'U32'), 'R',  {}],
-    ]
-    # append application PVs, defined in define_PVs()
-    C_.PVDefs += pvDefs
-    _create_PVs()
-    return C_.PVs
-
-#``````````````````Example of the Main() function````````````````````````````
-if __name__ == "__main__":
-    # Argument parsing
-    parser = argparse.ArgumentParser(description = __doc__,
-    formatter_class=argparse.ArgumentDefaultsHelpFormatter,
-    epilog=f'{__version__}')
-    parser.add_argument('-c','--channels', type=int, default=4, help=
-        'Number of channels in the scope')
-    parser.add_argument('-p', '--prefix', default='epicsDev:', help=
-        'Prefix to be prepended to all PVs')
-    parser.add_argument('-l', '--listPVs', action='store_true', help=\
-    'List all generated PVs')
-    parser.add_argument('-v', '--verbose', action='count', default=0, help=\
-    'Show more log messages (-vv: show even more)')
-    pargs = parser.parse_args()
-
-    PVs = create_PVs(_define_PVs())# Provide your PV definitions instead of _define_PVs()
-
-    # List the PVs
-    if pargs.listPVs:
-        print(f'List of PVs:')
-        for pvname in PVs:
-            print(pvname)
-
-    # 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 not C_.serverState.startswith('Exit'):
-        time.sleep(pvv("polling"))
-        if not C_.serverState.startswith('Stop'):
-            poll()
-    printi('Server is exited')