pymscada 0.1.0a5__tar.gz → 0.1.1__tar.gz

{pymscada-0.1.0a5 → pymscada-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pymscada
-Version: 0.1.0a5
+Version: 0.1.1
 Summary: Shared tag value SCADA with python backup and Angular UI
 Author-Email: Jamie Walton <jamie@walton.net.nz>
 License: GPL-3.0-or-later
@@ -13,7 +13,7 @@ Classifier: Development Status :: 1 - Planning
 Requires-Python: >=3.9
 Requires-Dist: PyYAML>=6.0.1
 Requires-Dist: aiohttp>=3.8.5
-Requires-Dist: pymscada-html<=0.1.0
+Requires-Dist: pymscada-html==0.1.0
 Requires-Dist: cerberus>=1.3.5
 Requires-Dist: pycomm3>=1.2.14
 Requires-Dist: pysnmplib>=5.0.24

{pymscada-0.1.0a5 → pymscada-0.1.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pymscada"
-version = "0.1.0a5"
+version = "0.1.1"
 description = "Shared tag value SCADA with python backup and Angular UI"
 authors = [
     { name = "Jamie Walton", email = "jamie@walton.net.nz" },
@@ -8,7 +8,7 @@ authors = [
 dependencies = [
     "PyYAML>=6.0.1",
     "aiohttp>=3.8.5",
-    "pymscada-html<=0.1.0",
+    "pymscada-html==0.1.0",
     "cerberus>=1.3.5",
     "pycomm3>=1.2.14",
     "pysnmplib>=5.0.24",
@@ -43,7 +43,6 @@ test = [
     "flake8-docstrings>=1.7.0",
     "pytest-asyncio>=0.21.1",
     "pytest-cov>=4.1.0",
-    "pdm>=2.11.1",
 ]
 pdm = []
 

{pymscada-0.1.0a5 → pymscada-0.1.1}/src/pymscada/bus_client.py

@@ -16,16 +16,18 @@ class BusClient:
     fails, die.
     """
 
-    def __init__(self, ip: str = '127.0.0.1', port: int = 1324, tag_info=None):
+    def __init__(self, ip: str = '127.0.0.1', port: int = 1324, tag_info=None,
+                 module: str = '_unset_'):
         """Create bus server."""
         self.ip = ip
         self.port = port
         self.read_task = None
         self.tag_info = tag_info
+        self.module = module
         self.tag_by_id: dict[int, Tag] = {}
         self.tag_by_name: dict[str, Tag] = {}
         self.to_publish: dict[str, Tag] = {}
-        self.rqs_handlers: dict[str, object] = {}
+        self.rta_handlers: dict[str, object] = {}
         self.pending = {}
 
     def publish(self, tag: Tag):
@@ -61,20 +63,20 @@ class BusClient:
             return
         self.write(pc.CMD_SET, tag.id, tag.time_us, data)
 
-    def add_callback_rqs(self, tagname, handler):
+    def add_callback_rta(self, tagname, handler):
         """Collect callback handlers."""
         if callable(handler):
-            self.rqs_handlers[tagname] = handler
+            self.rta_handlers[tagname] = handler
         else:
-            logging.error(f'invalid RQS handler for {tagname}')
+            logging.error(f'invalid RTA handler for {tagname}')
 
-    def rqs(self, tagname: str, request: dict):
+    def rta(self, tagname: str, request: dict):
         """Send a Request Set message."""
         time_us = int(time.time() * 1e6)
         jsonstr = json.dumps(request).encode()
         size = len(jsonstr)
         data = struct.pack(f'>B{size}s', pc.TYPE_JSON, jsonstr)
-        self.write(pc.CMD_RQS, self.tag_by_name[tagname].id, time_us, data)
+        self.write(pc.CMD_RTA, self.tag_by_name[tagname].id, time_us, data)
 
     def write(self, command: pc.COMMANDS, tag_id: int, time_us: int,
               data: bytes):
@@ -106,6 +108,7 @@ class BusClient:
         self.reader, self.writer = await asyncio.open_connection(
             self.ip, self.port)
         self.addr = self.writer.get_extra_info('sockname')
+        self.write(pc.CMD_LOG, 0, 0, f'{self.module} connected'.encode())
         logging.info(f'connected {self.addr}')
         for tag in Tag.get_all_tags().values():
             self.add_tag(tag)
@@ -127,7 +130,8 @@ class BusClient:
             try:
                 head = await self.reader.readexactly(14)
                 _, cmd, tag_id, size, time_us = struct.unpack('>BBHHQ', head)
-            except (ConnectionResetError, asyncio.IncompleteReadError):
+            except (ConnectionResetError, asyncio.IncompleteReadError,
+                    asyncio.CancelledError):
                 break
             if size == 0:
                 self.process(cmd, tag_id, time_us, None)
@@ -200,14 +204,14 @@ class BusClient:
                 logging.warning(f'process error {tag.name} {tag.type} {value}')
                 return
             tag.value = data, time_us, id(self)
-        elif cmd == pc.CMD_RQS:
+        elif cmd == pc.CMD_RTA:
             data = struct.unpack_from(f'!{len(value) - 1}s', value, offset=1
                                       )[0].decode()
             data = json.loads(data)
             try:
-                self.rqs_handlers[tag.name](data)
+                self.rta_handlers[tag.name](data)
             except KeyError:
-                logging.warning(f'unhandled RQS for {tag.name} {data}')
+                logging.warning(f'unhandled RTA for {tag.name} {data}')
         else:
             raise SystemExit(f'Invalid message {cmd}')
 

{pymscada-0.1.0a5 → pymscada-0.1.1}/src/pymscada/bus_server.py

@@ -141,9 +141,10 @@ class BusConnection():
 class BusServer:
     """Serve Tags on ip:port, echoing changes to any subscribers."""
 
-    __slots__ = ('ip', 'port', 'server', 'connections')
+    __slots__ = ('ip', 'port', 'server', 'connections', 'bus_tag')
 
-    def __init__(self, ip: str = '127.0.0.1', port: int = 1324):
+    def __init__(self, ip: str = '127.0.0.1', port: int = 1324,
+                 bus_tag: str = '__bus__'):
         """
         Serve Tags on ip:port, echoing changes to any subscribers.
 
@@ -157,10 +158,10 @@ class BusServer:
         self.port = port
         self.server = None
         self.connections: dict[int, BusConnection] = {}
-        bus_tag = BusTag(b'__bus__')
-        bus_tag.value = b'\x03started'  # \x03 is string type
-        bus_tag.time_us = int(time.time() * 1e6)
-        bus_tag.from_bus = 0
+        self.bus_tag = BusTag(bus_tag.encode())
+        self.bus_tag.value = b'\x03started'  # \x03 is string type
+        self.bus_tag.time_us = int(time.time() * 1e6)
+        self.bus_tag.from_bus = 0
 
     def publish(self, tag: BusTag, bus_id):
         """Update subcribers with tag value change."""
@@ -184,22 +185,22 @@ class BusServer:
                 self.connections[bus_id].write(
                     pc.CMD_ERR, tag_id, time_us,
                     f"SET KeyError {tag_id}".encode())
-        elif cmd == pc.CMD_RQS:
+        elif cmd == pc.CMD_RTA:
             try:
                 tag = BusTags._tag_by_id[tag_id]
             except KeyError:
                 self.connections[bus_id].write(
                     pc.CMD_ERR, tag_id, time_us,
-                    f"RQS KeyError {tag_id}".encode())
+                    f"RTA KeyError {tag_id}".encode())
             try:
                 self.connections[tag.from_bus].write(
-                    pc.CMD_RQS, tag_id, tag.time_us, data)
+                    pc.CMD_RTA, tag_id, tag.time_us, data)
             except KeyError:
                 logging.warning(f'likely busclient for {tag.name} is gone')
             except Exception as e:
                 self.connections[bus_id].write(
                     pc.CMD_ERR, tag_id, time_us,
-                    f"RQS {tag_id} {e}".encode())
+                    f"RTA {tag_id} {e}".encode())
             """Reply comes from another BusClient, not the Server."""
         elif cmd == pc.CMD_SUB:
             try:
@@ -260,6 +261,11 @@ class BusServer:
                         tagname_list.append(tag.name)
             self.connections[bus_id].write(
                 pc.CMD_LIST, 0, time_us, b' '.join(tagname_list))
+        elif cmd == pc.CMD_LOG:
+            if len(data) > 300:
+                logging.warning(f'process: log message too long from {bus_id}')
+            else:
+                logging.warning(data.decode())
         else:  # consider disconnecting
             logging.warn(f'invalid message {cmd}')
 

pymscada-0.1.1/src/pymscada/console.py

@@ -0,0 +1,243 @@
+"""Interactive console."""
+import asyncio
+import logging
+import sys
+import termios
+import tty
+from pymscada.bus_client import BusClient
+from pymscada.tag import Tag, tag_for_web
+
+
+class EC:
+    """Escape codes."""
+
+    backspace = b'\x7f'
+    enter = b'\r'
+    tab = b'\t'
+    up = b'\x1b[A'
+    down = b'\x1b[B'
+    right = b'\x1b[C'
+    left = b'\x1b[D'
+    end = b'\x1b[F'
+    home = b'\x1b[H'
+    cr_clr = b'\x1b[2K\x1b[G'  # clear line and move start
+    clear_line = b'\x1b[2K'
+    mv_start = b'\x1b[G'
+    mv_left = b'\x1b[1000D'
+
+
+class CustomHandler(logging.StreamHandler):
+    """Control the cursor position."""
+
+    def emit(self, record):
+        """Write to the console adding a carriage return."""
+        try:
+            msg = self.format(record)
+            self.stream.write(msg + '\r\n')
+            self.stream.flush()
+        except Exception:
+            self.handleError(record)
+
+
+class KeypressProtocol(asyncio.Protocol):
+    """Handle key presses, one at a time."""
+
+    def __init__(self, edit_line, process_command):
+        """Set up line buffers and pointers."""
+        self.edit_line = edit_line
+        self.process_command = process_command
+        self.lines = []
+        self.history = None  # not showing history
+        self.line = None  # not editing a line (yet)
+        self.cursor = 0  # cursor position in line
+        self.stash = None  # nothing stashed
+        self.connection_lost_future = asyncio.Future()
+
+    def data_received(self, data):
+        """Got keypress, update edit line, send to writer."""
+        if len(data) == 1:
+            if data == EC.backspace:
+                self.line = self.line[:self.cursor-1] + self.line[self.cursor:]
+                if self.cursor > 0:
+                    self.cursor -= 1
+            elif data == EC.enter:
+                self.stash = None
+                if self.lines:
+                    if self.line != self.lines[-1]:
+                        self.lines.append(self.line)
+                else:
+                    self.lines.append(self.line)
+                self.edit_line(None, 0)
+                self.process_command(self.line)
+                self.line = None
+                self.cursor = 0
+                self.history = None
+                return
+            elif self.line is None:
+                self.line = data
+                self.cursor = 1
+            else:
+                self.line = (self.line[:self.cursor] + data
+                             + self.line[self.cursor:])
+                self.cursor += 1
+        elif data == EC.left:
+            if self.cursor > 0:
+                self.cursor -= 1
+        elif data == EC.right:
+            if self.cursor < len(self.line):
+                self.cursor += 1
+        elif data == EC.up:
+            if not self.lines:
+                return
+            if self.history is None:
+                self.stash = self.line  # might be None
+                self.history = len(self.lines)
+            self.history -= 1
+            if self.history < 0:
+                self.history = 0
+            self.line = self.lines[self.history]
+            self.cursor = len(self.line)
+        elif data == EC.down:
+            if not self.lines or self.history is None:
+                return
+            self.history += 1
+            if self.history == len(self.lines):
+                self.line = self.stash
+                self.history = None
+            else:
+                self.line = self.lines[self.history]
+            if self.line is None:
+                self.line = b''
+            self.cursor = len(self.line)
+        self.edit_line(self.line, self.cursor)
+
+    def connection_lost(self, exc):
+        """Let parent know protocol transport has disconnected."""
+        self.connection_lost_future.set_result(True)
+
+
+class ConsoleWriter:
+    """Writer to group logging and console text."""
+
+    def __init__(self):
+        """Init."""
+        self.edit = None
+        self.cursor = 0
+
+    def write(self, data: bytes):
+        """Stream writer, primarily for logging."""
+        ln = EC.cr_clr + data + b'\r\n'
+        if self.edit is not None:
+            ln += EC.cr_clr + self.edit + EC.mv_left
+            if self.cursor > 0:
+                ln += b'\x1b[' + str(self.cursor).encode() + b'C'
+        sys.stdout.buffer.write(ln)
+        sys.stdout.flush()
+
+    def edit_line(self, edit: bytes, cursor: int):
+        """Update the edit line and cursor position."""
+        self.edit = edit
+        if self.edit is None:
+            sys.stdout.buffer.write(b'\r\n')
+            sys.stdout.flush()
+            return
+        self.cursor = cursor
+        ln = EC.cr_clr + self.edit + EC.mv_left
+        if self.cursor > 0:
+            ln += b'\x1b[' + str(self.cursor).encode() + b'C'
+        sys.stdout.buffer.write(ln)
+        sys.stdout.flush()
+
+
+class Console:
+    """Provide a text console to interact with a Bus."""
+
+    def __init__(self, bus_ip: str = '127.0.0.1', bus_port: int = 1324,
+                 tag_info: dict = {}):
+        """
+        Connect to bus_ip:bus_port and provide console interaction with a Bus.
+
+        Event loop must be running.
+        """
+        self.fdin = sys.stdin.fileno()
+        self.fdout = sys.stdout.fileno()
+        self.fdin_attr = termios.tcgetattr(self.fdin)
+        self.fdout_attr = termios.tcgetattr(self.fdout)
+        tty.setraw(self.fdin)
+        self.writer = ConsoleWriter()
+        self.protocol = None
+        self.transport = None
+        # all to add '\r\n' to the logging output
+        logger = logging.getLogger()
+        handler = CustomHandler()
+        handler.setFormatter(logging.Formatter(
+            '%(levelname)s:%(name)s:%(message)s'))
+        logger.handlers.clear()
+        logger.addHandler(handler)
+        self.busclient = BusClient(bus_ip, bus_port, module='Console')
+        self.tags: dict[str, Tag] = {}
+        for tagname, tag in tag_info.items():
+            tag_for_web(tagname, tag)
+            self.tags[tagname] = Tag(tagname, tag['type'])
+
+    def write_tag(self, tag: Tag):
+        """Append or insert tag value through writer."""
+        ln = f'{tag.name} {tag.value}'.encode()
+        self.writer.write(ln)
+
+    def process(self, command: bytes):
+        """Execute command."""
+        if command is None:
+            return
+        cmd, var, val = (command.split(b' ') + [None] * 3)[:3]
+        tagnames = self.tags.keys()
+        if var is not None:
+            tagname = var.decode()
+            tagnames = [x for x in self.tags.keys() if tagname in x]
+        if cmd in [b'q', b'quit']:
+            self.transport.close()
+        elif cmd in [b'g', b'get']:
+            for tagname in tagnames:
+                self.write_tag(self.tags[tagname])
+        elif cmd == b'set' and tagname in self.tags:
+            try:
+                typed_val = self.tags[tagname].type(val.decode())
+                self.tags[tagname].value = typed_val
+            except ValueError as e:
+                logging.warning(f'error setting {tagname}: {e}')
+        elif cmd in [b's', b'sub']:
+            for tagname in tagnames:
+                self.tags[tagname].add_callback(self.write_tag)
+                self.write_tag(self.tags[tagname])
+        elif cmd in [b'u', b'unsub']:
+            for tagname in tagnames:
+                if self.write_tag in self.tags[tagname].pub:
+                    self.tags[tagname].del_callback(self.write_tag)
+        elif cmd in [b'l', b'list']:
+            ln = ' '.join(tagnames).encode()
+            self.writer.write(ln)
+        elif cmd in [b'w', b'watch']:
+            pass
+        elif cmd in [b'h', b'help']:
+            self.writer.write(
+                b'list <match>              or l <match>\r\n'
+                b'get <match>               or g <match>\r\n'
+                b'set tagname value\r\n'
+                b'sub <match>               or s <match>\r\n'
+                b'unsub <match>             or u <match>\r\n'
+                b'watch <systemd name>      or w <systemd name>\r\n'
+                b'---------------------------------------------')
+
+    async def start(self):
+        """Start polling, does not return until finished."""
+        await self.busclient.start()
+        try:
+            self.protocol = \
+                KeypressProtocol(self.writer.edit_line, self.process)
+            self.transport, _ = \
+                await asyncio.get_event_loop().connect_read_pipe(
+                    lambda: self.protocol, sys.stdin)
+            await self.protocol.connection_lost_future
+        finally:
+            termios.tcsetattr(self.fdout, termios.TCSADRAIN, self.fdout_attr)
+            termios.tcsetattr(self.fdin, termios.TCSADRAIN, self.fdin_attr)

{pymscada-0.1.0a5 → pymscada-0.1.1}/src/pymscada/demo/files.yaml

@@ -1,5 +1,6 @@
 bus_ip: 127.0.0.1
 bus_port: 1324
+path: /home/mscada/pymscada
 files:
 - path: pdf/one.pdf
   desc: PDF

pymscada-0.1.1/src/pymscada/demo/opnotes.yaml

@@ -0,0 +1,5 @@
+bus_ip: 127.0.0.1
+bus_port: 1324
+rta_tag: __opnotes__
+db: /home/mscada/pymscada/pymscada.sqlite
+table: opnotes

pymscada-0.1.1/src/pymscada/demo/pymscada-opnotes.service

@@ -0,0 +1,16 @@
+[Unit]
+    Description=pymscada - history
+    BindsTo=pymscada-bus.service
+    After=pymscada-bus.service
+
+[Service]
+    WorkingDirectory=__DIR__
+    ExecStart=__PYMSCADA__ opnotes --config __DIR__/config/opnotes.yaml
+    Restart=always
+    RestartSec=5
+    User=mscada
+    Group=mscada
+    KillSignal=SIGINT
+
+[Install]
+    WantedBy=multi-user.target

{pymscada-0.1.0a5 → pymscada-0.1.1}/src/pymscada/demo/wwwserver.yaml

@@ -2,11 +2,8 @@ bus_ip: 127.0.0.1
 bus_port: 1324
 ip: 0.0.0.0
 port: 8324
-get_path:
-paths:
-- history
-- config
-- pdf
+get_path: /home/mscada/Documents/angmscada/dist/angmscada
+serve_path: /home/mscada/pymscada
 pages:
 - name: Default Main
   parent:

pymscada-0.1.1/src/pymscada/files.py

@@ -0,0 +1,75 @@
+"""Serve files through an RTA tag."""
+import logging
+from pathlib import Path
+from pymscada.bus_client import BusClient
+from pymscada.periodic import Periodic
+from pymscada.tag import Tag
+
+
+RATE = 10
+
+
+class Files():
+    """Connect to bus_ip:bus_port, store and provide a value history."""
+
+    def __init__(self, bus_ip: str = '127.0.0.1', bus_port: int = 1324,
+                 path: str = '', files: list = None,
+                 rta_tag: str = '__files__') -> None:
+        """
+        Connect to bus_ip:bus_port, serve and update files.
+
+        TODO
+        Write something.
+
+        Event loop must be running.
+        """
+        self.busclient = BusClient(bus_ip, bus_port, module='Files')
+        self.path = Path(path)
+        self.files = files
+        for file in self.files:
+            if 'desc' not in file:
+                file['desc'] = ''
+            if 'mode' not in file:
+                file['mode'] = 'ro'
+            file['_path'] = self.path.joinpath(file['path'])
+            file['st_mtime_ns'] = 0
+        self.rta = Tag(rta_tag, dict)
+        self.busclient.add_callback_rta(rta_tag, self.rta_cb)
+        self.scan_files()
+
+    def scan_files(self):
+        """Scan folders for files."""
+        update = False
+        for file in self.files:
+            stat = file['_path'].parent.stat()
+            if stat.st_mtime_ns <= file['st_mtime_ns']:
+                continue
+            update = True
+            file['st_mtime_ns'] = stat.st_mtime_ns
+        if not update:
+            return
+        info = []
+        for file in self.files:
+            path = file['_path']
+            for fn in sorted(Path(path.parent).glob(path.name)):
+                logging.info(fn)
+                info.append({'path': file['path'].split('/')[0],
+                             'name': fn.name,
+                             'desc': file['desc'],
+                             'mode': file['mode']})
+        self.rta.value = {'__rta_id__': 0, 'dat': info}
+
+    def rta_cb(self, tag):
+        """Respond to bus requests for data to publish on rta."""
+        logging.info(f'files rta_cb {tag.name} {tag.value}')
+        pass
+
+    async def check_files(self):
+        """Check to see if any files have changed."""
+        self.scan_files()
+
+    async def start(self):
+        """Async startup."""
+        await self.busclient.start()
+        self.periodic = Periodic(self.check_files, RATE)
+        await self.periodic.start()

{pymscada-0.1.0a5 → pymscada-0.1.1}/src/pymscada/history.py

@@ -65,7 +65,7 @@ class TagHistory():
 
     def __init__(self, tagname: str, tagtype, path: str,
                  min=None, max=None, deadband=None):
-        """Create persistent tag store. Respond to RQS."""
+        """Create persistent tag store. Respond to RTA."""
         self.name = tagname
         if type(tagtype) is type:
             self.type = tagtype
@@ -189,17 +189,18 @@ class History():
     """Connect to bus_ip:bus_port, store and provide a value history."""
 
     def __init__(self, bus_ip: str = '127.0.0.1', bus_port: int = 1324,
-                 path: str = 'history', tag_info: dict = {}) -> None:
+                 path: str = 'history', tag_info: dict = {},
+                 rta_tag: str = '__history__') -> None:
         """
         Connect to bus_ip:bus_port, store and provide a value history.
 
         History files are binary files named <tagname>_<time_us>.dat. On
-        receipt of a request via RQS message, History will send the data
-        via __history__.value which you can watch with a tag.add_callback.
+        receipt of a request via RTA message, History will send the data
+        via rta_tag.value which you can watch with a tag.add_callback.
 
         Event loop must be running.
         """
-        self.busclient = BusClient(bus_ip, bus_port)
+        self.busclient = BusClient(bus_ip, bus_port, module='History')
         self.path = path
         self.tags: dict[str, Tag] = {}
         self.hist_tags: dict[str, TagHistory] = {}
@@ -212,24 +213,24 @@ class History():
                 deadband=tag['deadband'])
             self.tags[tagname] = Tag(tagname, tag['type'])
             self.tags[tagname].add_callback(self.hist_tags[tagname].callback)
-        self.rqs = Tag('__history__', bytes)
-        self.rqs.value = b'\x00\x00\x00\x00\x00\x00'
-        self.busclient.add_callback_rqs('__history__', self.rqs_cb)
+        self.rta = Tag(rta_tag, bytes)
+        self.rta.value = b'\x00\x00\x00\x00\x00\x00'
+        self.busclient.add_callback_rta(rta_tag, self.rta_cb)
 
-    def rqs_cb(self, request):
-        """Respond to bus requests for data to publish on rqs."""
+    def rta_cb(self, request):
+        """Respond to bus requests for data to publish on rta."""
         if 'start_ms' in request:
             request['start_us'] = request['start_ms'] * 1000
             request['end_us'] = request['end_ms'] * 1000
-        rqs_id = 0
-        if '__rqs_id__' in request:
-            rqs_id = request['__rqs_id__']
+        rta_id = 0
+        if '__rta_id__' in request:
+            rta_id = request['__rta_id__']
         tagname = request['tagname']
         start_time = time.asctime(time.localtime(
             request['start_us'] / 1000000))
         end_time = time.asctime(time.localtime(
             request['end_us'] / 1000000))
-        logging.info(f"RQS {tagname} {start_time} {end_time}")
+        logging.info(f"RTA {tagname} {start_time} {end_time}")
         try:
             data = self.hist_tags[request['tagname']].read_bytes(
                 request['start_us'], request['end_us'])
@@ -240,11 +241,11 @@ class History():
                 packtype = 1
             elif tagtype == float:
                 packtype = 2
-            self.rqs.value = pack('>HHH', rqs_id, tagid, packtype) + data
+            self.rta.value = pack('>HHH', rta_id, tagid, packtype) + data
             logging.info(f'sent {len(data)} bytes for {request["tagname"]}')
-            self.rqs.value = b'\x00\x00\x00\x00\x00\x00'
+            self.rta.value = b'\x00\x00\x00\x00\x00\x00'
         except Exception as e:
-            logging.error(f'history rqs_cb {e}')
+            logging.error(f'history rta_cb {e}')
 
     async def start(self):
         """Async startup."""

{pymscada-0.1.0a5 → pymscada-0.1.1}/src/pymscada/iodrivers/logix_client.py

@@ -60,7 +60,7 @@ class LogixClient:
         """
         self.busclient = None
         if bus_ip is not None:
-            self.busclient = BusClient(bus_ip, bus_port)
+            self.busclient = BusClient(bus_ip, bus_port, module='Logix Client')
         self.mapping = LogixMaps(tags)
         self.connections: list[LogixClientConnector] = []
         for rtu in rtus:

{pymscada-0.1.0a5 → pymscada-0.1.1}/src/pymscada/iodrivers/modbus_client.py

@@ -249,7 +249,8 @@ class ModbusClient:
         """
         self.busclient = None
         if bus_ip is not None:
-            self.busclient = BusClient(bus_ip, bus_port)
+            self.busclient = BusClient(bus_ip, bus_port,
+                                       module='Modbus Client')
         self.mapping = ModbusMaps(tags)
         self.connections: list[ModbusClientConnector] = []
         for rtu in rtus:

{pymscada-0.1.0a5 → pymscada-0.1.1}/src/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['read']
+            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(':')