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

pymscada/demo/wwwserver.yaml

@@ -84,4 +84,450 @@ pages:
 - name: Files
   parent: Dropdown
   items:
-  - {tagname: __files__, type: files}
+  - {tagname: __files__, type: files}
+- name: Temperature
+  parent: Weather
+  items:
+  - type: uplot  # Do all times in seconds, which uplot uses.
+    ms:
+      desc: Temperature
+      age: 172800
+      legend_pos: left
+      time_pos: left
+      time_res: m
+    axes:
+    - scale: x
+      range: [-604800, 86400]  # 86400 172800 1209600
+    - scale: 'C'
+      range: [0.0, 35.0]
+      dp: 1
+    series:
+    - tagname: temperature
+      label: Current Temperature
+      scale: 'C'
+      color: black
+      width: 2
+      dp: 1
+    - tagname: temperature_01
+      label: 1h Temperature
+      scale: 'C'
+      color: darkgray
+      width: 1.5
+      dp: 1
+    - tagname: temperature_04
+      label: 4h Temperature
+      scale: 'C'
+      color: green
+      width: 1
+      dp: 1
+    - tagname: temperature_12
+      label: 12h Temperature
+      scale: 'C'
+      color: orange
+      width: 0.75
+      dp: 1
+    - tagname: temperature_24
+      label: 24h Temperature
+      scale: 'C'
+      color: red
+      width: 0.5
+      dp: 1
+- name: Wind Speed
+  parent: Weather
+  items:
+  - type: uplot  # Do all times in seconds, which uplot uses.
+    ms:
+      desc: Wind Speed
+      age: 172800
+      legend_pos: left
+      time_pos: left
+      time_res: m
+    axes:
+    - scale: x
+      range: [-604800, 86400]  # 86400 172800 1209600
+    - scale: 'm/s'
+      range: [0.0, 20.0]
+      dp: 1
+    series:
+    - tagname: windSpeed
+      label: Current Wind Speed
+      scale: 'm/s'
+      color: black
+      width: 2
+      dp: 1
+    - tagname: windSpeed_01
+      label: 1h Wind Speed
+      scale: 'm/s'
+      color: darkgray
+      width: 1.5
+      dp: 1
+    - tagname: windSpeed_04
+      label: 4h Wind Speed
+      scale: 'm/s'
+      color: green
+      width: 1
+      dp: 1
+    - tagname: windSpeed_12
+      label: 12h Wind Speed
+      scale: 'm/s'
+      color: orange
+      width: 0.75
+      dp: 1
+    - tagname: windSpeed_24
+      label: 24h Wind Speed
+      scale: 'm/s'
+      color: red
+      width: 0.5
+      dp: 1
+- name: Wind Direction
+  parent: Weather
+  items:
+  - type: uplot  # Do all times in seconds, which uplot uses.
+    ms:
+      desc: Wind Direction
+      age: 172800
+      legend_pos: left
+      time_pos: left
+      time_res: m
+    axes:
+    - scale: x
+      range: [-604800, 86400]  # 86400 172800 1209600
+    - scale: 'deg'
+      range: [0.0, 360.0]
+      dp: 1
+    series:
+    - tagname: windDirection
+      label: Current Wind Direction
+      scale: 'deg'
+      color: black
+      width: 2
+      dp: 1
+    - tagname: windDirection_01
+      label: 1h Wind Direction
+      scale: 'deg'
+      color: darkgray
+      width: 1.5
+      dp: 1
+    - tagname: windDirection_04
+      label: 4h Wind Direction
+      scale: 'deg'
+      color: green
+      width: 1
+      dp: 1
+    - tagname: windDirection_12
+      label: 12h Wind Direction
+      scale: 'deg'
+      color: orange
+      width: 0.75
+      dp: 1
+    - tagname: windDirection_24
+      label: 24h Wind Direction
+      scale: 'deg'
+      color: red
+      width: 0.5
+      dp: 1
+- name: Rain Accumulation
+  parent: Weather
+  items:
+  - type: uplot  # Do all times in seconds, which uplot uses.
+    ms:
+      desc: Rain Accumulation
+      age: 172800
+      legend_pos: left
+      time_pos: left
+      time_res: m
+    axes:
+    - scale: x
+      range: [-604800, 86400]  # 86400 172800 1209600
+    - scale: 'mm'
+      range: [0.0, 10.0]
+      dp: 1
+    series:
+    - tagname: rainAccumulation
+      label: Current Rain Accumulation
+      scale: 'mm'
+      color: black
+      width: 2
+      dp: 1
+    - tagname: rainAccumulation_01
+      label: 1h Rain Accumulation
+      scale: 'mm'
+      color: darkgray
+      width: 1.5
+      dp: 1
+    - tagname: rainAccumulation_04
+      label: 4h Rain Accumulation
+      scale: 'mm'
+      color: green
+      width: 1
+      dp: 1
+    - tagname: rainAccumulation_12
+      label: 12h Rain Accumulation
+      scale: 'mm'
+      color: orange
+      width: 0.75
+      dp: 1
+    - tagname: rainAccumulation_24
+      label: 24h Rain Accumulation
+      scale: 'mm'
+      color: red
+      width: 0.5
+      dp: 1
+- name: Humidity
+  parent: Weather
+  items:
+  - type: uplot  # Do all times in seconds, which uplot uses.
+    ms:
+      desc: Humidity
+      age: 172800
+      legend_pos: left
+      time_pos: left
+      time_res: m
+    axes:
+    - scale: x
+      range: [-604800, 86400]  # 86400 172800 1209600
+    - scale: '%'
+      range: [0.0, 100.0]
+      dp: 1
+    series:
+    - tagname: humidity
+      label: Current Humidity
+      scale: '%'
+      color: black
+      width: 2
+      dp: 1
+    - tagname: humidity_01
+      label: 1h Humidity
+      scale: '%'
+      color: darkgray
+      width: 1.5
+      dp: 1
+    - tagname: humidity_04
+      label: 4h Humidity
+      scale: '%'
+      color: green
+      width: 1
+      dp: 1
+    - tagname: humidity_12
+      label: 12h Humidity
+      scale: '%'
+      color: orange
+      width: 0.75
+      dp: 1
+    - tagname: humidity_24
+      label: 24h Humidity
+      scale: '%'
+      color: red
+      width: 0.5
+      dp: 1
+- name: Values
+  parent: Weather
+  items:
+  - {tagname: temperature, type: value}
+  - {tagname: temperature_01, type: value}
+  - {tagname: temperature_04, type: value}
+  - {tagname: temperature_12, type: value}
+  - {tagname: temperature_24, type: value}
+  - {tagname: windSpeed, type: value}
+  - {tagname: windSpeed_01, type: value}
+  - {tagname: windSpeed_04, type: value}
+  - {tagname: windSpeed_12, type: value}
+  - {tagname: windSpeed_24, type: value}
+  - {tagname: windDirection, type: value}
+  - {tagname: windDirection_01, type: value}
+  - {tagname: windDirection_04, type: value}
+  - {tagname: windDirection_12, type: value}
+  - {tagname: windDirection_24, type: value}
+  - {tagname: rainAccumulation, type: value}
+  - {tagname: rainAccumulation_01, type: value}
+  - {tagname: rainAccumulation_04, type: value}
+  - {tagname: rainAccumulation_12, type: value}
+  - {tagname: rainAccumulation_24, type: value}
+  - {tagname: humidity, type: value}
+  - {tagname: humidity_01, type: value}
+  - {tagname: humidity_04, type: value}
+  - {tagname: humidity_12, type: value}
+  - {tagname: humidity_24, type: value}
+- name: Logix
+  items:
+  - {tagname: Ani_Fin_20, type: setpoint}
+  - {tagname: Ani_Fout_20, type: value}
+  - {tagname: Ani_Iin_20, type: setpoint}
+  - {tagname: Ani_Iout_20, type: value}
+  - {tagname: InVar, type: setpoint}
+  - {tagname: OutVar, type: value}
+  - {tagname: Ani_Iin_21_0, type: setpoint}
+  - {tagname: Ani_Iout_21_0, type: value}
+  - {tagname: Ani_Iin_21_1, type: setpoint}
+  - {tagname: Ani_Iout_21_1, type: value}
+- name: Values
+  parent: SNMP
+  items:
+  - {tagname: Router_eth1_bytes_in, type: value}
+  - {tagname: Router_eth1_bytes_out, type: value}
+  - {tagname: Router_eth2_bytes_in, type: value}
+  - {tagname: Router_eth2_bytes_out, type: value}
+  - {tagname: Router_eth3_bytes_in, type: value}
+  - {tagname: Router_eth3_bytes_out, type: value}
+  - {tagname: Router_eth4_bytes_in, type: value}
+  - {tagname: Router_eth4_bytes_out, type: value}
+  - {tagname: Router_eth5_bytes_in, type: value}
+  - {tagname: Router_eth5_bytes_out, type: value}
+  - {tagname: Router_eth6_bytes_in, type: value}
+  - {tagname: Router_eth6_bytes_out, type: value}
+  - {tagname: Router_eth7_bytes_in, type: value}
+  - {tagname: Router_eth7_bytes_out, type: value}
+  - {tagname: Router_eth8_bytes_in, type: value}
+  - {tagname: Router_eth8_bytes_out, type: value}
+- name: Trend
+  parent: SNMP
+  items:
+  - type: uplot  # Do all times in seconds, which uplot uses.
+    ms:
+      desc: Bytes
+      age: 172800
+      legend_pos: left
+      time_pos: left
+      time_res: m
+    axes:
+    - scale: x
+      range: [-86400, 0]
+    - scale: 'bytes'
+      range: [0, 100000]
+      dp: 0
+    series:
+    - tagname: Router_eth1_bytes_in
+      label: eth1 in
+      scale: 'bytes'
+      color: violet
+      width: 1
+      dp: 0
+    - tagname: Router_eth1_bytes_out
+      label: eth1 out
+      scale: 'bytes'
+      color: violet
+      width: 0.5
+      dp: 0
+    - tagname: Router_eth2_bytes_in
+      label: eth2 in
+      scale: 'bytes'
+      color: blue
+      width: 1
+      dp: 0
+    - tagname: Router_eth2_bytes_out
+      label: eth2 out
+      scale: 'bytes'
+      color: blue
+      width: 0.5
+      dp: 0
+    - tagname: Router_eth3_bytes_in
+      label: eth3 in
+      scale: 'bytes'
+      color: green
+      width: 1
+      dp: 0
+    - tagname: Router_eth3_bytes_out
+      label: eth3 out
+      scale: 'bytes'
+      color: green
+      width: 0.5
+      dp: 0
+    - tagname: Router_eth4_bytes_in
+      label: eth4 in
+      scale: 'bytes'
+      color: gray
+      width: 1
+      dp: 0
+    - tagname: Router_eth4_bytes_out
+      label: eth4 out
+      scale: 'bytes'
+      color: gray
+      width: 0.5
+      dp: 0
+    - tagname: Router_eth5_bytes_in
+      label: eth5 in
+      scale: 'bytes'
+      color: goldenrod
+      width: 1
+      dp: 0
+    - tagname: Router_eth5_bytes_out
+      label: eth5 out
+      scale: 'bytes'
+      color: goldenrod
+      width: 0.5
+      dp: 0
+    - tagname: Router_eth6_bytes_in
+      label: eth6 in
+      scale: 'bytes'
+      color: brown
+      width: 1
+      dp: 0
+    - tagname: Router_eth6_bytes_out
+      label: eth6 out
+      scale: 'bytes'
+      color: brown
+      width: 0.5
+      dp: 0
+    - tagname: Router_eth7_bytes_in
+      label: eth7 in
+      scale: 'bytes'
+      color: orange
+      width: 1
+      dp: 0
+    - tagname: Router_eth7_bytes_out
+      label: eth7 out
+      scale: 'bytes'
+      color: orange
+      width: 0.5
+      dp: 0
+    - tagname: Router_eth8_bytes_in
+      label: eth8 in
+      scale: 'bytes'
+      color: aqua
+      width: 1
+      dp: 0
+    - tagname: Router_eth8_bytes_out
+      label: eth8 out
+      scale: 'bytes'
+      color: aqua
+      width: 0.5
+      dp: 0
+- name: Ping Values
+  parent: Ping
+  items:
+  - {desc: Default tags, type: h1}
+  - {tagname: localhost_ping, type: value}
+  - {tagname: google_ping, type: value}
+  - {tagname: electronet_ping, type: value}
+- name: Ping Trend
+  parent: Ping
+  items:
+  - type: uplot  # Do all times in seconds, which uplot uses.
+    ms:
+      desc: Ping Trend
+      age: 172800
+      legend_pos: left
+      time_pos: left
+      time_res: m
+    axes:
+    - scale: x
+      range: [-86400, 0]  # 86400 172800 1209600
+    - scale: mS
+      range: [0.0, 1.0]
+      dp: 1
+    series:
+    - tagname: localhost_ping
+      label: localhost
+      scale: mS
+      color: black
+      dp: 1
+    - tagname: electronet_ping
+      label: electronet
+      scale: mS
+      color: blue
+      dp: 1
+    - tagname: google_ping
+      label: google
+      scale: mS
+      color: red
+      dp: 1

pymscada/iodrivers/logix_client.py

@@ -7,23 +7,22 @@ from pymscada.iodrivers.logix_map import LogixMaps
 
 
 class LogixClientConnector:
-    """Poll Logix device, write on change in write range."""
+    """Manage interface to device."""
 
-    def __init__(self, name: str, ip:str, rate: float, read: list,
-                 writeok: list, mapping: LogixMaps):
+    def __init__(self, name: str, ip: str, rate: float, poll: list,
+                 mapping: LogixMaps):
         """Set up polling client."""
         self.plc_name = name
         self.ip = ip
         self.read_tags = []
-        for r in read:
+        for r in poll:
             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.mapping.add_write_callback(name, self.write_tag_update)
         self.periodic = Periodic(self.poll, rate)
         self.plc = LogixDriver(ip)
 
@@ -33,14 +32,14 @@ class LogixClientConnector:
             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
+        result = self.plc.write((addr, value))
+        logging.info(result)
 
     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 = None
         polled_tags = self.plc.read(*self.read_tags)
         self.mapping.polled_data(self.plc_name, polled_tags)
 
@@ -50,6 +49,7 @@ class LogixClientConnector:
 
 
 class LogixClient:
+    """Manage interface between bus and individual devices."""
 
     def __init__(self, bus_ip: str = '127.0.0.1', bus_port: int = 1324,
                  rtus: dict = {}, tags: dict = {}) -> None:

pymscada/iodrivers/logix_map.py

@@ -13,6 +13,7 @@ DTYPES = {
 
 
 def tag_split(plc_tag: str):
+    """Split the address into rtu, variable, element and bit."""
     separator = plc_tag.find(':')
     arr_start_loc = plc_tag.find('[')
     arr_end_loc = plc_tag.find(']')
@@ -40,27 +41,40 @@ def tag_split(plc_tag: str):
 class LogixMap:
     """Do value updates for each tag."""
 
-    def __init__(self, tagname: str, src_type: str, read_tag: str,
-                 write_tag: str):
+    def __init__(self, tagname: str, tagdict: dict):
         """Initialise modbus map and Tag."""
-        dtype, dmin, dmax = DTYPES[src_type][0:3]
+        dtype, dmin, dmax = DTYPES[tagdict['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
+        if 'read' in tagdict:
+            self.plc_read_tag = tagdict['read']
+            self.read_plc, self.read_var, self.read_elm, self.read_bit = \
+                tag_split(self.plc_read_tag)
+        else:
+            self.plc_read_tag = None
+            self.read_plc = None
+            self.read_var = None
+            self.read_elm = None
+            self.read_bit = None
+        if 'write' in tagdict:
+            self.plc_write_tag = tagdict['write']
+            self.write_plc, self.write_var, self.write_elm, self.write_bit = \
+                tag_split(self.plc_write_tag)
+        else:
+            self.plc_write_tag = None
+            self.write_plc = None
+            self.write_var = None
+            self.write_elm = None
+            self.write_bit = None
+        self.write_callback = None
 
     def set_callback(self, callback):
         """Add tag callback interface."""
-        self.callback = callback
+        self.write_callback = callback
         self.tag.add_callback(self.tag_value_changed, bus_id=self.map_bus)
 
     def set_tag_value(self, value, time_us):
@@ -83,7 +97,7 @@ class LogixMap:
             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)
+        self.write_callback(addr, tag.value)
 
 
 class LogixMaps:
@@ -95,14 +109,8 @@ class LogixMaps:
         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)
+        for tagname, tagdict in tags.items():
+            map = LogixMap(tagname, tagdict)
             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]:
@@ -111,21 +119,10 @@ class LogixMaps:
             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
+    def add_write_callback(self, plcname, callback):
+        """Register connector with map for write tags."""
         for map in self.tag_map.values():
-            if map.write_plc == plcname and \
-                    (map.write_var, map.write_elm) in write_set:
+            if map.write_plc == plcname:
                 map.set_callback(callback)
 
     def polled_data(self, plcname, polls):

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}'