Disregard OD variable description in SdoClient.upload().

The upload method should behave as a raw producer of byte data.
Interpretation of the returned data based on the Object Dictionary is
the responsibility of the SdoVariable class, which delegates to the
generic ODVariable decoding functions.

Move the data truncation to the method SdoVariable.get_data(), where
access to the ODVariable is certain.

The only truncation that still happens is based on the response size
specified by the server, which might be smaller for e.g. expedited
upload.  Extend the upload() function docstring to clarify the changed
behavior.  Adjust the test case for expedited upload with unspecified
size in the response, which is the only incompatible change.

Author: acolomb

canopen/sdo/base.py

@@ -148,7 +148,18 @@ def __init__(self, sdo_node: SdoBase, od: objectdictionary.ODVariable):
         variable.Variable.__init__(self, od)
 
     def get_data(self) -> bytes:
-        return self.sdo_node.upload(self.od.index, self.od.subindex)
+        data = self.sdo_node.upload(self.od.index, self.od.subindex)
+        response_size = len(data)
+
+        # If size is available through variable in OD, then use the smaller of the two sizes.
+        # Some devices send U32/I32 even if variable is smaller in OD
+        if self.od.fixed_size:
+            # Get the size in bytes for this variable
+            var_size = len(self.od) // 8
+            if response_size is None or var_size < response_size:
+                # Truncate the data to specified size
+                data = data[0:var_size]
+        return data
 
     def set_data(self, data: bytes):
         force_segment = self.od.data_type == objectdictionary.DOMAIN

canopen/sdo/client.py

@@ -105,6 +105,10 @@ def abort(self, abort_code=0x08000000):
     def upload(self, index: int, subindex: int) -> bytes:
         """May be called to make a read operation without an Object Dictionary.
 
+        No validation against the Object Dictionary is performed, even if an object description
+        would be available.  The length of the returned data depends only on the transferred
+        amount, possibly truncated to the size indicated by the server.
+
         :param index:
             Index of object to read.
         :param subindex:
@@ -121,17 +125,8 @@ def upload(self, index: int, subindex: int) -> bytes:
             response_size = fp.size
             data = fp.read()
 
-        # If size is available through variable in OD, then use the smaller of the two sizes.
-        # Some devices send U32/I32 even if variable is smaller in OD
-        var = self.od.get_variable(index, subindex)
-        if var is not None:
-            # Found a matching variable in OD
-            if var.fixed_size:
-                # Get the size in bytes for this variable
-                var_size = len(var) // 8
-                if response_size is None or var_size < response_size:
-                    # Truncate the data to specified size
-                    data = data[0:var_size]
+        if response_size and response_size < len(data):
+            data = data[:response_size]
         return data
 
     def download(

test/test_sdo.py

@@ -102,9 +102,9 @@ def test_size_not_specified(self):
             (TX, b'\x40\x00\x14\x02\x00\x00\x00\x00'),
             (RX, b'\x42\x00\x14\x02\xfe\x00\x00\x00')
         ]
-        # Make sure the size of the data is 1 byte
+        # This method used to truncate to 1 byte, but returns raw content now
         data = self.network[2].sdo.upload(0x1400, 2)
-        self.assertEqual(data, b'\xfe')
+        self.assertEqual(data, b'\xfe\x00\x00\x00')
         self.assertTrue(self.message_sent)
 
     def test_expedited_download(self):