adapt CANalystIIBus

Author: zariiii9003

can/interfaces/canalystii.py

@@ -1,24 +1,27 @@
 import collections
 from ctypes import c_ubyte
 import logging
-import canalystii as driver
 import time
-import warnings
 from typing import Any, Dict, Optional, Deque, Sequence, Tuple, Union
-from can import BitTiming, BusABC, Message
-from can.exceptions import CanTimeoutError
+
+from can import BitTiming, BusABC, Message, BitTimingFd
+from can.exceptions import CanTimeoutError, CanInitializationError
 from can.typechecking import CanFilters
+from can.util import deprecated_args_alias
+
+import canalystii as driver
 
 logger = logging.getLogger(__name__)
 
 
 class CANalystIIBus(BusABC):
+    @deprecated_args_alias(bit_timing="timing")
     def __init__(
         self,
         channel: Union[int, Sequence[int], str] = (0, 1),
         device: int = 0,
         bitrate: Optional[int] = None,
-        bit_timing: Optional[BitTiming] = None,
+        timing: Optional[Union[BitTiming, BitTimingFd]] = None,
         can_filters: Optional[CanFilters] = None,
         rx_queue_size: Optional[int] = None,
         **kwargs: Dict[str, Any],
@@ -33,9 +36,12 @@ def __init__(
             Optional USB device number. Default is 0 (first device found).
         :param bitrate:
             CAN bitrate in bits/second. Required unless the bit_timing argument is set.
-        :param bit_timing:
-            Optional BitTiming instance to use for custom bit timing setting.
-            If this argument is set then it overrides the bitrate argument.
+        :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 8_000_000 (8MHz)
+            for standard CAN.
+            CAN FD and the :class:`~can.BitTimingFd` class are not supported.
         :param can_filters:
             Optional filters for received CAN messages.
         :param rx_queue_size:
@@ -44,8 +50,8 @@ def __init__(
         """
         super().__init__(channel=channel, can_filters=can_filters, **kwargs)
 
-        if not (bitrate or bit_timing):
-            raise ValueError("Either bitrate or bit_timing argument is required")
+        if not (bitrate or timing):
+            raise ValueError("Either bitrate or timing argument is required")
 
         if isinstance(channel, str):
             # Assume comma separated string of channels
@@ -63,17 +69,17 @@ def __init__(
 
         self.device = driver.CanalystDevice(device_index=device)
         for channel in self.channels:
-            if bit_timing:
-                try:
-                    if bit_timing.f_clock != 8_000_000:
-                        warnings.warn(
-                            f"bit_timing.f_clock value {bit_timing.f_clock} "
-                            "doesn't match expected device f_clock 8MHz."
-                        )
-                except ValueError:
-                    pass  # f_clock not specified
-                self.device.init(
-                    channel, timing0=bit_timing.btr0, timing1=bit_timing.btr1
+            if isinstance(timing, BitTiming):
+                if timing.f_clock != 8_000_000:
+                    raise CanInitializationError(
+                        f"timing.f_clock value {timing.f_clock} "
+                        "doesn't match expected device f_clock 8MHz."
+                    )
+
+                self.device.init(channel, timing0=timing.btr0, timing1=timing.btr1)
+            elif isinstance(timing, BitTimingFd):
+                raise NotImplementedError(
+                    f"CAN FD is not supported by {self.__class__.__name__}."
                 )
             else:
                 self.device.init(channel, bitrate=bitrate)

test/test_interface_canalystii.py

@@ -39,8 +39,10 @@ def test_initialize_single_channel_only(self):
     def test_initialize_with_timing_registers(self):
         with create_mock_device() as mock_device:
             instance = mock_device.return_value
-            timing = can.BitTiming(btr0=0x03, btr1=0x6F)
-            bus = CANalystIIBus(bitrate=None, bit_timing=timing)
+            timing = can.BitTiming.from_registers(
+                f_clock=8_000_000, btr0=0x03, btr1=0x6F
+            )
+            bus = CANalystIIBus(bitrate=None, timing=timing)
             instance.init.assert_has_calls(
                 [
                     call(0, timing0=0x03, timing1=0x6F),
@@ -50,15 +52,9 @@ def test_initialize_with_timing_registers(self):
 
     def test_missing_bitrate(self):
         with self.assertRaises(ValueError) as cm:
-            bus = CANalystIIBus(0, bitrate=None, bit_timing=None)
+            bus = CANalystIIBus(0, bitrate=None, timing=None)
         self.assertIn("bitrate", str(cm.exception))
 
-    def test_invalid_bit_timing(self):
-        with create_mock_device() as mock_device:
-            with self.assertRaises(ValueError) as cm:
-                invalid_timings = can.BitTiming()
-                CANalystIIBus(0, bit_timing=invalid_timings)
-
     def test_receive_message(self):
         driver_message = driver.Message(
             can_id=0x333,