pymscada 0.0.14__py3-none-any.whl → 0.1.0__py3-none-any.whl

pymscada/iodrivers/modbus_client.py

@@ -1,6 +1,5 @@
 """Modbus Client."""
 import asyncio
-from itertools import chain
 import logging
 from struct import pack, unpack_from
 from pymscada.bus_client import BusClient
@@ -43,53 +42,40 @@ class ModbusClientProtocol(asyncio.Protocol):
         transport.set_write_buffer_limits(high=0)
         self.transport = transport
 
-    def data_received(self, recv):
-        """Received TCP data, see if there is a full modbus packet."""
-        # logging.info("data_received")
-        # logging.info(f'tcp echo server received: {recv}')
+    def unpack_mb(self):
+        """Return complete modbus packets and trim the buffer."""
         start = 0
-        self.buffer += recv
         while True:
             buf_len = len(self.buffer)
-            if buf_len < 6 + start:  # assumes possible mbap_len of 0
-                self.buffer = self.buffer[start:]
+            if buf_len < 6 + start:  # enough to unpack length
                 break
-            (_mbap_tr, _mbap_pr, mbap_len) = unpack_from(
-                ">3H", self.buffer, start
-            )
-            if buf_len < 6 + mbap_len:
-                self.buffer = self.buffer[start:]
+            mbap_tr, mbap_pr, mbap_len = unpack_from(">3H", self.buffer, start)
+            if buf_len < start + 6 + mbap_len:  # there is a complete message
                 break
             end = start + 6 + mbap_len
-            # got a complete message, set start to end for buffer prune
-            self.process(self.buffer[start:end])
+            yield self.buffer[start:end]
             start = end
+        self.buffer = self.buffer[end:]
+
+    def data_received(self, recv):
+        """Received TCP data, see if there is a full modbus packet."""
+        self.buffer += recv
+        for msg in self.unpack_mb():
+            self.process(msg)
 
     def datagram_received(self, recv, _addr):
         """Received a UDP packet, discard any partial packets."""
         # logging.info("datagram_received")
-        start = 0
-        buffer = recv
-        while True:
-            buf_len = len(buffer)
-            if buf_len < 6 + start:  # assumes possible mbap_len of 0
-                buffer = buffer[start:]
-                break
-            (_mbap_tr, _mbap_pr, mbap_len) = unpack_from(">3H", buffer, start)
-            if buf_len < 6 + mbap_len:
-                buffer = buffer[start:]
-                break
-            end = start + 6 + mbap_len
-            # got a complete message, set start to end for buffer prune
-            self.process(buffer[start:end])
-            start = end
+        self.buffer = recv
+        for msg in self.unpack_mb():
+            self.process(msg)
 
 
 class ModbusClientConnector:
     """Poll Modbus device, write on change in write range."""
 
     def __init__(self, name: str, ip: str, port: int, rate: int, tcp_udp: str,
-                 read: list, writeok: list, mapping: ModbusMaps):
+                 poll: list, mapping: ModbusMaps):
         """
         Set up polling client.
 
@@ -101,13 +87,13 @@ class ModbusClientConnector:
         self.tcp_udp = tcp_udp
         self.transport = None
         self.protocol = None
-        self.read = read
-        self.writeok = writeok
+        self.read = poll
+        self.writeok = None
         self.periodic = Periodic(self.poll, rate)
         self.mapping = mapping
         self.sent = {}
         tables = {}
-        for file_range in chain(read, writeok):
+        for file_range in poll:  # chain(read, writeok):
             unit = file_range['unit']
             file = file_range['file']
             table = f'{name}:{unit}:{file}'

pymscada/iodrivers/modbus_map.py

@@ -139,7 +139,10 @@ class ModbusMaps():
         """Make the maps."""
         for tagname, v in self.tags.items():
             dtype = v['type']
-            addr = v['addr']
+            try:
+                addr = v['read']
+            except KeyError:
+                addr = v['addr']
             map = ModbusMap(tagname, dtype, addr, self.data, self.value_chg)
             size = DTYPES[dtype][3]
             name, unit, file, word = addr.split(':')

pymscada/iodrivers/modbus_server.py

@@ -37,80 +37,65 @@ class ModbusServerProtocol:
         transport.set_write_buffer_limits(high=0)
         self.transport = transport
 
-    def data_received(self, recv):
-        """Received."""
-        # logging.info(f'received: {recv}')
+    def unpack_mb(self):
+        """Return complete modbus packets and trim the buffer."""
         start = 0
-        self.buffer += recv
         while True:
             buf_len = len(self.buffer)
             if buf_len < 6 + start:  # enough to unpack length
-                self.buffer = self.buffer[start:]
                 break
-            (_mbap_tr, _mbap_pr, mbap_len) = unpack_from(
-                ">3H", self.buffer, start
-            )
-            if buf_len < 6 + mbap_len:  # there is a complete message
-                self.buffer = self.buffer[start:]
+            mbap_tr, mbap_pr, mbap_len = unpack_from(">3H", self.buffer, start)
+            if buf_len < start + 6 + mbap_len:  # there is a complete message
                 break
             end = start + 6 + mbap_len
-            self.msg = self.buffer[start:end]
+            yield self.buffer[start:end]
             start = end
-            self.process()
-            if self.msg is not None:
-                self.transport.write(self.msg)
-            self.msg = b""
+        self.buffer = self.buffer[end:]
+
+    def data_received(self, recv):
+        """Received."""
+        # logging.info(f'received: {recv}')
+        self.buffer += recv
+        for msg in self.unpack_mb():
+            reply = self.process(msg)
+            self.transport.write(reply)
 
     def datagram_received(self, recv, addr):
         """Received."""
-        start = 0
-        buffer = recv
-        while True:
-            buf_len = len(buffer)
-            if buf_len < 6 + start:  # enough to unpack length
-                buffer = buffer[start:]
-                break
-            (_mbap_tr, _mbap_pr, mbap_len) = unpack_from(">3H", buffer, start)
-            if buf_len < 6 + mbap_len:  # there is a complete message
-                buffer = buffer[start:]
-                break
-            end = start + 6 + mbap_len
-            self.msg = buffer[start:end]
-            start = end
-            self.process()
-            if self.msg is not None:
-                self.transport.sendto(self.msg, addr)
-            self.msg = b""
+        self.buffer = recv
+        for msg in self.unpack_mb():
+            reply = self.process(msg)
+            self.transport.sendto(reply, addr)
 
-    def process(self):
+    def process(self, msg):
         """Process."""
         mbap_tr, mbap_pr, _mbap_len, mbap_unit, pdu_fc = unpack_from(
-            ">3H2B", self.msg, 0)
+            ">3H2B", msg, 0)
         if pdu_fc == 3:  # Read Holding Registers
             # Return 0 for missing addresses
-            pdu_start, pdu_count = unpack_from(">2H", self.msg, 8)
+            pdu_start, pdu_count = unpack_from(">2H", msg, 8)
             data = self.mapping.get_data(self.name, mbap_unit, '4x', pdu_start,
                                          pdu_count)
             data_len = len(data)
             msg_len = 3 + data_len
-            self.msg = pack('>3H3B', mbap_tr, mbap_pr, msg_len, mbap_unit,
-                            pdu_fc, data_len) + data
+            reply = pack('>3H3B', mbap_tr, mbap_pr, msg_len, mbap_unit,
+                         pdu_fc, data_len) + data
         elif pdu_fc == 6:  # Set Single Register    4x
-            pdu_start = unpack_from(">H", self.msg, 8)[0]
-            data = bytearray(self.msg[10:12])
+            pdu_start = unpack_from(">H", msg, 8)[0]
+            data = bytearray(msg[10:12])
             self.mapping.set_data(self.name, mbap_unit, '4x', pdu_start,
                                   1, data)
             msg_len = 6
-            self.msg = pack(">3H2BH", mbap_tr, mbap_pr, msg_len, mbap_unit,
-                            pdu_fc, pdu_start) + data
+            reply = pack(">3H2BH", mbap_tr, mbap_pr, msg_len, mbap_unit,
+                         pdu_fc, pdu_start) + data
         elif pdu_fc == 16:  # Set Multiple Registers 4x
-            pdu_start, pdu_count, pdu_bytes = unpack_from(">2HB", self.msg, 8)
-            data = bytearray(self.msg[13:13 + pdu_bytes])
+            pdu_start, pdu_count, pdu_bytes = unpack_from(">2HB", msg, 8)
+            data = bytearray(msg[13:13 + pdu_bytes])
             self.mapping.set_data(self.name, mbap_unit, '4x', pdu_start,
                                   pdu_count, data)
             msg_len = 6
-            self.msg = pack(">3H2B2H", mbap_tr, mbap_pr, msg_len, mbap_unit,
-                            pdu_fc, pdu_start, pdu_count)
+            reply = pack(">3H2B2H", mbap_tr, mbap_pr, msg_len, mbap_unit,
+                         pdu_fc, pdu_start, pdu_count)
         else:
             # Unsupported, send the standard Modbus exception
             logging.warn(
@@ -118,8 +103,9 @@ class ModbusServerProtocol:
                 f" attempted FC {pdu_fc}"
             )
             msg_len = 3
-            self.msg = pack(">3H2BB", mbap_tr, mbap_pr, msg_len, mbap_unit,
-                            pdu_fc + 128, 1)
+            reply = pack(">3H2BB", mbap_tr, mbap_pr, msg_len, mbap_unit,
+                         pdu_fc + 128, 1)
+        return reply
 
 
 class ModbusServerConnector:

pymscada/iodrivers/ping_client.py

@@ -0,0 +1,120 @@
+"""Network monitoring / scanning."""
+import asyncio
+import logging
+import socket
+import struct
+import time
+from pymscada.bus_client import BusClient
+from pymscada.periodic import Periodic
+from pymscada.iodrivers.ping_map import PingMaps
+
+
+ICMP_REQUEST = 8
+ICMP_REPLY = 0
+RATE = 60
+
+
+def checksum_chat(data):
+    """Calculate ICMP Checksum."""
+    if len(data) & 1:  # If the packet length is odd
+        data += b'\0'
+    res = 0
+    # Process two bytes at a time
+    for i in range(0, len(data), 2):
+        res += (data[i] << 8) + data[i + 1]
+    res = (res >> 16) + (res & 0xffff)
+    res += res >> 16
+    return (~res) & 0xffff  # Return ones' complement of the result
+
+
+class PingClientConnector:
+    """Ping a list of addresses."""
+
+    def __init__(self, mapping: PingMaps):
+        """Accept list of addresses, ip or name."""
+        self.mapping = mapping
+        self.dns = {}
+        self.addr_info = {}
+        self.socket = None
+        self.ping_id = 0
+        self.ping_dict = {}
+
+    async def poll(self):
+        """Do pings."""
+        self.reply_dict = {}
+        if self.socket is None:
+            self.socket = socket.socket(socket.AF_INET, socket.SOCK_RAW,
+                                        socket.IPPROTO_ICMP)
+            asyncio.get_event_loop().add_reader(self.socket,
+                                                self.read_response)
+        for ping_id, address in list(self.ping_dict.items()):
+            logging.info(f'failed {self.dns[address]} {ping_id}')
+            self.mapping.polled_data(self.dns[address], float('NAN'))
+            del self.ping_dict[ping_id]
+        self.send_ping()
+
+    def send_ping(self):
+        """Build and send ping messages."""
+        for address in self.dns.keys():
+            self.ping_id = (self.ping_id + 1) & 0xffff
+            self.ping_dict[self.ping_id] = address
+            logging.info(f'ping {address} id {self.ping_id}')
+            header = struct.pack("!BbHHh", ICMP_REQUEST, 0, 0, self.ping_id, 1)
+            data = struct.pack("!d", time.perf_counter()) + (60 * b'\0')
+            checksum = checksum_chat(header + data)
+            packet = struct.pack("!BbHHh", ICMP_REQUEST, 0, checksum,
+                                 self.ping_id, 1) + data
+            self.socket.sendto(packet, (address, 0))
+
+    def read_response(self):
+        """Match ping response."""
+        data, address = self.socket.recvfrom(1024)
+        msgtype, _, _, ping_id, _ = struct.unpack('!BBHHH', data[20:28])
+        if msgtype != ICMP_REPLY:
+            return
+        if ping_id in self.ping_dict:
+            latency = 1000 * (time.perf_counter() -
+                              struct.unpack('!d', data[28:36])[0])
+            name = self.dns[address[0]]
+            logging.info(f'success {name} {ping_id} {latency}ms')
+            self.mapping.polled_data(name, latency)
+            del self.ping_dict[ping_id]
+
+    async def start(self):
+        """Start pinging."""
+        loop = asyncio.get_event_loop()
+        for address in self.mapping.var_map.keys():
+            info = await loop.getaddrinfo(address, None, family=socket.AF_INET,
+                                          type=socket.SOCK_STREAM)
+            ip = info[0][4][0]
+            self.dns[ip] = address
+        self.periodic = Periodic(self.poll, RATE)
+        await self.periodic.start()
+
+
+class PingClient:
+    """Ping client."""
+
+    def __init__(self, bus_ip: str = '127.0.0.1', bus_port: int = 1324,
+                 tags: dict = {}) -> None:
+        """
+        Connect to bus on bus_ip:bus_port, ping a list.
+
+        Event loop must be running.
+        """
+        self.busclient = None
+        if bus_ip is not None:
+            self.busclient = BusClient(bus_ip, bus_port)
+        self.mapping = PingMaps(tags)
+        self.pinger = PingClientConnector(mapping=self.mapping)
+
+    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()
+        await self.pinger.start()

pymscada/iodrivers/ping_map.py

@@ -0,0 +1,43 @@
+"""Map between snmp MIB and Tag."""
+from time import time
+from pymscada.tag import Tag
+
+
+class PingMap:
+    """Do value updates for each tag."""
+
+    def __init__(self, tagname: str, addr: str):
+        """Initialise MIB map and Tag."""
+        self.last_value = None
+        self.tag = Tag(tagname, float)
+        self.addr = addr
+        self.map_bus = id(self)
+
+    def set_tag_value(self, value, time_us):
+        """Pass update from IO driver to tag value."""
+        if self.last_value is None:
+            self.last_value = value
+            return
+        if self.last_value != value:
+            self.tag.value = value, time_us, self.map_bus
+
+
+class PingMaps:
+    """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, PingMap] = {}
+        # use the plc_name then variable name to access a list of maps.
+        self.var_map: dict[str, PingMap] = {}
+        for tagname, v in tags.items():
+            addr = v['addr']
+            map = PingMap(tagname, addr)
+            self.var_map[addr] = map
+            self.tag_map[tagname] = map
+
+    def polled_data(self, address, latency):
+        """Pass updates read from the PLC to the tags."""
+        time_us = int(time() * 1e6)
+        self.var_map[address].set_tag_value(latency, time_us)

pymscada/iodrivers/snmp_client.py

@@ -1,3 +1,4 @@
+"""Poll SNMP OIDs from devices."""
 import logging
 import pysnmp.hlapi.asyncio as snmp
 from pymscada.bus_client import BusClient
@@ -8,14 +9,14 @@ 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,
+    def __init__(self, name: str, ip: str, rate: float, poll: 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]
+                          for x in poll]
         self.mapping = mapping
         self.periodic = Periodic(self.poll, rate)
         self.snmp_engine = snmp.SnmpEngine()
@@ -45,6 +46,7 @@ class SnmpClientConnector:
 
 
 class SnmpClient:
+    """SNMP client."""
 
     def __init__(self, bus_ip: str = '127.0.0.1', bus_port: int = 1324,
                  rtus: dict = {}, tags: dict = {}) -> None:

pymscada/iodrivers/snmp_map.py

@@ -52,7 +52,7 @@ class SnmpMaps:
         # 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']
+            addr = v['read']
             map = SnmpMap(tagname, v['type'], addr)
             if map.plc not in self.var_map:
                 self.var_map[map.plc] = {}