pymscada 0.0.14__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

@@ -12,52 +12,75 @@ 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(']')
+    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, plc_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)
-        separator = plc_tag.find(':')
-        arr_start_loc = plc_tag.find('[')
-        arr_end_loc = plc_tag.find(']')
-        bit_loc = plc_tag.find('.')
-        self.plc = plc_tag[:separator]
-        if arr_start_loc == -1 and bit_loc == -1:
-            self.var = plc_tag[separator + 1:]
-            self.elm = None
-            self.bit = None
-        elif arr_start_loc == -1:
-            self.var = plc_tag[separator + 1:bit_loc]
-            self.elm = None
-            self.bit = int(plc_tag[bit_loc + 1:])
-        elif bit_loc == -1:
-            self.var = plc_tag[separator + 1:arr_start_loc]
-            self.elm = int(plc_tag[arr_start_loc + 1:arr_end_loc])
-            self.bit = None
-        else:
-            self.var = plc_tag[separator + 1:arr_start_loc]
-            self.elm = int(plc_tag[arr_start_loc + 1:arr_end_loc])
-            self.bit = int(plc_tag[bit_loc + 1:])
-        self.plc_tag = plc_tag
-        self.callback = None
         if dmin is not None:
             self.tag.value_min = dmin
         if dmax is not None:
             self.tag.value_max = dmax
-        self.write_cb = None  # used?
+        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):
         """Pass update from IO driver to tag value."""
-        if self.bit is not None:
-            if value & 1 << self.bit:
+        if self.read_bit is not None:
+            if value & 1 << self.read_bit:
                 value = 1
             else:
                 value = 0
@@ -66,15 +89,15 @@ class LogixMap:
 
     def tag_value_changed(self, tag: Tag):
         """Pass update from tag value to IO driver."""
-        if self.elm is None and self.bit is None:
-            addr = self.var
-        elif self.elm is None:
-            addr = f'{self.var}.{self.bit}'
-        elif self.bit is None:
-            addr = f'{self.var}[{self.elm}]'
+        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.var}[{self.elm}].{self.bit}'
-        self.callback(addr, tag.value)
+            addr = f'{self.write_var}[{self.write_elm}].{self.write_bit}'
+        self.write_callback(addr, tag.value)
 
 
 class LogixMaps:
@@ -85,32 +108,21 @@ class LogixMaps:
         # 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.var_map: dict[str, dict[str, list[LogixMap]]] = {}
-        for tagname, v in tags.items():
-            addr = v['addr']
-            map = LogixMap(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]:
+        self.read_var_map: dict[str, dict[str, list[LogixMap]]] = {}
+        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]:
                 # 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.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
+    def add_write_callback(self, plcname, callback):
+        """Register connector with map for write tags."""
         for map in self.tag_map.values():
-            if map.plc == plcname and (map.var, map.elm) in write_set:
+            if map.write_plc == plcname:
                 map.set_callback(callback)
 
     def polled_data(self, plcname, polls):
@@ -121,12 +133,12 @@ class LogixMaps:
                 logging.error(poll.error)
             arr_start_loc = poll.tag.find('[')
             if arr_start_loc == -1:
-                for map in self.var_map[plcname][poll.tag]:
+                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.var_map[plcname][var]:
-                    elm_offset = map.elm - elm
+                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)