Extended access to device from Python script

Author: serhmarch

README.md

@@ -115,7 +115,7 @@ Every device has its own set of scripts: `Init`, `Loop` and `Final`.
 Those scripts accessable through device menu or contex menu for device.
 
 `Init` script performs once at program start (when push `Start` button).
-It intended for making python `import` instruction, create objects, files etc.
+It intended for making python `import` instructions, create objects, files etc.
 Modules, objects and files created within will be accessable from `Loop` and `Final` scripts.
 
 `Loop` script performs cyclic until program not stopped.

src/server/python/mbServer.py

@@ -4,56 +4,127 @@
 More details.
 """
 
-import time
-from typing import Union
+#from typing import Union
 
 from PyQt5.QtCore import QSharedMemory
 
 from ctypes import *
 import struct
 
-class CControlBlock(Structure): 
-    _fields_ = [("flags"  , c_ulong),
-                ("count0x", c_ulong),
-                ("count1x", c_ulong),
-                ("count3x", c_ulong),
-                ("count4x", c_ulong),
-                ("cycle"  , c_ulong),
-                ("pycycle", c_ulong)]
+MB_DATAORDER_DEFAULT      = -1
+MB_DATAORDER_LITTLEENDIAN = 0
+MB_DATAORDER_BIGENDIAN    = 1
+
+MB_REGISTERORDER_DEFAULT  = -1
+MB_REGISTERORDER_R0R1R2R3 = 0
+MB_REGISTERORDER_R3R2R1R0 = 1
+MB_REGISTERORDER_R1R0R3R2 = 2
+MB_REGISTERORDER_R2R3R0R1 = 3
+
+class CDeviceBlock(Structure): 
+    _fields_ = [("flags"             , c_ulong),
+                ("cycle"             , c_ulong),
+                ("count0x"           , c_ulong),
+                ("count1x"           , c_ulong),
+                ("count3x"           , c_ulong),
+                ("count4x"           , c_ulong),
+                ("exceptionStatusRef", c_ulong),
+                ("byteOrder"         , c_long ),
+                ("registerOrder"     , c_long ),
+                ("stoDeviceName"     , c_ulong),
+                ("stringTableSize"   , c_ulong)]
+
+class CPythonBlock(Structure): 
+    _fields_ = [("pycycle"           , c_ulong)]
 
 class CMemoryBlockHeader(Structure): 
-    _fields_ = [("changeCounter"    , c_ulong),
-                ("changeByteOffset" , c_ulong),
-                ("changeByteCount"  , c_ulong),
-                ("dummy"            , c_ulong)]
-
-
-class _MemoryControlBlock:
-    def __init__(self, memid:str):
-        shm = QSharedMemory(memid)
+    _fields_ = [("changeCounter"     , c_ulong),
+                ("changeByteOffset"  , c_ulong),
+                ("changeByteCount"   , c_ulong),
+                ("dummy"             , c_ulong)]
+
+
+class _MbDevice:
+    def __init__(self, memidprefix:str):
+        memid_device = memidprefix + ".device"
+        memid_python = memidprefix + ".python"
+        memid_mem0x  = memidprefix + ".mem0x"
+        memid_mem1x  = memidprefix + ".mem1x"
+        memid_mem3x  = memidprefix + ".mem3x"
+        memid_mem4x  = memidprefix + ".mem4x"
+        shm = QSharedMemory(memid_device)
         res = shm.attach()
         if not res:
-            raise RuntimeError(f"Cannot attach to Shared Memory with id = '{memid}'")
+            raise RuntimeError(f"Cannot attach to Shared Memory with id = '{memid_device}'")
         qptr = shm.data()
         size = shm.size()
         memptr = c_void_p(qptr.__int__())
-        pcontrol = cast(memptr, POINTER(CControlBlock))
+        pcontrol = cast(memptr, POINTER(CDeviceBlock))
         self._shm = shm
         self._pcontrol = pcontrol
         self._control = pcontrol.contents
+        self._shm.lock()
+        self._count0x       = int(self._control.count0x)
+        self._count1x       = int(self._control.count1x)
+        self._count3x       = int(self._control.count3x)
+        self._count4x       = int(self._control.count4x)
+        self._excstatusref  = int(self._control.exceptionStatusRef)
+        self._byteorder     = int(self._control.byteOrder)
+        self._registerorder = int(self._control.registerOrder)
+        self._strtablesize  = int(self._control.stringTableSize)
+        stoDeviceName = int(self._control.stoDeviceName)
+        self._pmemstrtable = cast(byref(pcontrol[1]),POINTER(c_ubyte*1))
+        self._name = self._getstring(stoDeviceName)
+        self._shm.unlock()
+        # submodules
+        self._python = _MemoryPythonBlock(memid_python)
+        self._mem0x  = _MemoryBlockBits(memid_mem0x, self._count0x)
+        self._mem1x  = _MemoryBlockBits(memid_mem1x, self._count1x)
+        self._mem3x  = _MemoryBlockRegs(memid_mem3x, self._count3x)
+        self._mem4x  = _MemoryBlockRegs(memid_mem4x, self._count4x)
+        # Exception status
+        memtype = self._excstatusref // 10000
+        self._excoffset = (self._excstatusref % 10000) - 1
+        if   memtype == 0:
+            self._excmem = self._mem0x
+        elif memtype == 1:
+            self._excmem = self._mem1x
+        elif memtype == 3:
+            self._excmem = self._mem3x
+        elif memtype == 4:
+            self._excmem = self._mem4x
+        else:
+            self._excmem = self._mem0x
+            self._excoffset = 0
 
     def __del__(self):
         try:
             self._shm.detach()
         except RuntimeError:
             pass
 
+    def _getstring(self, offset:int)->str:
+        c = 0
+        while self._pmemstrtable[offset+c][0] != 0:
+            c += 1
+        bs = bytes(cast(self._pmemstrtable[offset], POINTER(c_ubyte*c))[0])
+        return bs.decode('utf-8')
+    
+    def getname(self)->str:
+        return self._name
+    
     def getflags(self):
         self._shm.lock()
         r = self._control.flags
         self._shm.unlock()
         return r
 
+    def getcycle(self):
+        self._shm.lock()
+        r = self._control.cycle
+        self._shm.unlock()
+        return r
+
     def getcount0x(self):
         self._shm.lock()
         r = self._control.count0x
@@ -78,21 +149,69 @@ def getcount4x(self):
         self._shm.unlock()
         return r
 
-    def getcycle(self):
-        self._shm.lock()
-        r = self._control.cycle
-        self._shm.unlock()
-        return r
+    def getexcstatus(self)->int:
+        return self._excmem.getuint8(self._excoffset)
+
+    def setexcstatus(self, value:int)->None:
+        self._excmem.setuint8(self._excoffset, value)
+    
+    def getbyteorder(self):
+        return self._byteorder
+    
+    def getregisterorder(self):
+        return self._registerorder
+    
+    def getpycycle(self):
+        return self._python.getpycycle()
+    
+    def _incpycycle(self):
+        return self._python.incpycycle()
+    
+    def getmem0x(self):
+        return self._mem0x
+    
+    def getmem1x(self):
+        return self._mem1x
+
+    def getmem3x(self):
+        return self._mem3x
+    
+    def getmem4x(self):
+        return self._mem4x
+    
+
+class _MemoryPythonBlock:
+    def __init__(self, memid:str):
+        shm = QSharedMemory(memid)
+        res = shm.attach()
+        if not res:
+            raise RuntimeError(f"Cannot attach to Shared Memory with id = '{memid}'")
+        qptr = shm.data()
+        self._memsize = shm.size()
+        memptr = c_void_p(qptr.__int__())
+        pcontrol = cast(memptr, POINTER(CPythonBlock))
+        self._shm = shm
+        self._pcontrol = pcontrol
+        self._control = pcontrol.contents
+        self._cyclecounter = 0
+
+    def __del__(self):
+        try:
+            self._shm.detach()
+        except RuntimeError:
+            pass
+    
 
     def getpycycle(self):
         self._shm.lock()
         r = self._control.pycycle
         self._shm.unlock()
         return r
 
-    def setpycycle(self, value):
+    def incpycycle(self):
+        self._cyclecounter += 1
         self._shm.lock()
-        self._control.pycycle = value
+        self._control.pycycle = self._cyclecounter
         self._shm.unlock()
 
 
@@ -115,7 +234,7 @@ def __init__(self, memid:str, bytecount:int):
         ptrhead = cast(memptr, POINTER(CMemoryBlockHeader))
         self._head = ptrhead[0]
         self._pmembytes = cast(byref(ptrhead[1]),POINTER(c_ubyte*1))
-        self._pmaskbytes  = cast(byref(cast(byref(ptrhead[1]),POINTER(c_byte*cbytes))[1]),POINTER(c_ubyte*1))
+        self._pmaskbytes = cast(byref(cast(byref(ptrhead[1]),POINTER(c_byte*cbytes))[1]),POINTER(c_ubyte*1))
 
     def __del__(self):
         try:
@@ -172,7 +291,7 @@ def getbytearray(self, byteoffset:int, count:int)->bytearray:
         """
         return self._getbytes(byteoffset, count, bytearray)
 
-    def setbytes(self, byteoffset:int, value:Union[bytes, bytearray])->None:
+    def setbytes(self, byteoffset:int, value:type[bytes|bytearray])->None:
         """
         @details 
         Function set `value` (`bytes` or `bytearray`) array object into device memory
@@ -245,7 +364,7 @@ def getbitbytes(self, bitoffset:int, bitcount:int)->bytes:
         """
         return bytes(self.getbitbytearray(bitoffset, bitcount))
 
-    def setbitbytes(self, bitoffset:int, bitcount:int, value:Union[bytes, bytearray])->None:
+    def setbitbytes(self, bitoffset:int, bitcount:int, value:type[bytes|bytearray])->None:
         """
         @details
         Function set `value` (`bytes` or `bytearray`) array object into device memory

src/server/resource/python/programhead.py

@@ -15,25 +15,11 @@
 
 print("PathList from args:"+str(_pathList))
 
-from mbserver import _MemoryControlBlock, _MemoryBlockBits, _MemoryBlockRegs
-
-_sId = _args.memid
-
-_sControl = _sId + ".control"
-_sMem0x   = _sId + ".mem0x"
-_sMem1x   = _sId + ".mem1x"
-_sMem3x   = _sId + ".mem3x"
-_sMem4x   = _sId + ".mem4x"
-
-print("ControlId: " , _sControl)
-print("Memory0xId: ", _sMem0x  )
-print("Memory1xId: ", _sMem1x  )
-print("Memory3xId: ", _sMem3x  )
-print("Memory4xId: ", _sMem4x  )
-
-_ctrl = _MemoryControlBlock(_sControl)
-mem0x = _MemoryBlockBits(_sMem0x, _ctrl.getcount0x())
-mem1x = _MemoryBlockBits(_sMem1x, _ctrl.getcount1x())
-mem3x = _MemoryBlockRegs(_sMem3x, _ctrl.getcount3x())
-mem4x = _MemoryBlockRegs(_sMem4x, _ctrl.getcount4x())
+from mbserver import _MbDevice
+
+mbdevice = _MbDevice(_args.memid)
+mem0x = mbdevice.getmem0x()
+mem1x = mbdevice.getmem1x()
+mem3x = mbdevice.getmem3x()
+mem4x = mbdevice.getmem4x()