adapt CantactBus

Author: zariiii9003

can/interfaces/cantact.py

@@ -4,14 +4,16 @@
 
 import time
 import logging
+from typing import Optional, Union, Any
 from unittest.mock import Mock
 
-from can import BusABC, Message
+from can import BusABC, Message, BitTiming, BitTimingFd
 from ..exceptions import (
     CanInitializationError,
     CanInterfaceNotImplementedError,
     error_check,
 )
+from ..util import deprecated_args_alias
 
 logger = logging.getLogger(__name__)
 
@@ -42,28 +44,32 @@ def _detect_available_configs():
             channels.append({"interface": "cantact", "channel": f"ch:{i}"})
         return channels
 
+    @deprecated_args_alias(bit_timing="timing")
     def __init__(
         self,
-        channel,
-        bitrate=500000,
-        poll_interval=0.01,
-        monitor=False,
-        bit_timing=None,
-        _testing=False,
-        **kwargs,
-    ):
+        channel: int,
+        bitrate: int = 500000,
+        poll_interval: float = 0.01,
+        monitor: bool = False,
+        timing: Optional[Union[BitTiming, BitTimingFd]] = None,
+        **kwargs: Any,
+    ) -> None:
         """
         :param int channel:
             Channel number (zero indexed, labeled on multi-channel devices)
         :param int bitrate:
             Bitrate in bits/s
         :param bool monitor:
             If true, operate in listen-only monitoring mode
-        :param BitTiming bit_timing:
-            Optional BitTiming to use for custom bit timing setting. Overrides bitrate if not None.
+        :param timing:
+            Optional :class:`~can.BitTiming` instance to use for custom bit timing setting.
+            If this argument is set then it overrides the bitrate argument. The
+            `f_clock` value of the timing instance must be set to 24_000_000 (24MHz)
+            for standard CAN.
+            CAN FD and the :class:`~can.BitTimingFd` class are not supported.
         """
 
-        if _testing:
+        if kwargs.get("_testing", False):
             self.interface = MockInterface()
         else:
             if cantact is None:
@@ -80,18 +86,28 @@ def __init__(
 
         # Configure the interface
         with error_check("Cannot setup the cantact.Interface", CanInitializationError):
-            if bit_timing is None:
-                # use bitrate
-                self.interface.set_bitrate(int(channel), int(bitrate))
-            else:
+            if isinstance(timing, BitTiming):
+                if timing.f_clock != 24_000_000:
+                    raise CanInitializationError(
+                        f"timing.f_clock value {timing.f_clock} "
+                        "doesn't match expected device f_clock 24MHz."
+                    )
                 # use custom bit timing
                 self.interface.set_bit_timing(
                     int(channel),
-                    int(bit_timing.brp),
-                    int(bit_timing.tseg1),
-                    int(bit_timing.tseg2),
-                    int(bit_timing.sjw),
+                    int(timing.brp),
+                    int(timing.tseg1),
+                    int(timing.tseg2),
+                    int(timing.sjw),
+                )
+            elif isinstance(timing, BitTimingFd):
+                raise NotImplementedError(
+                    f"CAN FD is not supported by {self.__class__.__name__}."
                 )
+            else:
+                # use bitrate
+                self.interface.set_bitrate(int(channel), int(bitrate))
+
             self.interface.set_enabled(int(channel), True)
             self.interface.set_monitor(int(channel), monitor)
             self.interface.start()

test/test_cantact.py

@@ -23,8 +23,10 @@ def test_bus_creation(self):
     def test_bus_creation_bittiming(self):
         cantact.MockInterface.set_bitrate.reset_mock()
 
-        bt = can.BitTiming(tseg1=13, tseg2=2, brp=6, sjw=1)
-        bus = can.Bus(channel=0, interface="cantact", bit_timing=bt, _testing=True)
+        bt = can.BitTiming(
+            f_clock=24_000_000, bitrate=500_000, tseg1=13, tseg2=2, sjw=1
+        )
+        bus = can.Bus(channel=0, interface="cantact", timing=bt, _testing=True)
         self.assertIsInstance(bus, cantact.CantactBus)
         cantact.MockInterface.set_bitrate.assert_not_called()
         cantact.MockInterface.set_bit_timing.assert_called()