pymscada 0.0.6__py3-none-any.whl → 0.0.15__py3-none-any.whl

pymscada/history.py

@@ -19,7 +19,7 @@ def tag_for_history(tagname: str, tag: dict):
     tag['name'] = tagname
     tag['id'] = None
     if 'desc' not in tag:
-        tag['desc'] = tag.name
+        tag['desc'] = tag['name']
     if 'multi' in tag:
         tag['type'] = int
     else:
@@ -38,6 +38,18 @@ def tag_for_history(tagname: str, tag: dict):
         tag['deadband'] = None
 
 
+def get_tag_hist_files(path: Path, tagname: str) -> dict[int, Path]:
+    """Parse path for history files matching tagname."""
+    files_us = {}
+    for file in path.glob(f'{tagname}_*.dat'):
+        parts = file.stem.split('_')
+        parts_tag = '_'.join(parts[:-1])
+        if parts_tag != tagname or not parts[-1].isdigit():
+            continue
+        files_us[int(parts[-1])] = file
+    return files_us
+
+
 class TagHistory():
     """Efficiently store and serve history for a given tagname."""
 
@@ -87,109 +99,46 @@ class TagHistory():
         self.chunks: int = 0
         self.file: Path = None
 
-    def read(self, start_us: int = 0, end_us: int = -1):
+    def read_bytes(self, start_us: int = 0, end_us: int = -1):
         """Read in partial store on start-up, or read-in older data."""
-        resp_time = []
-        resp_values = []
-        files_us: dict[int, Path] = {}
-        for file in self.path.glob(f'{self.name}_*.dat'):
-            i = file.stem.rindex('_') + 1
-            files_us[int(file.stem[i:])] = file
-        times = [x for x in sorted(files_us.keys())]
-        while len(times) > 2:
-            if times[0] < start_us and times[1] < start_us:
-                times.pop(0)
+        resp: bytes = b''
+        # find the chunks that cover the time span requested
+        srcs = get_tag_hist_files(self.path, self.name)
+        if self.chunk_idx > 0:
+            time_us, _ = unpack_from(self.packstr, self.chunk)
+            srcs[time_us] = None
+        times_us = [x for x in sorted(srcs.keys())]
+        while len(times_us) > 1:
+            if times_us[1] <= start_us:
+                times_us.pop(0)
             else:
                 break
         if end_us != -1:
-            while times[-1] > end_us:
-                times.pop()
-        for time_us in times:
-            size = files_us[time_us].stat().st_size
-            if size % ITEM_SIZE != 0:
-                logging.warning(f'{files_us[time_us]} size is incorrect.')
-                size -= size % ITEM_SIZE
-            with open(files_us[time_us], 'rb') as fh:
-                dat = fh.read()
-                for i in range(0, size, ITEM_SIZE):
-                    vtime_us, value = unpack_from(self.packstr, dat, offset=i)
-                    if end_us != -1 and vtime_us >= end_us:
-                        break
-                    if vtime_us >= start_us:
-                        resp_time.append(vtime_us)
-                        resp_values.append(value)
-                if end_us != -1 and vtime_us >= end_us:
+            while len(times_us) > 1:
+                if times_us[-1] > end_us:
+                    times_us.pop()
+                else:
                     break
-        for i in range(0, self.chunk_idx, ITEM_SIZE):
-            vtime_us, value = unpack_from(self.packstr, self.chunk, offset=i)
-            if end_us != -1 and vtime_us >= end_us:
-                break
-            if vtime_us >= start_us:
-                resp_time.append(vtime_us)
-                resp_values.append(value)
-        return resp_time, resp_values
-
-    def read_bytes(self, start_us: int = 0, end_us: int = -1):
-        """Read in partial store on start-up, or read-in older data."""
-        resp: bytes = b''
-        files_us: dict[int, Path] = {}
-        for file in self.path.glob(f'{self.name}_*.dat'):
-            i = file.stem.rindex('_') + 1
-            files_us[int(file.stem[i:])] = file
-        times = [x for x in sorted(files_us.keys())]
-        while len(times) > 1:
-            if times[0] < start_us and times[1] < start_us:
-                times.pop(0)
-            elif end_us != -1 and times[-1] > end_us:
-                times.pop()
+        # collect the chunks into a single response
+        for time_us in times_us:
+            if srcs[time_us] is None:
+                dat = self.chunk
+                end = self.chunk_idx
             else:
-                break
-        idx = 0
-        dat = b''
-        for idx, time_us in enumerate(times):
-            start = 0
-            end = files_us[time_us].stat().st_size
-            if end % ITEM_SIZE != 0:
-                logging.warning(f'{files_us[time_us]} size is incorrect.')
-                end -= end % ITEM_SIZE
-            with open(files_us[time_us], 'rb') as fh:
-                dat = fh.read()
-                if idx == 0:  # find start
-                    for i in range(0, end, ITEM_SIZE):
-                        vtime_us, value = unpack_from(self.packstr, dat,
-                                                      offset=i)
-                        if vtime_us >= start_us:
-                            start = i
-                            break
-                if end_us != -1 and idx == len(times) - 1:  # find end
-                    for i in range(end - ITEM_SIZE, 0, -ITEM_SIZE):
-                        vtime_us, value = unpack_from(self.packstr, dat,
-                                                      offset=i)
-                        if vtime_us < end_us:
-                            end = i + ITEM_SIZE
-                            break
-                resp += dat[start:end]
-        add_chunk = False
-        if self.chunk_idx > 0:
-            vtime_us, value = unpack_from(self.packstr, self.chunk, offset=0)
-            if vtime_us < end_us:
-                add_chunk = True
-        if end_us == -1 or add_chunk:
-            start = 0
-            end = self.chunk_idx
-            if idx == 0:  # find start
-                for i in range(0, self.chunk_idx, ITEM_SIZE):
-                    vtime_us, value = unpack_from(self.packstr, dat, offset=i)
-                    if vtime_us >= start_us:
-                        start = i
-                        break
-            for i in range(self.chunk_idx - ITEM_SIZE, 0, -ITEM_SIZE):
-                vtime_us, value = unpack_from(self.packstr, self.chunk,
-                                              offset=i)
-                if vtime_us < end_us:
-                    end = i + ITEM_SIZE
+                with open(srcs[time_us], 'rb') as fh:
+                    dat = fh.read()
+                    end = len(dat)
+            for start in range(0, end, ITEM_SIZE):
+                first_us, _ = unpack_from(self.packstr, dat, offset=start)
+                if first_us >= start_us:
+                    break
+            for end in range(end - ITEM_SIZE, start - ITEM_SIZE, -ITEM_SIZE):
+                last_us, _ = unpack_from(self.packstr, dat,
+                                         offset=end)
+                if last_us < end_us or end_us == -1:
+                    end += ITEM_SIZE
                     break
-            resp += self.chunk[start:end]
+            resp += dat[start:end]
         return resp
 
     def flush(self):

pymscada/iodrivers/logix_client.py

@@ -0,0 +1,80 @@
+"""Read and write to Logix PLC processor."""
+import logging
+from pycomm3 import LogixDriver
+from pymscada.bus_client import BusClient
+from pymscada.periodic import Periodic
+from pymscada.iodrivers.logix_map import LogixMaps
+
+
+class LogixClientConnector:
+    """Poll Logix device, write on change in write range."""
+
+    def __init__(self, name: str, ip:str, rate: float, read: list,
+                 writeok: list, mapping: LogixMaps):
+        """Set up polling client."""
+        self.plc_name = name
+        self.ip = ip
+        self.read_tags = []
+        for r in read:
+            tag = r['addr']
+            if r['type'].endswith('[]'):
+                count = r['end'] - r['start'] + 1
+                tag = f"{r['addr']}[{r['start']}]{{{count}}}"
+            self.read_tags.append(tag)
+        self.mapping = mapping
+        self.mapping.add_write_callback(name, writeok,
+                                        self.write_tag_update)
+        self.periodic = Periodic(self.poll, rate)
+        self.plc = LogixDriver(ip)
+
+    def write_tag_update(self, addr: str, value):  # : int|float
+        """Write out any tag updates."""
+        if not self.plc.connected and not self.plc.open():
+            logging.warning(f'write failed {self.plc_name} {addr} to {value}')
+            return
+        logging.info(f'writing {addr} {value}')
+        res = self.plc.write((addr, value))
+        pass
+
+    async def poll(self):
+        """Poll data, reopen connection if dead."""
+        if not self.plc.connected and not self.plc.open():
+            return
+        polled_tags = None
+        polled_tags = self.plc.read(*self.read_tags)
+        self.mapping.polled_data(self.plc_name, polled_tags)
+
+    async def start(self):
+        """Start polling."""
+        await self.periodic.start()
+
+
+class LogixClient:
+
+    def __init__(self, bus_ip: str = '127.0.0.1', bus_port: int = 1324,
+                 rtus: dict = {}, tags: dict = {}) -> None:
+        """
+        Connect to bus on bus_ip:bus_port, connect to Logix PLCs.
+
+        Event loop must be running.
+        """
+        self.busclient = None
+        if bus_ip is not None:
+            self.busclient = BusClient(bus_ip, bus_port)
+        self.mapping = LogixMaps(tags)
+        self.connections: list[LogixClientConnector] = []
+        for rtu in rtus:
+            connection = LogixClientConnector(**rtu, mapping=self.mapping)
+            self.connections.append(connection)
+
+    async def _poll(self):
+        """For testing."""
+        for connection in self.connections:
+            await connection.poll()
+
+    async def start(self):
+        """Start bus connection and PLC polling."""
+        if self.busclient is not None:
+            await self.busclient.start()
+        for connection in self.connections:
+            await connection.start()

pymscada/iodrivers/logix_map.py

@@ -0,0 +1,147 @@
+"""Map between modbus table and Tag."""
+import logging
+from time import time
+from pymscada.tag import Tag
+
+
+# data types for PLCs
+DTYPES = {
+    'int32': [int, -2147483648, 2147483647],
+    'float32': [float, -3.40282346639e+38, 3.40282346639e+38],
+    'bool': [int, 0, 1]
+}
+
+
+def tag_split(plc_tag: str):
+    separator = plc_tag.find(':')
+    arr_start_loc = plc_tag.find('[')
+    arr_end_loc = plc_tag.find(']')
+    bit_loc = plc_tag.find('.')
+    plc = plc_tag[:separator]
+    if arr_start_loc == -1 and bit_loc == -1:
+        var = plc_tag[separator + 1:]
+        elm = None
+        bit = None
+    elif arr_start_loc == -1:
+        var = plc_tag[separator + 1:bit_loc]
+        elm = None
+        bit = int(plc_tag[bit_loc + 1:])
+    elif bit_loc == -1:
+        var = plc_tag[separator + 1:arr_start_loc]
+        elm = int(plc_tag[arr_start_loc + 1:arr_end_loc])
+        bit = None
+    else:
+        var = plc_tag[separator + 1:arr_start_loc]
+        elm = int(plc_tag[arr_start_loc + 1:arr_end_loc])
+        bit = int(plc_tag[bit_loc + 1:])
+    return plc, var, elm, bit
+
+
+class LogixMap:
+    """Do value updates for each tag."""
+
+    def __init__(self, tagname: str, src_type: str, read_tag: str,
+                 write_tag: str):
+        """Initialise modbus map and Tag."""
+        dtype, dmin, dmax = DTYPES[src_type][0:3]
+        self.tag = Tag(tagname, dtype)
+        self.map_bus = id(self)
+        self.read_plc, self.read_var, self.read_elm, self.read_bit = \
+            tag_split(read_tag)
+        self.plc_read_tag = read_tag
+        self.write_plc, self.write_var, self.write_elm, self.write_bit = \
+            tag_split(write_tag)
+        self.plc_write_tag = write_tag
+        self.callback = None
+        if dmin is not None:
+            self.tag.value_min = dmin
+        if dmax is not None:
+            self.tag.value_max = dmax
+
+    def set_callback(self, callback):
+        """Add tag callback interface."""
+        self.callback = callback
+        self.tag.add_callback(self.tag_value_changed, bus_id=self.map_bus)
+
+    def set_tag_value(self, value, time_us):
+        """Pass update from IO driver to tag value."""
+        if self.read_bit is not None:
+            if value & 1 << self.read_bit:
+                value = 1
+            else:
+                value = 0
+        if self.tag.value != value:
+            self.tag.value = value, time_us, self.map_bus
+
+    def tag_value_changed(self, tag: Tag):
+        """Pass update from tag value to IO driver."""
+        if self.write_elm is None and self.write_bit is None:
+            addr = self.write_var
+        elif self.write_elm is None:
+            addr = f'{self.write_var}.{self.write_bit}'
+        elif self.write_bit is None:
+            addr = f'{self.write_var}[{self.write_elm}]'
+        else:
+            addr = f'{self.write_var}[{self.write_elm}].{self.write_bit}'
+        self.callback(addr, tag.value)
+
+
+class LogixMaps:
+    """Link tags with protocol connector."""
+
+    def __init__(self, tags: dict):
+        """Collect maps based on a tag dictionary."""
+        # use the tagname to access the map.
+        self.tag_map: dict[str, LogixMap] = {}
+        # use the plc_name then variable name to access a list of maps.
+        self.read_var_map: dict[str, dict[str, list[LogixMap]]] = {}
+        for tagname, v in tags.items():
+            if 'addr' in v:
+                read_addr = v['addr']
+                write_addr = v['addr']
+            else:
+                read_addr = v['read']
+                write_addr = v['write']
+            map = LogixMap(tagname, v['type'], read_addr, write_addr)
+            if map.read_plc not in self.read_var_map:
+                self.read_var_map[map.read_plc] = {}
+            if map.read_var not in self.read_var_map[map.read_plc]:
+                # make a list so multiple bits can map to a word
+                self.read_var_map[map.read_plc][map.read_var] = []
+            self.read_var_map[map.read_plc][map.read_var].append(map)
+            self.tag_map[map.tag.name] = map
+
+    def add_write_callback(self, plcname, writeok, callback):
+        """Connection advises device links."""
+        # Create a set of all possible valid addresses
+        write_set = set()
+        for w in writeok:
+            if '[' in w['type']:
+                for i in range(w['start'], w['end'] + 1):
+                    write_set.add((w['addr'], i))
+            else:
+                write_set.add((w['addr'], None))
+        # where the mapped tag uses a valid address, add callback to
+        # the connection writer
+        for map in self.tag_map.values():
+            if map.write_plc == plcname and \
+                    (map.write_var, map.write_elm) in write_set:
+                map.set_callback(callback)
+
+    def polled_data(self, plcname, polls):
+        """Pass updates read from the PLC to the tags."""
+        time_us = int(time() * 1e6)
+        for poll in polls:
+            if poll.error is not None:
+                logging.error(poll.error)
+            arr_start_loc = poll.tag.find('[')
+            if arr_start_loc == -1:
+                for map in self.read_var_map[plcname][poll.tag]:
+                    map.set_tag_value(poll.value, time_us)
+            else:
+                var = poll.tag[:arr_start_loc]
+                elm = int(poll.tag[arr_start_loc + 1: -1])
+                for map in self.read_var_map[plcname][var]:
+                    elm_offset = map.read_elm - elm
+                    if elm_offset > 0 and elm_offset < len(poll.value):
+                        map.set_tag_value(poll.value[elm_offset], time_us)

pymscada/{modbus_client.py → iodrivers/modbus_client.py}

@@ -4,7 +4,7 @@ from itertools import chain
 import logging
 from struct import pack, unpack_from
 from pymscada.bus_client import BusClient
-from pymscada.modbus_map import ModbusMaps
+from pymscada.iodrivers.modbus_map import ModbusMaps
 from pymscada.periodic import Periodic
 
 
@@ -66,7 +66,7 @@ class ModbusClientProtocol(asyncio.Protocol):
             start = end
 
     def datagram_received(self, recv, _addr):
-        """Received a UDP packet, see if it is a full modbus packet."""
+        """Received a UDP packet, discard any partial packets."""
         # logging.info("datagram_received")
         start = 0
         buffer = recv
@@ -81,7 +81,7 @@ class ModbusClientProtocol(asyncio.Protocol):
                 break
             end = start + 6 + mbap_len
             # got a complete message, set start to end for buffer prune
-            self.process(self.buffer[start:end])
+            self.process(buffer[start:end])
             start = end
 
 

pymscada/{modbus_server.py → iodrivers/modbus_server.py}

@@ -3,7 +3,7 @@ import asyncio
 import logging
 from struct import pack, unpack_from
 from pymscada.bus_client import BusClient
-from pymscada.modbus_map import ModbusMaps
+from pymscada.iodrivers.modbus_map import ModbusMaps
 
 
 class ModbusServerProtocol:

pymscada/iodrivers/snmp_client.py

@@ -0,0 +1,75 @@
+import logging
+import pysnmp.hlapi.asyncio as snmp
+from pymscada.bus_client import BusClient
+from pymscada.periodic import Periodic
+from pymscada.iodrivers.snmp_map import SnmpMaps
+
+
+class SnmpClientConnector:
+    """Poll snmp devices, write and traps are not implemented."""
+
+    def __init__(self, name: str, ip:str, rate: float, read: list,
+                 community: str, mapping: SnmpMaps):
+        """Set up polling client."""
+        self.snmp_name = name
+        self.ip = ip
+        self.community = community
+        self.read_oids = [snmp.ObjectType(snmp.ObjectIdentity(x))
+                          for x in read]
+        self.mapping = mapping
+        self.periodic = Periodic(self.poll, rate)
+        self.snmp_engine = snmp.SnmpEngine()
+
+    async def poll(self):
+        """Poll data."""
+        r = await snmp.getCmd(
+            self.snmp_engine,
+            snmp.CommunityData(self.community),
+            snmp.UdpTransportTarget((self.ip, 161)),
+            snmp.ContextData(),
+            *self.read_oids
+        )
+        errorIndication, errorStatus, errorIndex, varBinds = r
+        if errorIndication:
+            logging.error(errorIndication)
+        elif errorStatus:
+            logging.error('%s at %s' % (
+                errorStatus.prettyPrint(),
+                errorIndex and varBinds[int(errorIndex) - 1][0] or '?'))
+        else:
+            self.mapping.polled_data(self.snmp_name, varBinds)
+
+    async def start(self):
+        """Start polling."""
+        await self.periodic.start()
+
+
+class SnmpClient:
+
+    def __init__(self, bus_ip: str = '127.0.0.1', bus_port: int = 1324,
+                 rtus: dict = {}, tags: dict = {}) -> None:
+        """
+        Connect to bus on bus_ip:bus_port, connect to snmp devices.
+
+        Event loop must be running.
+        """
+        self.busclient = None
+        if bus_ip is not None:
+            self.busclient = BusClient(bus_ip, bus_port)
+        self.mapping = SnmpMaps(tags)
+        self.connections: list[SnmpClientConnector] = []
+        for rtu in rtus:
+            connection = SnmpClientConnector(**rtu, mapping=self.mapping)
+            self.connections.append(connection)
+
+    async def _poll(self):
+        """For testing."""
+        for connection in self.connections:
+            await connection.poll()
+
+    async def start(self):
+        """Start bus connection and PLC polling."""
+        if self.busclient is not None:
+            await self.busclient.start()
+        for connection in self.connections:
+            await connection.start()

pymscada/iodrivers/snmp_client2.py

@@ -0,0 +1,53 @@
+import asyncio
+from pysnmp.hlapi.asyncio import *
+
+
+async def run():
+    base = [
+        '1.3.6.1.2.1.2.2.1.2.',  # name
+        # '.1.3.6.1.2.1.2.2.1.4.',  # mtu
+        # '.1.3.6.1.2.1.2.2.1.6.',  # mac address
+        # '.1.3.6.1.2.1.2.2.1.7.',  # admin status
+        # '.1.3.6.1.2.1.2.2.1.8.',  # oper status
+        '1.3.6.1.2.1.31.1.1.1.6.',  # bytes in
+        # '.1.3.6.1.2.1.31.1.1.1.7.',  # packets in
+        # '.1.3.6.1.2.1.2.2.1.13.',  # discards in
+        # '.1.3.6.1.2.1.2.2.1.14.',  # errors in
+        '1.3.6.1.2.1.31.1.1.1.10.',  # bytes out
+        # '.1.3.6.1.2.1.31.1.1.1.11.',  # packets out
+        # '.1.3.6.1.2.1.2.2.1.19.',  # discards out
+        # '.1.3.6.1.2.1.2.2.1.20.',  # errors out
+    ]
+    oids = []
+    for i in range(1, 9):
+        for b in base:
+            oids.append(ObjectType(ObjectIdentity(f'{b}{i}')))
+    ip_address = '172.26.3.254'
+    community = 'public'
+
+    snmp_engine = SnmpEngine()
+
+    r = await getCmd(
+        snmp_engine,
+        CommunityData(community),
+        UdpTransportTarget((ip_address, 161)),
+        ContextData(),
+        *oids
+    )
+    errorIndication, errorStatus, errorIndex, varBinds = r
+    if errorIndication:
+        print(errorIndication)
+    elif errorStatus:
+        print('%s at %s' % (
+            errorStatus.prettyPrint(),
+            errorIndex and varBinds[int(errorIndex) - 1][0] or '?'))
+    else:
+        for varBind in varBinds:
+            oid, value = varBind
+            print(str(oid), type(oid), str(value), type(value))
+    # snmp_engine.transportDispatcher.closeDispatcher()
+
+
+if __name__ == '__main__':
+    """Starts with creating an event loop."""
+    asyncio.run(run())

pymscada/iodrivers/snmp_map.py

@@ -0,0 +1,71 @@
+"""Map between snmp MIB and Tag."""
+import logging
+from time import time
+from pymscada.tag import Tag
+
+
+# data types for MIBs
+DTYPES = {
+    'int_roc': [int]
+}
+
+
+class SnmpMap:
+    """Do value updates for each tag."""
+
+    def __init__(self, tagname: str, src_type: str, plc_tag: str):
+        """initialise MIB map and Tag."""
+        dtype = DTYPES[src_type][0]
+        self.last_value = None
+        self.tag = Tag(tagname, dtype)
+        self.map_bus = id(self)
+        separator = plc_tag.find(':')
+        self.plc = plc_tag[:separator]
+        self.var = plc_tag[separator + 1:]
+
+    def set_tag_value(self, value, time_us):
+        """Pass update from IO driver to tag value."""
+        vtype = type(value).__name__
+        if vtype == 'Counter64':
+            v = int(value)
+            if self.last_value is None:
+                self.last_value = v
+                return
+            d = v - self.last_value
+            self.last_value = v
+            if d < 0:
+                d += 2**64
+            if self.tag.value != d:
+                self.tag.value = d, time_us, self.map_bus    
+        else:
+            logging.warning(
+                f'SnmpMap: {self.tag.name} {vtype} not implemented')
+
+
+class SnmpMaps:
+    """Link tags with protocol connector."""
+
+    def __init__(self, tags: dict):
+        """Collect maps based on a tag dictionary."""
+        # use the tagname to access the map.
+        self.tag_map: dict[str, SnmpMap] = {}
+        # use the plc_name then variable name to access a list of maps.
+        self.var_map: dict[str, dict[str, list[SnmpMap]]] = {}
+        for tagname, v in tags.items():
+            addr = v['addr']
+            map = SnmpMap(tagname, v['type'], addr)
+            if map.plc not in self.var_map:
+                self.var_map[map.plc] = {}
+            if map.var not in self.var_map[map.plc]:
+                # make a list so multiple bits can map to a word
+                self.var_map[map.plc][map.var] = []
+            self.var_map[map.plc][map.var].append(map)
+            self.tag_map[map.tag.name] = map
+
+    def polled_data(self, plcname, polls):
+        """Pass updates read from the PLC to the tags."""
+        time_us = int(time() * 1e6)
+        for poll in polls:
+            oid, value = poll
+            for map in self.var_map[plcname][str(oid)]:
+                map.set_tag_value(value, time_us)