Support alfid 64bits (#142)

* Modified ALFID to support 64bits addresses

Author: pylessard

test/client/test_security_access.py

@@ -201,10 +201,10 @@ def _test_send_key_wrongservice_exception(self):
         with self.assertRaises(UnexpectedResponseException) as handle:
             self.udsclient.send_key(0x06, b"\x11\x22\x33\x44")
 
-    def test_send_key_wrongservice_exception(self):
+    def test_send_key_wrongservice_no_exception(self):
         self.wait_request_and_respond(b"\x7E\x00") # Valid but wrong service (Tester Present)
 
-    def _test_send_key_wrongservice_exception(self):
+    def _test_send_key_wrongservice_no_exception(self):
         self.udsclient.config['exception_on_unexpected_response'] = False
         response = self.udsclient.send_key(0x06, b"\x11\x22\x33\x44")
         self.assertTrue(response.valid)

test/test_helper_class.py

@@ -25,7 +25,7 @@ def test_ali_oob_values(self):	# Out Of Bounds Value
             AddressAndLengthFormatIdentifier(memorysize_format=40, address_format=0)
 
         with self.assertRaises(ValueError):
-            AddressAndLengthFormatIdentifier(memorysize_format=8, address_format=48)
+            AddressAndLengthFormatIdentifier(memorysize_format=8, address_format=65)
 
         with self.assertRaises(ValueError):
             AddressAndLengthFormatIdentifier(memorysize_format='8', address_format=8)

udsoncan/__init__.py

@@ -294,12 +294,12 @@ class AddressAndLengthFormatIdentifier:
     This class defines how many bytes of a memorylocation, composed of an address and a memorysize, should be encoded when sent over the underlying protocol.
     Mainly used by :ref:`ReadMemoryByAddress<ReadMemoryByAddress>`, :ref:`WriteMemoryByAddress<WriteMemoryByAddress>`, :ref:`RequestDownload<RequestDownload>` and :ref:`RequestUpload<RequestUpload>` services
 
-    Defined by ISO-14229:2006, Annex G
+    Defined by ISO-14229:2020, Annex H
 
-    :param address_format: The number of bits on which an address should be encoded. Possible values are 8, 16, 24, 32, 40
+    :param address_format: The number of bits on which an address should be encoded. Possible values are 8, 16, 24, 32, 40, 48, 56, 64
     :type address_format: int
 
-    :param memorysize_format: The number of bits on which a memory size should be encoded. Possible values are 8, 16, 24, 32
+    :param memorysize_format: The number of bits on which a memory size should be encoded. Possible values are 8, 16, 24, 32, 40, 48, 56, 64
     :type memorysize_format: int
 
     """
@@ -308,14 +308,21 @@ class AddressAndLengthFormatIdentifier:
             16 	: 2,
             24	: 3,
             32 	: 4,
-            40	: 5
+            40	: 5,
+            48	: 6,
+            56	: 7,
+            64	: 8
     }
 
     memsize_map = {
-            8 : 1,
-            16 : 2,
-            24 : 3,
-            32 : 4
+            8 	: 1,
+            16 	: 2,
+            24	: 3,
+            32 	: 4,
+            40	: 5,
+            48	: 6,
+            56	: 7,
+            64	: 8
     }
 
     def __init__(self, address_format, memorysize_format):
@@ -397,15 +404,15 @@ def set_format_if_none(self, address_format=None, memorysize_format=None):
     # Finds the smallest size that fits the address
     def autosize_address(self, val):
         fmt = math.ceil(val.bit_length()/8)*8
-        if fmt > 40:
-            raise ValueError("address size must be smaller or equal than 40 bits")
+        if fmt > 64:
+            raise ValueError("address size must be smaller or equal than 64 bits")
         return fmt
 
     # Finds the smallest size that fits the memory size
     def autosize_memorysize(self, val):
         fmt = math.ceil(val.bit_length()/8)*8
-        if fmt > 32:
-            raise ValueError("memory size must be smaller or equal than 32 bits")
+        if fmt > 64:
+            raise ValueError("memory size must be smaller or equal than 64 bits")
         return fmt
 
     # Gets the address byte in the requested format