Report warning on unknown NRC (2020 support)

Author: pylessard

doc/source/udsoncan/questions_answers.rst

@@ -6,17 +6,8 @@ What version of the standard has been used?
 
 .. epigraph::
 
-   The cod ewas originally written based on ISO-14229:2006. Some addition from the 2013 version has been added, but not exhaustively.
+   The code was originally written based on ISO-14229:2006. Some addition from the 2013 and 2020 version has been added, but not exhaustively.
 
-Can we expect an update for the 2020 version?
----------------------------------------------
-
-.. epigraph::
-   
-   Yes, one day, when I'll put my hands on the 2020 document. 
-   Access to ISO standard costs money and this project is 100% voluntary.
-
------
 
 How reliable is this code?
 --------------------------
@@ -28,6 +19,8 @@ How reliable is this code?
 
    Only a few common services have been tested on a real ECU.
 
+   The project lacks static type check, but it is in the plan to introduce it.
+
 -----
 
 Why is there unimplemented services?
@@ -39,6 +32,7 @@ Why is there unimplemented services?
 
       - The actual synchronous client doesn't support it.
       - The ratio of "service usage in the industry" over "the amount of work necessary to implement it" is too poor.
+      - The service has been added in the 2020 version and I haven't taken the time to implement it.
 
    As for the client capabilities, I am aware that the single-request/single-response mechanism of the actual client is limiting. I believe it is enough to handle the majority of today's use-cases. 
    I may work in a future version for a more sophisticated client that will have message queues for each service with callback and everything, therefore allowing asynchronous services such as :ref:`ResponseOnEvent<ResponseOnEvent>` or :ref:`ReadDataByPeriodicIdentifier<ReadDataByPeriodicIdentifier>`

doc/source/udsoncan/request_response.rst

@@ -52,4 +52,4 @@ Response Codes
    :members: 
    :undoc-members:
    :member-order: bysource
-   :exclude-members: get_name, is_negative
+   :exclude-members: get_name, is_negative, is_supported_by_standard

test/test_response.py

@@ -1,5 +1,6 @@
 from udsoncan import Response, services
 from test.UdsTest import UdsTest
+import inspect
 
 class DummyServiceNormal(services.BaseService):
     _sid = 0x13
@@ -125,3 +126,20 @@ def test_from_input_param(self):
         with self.assertRaises(ValueError):
             response = Response(service=DummyServiceNormal(), code = 0x10, data=11)	
 
+    def test_all_response_code_have_version(self):
+        codes = [ member[1] for member in inspect.getmembers(Response.Code) if isinstance(member[1], int) and not member[0].startswith('_')]
+        self.assertGreater(len(codes), 0)
+        for code in codes:
+            # Make sure no exception is raised
+            Response.Code.is_supported_by_standard(code, 2006)
+            Response.Code.is_supported_by_standard(code, 2013)
+            Response.Code.is_supported_by_standard(code, 2020)
+
+        # Case of known code introduced in 2020
+        self.assertFalse(Response.Code.is_supported_by_standard(Response.Code.ResourceTemporarilyNotAvailable , 2006))
+        self.assertFalse(Response.Code.is_supported_by_standard(Response.Code.ResourceTemporarilyNotAvailable , 2013))
+        self.assertTrue(Response.Code.is_supported_by_standard(Response.Code.ResourceTemporarilyNotAvailable , 2020))
+
+        self.assertTrue(Response.Code.is_supported_by_standard(Response.Code.GeneralReject , 2006))
+        self.assertTrue(Response.Code.is_supported_by_standard(Response.Code.GeneralReject , 2013))
+        self.assertTrue(Response.Code.is_supported_by_standard(Response.Code.GeneralReject , 2020))

udsoncan/Response.py

@@ -113,7 +113,6 @@ class Code:
         ThrottlePedalTooLow = 0x8B
         TransmissionRangeNotInNeutral = 0x8C
         TransmissionRangeNotInGear = 0x8D
-        ISOSAEReserved = 0x8E
         BrakeSwitchNotClosed = 0x8F
         ShifterLeverNotInPark = 0x90
         TorqueConverterClutchLocked = 0x91
@@ -131,6 +130,92 @@ class Code:
         SecuredLinkNotSupported 			= 0x38 + 6
         CertificateNotAvailable 			= 0x38 + 7
         AuditTrailInformationNotAvailable 	= 0x38 + 8
+        
+        @classmethod
+        def is_supported_by_standard(cls, code, standard_version):
+            if not isinstance(code, int):
+                raise ValueError("given code must be an integer value, not %s" % (code.__class__.__name__))
+            
+            if not isinstance(standard_version, int):
+                raise ValueError("given standard_version must be an integer value, not %s" % (standard_version.__class__.__name__))
+
+            codes_version = {
+                cls.PositiveResponse : 2006,
+                cls.GeneralReject : 2006,
+                cls.ServiceNotSupported : 2006,
+                cls.SubFunctionNotSupported : 2006,
+                cls.IncorrectMessageLengthOrInvalidFormat : 2006,
+                cls.ResponseTooLong : 2006,
+                cls.BusyRepeatRequest : 2006,
+                cls.ConditionsNotCorrect : 2006,
+                cls.RequestSequenceError : 2006,
+                cls.NoResponseFromSubnetComponent : 2006,
+                cls.FailurePreventsExecutionOfRequestedAction : 2006,
+                cls.RequestOutOfRange : 2006,
+                cls.SecurityAccessDenied : 2006,
+                cls.AuthenticationRequired : 2006,
+                cls.InvalidKey : 2006,
+                cls.ExceedNumberOfAttempts : 2006,
+                cls.RequiredTimeDelayNotExpired : 2006,
+                cls.SecureDataTransmissionRequired : 2020,
+                cls.SecureDataTransmissionNotAllowed : 2020,
+                cls.SecureDataVerificationFailed : 2020,
+                cls.CertificateVerificationFailed_InvalidTimePeriod : 2020,
+                cls.CertificateVerificationFailed_InvalidSignature : 2020,
+                cls.CertificateVerificationFailed_InvalidChainOfTrust : 2020,
+                cls.CertificateVerificationFailed_InvalidType : 2020,
+                cls.CertificateVerificationFailed_InvalidFormat : 2020,
+                cls.CertificateVerificationFailed_InvalidContent : 2020,
+                cls.CertificateVerificationFailed_InvalidScope : 2020,
+                cls.CertificateVerificationFailed_InvalidCertificate : 2020,
+                cls.OwnershipVerificationFailed : 2020,
+                cls.ChallengeCalculationFailed : 2020,
+                cls.SettingAccessRightsFailed : 2020,
+                cls.SessionKeyCreationDerivationFailed : 2020,
+                cls.ConfigurationDataUsageFailed : 2020,
+                cls.DeAuthenticationFailed : 2020,
+                cls.UploadDownloadNotAccepted : 2006,
+                cls.TransferDataSuspended : 2006,
+                cls.GeneralProgrammingFailure : 2006,
+                cls.WrongBlockSequenceCounter : 2006,
+                cls.RequestCorrectlyReceived_ResponsePending : 2006,
+                cls.SubFunctionNotSupportedInActiveSession : 2006,
+                cls.ServiceNotSupportedInActiveSession : 2006,
+                cls.RpmTooHigh : 2006,
+                cls.RpmTooLow : 2006,
+                cls.EngineIsRunning : 2006,
+                cls.EngineIsNotRunning : 2006,
+                cls.EngineRunTimeTooLow : 2006,
+                cls.TemperatureTooHigh : 2006,
+                cls.TemperatureTooLow : 2006,
+                cls.VehicleSpeedTooHigh : 2006,
+                cls.VehicleSpeedTooLow : 2006,
+                cls.ThrottlePedalTooHigh : 2006,
+                cls.ThrottlePedalTooLow : 2006,
+                cls.TransmissionRangeNotInNeutral : 2006,
+                cls.TransmissionRangeNotInGear : 2006,
+                cls.BrakeSwitchNotClosed : 2006,
+                cls.ShifterLeverNotInPark : 2006,
+                cls.TorqueConverterClutchLocked : 2006,
+                cls.VoltageTooHigh : 2006,
+                cls.VoltageTooLow : 2006,
+                cls.ResourceTemporarilyNotAvailable : 2020,
+                cls.GeneralSecurityViolation : 2006,
+                cls.SecuredModeRequested : 2006,
+                cls.InsufficientProtection : 2006,
+                cls.TerminationWithSignatureRequested : 2006,
+                cls.AccessDenied : 2006,
+                cls.VersionNotSupported : 2006,
+                cls.SecuredLinkNotSupported : 2006,
+                cls.CertificateNotAvailable : 2006,
+                cls.AuditTrailInformationNotAvailable : 2006,
+            }
+
+            if code not in codes_version:
+                raise ValueError('Do not know the standard version in which this code has been introduced: %s' % (code))
+            
+            return standard_version >= codes_version[code]
+
 
         #Returns the name of the response code as a string
         @classmethod
@@ -154,7 +239,8 @@ def is_negative(cls, given_id):
                 if isinstance(member[1], int):
                     if member[1] == given_id:
                         return True
-            return False	
+            return False
+        
 
 
     def __init__(self, service = None, code = None, data=None):

udsoncan/client.py

@@ -1991,6 +1991,12 @@ def send_request(self, request, timeout=-1):
                 raise UnexpectedResponseException(response, msg)
 
             if not response.positive:
+                try:
+                    if not Response.Code.is_supported_by_standard(response.code, self.config['standard_version']):
+                        self.logger.warning('Given response code "%s" (0x%02x) is not supported byt the UDS standard version that the clients s enforcing (%s)' % (response.code_name, response.code, self.config['standard_version']))
+                except ValueError:
+                    self.logger.warning('Unkown response code "%s" (0x%02x)', response.code_name, response.code)
+
                 if not request.service.is_supported_negative_response(response.code):
                     self.logger.warning('Given response code "%s" (0x%02x) is not a supported negative response code according to UDS standard.' % (response.code_name, response.code))
 

udsoncan/services/__init__.py

@@ -38,7 +38,8 @@ class BaseService(ABC):
             Response.Code.FailurePreventsExecutionOfRequestedAction,
             Response.Code.SecurityAccessDenied, # ISO-14229:2006 Table A.1:  "Besides the mandatory use of this negative response code as specified in the applicable services within ISO 14229, this negative response code can also be used for any case where security is required and is not yet granted to perform the required service."
             Response.Code.RequestCorrectlyReceived_ResponsePending,
-            Response.Code.ServiceNotSupportedInActiveSession
+            Response.Code.ServiceNotSupportedInActiveSession,
+            Response.Code.ResourceTemporarilyNotAvailable
     ]
 
     @classmethod	# Returns the service ID used for a client request