Workaround issue when recevied serial packets are too large (#25)

Adds a workaround to trim the front off any packets that are larger than expected. This should help in the case the start of the packet was not correctly found.

To turn off the workaround, specify `ser.TRIM_LARGE_PACKETS = False` where `ser` is `MateNETSerial`.

This does not apply when using the PJON transport.

Also adds packet length checking for known packet types, for robustness.

Resolves #22

Author: jorticus

pymate/cstruct.py

@@ -26,6 +26,8 @@ class _struct(object):
         _size = fmt.size
         _nfields = nfields
 
+        size = fmt.size
+
         def __init__(self, *args, **kwargs):
             """
             Initialize the struct's fields from the provided args.

pymate/matenet/flexnetdc.py

@@ -161,7 +161,7 @@ def get_status(self):
     def get_status_raw(self):
         data = ''
         for i in range(0x0A,0x0F+1):
-            resp = self.send(MateNET.TYPE_STATUS, addr=i)
+            resp = self.send(MateNET.TYPE_STATUS, addr=i, response_len=(13*6))
             if not resp:
                 return None
             data += str(resp)

pymate/matenet/fx.py

@@ -14,6 +14,7 @@
 
 class FXStatusPacket(object):
     fmt = Struct('>BBBBBBBBBhBB')
+    size = fmt.size
 
     def __init__(self, misc=None):
         self.raw = None
@@ -220,7 +221,7 @@ def get_status(self):
         Request a status packet from the inverter
         :return: A FXStatusPacket
         """
-        resp = self.send(MateNET.TYPE_STATUS, addr=1)
+        resp = self.send(MateNET.TYPE_STATUS, addr=1, response_len=FXStatusPacket.size)
         if resp:
             status = FXStatusPacket.from_buffer(resp)
             self._is_230v = status.is_230v

pymate/matenet/matedevice.py

@@ -37,8 +37,8 @@ def __init__(self, matenet, port=0):
     def scan(self):
         return self.matenet.scan(self.port)
 
-    def send(self, ptype, addr, param=0):
-        return self.matenet.send(ptype, addr, param=param, port=self.port)
+    def send(self, ptype, addr, param=0, response_len=None):
+        return self.matenet.send(ptype, addr, param=param, port=self.port, response_len=None)
 
     def query(self, reg, param=0):
         return self.matenet.query(reg, param=param, port=self.port)

pymate/matenet/matenet.py

@@ -66,7 +66,7 @@ def __init__(self, port, supports_spacemark=None, tap=None):
 
         self.tap = tap
 
-    def send(self, ptype, addr, param=0, port=0):
+    def send(self, ptype, addr, param=0, port=0, response_len=None):
         """
         Send a MateNET packet to the bus (as if it was sent by a MATE unit) and return the response
         :param port: Port to send to, if a hub is present (0 if no hub or talking to the hub)
@@ -77,14 +77,17 @@ def send(self, ptype, addr, param=0, port=0):
         if self.log.isEnabledFor(logging.DEBUG):
             self.log.debug('Send [Port%d, Type=0x%.2x, Addr=0x%.4x, Param=0x%.4x]', port, ptype, addr, param)
 
+        if response_len is not None:
+            response_len += 1 # Account for command ack byte
+
         packet = MateNET.TxPacket(port, ptype, addr, param)
         data = None
         for i in range(self.RETRY_PACKET+1):
             try:
                 txbuf = packet.to_buffer()
                 self.port.send(txbuf)
 
-                rxbuf = self.port.recv()
+                rxbuf = self.port.recv(response_len)
                 if not rxbuf:
                     self.log.debug('RETRY')
                     continue  # No response - try again
@@ -131,7 +134,7 @@ def query(self, reg, param=0, port=0):
         :param param: Optional parameter
         :return: The value (16-bit uint)
         """
-        resp = self.send(MateNET.TYPE_QUERY, addr=reg, param=param, port=port)
+        resp = self.send(MateNET.TYPE_QUERY, addr=reg, param=param, port=port, response_len=MateNET.QueryResponse.size)
         if resp:
             response = MateNET.QueryResponse.from_buffer(resp)
             return response.value
@@ -144,7 +147,7 @@ def control(self, reg, value, port=0):
         :param port: Port (0-10)
         :return: ???
         """
-        resp = self.send(MateNET.TYPE_CONTROL, addr=reg, param=value, port=port)
+        resp = self.send(MateNET.TYPE_CONTROL, addr=reg, param=value, port=port, response_len=MateNET.QueryResponse.size)
         if resp:
             return None  # TODO: What kind of response do we get from a control packet?
 
@@ -168,6 +171,7 @@ def scan(self, port=0):
         """
         result = self.query(0x00, port=port)
         if result is not None:
+            # TODO: Don't know what the upper byte is for, but it is seen on some MX units
             result = result & 0x00FF
         return result
 
@@ -206,7 +210,7 @@ def find_device(self, device_type):
         mx = MateMXDevice(bus, port)
         """
         for i in range(0,10):
-            dtype = self.query(0x00, port=i)
+            dtype = self.scan(port=i)
             if dtype and dtype == device_type:
                 self.log.info('Found %s device at port %d',
                     MateNET.DEVICE_TYPES[dtype],

pymate/matenet/matenet_pjon.py

@@ -184,7 +184,7 @@ def _recv_frame(self, timeout=1.0):
         self.log.info('RX TIMEOUT')
         return None
 
-    def recv(self, timeout=1.0):
+    def recv(self, expected_len=None, timeout=1.0):
         """
         Receive a packet from PJON bus
         :param timeout: seconds to wait until returning, 0 to return immediately, None to block indefinitely
@@ -262,6 +262,8 @@ def recv(self, timeout=1.0):
             if len(payload) == 1:
                 raise RuntimeError("PJON error: Error returned from controller: %.2x" % (payload[0]))
 
+            # TODO: Validate payload length against expected_len
+
             return ''.join(chr(c) for c in payload) # TODO: Hacky
 
 if __name__ == "__main__":

pymate/matenet/matenet_ser.py

@@ -57,6 +57,9 @@ def __init__(self, comport, supports_spacemark=None):
         # Amount of time with no communication that signifies the end of the packet
         self.END_OF_PACKET_TIMEOUT = 0.02 # seconds
 
+        # Set to true to workaround issue where some received packets are too large
+        self.TRIM_LARGE_PACKETS = True
+
         self.supports_spacemark = supports_spacemark
         if self.supports_spacemark is None:
             self.supports_spacemark = (
@@ -97,7 +100,7 @@ def _calc_checksum(data):
         return sum(ord(c) for c in data) % 0xFFFF
 
     @staticmethod
-    def _parse_packet(data):
+    def _parse_packet(data, expected_len=None):
         """
         Parse a MATE packet, validatin the length and checksum
         :param data: Raw string data
@@ -109,6 +112,12 @@ def _parse_packet(data):
         if len(data) < 3:
             raise RuntimeError("Error receiving mate packet - Received packet too small (%d bytes)" % (len(data)))
 
+        if expected_len is not None:
+            if len(data) < expected_len:
+                raise RuntimeError("Error receiving mate packet - Received packet too small (%d bytes, expected %d)" % (len(data), expected_len))
+            if len(data) > expected_len:
+                RuntimeError("Error receiving mate packet - Received packet too large (%d bytes, expected %d)" % (len(data), expected_len)) 
+
         # Checksum
         packet = data[0:-2]
         expected_chksum = (ord(data[-2]) << 8) | ord(data[-1])
@@ -133,7 +142,7 @@ def send(self, data):
         # Rest of the bytes have bit8 cleared (data byte)
         self._write_9b(data[1:] + footer, 0)
 
-    def recv(self, timeout=1.0):
+    def recv(self, expected_len=None, timeout=1.0):
         """
         Receive a packet from the MateNET bus, waiting if necessary
         :param timeout: seconds to wait until returning, 0 to return immediately, None to block indefinitely
@@ -156,4 +165,10 @@ def recv(self, timeout=1.0):
         if self.log.isEnabledFor(logging.DEBUG):
             self.log.debug('RX: %s', (' '.join('%.2x' % ord(c) for c in rawdata)))
 
-        return MateNETSerial._parse_packet(rawdata)
+        if expected_len is not None:
+            expected_len += 2 # Account for checksum
+
+            if self.TRIM_LARGE_PACKETS and (len(rawdata) > expected_len):
+                rawdata = rawdata[-expected_len:]
+
+        return MateNETSerial._parse_packet(rawdata, expected_len)

pymate/matenet/mx.py

@@ -13,6 +13,7 @@
 
 class MXStatusPacket(object):
     fmt = Struct('>BbbbBBBBBHH')
+    size = fmt.size
 
     STATUS_SLEEPING = 0
     STATUS_FLOATING = 1
@@ -83,6 +84,7 @@ def __str__(self):
 
 class MXLogPagePacket(object):
     fmt = Struct('>BBBBBBBBBBBBBB')
+    size = fmt.size
 
     def __init__(self):
         self.day = None
@@ -162,7 +164,7 @@ def get_status(self):
         Request a status packet from the controller
         :return: A MXStatusPacket
         """
-        resp = self.send(MateNET.TYPE_STATUS, addr=1, param=0x00)
+        resp = self.send(MateNET.TYPE_STATUS, addr=1, param=0x00, response_len=MXStatusPacket.size)
         if resp:
             return MXStatusPacket.from_buffer(resp)
 
@@ -172,7 +174,7 @@ def get_logpage(self, day):
         :param day: The day, counting backwards from today (0:Today, -1..-255)
         :return: A MXLogPagePacket
         """
-        resp = self.send(MateNET.TYPE_LOG, addr=0, param=-day)
+        resp = self.send(MateNET.TYPE_LOG, addr=0, param=-day, response_len=MXLogPagePacket.size)
         if resp:
             return MXLogPagePacket.from_buffer(resp)