add BitTiming configuration to PCAN

Author: zariiii9003

can/interfaces/pcan/pcan.py

@@ -7,10 +7,11 @@
 from datetime import datetime
 import platform
 
-from typing import Optional
+from typing import Optional, Union
 
 from packaging import version
 
+from ... import BitTiming, BitTimingFd
 from ...message import Message
 from ...bus import BusABC, BusState
 from ...util import len2dlc, dlc2len
@@ -57,6 +58,7 @@
     FEATURE_FD_CAPABLE,
     PCAN_DICT_STATUS,
     PCAN_BUSOFF_AUTORESET,
+    TPCANBaudrate,
 )
 
 
@@ -103,10 +105,11 @@
 class PcanBus(BusABC):
     def __init__(
         self,
-        channel="PCAN_USBBUS1",
-        device_id=None,
-        state=BusState.ACTIVE,
-        bitrate=500000,
+        channel: str = "PCAN_USBBUS1",
+        device_id: Optional[int] = None,
+        state: BusState = BusState.ACTIVE,
+        timing: Optional[Union[BitTiming, BitTimingFd]] = None,
+        bitrate: int = 500000,
         *args,
         **kwargs,
     ):
@@ -133,6 +136,18 @@ def __init__(
             BusState of the channel.
             Default is ACTIVE
 
+        :param timing:
+            An instance of :class:`~can.BitTiming` or :class:`~can.BitTimingFd`
+            to specify the bit timing parameters for the PCAN interface. If this parameter
+            is provided, it takes precedence over all other timing-related parameters.
+            If this parameter is not provided, the bit timing parameters can be specified
+            using the `bitrate` parameter for standard CAN or the `fd`, `f_clock`,
+            `f_clock_mhz`, `nom_brp`, `nom_tseg1`, `nom_tseg2`, `nom_sjw`, `data_brp`,
+            `data_tseg1`, `data_tseg2`, and `data_sjw` parameters for CAN FD.
+            Note that the `f_clock` value of the `timing` instance must be 8_000_000
+            for standard CAN or any of the following values for CAN FD: 20_000_000,
+            24_000_000, 30_000_000, 40_000_000, 60_000_000, 80_000_000.
+
         :param int bitrate:
             Bitrate of channel in bit/s.
             Default is 500 kbit/s.
@@ -222,8 +237,9 @@ def __init__(
                 raise ValueError(err_msg)
 
         self.channel_info = str(channel)
-        self.fd = kwargs.get("fd", False)
-        pcan_bitrate = PCAN_BITRATES.get(bitrate, PCAN_BAUD_500K)
+        self.fd = isinstance(timing, BitTimingFd) or (
+            timing is None and kwargs.get("fd", False)
+        )
 
         hwtype = PCAN_TYPE_ISA
         ioport = 0x02A0
@@ -241,28 +257,69 @@ def __init__(
         else:
             raise ValueError("BusState must be Active or Passive")
 
-        if self.fd:
-            f_clock_val = kwargs.get("f_clock", None)
-            if f_clock_val is None:
-                f_clock = "{}={}".format("f_clock_mhz", kwargs.get("f_clock_mhz", None))
-            else:
-                f_clock = "{}={}".format("f_clock", kwargs.get("f_clock", None))
-
-            fd_parameters_values = [f_clock] + [
-                f"{key}={kwargs.get(key, None)}"
-                for key in PCAN_FD_PARAMETER_LIST
-                if kwargs.get(key, None) is not None
+        if isinstance(timing, BitTimingFd):
+            valid_fd_clocks = [
+                20000000,
+                24000000,
+                30000000,
+                40000000,
+                60000000,
+                80000000,
             ]
-
-            self.fd_bitrate = " ,".join(fd_parameters_values).encode("ascii")
-
+            if timing.f_clock not in valid_fd_clocks:
+                raise CanInitializationError(
+                    f"The PcanBus requires one of the following CAN clocks for CAN FD: "
+                    f"{','.join([str(f) for f in valid_fd_clocks])} (timing={timing!r})"
+                )
+            self.fd_bitrate = (
+                f"f_clock={timing.f_clock},"
+                f"nom_brp={timing.nom_brp},"
+                f"nom_tseg1={timing.nom_tseg1},"
+                f"nom_tseg2={timing.nom_tseg2},"
+                f"nom_sjw={timing.nom_sjw},"
+                f"data_brp={timing.data_brp},"
+                f"data_tseg1={timing.data_tseg1},"
+                f"data_tseg2={timing.data_tseg2},"
+                f"data_sjw={timing.data_sjw}"
+            ).encode("ascii")
             result = self.m_objPCANBasic.InitializeFD(
                 self.m_PcanHandle, self.fd_bitrate
             )
-        else:
+        elif isinstance(timing, BitTiming):
+            if timing.f_clock != 8_000_000:
+                raise CanInitializationError(
+                    f"The PcanBus requires a 8MHz CAN clock for CAN2.0 (timing={timing!r})"
+                )
+            pcan_bitrate = TPCANBaudrate(timing.btr0 << 8 | timing.btr1)
             result = self.m_objPCANBasic.Initialize(
                 self.m_PcanHandle, pcan_bitrate, hwtype, ioport, interrupt
             )
+        else:
+            if self.fd:
+                f_clock_val = kwargs.get("f_clock", None)
+                if f_clock_val is None:
+                    f_clock = "{}={}".format(
+                        "f_clock_mhz", kwargs.get("f_clock_mhz", None)
+                    )
+                else:
+                    f_clock = "{}={}".format("f_clock", kwargs.get("f_clock", None))
+
+                fd_parameters_values = [f_clock] + [
+                    f"{key}={kwargs.get(key, None)}"
+                    for key in PCAN_FD_PARAMETER_LIST
+                    if kwargs.get(key, None) is not None
+                ]
+
+                self.fd_bitrate = " ,".join(fd_parameters_values).encode("ascii")
+
+                result = self.m_objPCANBasic.InitializeFD(
+                    self.m_PcanHandle, self.fd_bitrate
+                )
+            else:
+                pcan_bitrate = PCAN_BITRATES.get(bitrate, PCAN_BAUD_500K)
+                result = self.m_objPCANBasic.Initialize(
+                    self.m_PcanHandle, pcan_bitrate, hwtype, ioport, interrupt
+                )
 
         if result != PCAN_ERROR_OK:
             raise PcanCanInitializationError(self._get_formatted_error(result))