add strict parameter to can.BitTimingFd

Author: zariiii9003

can/bit_timing.py

@@ -491,7 +491,7 @@ class BitTimingFd(Mapping):
         )
     """
 
-    def __init__(
+    def __init__(  # pylint: disable=too-many-arguments
         self,
         f_clock: int,
         nom_brp: int,
@@ -502,6 +502,7 @@ def __init__(
         data_tseg1: int,
         data_tseg2: int,
         data_sjw: int,
+        strict: bool = False,
     ) -> None:
         """
         Initialize a BitTimingFd instance with the specified parameters.
@@ -530,6 +531,10 @@ def __init__(
         :param int data_sjw:
             The Synchronization Jump Width for the data phase. This value determines
             the maximum number of time quanta that the controller can resynchronize every bit.
+        :param strict:
+            If True, restrict bit timings to the minimum required range as defined in
+            ISO 11898. This can be used to ensure compatibility across a wide variety
+            of CAN hardware.
         :raises ValueError:
             if the arguments are invalid.
         """
@@ -545,32 +550,23 @@ def __init__(
             "data_sjw": data_sjw,
         }
         self._validate()
+        if strict:
+            self._restrict_to_minimum_range()
 
     def _validate(self) -> None:
-        if self.nbt < 8:
-            raise ValueError(f"nominal bit time (={self.nbt}) must be at least 8.")
-
-        if self.dbt < 8:
-            raise ValueError(f"data bit time (={self.dbt}) must be at least 8.")
+        for param, value in self._data.items():
+            if value < 0:  # type: ignore[operator]
+                err_msg = f"'{param}' (={value}) must not be negative."
+                raise ValueError(err_msg)
 
-        if not 1 <= self.nom_brp <= 256:
+        if self.nom_brp < 1:
             raise ValueError(
-                f"nominal bitrate prescaler (={self.nom_brp}) must be in [1...256]."
+                f"nominal bitrate prescaler (={self.nom_brp}) must be at least 1."
             )
 
-        if not 1 <= self.data_brp <= 256:
+        if self.data_brp < 1:
             raise ValueError(
-                f"data bitrate prescaler (={self.data_brp}) must be in [1...256]."
-            )
-
-        if not 5_000 <= self.nom_bitrate <= 2_000_000:
-            raise ValueError(
-                f"nom_bitrate (={self.nom_bitrate}) must be in [5,000...2,000,000]."
-            )
-
-        if not 25_000 <= self.data_bitrate <= 8_000_000:
-            raise ValueError(
-                f"data_bitrate (={self.data_bitrate}) must be in [25,000...8,000,000]."
+                f"data bitrate prescaler (={self.data_brp}) must be at least 1."
             )
 
         if self.data_bitrate < self.nom_bitrate:
@@ -579,30 +575,12 @@ def _validate(self) -> None:
                 f"equal to nom_bitrate (={self.nom_bitrate})"
             )
 
-        if not 2 <= self.nom_tseg1 <= 256:
-            raise ValueError(f"nom_tseg1 (={self.nom_tseg1}) must be in [2...256].")
-
-        if not 1 <= self.nom_tseg2 <= 128:
-            raise ValueError(f"nom_tseg2 (={self.nom_tseg2}) must be in [1...128].")
-
-        if not 1 <= self.data_tseg1 <= 32:
-            raise ValueError(f"data_tseg1 (={self.data_tseg1}) must be in [1...32].")
-
-        if not 1 <= self.data_tseg2 <= 16:
-            raise ValueError(f"data_tseg2 (={self.data_tseg2}) must be in [1...16].")
-
-        if not 1 <= self.nom_sjw <= 128:
-            raise ValueError(f"nom_sjw (={self.nom_sjw}) must be in [1...128].")
-
         if self.nom_sjw > self.nom_tseg2:
             raise ValueError(
                 f"nom_sjw (={self.nom_sjw}) must not be "
                 f"greater than nom_tseg2 (={self.nom_tseg2})."
             )
 
-        if not 1 <= self.data_sjw <= 16:
-            raise ValueError(f"data_sjw (={self.data_sjw}) must be in [1...128].")
-
         if self.data_sjw > self.data_tseg2:
             raise ValueError(
                 f"data_sjw (={self.data_sjw}) must not be "
@@ -621,6 +599,44 @@ def _validate(self) -> None:
                 f"(data_sample_point={self.data_sample_point:.2f}%)."
             )
 
+    def _restrict_to_minimum_range(self) -> None:
+        # restrict to minimum required range as defined in ISO 11898
+        if not 8 <= self.nbt <= 80:
+            raise ValueError(f"Nominal bit time (={self.nbt}) must be in [8...80]")
+
+        if not 5 <= self.dbt <= 25:
+            raise ValueError(f"Nominal bit time (={self.dbt}) must be in [5...25]")
+
+        if not 1 <= self.data_tseg1 <= 16:
+            raise ValueError(f"data_tseg1 (={self.data_tseg1}) must be in [1...16].")
+
+        if not 2 <= self.data_tseg2 <= 8:
+            raise ValueError(f"data_tseg2 (={self.data_tseg2}) must be in [2...8].")
+
+        if not 1 <= self.data_sjw <= 8:
+            raise ValueError(f"data_sjw (={self.data_sjw}) must be in [1...8].")
+
+        if self.nom_brp == self.data_brp:
+            # shared prescaler
+            if not 2 <= self.nom_tseg1 <= 128:
+                raise ValueError(f"nom_tseg1 (={self.nom_tseg1}) must be in [2...128].")
+
+            if not 2 <= self.nom_tseg2 <= 32:
+                raise ValueError(f"nom_tseg2 (={self.nom_tseg2}) must be in [2...32].")
+
+            if not 1 <= self.nom_sjw <= 32:
+                raise ValueError(f"nom_sjw (={self.nom_sjw}) must be in [1...32].")
+        else:
+            # separate prescaler
+            if not 2 <= self.nom_tseg1 <= 64:
+                raise ValueError(f"nom_tseg1 (={self.nom_tseg1}) must be in [2...64].")
+
+            if not 2 <= self.nom_tseg2 <= 16:
+                raise ValueError(f"nom_tseg2 (={self.nom_tseg2}) must be in [2...16].")
+
+            if not 1 <= self.nom_sjw <= 16:
+                raise ValueError(f"nom_sjw (={self.nom_sjw}) must be in [1...16].")
+
     @classmethod
     def from_bitrate_and_segments(
         cls,
@@ -741,34 +757,36 @@ def from_sample_point(
 
         possible_solutions: List[BitTimingFd] = []
 
+        sync_seg = 1
+
         for nom_brp in range(1, 257):
             nbt = round(int(f_clock / (nom_bitrate * nom_brp)))
-            if nbt < 8:
+            if nbt < 1:
                 break
 
             effective_nom_bitrate = f_clock / (nbt * nom_brp)
             if abs(effective_nom_bitrate - nom_bitrate) > nom_bitrate / 256:
                 continue
 
             nom_tseg1 = int(round(nom_sample_point / 100 * nbt)) - 1
-            # limit tseg1, so tseg2 is at least 1 TQ
-            nom_tseg1 = min(nom_tseg1, nbt - 2)
+            # limit tseg1, so tseg2 is at least 2 TQ
+            nom_tseg1 = min(nom_tseg1, nbt - sync_seg - 2)
             nom_tseg2 = nbt - nom_tseg1 - 1
 
             nom_sjw = min(nom_tseg2, 128)
 
             for data_brp in range(1, 257):
                 dbt = round(int(f_clock / (data_bitrate * data_brp)))
-                if dbt < 8:
+                if dbt < 1:
                     break
 
                 effective_data_bitrate = f_clock / (dbt * data_brp)
                 if abs(effective_data_bitrate - data_bitrate) > data_bitrate / 256:
                     continue
 
                 data_tseg1 = int(round(data_sample_point / 100 * dbt)) - 1
-                # limit tseg1, so tseg2 is at least 1 TQ
-                data_tseg1 = min(data_tseg1, dbt - 2)
+                # limit tseg1, so tseg2 is at least 2 TQ
+                data_tseg1 = min(data_tseg1, dbt - sync_seg - 2)
                 data_tseg2 = dbt - data_tseg1 - 1
 
                 data_sjw = min(data_tseg2, 16)
@@ -784,6 +802,7 @@ def from_sample_point(
                         data_tseg1=data_tseg1,
                         data_tseg2=data_tseg2,
                         data_sjw=data_sjw,
+                        strict=True,
                     )
                     possible_solutions.append(bt)
                 except ValueError:

can/util.py

@@ -250,7 +250,8 @@ def _create_bus_config(config: Dict[str, Any]) -> typechecking.BusConfig:
                     **{
                         key: int(config[key])
                         for key in typechecking.BitTimingFdDict.__annotations__
-                    }
+                    },
+                    strict=False,
                 )
             elif set(typechecking.BitTimingDict.__annotations__).issubset(config):
                 config["timing"] = can.BitTiming(