import logging
import time
from collections import deque
from ctypes import c_ubyte
from typing import Any, Deque, Dict, Optional, Sequence, Tuple, Union
import canalystii as driver
from can import BitTiming, BitTimingFd, BusABC, CanProtocol, Message
from can.exceptions import CanTimeoutError
from can.typechecking import CanFilters
from can.util import check_or_adjust_timing_clock, deprecated_args_alias
logger = logging.getLogger(__name__)
[docs]
class CANalystIIBus(BusABC):
@deprecated_args_alias(
deprecation_start="4.2.0", deprecation_end="5.0.0", bit_timing="timing"
)
def __init__(
self,
channel: Union[int, Sequence[int], str] = (0, 1),
device: int = 0,
bitrate: Optional[int] = None,
timing: Optional[Union[BitTiming, BitTimingFd]] = None,
can_filters: Optional[CanFilters] = None,
rx_queue_size: Optional[int] = None,
**kwargs: Dict[str, Any],
):
"""
:param channel:
Optional channel number, list/tuple of multiple channels, or comma
separated string of channels. Default is to configure both
channels.
:param device:
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 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:
If set, software received message queue can only grow to this many
messages (for all channels) before older messages are dropped
"""
if not (bitrate or timing):
raise ValueError("Either bitrate or timing argument is required")
# Do this after the error handling
super().__init__(
channel=channel,
can_filters=can_filters,
**kwargs,
)
if isinstance(channel, str):
# Assume comma separated string of channels
self.channels = [int(ch.strip()) for ch in channel.split(",")]
elif isinstance(channel, int):
self.channels = [channel]
else: # Sequence[int]
self.channels = list(channel)
self.channel_info = f"CANalyst-II: device {device}, channels {self.channels}"
self.rx_queue: Deque[Tuple[int, driver.Message]] = deque(maxlen=rx_queue_size)
self.device = driver.CanalystDevice(device_index=device)
self._can_protocol = CanProtocol.CAN_20
for single_channel in self.channels:
if isinstance(timing, BitTiming):
timing = check_or_adjust_timing_clock(timing, valid_clocks=[8_000_000])
self.device.init(
single_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(single_channel, bitrate=bitrate)
# Delay to use between each poll for new messages
#
# The timeout is deliberately kept low to avoid the possibility of
# a hardware buffer overflow. This value was determined
# experimentally, but the ideal value will depend on the specific
# system.
RX_POLL_DELAY = 0.020
def send(self, msg: Message, timeout: Optional[float] = None) -> None:
"""Send a CAN message to the bus
:param msg: message to send
:param timeout: timeout (in seconds) to wait for the TX queue to clear.
If set to ``None`` (default) the function returns immediately.
Note: Due to limitations in the device firmware and protocol, the
timeout will not trigger if there are problems with CAN arbitration,
but only if the device is overloaded with a backlog of too many
messages to send.
"""
raw_message = driver.Message(
msg.arbitration_id,
0, # timestamp
1, # time_flag
0, # send_type
msg.is_remote_frame,
msg.is_extended_id,
msg.dlc,
(c_ubyte * 8)(*msg.data),
)
if msg.channel is not None:
channel = msg.channel
elif len(self.channels) == 1:
channel = self.channels[0]
else:
raise ValueError(
"Message channel must be set when using multiple channels."
)
send_result = self.device.send(channel, [raw_message], timeout)
if timeout is not None and not send_result:
raise CanTimeoutError(f"Send timed out after {timeout} seconds")
def _recv_from_queue(self) -> Tuple[Message, bool]:
"""Return a message from the internal receive queue"""
channel, raw_msg = self.rx_queue.popleft()
# Protocol timestamps are in units of 100us, convert to seconds as
# float
timestamp = raw_msg.timestamp * 100e-6
return (
Message(
channel=channel,
timestamp=timestamp,
arbitration_id=raw_msg.can_id,
is_extended_id=raw_msg.extended,
is_remote_frame=raw_msg.remote,
dlc=raw_msg.data_len,
data=bytes(raw_msg.data),
),
False,
)
def poll_received_messages(self) -> None:
"""Poll new messages from the device into the rx queue but don't
return any message to the caller
Calling this function isn't necessary as polling the device is done
automatically when calling recv(). This function is for the situation
where an application needs to empty the hardware receive buffer without
consuming any message.
"""
for channel in self.channels:
self.rx_queue.extend(
(channel, raw_msg) for raw_msg in self.device.receive(channel)
)
def _recv_internal(
self, timeout: Optional[float] = None
) -> Tuple[Optional[Message], bool]:
"""
:param timeout: float in seconds
:return:
"""
if self.rx_queue:
return self._recv_from_queue()
deadline = None
while deadline is None or time.time() < deadline:
if deadline is None and timeout is not None:
deadline = time.time() + timeout
self.poll_received_messages()
if self.rx_queue:
return self._recv_from_queue()
# If blocking on a timeout, add a sleep before we loop again
# to reduce CPU usage.
if deadline is None or deadline - time.time() > 0.050:
time.sleep(self.RX_POLL_DELAY)
return (None, False)
def flush_tx_buffer(self, channel: Optional[int] = None) -> None:
"""Flush the TX buffer of the device.
:param channel:
Optional channel number to flush. If set to None, all initialized
channels are flushed.
Note that because of protocol limitations this function returning
doesn't mean that messages have been sent, it may also mean they
failed to send.
"""
if channel:
self.device.flush_tx_buffer(channel, float("infinity"))
else:
for ch in self.channels:
self.device.flush_tx_buffer(ch, float("infinity"))
def shutdown(self) -> None:
super().shutdown()
for channel in self.channels:
self.device.stop(channel)
self.device = None