diff --git a/.appveyor.yml b/.appveyor.yml
deleted file mode 100644
index 500c71320..000000000
--- a/.appveyor.yml
+++ /dev/null
@@ -1,27 +0,0 @@
-environment:
- matrix:
-
- # For Python versions available on Appveyor, see
- # https://www.appveyor.com/docs/windows-images-software/#python
- # Only Python 3.6+ is supported
-
- - PYTHON: "C:\\Python36"
- - PYTHON: "C:\\Python37"
- - PYTHON: "C:\\Python36-x64"
- - PYTHON: "C:\\Python37-x64"
-
-install:
- # Prepend Python installation and scripts (e.g. pytest) to PATH
- - set PATH=%PYTHON%;%PYTHON%\\Scripts;%PATH%
-
- # We need to install the python-can library itself including the dependencies
- - "python -m pip install .[test,neovi]"
-
-build: off
-
-test_script:
- # run tests
- - "pytest"
-
- # uplad coverage reports
- - "codecov -X gcov"
diff --git a/.codecov.yml b/.codecov.yml
deleted file mode 100644
index 16168f521..000000000
--- a/.codecov.yml
+++ /dev/null
@@ -1,21 +0,0 @@
-# Validate with curl --data-binary @.codecov.yml https://codecov.io/validate
-codecov:
- archive:
- uploads: no
-
-coverage:
- precision: 2
- round: down
- range: 50...100
- status:
- project:
- default:
- # coverage may fall by <1.0% and still be considered "passing"
- threshold: 1.0%
- patch:
- default:
- # coverage may fall by <1.0% and still be considered "passing"
- threshold: 1.0%
-
-comment:
- layout: "header, diff, changes"
diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 000000000..a661f6235
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1,2 @@
+.git* export-ignore
+.*.yml export-ignore
diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md
new file mode 100644
index 000000000..0fe9b647c
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -0,0 +1,41 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: bug
+assignees: ''
+
+---
+
+### Describe the bug
+
+
+
+### To Reproduce
+
+
+
+### Expected behavior
+
+
+
+### Additional context
+
+OS and version:
+Python version:
+python-can version:
+python-can interface/s (if applicable):
+
+
+
+Traceback and logs
+
+
+
+
+
+```python
+def func():
+ return "hello, world!"
+```
+ minimum time between replayed frames""",
+ help=" minimum time between replayed frames",
default=0.0001,
)
- parser.add_argument(
+ player_group.add_argument(
"-s",
"--skip",
type=float,
default=60 * 60 * 24,
- help=""" skip gaps greater than 's' seconds""",
+ help="Skip gaps greater than 's' seconds between messages. "
+ "Default is 86400 (24 hours), meaning only very large gaps are skipped. "
+ "Set to 0 to never skip any gaps (all delays are preserved). "
+ "Set to a very small value (e.g., 1e-4) "
+ "to skip all gaps and send messages as fast as possible.",
)
-
- parser.add_argument(
+ player_group.add_argument(
+ "-l",
+ "--loop",
+ type=_parse_loop,
+ metavar="NUM",
+ default=1,
+ help="Replay file NUM times. Use 'i' for infinite loop (default: 1)",
+ )
+ player_group.add_argument(
"infile",
metavar="input-file",
type=str,
help="The file to replay. For supported types see can.LogReader.",
)
+ # handle remaining arguments
+ _add_extra_args(player_group)
+
+ # add bus options
+ add_bus_arguments(parser)
+
# print help message when no arguments were given
if len(sys.argv) < 2:
parser.print_help(sys.stderr)
- import errno
-
raise SystemExit(errno.EINVAL)
- results = parser.parse_args()
+ results, unknown_args = parser.parse_known_args()
+ additional_config = _parse_additional_config([*results.extra_args, *unknown_args])
+ _set_logging_level_from_namespace(results)
verbosity = results.verbosity
- logging_level_name = ["critical", "error", "warning", "info", "debug", "subdebug"][
- min(5, verbosity)
- ]
- can.set_logging_level(logging_level_name)
-
error_frames = results.error_frames
- config = {"single_handle": True}
- if results.interface:
- config["interface"] = results.interface
- if results.bitrate:
- config["bitrate"] = results.bitrate
- if results.fd:
- config["fd"] = True
- if results.data_bitrate:
- config["data_bitrate"] = results.data_bitrate
- bus = Bus(results.channel, **config)
-
- reader = LogReader(results.infile)
-
- in_sync = MessageSync(
- reader, timestamps=results.timestamps, gap=results.gap, skip=results.skip
- )
-
- print(f"Can LogReader (Started on {datetime.now()})")
-
- try:
- for m in in_sync:
- if m.is_error_frame and not error_frames:
- continue
- if verbosity >= 3:
- print(m)
- bus.send(m)
- except KeyboardInterrupt:
- pass
- finally:
- bus.shutdown()
- reader.stop()
+ with create_bus_from_namespace(results) as bus:
+ loop_count: int | float = results.loop
+ iteration = 0
+ try:
+ while iteration < loop_count:
+ with LogReader(results.infile, **additional_config) as reader:
+ in_sync = MessageSync(
+ cast("Iterable[Message]", reader),
+ timestamps=results.timestamps,
+ gap=results.gap,
+ skip=results.skip,
+ )
+ print(_format_player_start_message(iteration, loop_count))
+
+ for message in in_sync:
+ if message.is_error_frame and not error_frames:
+ continue
+ if verbosity >= 3:
+ print(message)
+ bus.send(message)
+ iteration += 1
+ except KeyboardInterrupt:
+ pass
if __name__ == "__main__":
diff --git a/can/py.typed b/can/py.typed
new file mode 100644
index 000000000..e69de29bb
diff --git a/can/thread_safe_bus.py b/can/thread_safe_bus.py
index f36119751..518604364 100644
--- a/can/thread_safe_bus.py
+++ b/can/thread_safe_bus.py
@@ -1,4 +1,14 @@
+from contextlib import nullcontext
from threading import RLock
+from typing import TYPE_CHECKING, Any, cast
+
+from . import typechecking
+from .bus import BusState, CanProtocol
+from .interface import Bus
+from .message import Message
+
+if TYPE_CHECKING:
+ from .bus import BusABC
try:
# Only raise an exception on instantiation but allow module
@@ -7,33 +17,13 @@
import_exc = None
except ImportError as exc:
- ObjectProxy = object
+ ObjectProxy = None # type: ignore[misc,assignment]
import_exc = exc
-from .interface import Bus
-
-
-try:
- from contextlib import nullcontext # type: ignore
-
-except ImportError:
- class nullcontext: # type: ignore
- """A context manager that does nothing at all.
- A fallback for Python 3.7's :class:`contextlib.nullcontext` manager.
- """
-
- def __init__(self, enter_result=None):
- self.enter_result = enter_result
-
- def __enter__(self):
- return self.enter_result
-
- def __exit__(self, *args):
- pass
-
-
-class ThreadSafeBus(ObjectProxy): # pylint: disable=abstract-method
+class ThreadSafeBus(
+ ObjectProxy
+): # pylint: disable=abstract-method # type: ignore[assignment]
"""
Contains a thread safe :class:`can.BusABC` implementation that
wraps around an existing interface instance. All public methods
@@ -50,61 +40,82 @@ class ThreadSafeBus(ObjectProxy): # pylint: disable=abstract-method
instead of :meth:`~can.BusABC.recv` directly.
"""
- def __init__(self, *args, **kwargs):
+ def __init__(
+ self,
+ channel: typechecking.Channel | None = None,
+ interface: str | None = None,
+ config_context: str | None = None,
+ ignore_config: bool = False,
+ **kwargs: Any,
+ ) -> None:
if import_exc is not None:
raise import_exc
- super().__init__(Bus(*args, **kwargs))
+ super().__init__(
+ Bus(
+ channel=channel,
+ interface=interface,
+ config_context=config_context,
+ ignore_config=ignore_config,
+ **kwargs,
+ )
+ )
+
+ # store wrapped bus as a proxy-local attribute. Name it with the
+ # `_self_` prefix so wrapt won't forward it onto the wrapped object.
+ self._self_wrapped = cast(
+ "BusABC", object.__getattribute__(self, "__wrapped__")
+ )
# now, BusABC.send_periodic() does not need a lock anymore, but the
# implementation still requires a context manager
- # pylint: disable=protected-access
- self.__wrapped__._lock_send_periodic = nullcontext()
- # pylint: enable=protected-access
+ self._self_wrapped._lock_send_periodic = nullcontext() # type: ignore[assignment]
# init locks for sending and receiving separately
- self._lock_send = RLock()
- self._lock_recv = RLock()
-
- def recv(self, timeout=None, *args, **kwargs):
- with self._lock_recv:
- return self.__wrapped__.recv(timeout=timeout, *args, **kwargs)
+ self._self_lock_send = RLock()
+ self._self_lock_recv = RLock()
- def send(self, msg, timeout=None, *args, **kwargs):
- with self._lock_send:
- return self.__wrapped__.send(msg, timeout=timeout, *args, **kwargs)
+ def recv(self, timeout: float | None = None) -> Message | None:
+ with self._self_lock_recv:
+ return self._self_wrapped.recv(timeout=timeout)
- # send_periodic does not need a lock, since the underlying
- # `send` method is already synchronized
+ def send(self, msg: Message, timeout: float | None = None) -> None:
+ with self._self_lock_send:
+ return self._self_wrapped.send(msg=msg, timeout=timeout)
@property
- def filters(self):
- with self._lock_recv:
- return self.__wrapped__.filters
+ def filters(self) -> typechecking.CanFilters | None:
+ with self._self_lock_recv:
+ return self._self_wrapped.filters
@filters.setter
- def filters(self, filters):
- with self._lock_recv:
- self.__wrapped__.filters = filters
+ def filters(self, filters: typechecking.CanFilters | None) -> None:
+ with self._self_lock_recv:
+ self._self_wrapped.filters = filters
- def set_filters(self, filters=None, *args, **kwargs):
- with self._lock_recv:
- return self.__wrapped__.set_filters(filters=filters, *args, **kwargs)
+ def set_filters(self, filters: typechecking.CanFilters | None = None) -> None:
+ with self._self_lock_recv:
+ return self._self_wrapped.set_filters(filters=filters)
- def flush_tx_buffer(self, *args, **kwargs):
- with self._lock_send:
- return self.__wrapped__.flush_tx_buffer(*args, **kwargs)
+ def flush_tx_buffer(self) -> None:
+ with self._self_lock_send:
+ return self._self_wrapped.flush_tx_buffer()
- def shutdown(self, *args, **kwargs):
- with self._lock_send, self._lock_recv:
- return self.__wrapped__.shutdown(*args, **kwargs)
+ def shutdown(self) -> None:
+ with self._self_lock_send, self._self_lock_recv:
+ return self._self_wrapped.shutdown()
@property
- def state(self):
- with self._lock_send, self._lock_recv:
- return self.__wrapped__.state
+ def state(self) -> BusState:
+ with self._self_lock_send, self._self_lock_recv:
+ return self._self_wrapped.state
@state.setter
- def state(self, new_state):
- with self._lock_send, self._lock_recv:
- self.__wrapped__.state = new_state
+ def state(self, new_state: BusState) -> None:
+ with self._self_lock_send, self._self_lock_recv:
+ self._self_wrapped.state = new_state
+
+ @property
+ def protocol(self) -> CanProtocol:
+ with self._self_lock_send, self._self_lock_recv:
+ return self._self_wrapped.protocol
diff --git a/can/typechecking.py b/can/typechecking.py
index 0327874f5..56ac5927f 100644
--- a/can/typechecking.py
+++ b/can/typechecking.py
@@ -1,36 +1,82 @@
-"""Types for mypy type-checking
-"""
+"""Types for mypy type-checking"""
-import typing
+import io
+import os
+import sys
+from collections.abc import Iterable, Sequence
+from typing import IO, TYPE_CHECKING, Any, NewType, TypeAlias
-if typing.TYPE_CHECKING:
- import os
+if sys.version_info >= (3, 12):
+ from typing import TypedDict
+else:
+ from typing_extensions import TypedDict
-import mypy_extensions
-CanFilter = mypy_extensions.TypedDict("CanFilter", {"can_id": int, "can_mask": int})
-CanFilterExtended = mypy_extensions.TypedDict(
- "CanFilterExtended", {"can_id": int, "can_mask": int, "extended": bool}
-)
-CanFilters = typing.Sequence[typing.Union[CanFilter, CanFilterExtended]]
+if TYPE_CHECKING:
+ import struct
+
+
+class _CanFilterBase(TypedDict):
+ can_id: int
+ can_mask: int
+
+
+class CanFilter(_CanFilterBase, total=False):
+ extended: bool
+
+
+CanFilters = Sequence[CanFilter]
# TODO: Once buffer protocol support lands in typing, we should switch to that,
# since can.message.Message attempts to call bytearray() on the given data, so
# this should have the same typing info.
#
# See: https://github.com/python/typing/issues/593
-CanData = typing.Union[bytes, bytearray, int, typing.Iterable[int]]
+CanData = bytes | bytearray | int | Iterable[int]
# Used for the Abstract Base Class
-Channel = typing.Union[int, str]
+ChannelStr = str
+ChannelInt = int
+Channel = ChannelInt | ChannelStr | Sequence[ChannelInt]
# Used by the IO module
-FileLike = typing.IO[typing.Any]
-StringPathLike = typing.Union[str, "os.PathLike[str]"]
-AcceptedIOType = typing.Optional[typing.Union[FileLike, StringPathLike]]
+FileLike = IO[Any] | io.TextIOWrapper | io.BufferedIOBase
+StringPathLike = str | os.PathLike[str]
+
+BusConfig = NewType("BusConfig", dict[str, Any])
+
+# Used by CLI scripts
+TAdditionalCliArgs: TypeAlias = dict[str, str | int | float | bool]
+TDataStructs: TypeAlias = dict[
+ int | tuple[int, ...],
+ "struct.Struct | tuple[struct.Struct, *tuple[float, ...]]",
+]
+
+
+class AutoDetectedConfig(TypedDict):
+ interface: str
+ channel: Channel
+
+
+ReadableBytesLike = bytes | bytearray | memoryview
+
+
+class BitTimingDict(TypedDict):
+ f_clock: int
+ brp: int
+ tseg1: int
+ tseg2: int
+ sjw: int
+ nof_samples: int
-BusConfig = typing.NewType("BusConfig", dict)
-AutoDetectedConfig = mypy_extensions.TypedDict(
- "AutoDetectedConfig", {"interface": str, "channel": Channel}
-)
+class BitTimingFdDict(TypedDict):
+ f_clock: int
+ nom_brp: int
+ nom_tseg1: int
+ nom_tseg2: int
+ nom_sjw: int
+ data_brp: int
+ data_tseg1: int
+ data_tseg2: int
+ data_sjw: int
diff --git a/can/util.py b/can/util.py
index 968f1f7fd..4cbeec60e 100644
--- a/can/util.py
+++ b/can/util.py
@@ -2,20 +2,33 @@
Utilities and configuration file parsing.
"""
-from typing import Dict, Optional, Union
-
-from can import typechecking
-
+import contextlib
+import copy
+import functools
import json
+import logging
import os
import os.path
import platform
import re
-import logging
+import warnings
+from collections.abc import Callable, Iterable
from configparser import ConfigParser
+from time import get_clock_info, perf_counter, time
+from typing import (
+ Any,
+ TypeVar,
+ cast,
+)
+
+from typing_extensions import ParamSpec
import can
-from can.interfaces import VALID_INTERFACES
+
+from . import typechecking
+from .bit_timing import BitTiming, BitTimingFd
+from .exceptions import CanInitializationError, CanInterfaceNotImplementedError
+from .interfaces import VALID_INTERFACES
log = logging.getLogger("can.util")
@@ -27,15 +40,15 @@
CONFIG_FILES = ["~/can.conf"]
-if platform.system() == "Linux":
+if platform.system() in ("Linux", "Darwin"):
CONFIG_FILES.extend(["/etc/can.conf", "~/.can", "~/.canrc"])
elif platform.system() == "Windows" or platform.python_implementation() == "IronPython":
CONFIG_FILES.extend(["can.ini", os.path.join(os.getenv("APPDATA", ""), "can.ini")])
def load_file_config(
- path: Optional[typechecking.AcceptedIOType] = None, section: str = "default"
-) -> Dict[str, str]:
+ path: typechecking.StringPathLike | None = None, section: str = "default"
+) -> dict[str, str]:
"""
Loads configuration from file with following content::
@@ -50,20 +63,24 @@ def load_file_config(
name of the section to read configuration from.
"""
config = ConfigParser()
+
+ # make sure to not transform the entries such that capitalization is preserved
+ config.optionxform = lambda optionstr: optionstr # type: ignore[method-assign]
+
if path is None:
config.read([os.path.expanduser(path) for path in CONFIG_FILES])
else:
config.read(path)
- _config = {}
+ _config: dict[str, str] = {}
if config.has_section(section):
- _config.update(dict((key, val) for key, val in config.items(section)))
+ _config.update(config.items(section))
return _config
-def load_environment_config(context: Optional[str] = None) -> Dict[str, str]:
+def load_environment_config(context: str | None = None) -> dict[str, str]:
"""
Loads config dict from environmental variables (if set):
@@ -87,10 +104,9 @@ def load_environment_config(context: Optional[str] = None) -> Dict[str, str]:
"bitrate": "CAN_BITRATE",
}
- context_suffix = "_{}".format(context) if context else ""
-
- can_config_key = "CAN_CONFIG" + context_suffix
- config: Dict[str, str] = json.loads(os.environ.get(can_config_key, "{}"))
+ context_suffix = f"_{context}" if context else ""
+ can_config_key = f"CAN_CONFIG{context_suffix}"
+ config: dict[str, str] = json.loads(os.environ.get(can_config_key, "{}"))
for key, val in mapper.items():
config_option = os.environ.get(val + context_suffix, None)
@@ -101,9 +117,9 @@ def load_environment_config(context: Optional[str] = None) -> Dict[str, str]:
def load_config(
- path: Optional[typechecking.AcceptedIOType] = None,
- config=None,
- context: Optional[str] = None,
+ path: typechecking.StringPathLike | None = None,
+ config: dict[str, Any] | None = None,
+ context: str | None = None,
) -> typechecking.BusConfig:
"""
Returns a dict with configuration details which is loaded from (in this order):
@@ -130,7 +146,7 @@ def load_config(
It may set other values that are passed through.
:param context:
- Extra 'context' pass to config sources. This can be use to section
+ Extra 'context' pass to config sources. This can be used to section
other than 'default' in the configuration file.
:return:
@@ -148,96 +164,143 @@ def load_config(
All unused values are passed from ``config`` over to this.
:raises:
- NotImplementedError if the ``interface`` isn't recognized
+ CanInterfaceNotImplementedError if the ``interface`` name isn't recognized
"""
- # start with an empty dict to apply filtering to all sources
+ # Start with an empty dict to apply filtering to all sources
given_config = config or {}
config = {}
- # use the given dict for default values
- config_sources = [
- given_config,
- can.rc,
- lambda _context: load_environment_config( # pylint: disable=unnecessary-lambda
- _context
- ),
- lambda _context: load_environment_config(),
- lambda _context: load_file_config(path, _context),
- lambda _context: load_file_config(path),
- ]
+ # Use the given dict for default values
+ config_sources = cast(
+ "Iterable[dict[str, Any] | Callable[[Any], dict[str, Any]]]",
+ [
+ given_config,
+ can.rc,
+ lambda _context: load_environment_config( # pylint: disable=unnecessary-lambda
+ _context
+ ),
+ lambda _context: load_environment_config(),
+ lambda _context: load_file_config(path, _context),
+ lambda _context: load_file_config(path),
+ ],
+ )
# Slightly complex here to only search for the file config if required
- for cfg in config_sources:
- if callable(cfg):
- cfg = cfg(context)
+ for _cfg in config_sources:
+ cfg = _cfg(context) if callable(_cfg) else _cfg
# remove legacy operator (and copy to interface if not already present)
if "bustype" in cfg:
if "interface" not in cfg or not cfg["interface"]:
cfg["interface"] = cfg["bustype"]
del cfg["bustype"]
# copy all new parameters
- for key in cfg:
+ for key, val in cfg.items():
if key not in config:
- config[key] = cfg[key]
+ if isinstance(val, str):
+ config[key] = cast_from_string(val)
+ else:
+ config[key] = cfg[key]
+
+ bus_config = _create_bus_config(config)
+ can.log.debug("can config: %s", bus_config)
+ return bus_config
+
+def _create_bus_config(config: dict[str, Any]) -> typechecking.BusConfig:
+ """Validates some config values, performs compatibility mappings and creates specific
+ structures (e.g. for bit timings).
+
+ :param config: The raw config as specified by the user
+ :return: A config that can be used by a :class:`~can.BusABC`
+ :raises NotImplementedError: if the ``interface`` is unknown
+ """
# substitute None for all values not found
for key in REQUIRED_KEYS:
if key not in config:
config[key] = None
if config["interface"] not in VALID_INTERFACES:
- raise NotImplementedError(
- "Invalid CAN Bus Type - {}".format(config["interface"])
+ raise CanInterfaceNotImplementedError(
+ f'Unknown interface type "{config["interface"]}"'
)
+ if "port" in config:
+ # convert port to integer if necessary
+ if isinstance(config["port"], int):
+ port = config["port"]
+ elif isinstance(config["port"], str):
+ if config["port"].isnumeric():
+ config["port"] = port = int(config["port"])
+ else:
+ raise ValueError("Port config must be a number!")
+ else:
+ raise TypeError("Port config must be string or integer!")
+
+ if not 0 < port < 65535:
+ raise ValueError("Port config must be inside 0-65535 range!")
+
+ if "timing" not in config:
+ if timing := _dict2timing(config):
+ config["timing"] = timing
- if "bitrate" in config:
- config["bitrate"] = int(config["bitrate"])
if "fd" in config:
- config["fd"] = config["fd"] not in ("0", "False", "false")
- if "data_bitrate" in config:
- config["data_bitrate"] = int(config["data_bitrate"])
-
- # Create bit timing configuration if given
- timing_conf = {}
- for key in (
- "f_clock",
- "brp",
- "tseg1",
- "tseg2",
- "sjw",
- "nof_samples",
- "btr0",
- "btr1",
- ):
- if key in config:
- timing_conf[key] = int(config[key], base=0)
- del config[key]
- if timing_conf:
- timing_conf["bitrate"] = config.get("bitrate")
- config["timing"] = can.BitTiming(**timing_conf)
-
- can.log.debug("can config: {}".format(config))
- return config
+ config["fd"] = config["fd"] not in (0, False)
+
+ if "state" in config and not isinstance(config["state"], can.BusState):
+ try:
+ config["state"] = can.BusState[config["state"]]
+ except KeyError as e:
+ raise ValueError("State config not valid!") from e
+
+ return cast("typechecking.BusConfig", config)
+
+
+def _dict2timing(data: dict[str, Any]) -> BitTiming | BitTimingFd | None:
+ """Try to instantiate a :class:`~can.BitTiming` or :class:`~can.BitTimingFd` from
+ a dictionary. Return `None` if not possible."""
+
+ with contextlib.suppress(ValueError, TypeError):
+ if set(typechecking.BitTimingFdDict.__annotations__).issubset(data):
+ return BitTimingFd(
+ **{
+ key: int(data[key])
+ for key in typechecking.BitTimingFdDict.__annotations__
+ },
+ strict=False,
+ )
+ elif set(typechecking.BitTimingDict.__annotations__).issubset(data):
+ return BitTiming(
+ **{
+ key: int(data[key])
+ for key in typechecking.BitTimingDict.__annotations__
+ },
+ strict=False,
+ )
+
+ return None
+
+def set_logging_level(level_name: str) -> None:
+ """Set the logging level for the `"can"` logger.
-def set_logging_level(level_name: Optional[str] = None):
- """Set the logging level for the "can" logger.
- Expects one of: 'critical', 'error', 'warning', 'info', 'debug', 'subdebug'
+ :param level_name:
+ One of: `'critical'`, `'error'`, `'warning'`, `'info'`,
+ `'debug'`, `'subdebug'`, or the value :obj:`None` (=default).
+ Defaults to `'debug'`.
"""
can_logger = logging.getLogger("can")
try:
- can_logger.setLevel(getattr(logging, level_name.upper())) # type: ignore
+ can_logger.setLevel(getattr(logging, level_name.upper()))
except AttributeError:
can_logger.setLevel(logging.DEBUG)
- log.debug("Logging set to {}".format(level_name))
+ log.debug("Logging set to %s", level_name)
def len2dlc(length: int) -> int:
"""Calculate the DLC from data length.
- :param int length: Length in number of bytes (0-64)
+ :param length: Length in number of bytes (0-64)
:returns: DLC (0-15)
"""
@@ -259,29 +322,199 @@ def dlc2len(dlc: int) -> int:
return CAN_FD_DLC[dlc] if dlc <= 15 else 64
-def channel2int(channel: Optional[Union[typechecking.Channel]]) -> Optional[int]:
+def channel2int(channel: typechecking.Channel | None) -> int | None:
"""Try to convert the channel to an integer.
:param channel:
- Channel string (e.g. can0, CAN1) or integer
+ Channel string (e.g. `"can0"`, `"CAN1"`) or an integer
- :returns: Channel integer or `None` if unsuccessful
+ :returns: Channel integer or ``None`` if unsuccessful
"""
- if channel is None:
- return None
if isinstance(channel, int):
return channel
- # String and byte objects have a lower() method
- if hasattr(channel, "lower"):
- match = re.match(r".*(\d+)$", channel)
+ if isinstance(channel, str):
+ match = re.match(r".*?(\d+)$", channel)
if match:
return int(match.group(1))
return None
-if __name__ == "__main__":
- print("Searching for configuration named:")
- print("\n".join(CONFIG_FILES))
- print()
- print("Settings:")
- print(load_config())
+P1 = ParamSpec("P1")
+T1 = TypeVar("T1")
+
+
+def deprecated_args_alias(
+ deprecation_start: str,
+ deprecation_end: str | None = None,
+ **aliases: str | None,
+) -> Callable[[Callable[P1, T1]], Callable[P1, T1]]:
+ """Allows to rename/deprecate a function kwarg(s) and optionally
+ have the deprecated kwarg(s) set as alias(es)
+
+ Example::
+
+ @deprecated_args_alias("1.2.0", oldArg="new_arg", anotherOldArg="another_new_arg")
+ def library_function(new_arg, another_new_arg):
+ pass
+
+ @deprecated_args_alias(
+ deprecation_start="1.2.0",
+ deprecation_end="3.0.0",
+ oldArg="new_arg",
+ obsoleteOldArg=None,
+ )
+ def library_function(new_arg):
+ pass
+
+ :param deprecation_start:
+ The *python-can* version, that introduced the :class:`DeprecationWarning`.
+ :param deprecation_end:
+ The *python-can* version, that marks the end of the deprecation period.
+ :param aliases:
+ keyword arguments, that map the deprecated argument names
+ to the new argument names or ``None``.
+
+ """
+
+ def deco(f: Callable[P1, T1]) -> Callable[P1, T1]:
+ @functools.wraps(f)
+ def wrapper(*args: P1.args, **kwargs: P1.kwargs) -> T1:
+ _rename_kwargs(
+ func_name=f.__name__,
+ start=deprecation_start,
+ end=deprecation_end,
+ kwargs=kwargs,
+ aliases=aliases,
+ )
+ return f(*args, **kwargs)
+
+ return wrapper
+
+ return deco
+
+
+def _rename_kwargs(
+ func_name: str,
+ start: str,
+ end: str | None,
+ kwargs: dict[str, Any],
+ aliases: dict[str, str | None],
+) -> None:
+ """Helper function for `deprecated_args_alias`"""
+ for alias, new in aliases.items():
+ if alias in kwargs:
+ deprecation_notice = (
+ f"The '{alias}' argument is deprecated since python-can v{start}"
+ )
+ if end:
+ deprecation_notice += (
+ f", and scheduled for removal in python-can v{end}"
+ )
+ deprecation_notice += "."
+
+ value = kwargs.pop(alias)
+ if new is not None:
+ deprecation_notice += f" Use '{new}' instead."
+
+ if new in kwargs:
+ raise TypeError(
+ f"{func_name} received both '{alias}' (deprecated) and '{new}'."
+ )
+ kwargs[new] = value
+
+ warnings.warn(deprecation_notice, DeprecationWarning, stacklevel=3)
+
+
+T2 = TypeVar("T2", BitTiming, BitTimingFd)
+
+
+def check_or_adjust_timing_clock(timing: T2, valid_clocks: Iterable[int]) -> T2:
+ """Adjusts the given timing instance to have an *f_clock* value that is within the
+ allowed values specified by *valid_clocks*. If the *f_clock* value of timing is
+ already within *valid_clocks*, then *timing* is returned unchanged.
+
+ :param timing:
+ The :class:`~can.BitTiming` or :class:`~can.BitTimingFd` instance to adjust.
+ :param valid_clocks:
+ An iterable of integers representing the valid *f_clock* values that the timing instance
+ can be changed to. The order of the values in *valid_clocks* determines the priority in
+ which they are tried, with earlier values being tried before later ones.
+ :return:
+ A new :class:`~can.BitTiming` or :class:`~can.BitTimingFd` instance with an
+ *f_clock* value within *valid_clocks*.
+ :raises ~can.exceptions.CanInitializationError:
+ If no compatible *f_clock* value can be found within *valid_clocks*.
+ """
+ if timing.f_clock in valid_clocks:
+ # create a copy so this function always returns a new instance
+ return copy.deepcopy(timing)
+
+ for clock in valid_clocks:
+ try:
+ # Try to use a different f_clock
+ adjusted_timing = timing.recreate_with_f_clock(clock)
+ warnings.warn(
+ f"Adjusted f_clock in {timing.__class__.__name__} from "
+ f"{timing.f_clock} to {adjusted_timing.f_clock}",
+ stacklevel=2,
+ )
+ return adjusted_timing
+ except ValueError:
+ pass
+
+ raise CanInitializationError(
+ f"The specified timing.f_clock value {timing.f_clock} "
+ f"doesn't match any of the allowed device f_clock values: "
+ f"{', '.join([str(f) for f in valid_clocks])}"
+ ) from None
+
+
+def time_perfcounter_correlation() -> tuple[float, float]:
+ """Get the `perf_counter` value nearest to when time.time() is updated
+
+ Computed if the default timer used by `time.time` on this platform has a resolution
+ higher than 10μs, otherwise the current time and perf_counter is directly returned.
+ This was chosen as typical timer resolution on Linux/macOS is ~1μs, and the Windows
+ platform can vary from ~500μs to 10ms.
+
+ Note this value is based on when `time.time()` is observed to update from Python,
+ it is not directly returned by the operating system.
+
+ :returns:
+ (t, performance_counter) time.time value and time.perf_counter value when the time.time
+ is updated
+
+ """
+
+ # use this if the resolution is higher than 10us
+ if get_clock_info("time").resolution > 1e-5:
+ t0 = time()
+ while True:
+ t1, performance_counter = time(), perf_counter()
+ if t1 != t0:
+ break
+ else:
+ return time(), perf_counter()
+ return t1, performance_counter
+
+
+def cast_from_string(string_val: str) -> str | int | float | bool:
+ """Perform trivial type conversion from :class:`str` values.
+
+ :param string_val:
+ the string, that shall be converted
+ """
+ if re.match(r"^[-+]?\d+$", string_val):
+ # value is integer
+ return int(string_val)
+
+ if re.match(r"^[-+]?\d*\.\d+(?:e[-+]?\d+)?$", string_val):
+ # value is float
+ return float(string_val)
+
+ if re.match(r"^(?:True|False)$", string_val, re.IGNORECASE):
+ # value is bool
+ return string_val.lower() == "true"
+
+ # value is string
+ return string_val
diff --git a/can/viewer.py b/can/viewer.py
index 107c028ae..8d9d228bb 100644
--- a/can/viewer.py
+++ b/can/viewer.py
@@ -21,51 +21,63 @@
# e-mail : lauszus@gmail.com
import argparse
+import errno
import logging
import os
import struct
import sys
import time
-from typing import Dict, List, Tuple, Union
-import can
from can import __version__
+from can.cli import (
+ _set_logging_level_from_namespace,
+ add_bus_arguments,
+ create_bus_from_namespace,
+)
+from can.typechecking import TDataStructs
-logger = logging.getLogger("can.serial")
+logger = logging.getLogger("can.viewer")
try:
import curses
- from curses.ascii import ESC as KEY_ESC, SP as KEY_SPACE
+ from curses.ascii import ESC as KEY_ESC # type: ignore[attr-defined,unused-ignore]
+ from curses.ascii import SP as KEY_SPACE # type: ignore[attr-defined,unused-ignore]
except ImportError:
- # Probably on windows
+ # Probably on Windows while windows-curses is not installed (e.g. in PyPy)
logger.warning(
- "You won't be able to use the viewer program without " "curses installed!"
+ "You won't be able to use the viewer program without curses installed!"
)
- curses = None # type: ignore
+ curses = None # type: ignore[assignment]
-class CanViewer:
+class CanViewer: # pylint: disable=too-many-instance-attributes
def __init__(self, stdscr, bus, data_structs, testing=False):
self.stdscr = stdscr
self.bus = bus
self.data_structs = data_structs
- # Initialise the ID dictionary, start timestamp, scroll and variable for pausing the viewer
+ # Initialise the ID dictionary, Previous values dict, start timestamp,
+ # scroll and variables for pausing the viewer and enabling byte highlighting
self.ids = {}
self.start_time = None
self.scroll = 0
self.paused = False
+ self.highlight_changed_bytes = False
+ self.previous_values = {}
# Get the window dimensions - used for resizing the window
self.y, self.x = self.stdscr.getmaxyx()
- # Do not wait for key inputs, disable the cursor and choose the background color automatically
+ # Do not wait for key inputs, disable the cursor and choose the background color
+ # automatically
self.stdscr.nodelay(True)
curses.curs_set(0)
curses.use_default_colors()
# Used to color error frames red
curses.init_pair(1, curses.COLOR_RED, -1)
+ # Used to color changed bytes
+ curses.init_pair(2, curses.COLOR_CYAN, curses.COLOR_BLUE)
if not testing: # pragma: no cover
self.run()
@@ -74,7 +86,7 @@ def run(self):
# Clear the terminal and draw the header
self.draw_header()
- while 1:
+ while True:
# Do not read the CAN-Bus when in paused mode
if not self.paused:
# Read the CAN-Bus and draw it in the terminal window
@@ -93,12 +105,20 @@ def run(self):
break
# Clear by pressing 'c'
- elif key == ord("c"):
+ if key == ord("c"):
self.ids = {}
self.start_time = None
self.scroll = 0
self.draw_header()
+ # Toggle byte change highlighting pressing 'h'
+ elif key == ord("h"):
+ self.highlight_changed_bytes = not self.highlight_changed_bytes
+ if not self.highlight_changed_bytes:
+ # empty the previous values dict when leaving higlighting mode
+ self.previous_values.clear()
+ self.draw_header()
+
# Sort by pressing 's'
elif key == ord("s"):
# Sort frames based on the CAN-Bus ID
@@ -139,16 +159,13 @@ def run(self):
# Unpack the data and then convert it into SI-units
@staticmethod
- def unpack_data(
- cmd, cmd_to_struct, data
- ): # type: (int, Dict, bytes) -> List[Union[float, int]]
+ def unpack_data(cmd: int, cmd_to_struct: TDataStructs, data: bytes) -> list[float]:
if not cmd_to_struct or not data:
# These messages do not contain a data package
return []
- for key in cmd_to_struct:
+ for key, value in cmd_to_struct.items():
if cmd == key if isinstance(key, int) else cmd in key:
- value = cmd_to_struct[key]
if isinstance(value, tuple):
# The struct is given as the fist argument
struct_t: struct.Struct = value[0]
@@ -156,7 +173,9 @@ def unpack_data(
# The conversion from raw values to SI-units are given in the rest of the tuple
values = [
d // val if isinstance(val, int) else float(d) / val
- for d, val in zip(struct_t.unpack(data), value[1:])
+ for d, val in zip(
+ struct_t.unpack(data), value[1:], strict=False
+ )
]
else:
# No conversion from SI-units is needed
@@ -164,8 +183,8 @@ def unpack_data(
values = list(as_struct_t.unpack(data))
return values
- else:
- raise ValueError("Unknown command: 0x{:02X}".format(cmd))
+
+ raise ValueError(f"Unknown command: 0x{cmd:02X}")
def draw_can_bus_message(self, msg, sorting=False):
# Use the CAN-Bus ID as the key in the dict
@@ -186,6 +205,16 @@ def draw_can_bus_message(self, msg, sorting=False):
elif msg.dlc != self.ids[key]["msg"].dlc:
length_changed = True
+ # Clear the old data bytes when the length of the new message is shorter
+ if msg.dlc < self.ids[key]["msg"].dlc:
+ self.draw_line(
+ self.ids[key]["row"],
+ # Start drawing at the last byte that is not in the new message
+ 52 + msg.dlc * 3,
+ # Draw spaces where the old bytes were drawn
+ " " * ((self.ids[key]["msg"].dlc - msg.dlc) * 3 - 1),
+ )
+
if new_id_added or length_changed:
# Increment the index if it was just added, but keep it if the length just changed
row = len(self.ids) + 1 if new_id_added else self.ids[key]["row"]
@@ -206,8 +235,11 @@ def draw_can_bus_message(self, msg, sorting=False):
self.ids[key]["count"] += 1
# Format the CAN-Bus ID as a hex value
- arbitration_id_string = "0x{0:0{1}X}".format(
- msg.arbitration_id, 8 if msg.is_extended_id else 3
+ arbitration_id_string = (
+ "0x{0:0{1}X}".format( # pylint: disable=consider-using-f-string
+ msg.arbitration_id,
+ 8 if msg.is_extended_id else 3,
+ )
)
# Use red for error frames
@@ -221,22 +253,42 @@ def draw_can_bus_message(self, msg, sorting=False):
self.draw_line(
self.ids[key]["row"],
8,
- "{0:.6f}".format(self.ids[key]["msg"].timestamp - self.start_time),
+ f"{self.ids[key]['msg'].timestamp - self.start_time:.6f}",
color,
)
- self.draw_line(
- self.ids[key]["row"], 23, "{0:.6f}".format(self.ids[key]["dt"]), color
- )
+ self.draw_line(self.ids[key]["row"], 23, f"{self.ids[key]['dt']:.6f}", color)
self.draw_line(self.ids[key]["row"], 35, arbitration_id_string, color)
self.draw_line(self.ids[key]["row"], 47, str(msg.dlc), color)
+
+ try:
+ previous_byte_values = self.previous_values[key]
+ except KeyError: # no row of previous values exists for the current message ID
+ # initialise a row to store the values for comparison next time
+ self.previous_values[key] = {}
+ previous_byte_values = self.previous_values[key]
for i, b in enumerate(msg.data):
col = 52 + i * 3
if col > self.x - 2:
# Data does not fit
self.draw_line(self.ids[key]["row"], col - 4, "...", color)
break
- text = "{:02X}".format(b)
- self.draw_line(self.ids[key]["row"], col, text, color)
+ if self.highlight_changed_bytes:
+ try:
+ if b != previous_byte_values[i]:
+ # set colour to highlight a changed value
+ data_color = curses.color_pair(2)
+ else:
+ data_color = color
+ except KeyError:
+ # previous entry for byte didn't exist - default to rest of line colour
+ data_color = color
+ finally:
+ # write the new value to the previous values dict for next time
+ previous_byte_values[i] = b
+ else:
+ data_color = color
+ text = f"{b:02X}"
+ self.draw_line(self.ids[key]["row"], col, text, data_color)
if self.data_structs:
try:
@@ -245,10 +297,13 @@ def draw_can_bus_message(self, msg, sorting=False):
msg.arbitration_id, self.data_structs, msg.data
):
if isinstance(x, float):
- values_list.append("{0:.6f}".format(x))
+ values_list.append(f"{x:.6f}")
else:
values_list.append(str(x))
values_string = " ".join(values_list)
+ self.ids[key]["values_string_length"] = len(values_string)
+ values_string += " " * (self.x - len(values_string))
+
self.draw_line(self.ids[key]["row"], 77, values_string, color)
except (ValueError, struct.error):
pass
@@ -257,7 +312,7 @@ def draw_can_bus_message(self, msg, sorting=False):
def draw_line(self, row, col, txt, *args):
if row - self.scroll < 0:
- # Skip if we have scrolled passed the line
+ # Skip if we have scrolled past the line
return
try:
self.stdscr.addstr(row - self.scroll, col, txt, *args)
@@ -274,17 +329,21 @@ def draw_header(self):
self.draw_line(0, 35, "ID", curses.A_BOLD)
self.draw_line(0, 47, "DLC", curses.A_BOLD)
self.draw_line(0, 52, "Data", curses.A_BOLD)
- if self.data_structs: # Only draw if the dictionary is not empty
+
+ # Indicate that byte change highlighting is enabled
+ if self.highlight_changed_bytes:
+ self.draw_line(0, 57, "(changed)", curses.color_pair(2))
+ # Only draw if the dictionary is not empty
+ if self.data_structs:
self.draw_line(0, 77, "Parsed values", curses.A_BOLD)
def redraw_screen(self):
# Trigger a complete redraw
self.draw_header()
- for key in self.ids:
- self.draw_can_bus_message(self.ids[key]["msg"])
+ for ids in self.ids.values():
+ self.draw_can_bus_message(ids["msg"])
-# noinspection PyProtectedMember
class SmartFormatter(argparse.HelpFormatter):
def _get_default_metavar_for_optional(self, action):
return action.dest.upper()
@@ -294,12 +353,12 @@ def _format_usage(self, usage, actions, groups, prefix):
return super()._format_usage(usage, actions, groups, "Usage: ")
def _format_args(self, action, default_metavar):
- if action.nargs != argparse.REMAINDER and action.nargs != argparse.ONE_OR_MORE:
+ if action.nargs not in (argparse.REMAINDER, argparse.ONE_OR_MORE):
return super()._format_args(action, default_metavar)
# Use the metavar if "REMAINDER" or "ONE_OR_MORE" is set
get_metavar = self._metavar_formatter(action, default_metavar)
- return "%s" % get_metavar(1)
+ return str(get_metavar(1))
def _format_action_invocation(self, action):
if not action.option_strings or action.nargs == 0:
@@ -312,9 +371,9 @@ def _format_action_invocation(self, action):
args_string = self._format_args(action, default)
for i, option_string in enumerate(action.option_strings):
if i == len(action.option_strings) - 1:
- parts.append("%s %s" % (option_string, args_string))
+ parts.append(f"{option_string} {args_string}")
else:
- parts.append("%s" % option_string)
+ parts.append(str(option_string))
return ", ".join(parts)
def _split_lines(self, text, width):
@@ -325,37 +384,37 @@ def _split_lines(self, text, width):
def _fill_text(self, text, width, indent):
if text.startswith("R|"):
- # noinspection PyTypeChecker
return "".join(indent + line + "\n" for line in text[2:].splitlines())
else:
return super()._fill_text(text, width, indent)
-def parse_args(args):
- # Python versions >= 3.5
- kwargs = {}
- if sys.version_info[0] * 10 + sys.version_info[1] >= 35: # pragma: no cover
- kwargs = {"allow_abbrev": False}
-
+def _parse_viewer_args(
+ args: list[str],
+) -> tuple[argparse.Namespace, TDataStructs]:
# Parse command line arguments
parser = argparse.ArgumentParser(
"python -m can.viewer",
description="A simple CAN viewer terminal application written in Python",
epilog="R|Shortcuts: "
- "\n +---------+-------------------------+"
- "\n | Key | Description |"
- "\n +---------+-------------------------+"
- "\n | ESQ/q | Exit the viewer |"
- "\n | c | Clear the stored frames |"
- "\n | s | Sort the stored frames |"
- "\n | SPACE | Pause the viewer |"
- "\n | UP/DOWN | Scroll the viewer |"
- "\n +---------+-------------------------+",
+ "\n +---------+-------------------------------+"
+ "\n | Key | Description |"
+ "\n +---------+-------------------------------+"
+ "\n | ESQ/q | Exit the viewer |"
+ "\n | c | Clear the stored frames |"
+ "\n | s | Sort the stored frames |"
+ "\n | h | Toggle highlight byte changes |"
+ "\n | SPACE | Pause the viewer |"
+ "\n | UP/DOWN | Scroll the viewer |"
+ "\n +---------+-------------------------------+",
formatter_class=SmartFormatter,
add_help=False,
- **kwargs
+ allow_abbrev=False,
)
+ # add bus options group
+ add_bus_arguments(parser, filter_arg=True, group_title="Bus arguments")
+
optional = parser.add_argument_group("Optional arguments")
optional.add_argument(
@@ -366,32 +425,7 @@ def parse_args(args):
"--version",
action="version",
help="Show program's version number and exit",
- version="%(prog)s (version {version})".format(version=__version__),
- )
-
- # Copied from: https://github.com/hardbyte/python-can/blob/develop/can/logger.py
- optional.add_argument(
- "-b",
- "--bitrate",
- type=int,
- help="""Bitrate to use for the given CAN interface""",
- )
-
- optional.add_argument("--fd", help="Activate CAN-FD support", action="store_true")
-
- optional.add_argument(
- "--data_bitrate",
- type=int,
- help="""Bitrate to use for the data phase in case of CAN-FD.""",
- )
-
- optional.add_argument(
- "-c",
- "--channel",
- help="""Most backend interfaces require some sort of channel.
- For example with the serial interface the channel might be a rfcomm device: "/dev/rfcomm0"
- with the socketcan interfaces valid channel examples include: "can0", "vcan0".
- (default: use default for the specified interface)""",
+ version=f"%(prog)s (version {__version__})",
)
optional.add_argument(
@@ -437,51 +471,22 @@ def parse_args(args):
)
optional.add_argument(
- "-f",
- "--filter",
- help="R|Space separated CAN filters for the given CAN interface:"
- "\n : (matches when & mask == can_id & mask)"
- "\n ~ (matches when & mask != can_id & mask)"
- "\nFx to show only frames with ID 0x100 to 0x103 and 0x200 to 0x20F:"
- "\n python -m can.viewer -f 100:7FC 200:7F0"
- "\nNote that the ID and mask are alway interpreted as hex values",
- metavar="{:,~}",
- nargs=argparse.ONE_OR_MORE,
- default="",
- )
-
- optional.add_argument(
- "-i",
- "--interface",
- dest="interface",
- help="R|Specify the backend CAN interface to use.",
- choices=sorted(can.VALID_INTERFACES),
+ "-v",
+ action="count",
+ dest="verbosity",
+ help="""How much information do you want to see at the command line?
+ You can add several of these e.g., -vv is DEBUG""",
+ default=2,
)
# Print help message when no arguments are given
if not args:
parser.print_help(sys.stderr)
- import errno
-
raise SystemExit(errno.EINVAL)
- parsed_args = parser.parse_args(args)
-
- can_filters = []
- if parsed_args.filter:
- # print('Adding filter/s', parsed_args.filter)
- for flt in parsed_args.filter:
- # print(filter)
- if ":" in flt:
- _ = flt.split(":")
- can_id, can_mask = int(_[0], base=16), int(_[1], base=16)
- elif "~" in flt:
- can_id, can_mask = flt.split("~")
- can_id = int(can_id, base=16) | 0x20000000 # CAN_INV_FILTER
- can_mask = int(can_mask, base=16) & 0x20000000 # socket.CAN_ERR_FLAG
- else:
- raise argparse.ArgumentError(None, "Invalid filter argument")
- can_filters.append({"can_id": can_id, "can_mask": can_mask})
+ parsed_args, unknown_args = parser.parse_known_args(args)
+ if unknown_args:
+ print("Unknown arguments:", unknown_args)
# Dictionary used to convert between Python values and C structs represented as Python strings.
# If the value is 'None' then the message does not contain any data package.
@@ -499,14 +504,14 @@ def parse_args(args):
# f = float (32-bits), d = double (64-bits)
#
# An optional conversion from real units to integers can be given as additional arguments.
- # In order to convert from raw integer value the real units are multiplied with the values and similarly the values
+ # In order to convert from raw integer value the real units are multiplied with the values and
+ # similarly the values
# are divided by the value in order to convert from real units to raw integer values.
- data_structs = (
- {}
- ) # type: Dict[Union[int, Tuple[int, ...]], Union[struct.Struct, Tuple, None]]
+
+ data_structs: TDataStructs = {}
if parsed_args.decode:
if os.path.isfile(parsed_args.decode[0]):
- with open(parsed_args.decode[0], "r") as f:
+ with open(parsed_args.decode[0], encoding="utf-8") as f:
structs = f.readlines()
else:
structs = parsed_args.decode
@@ -518,7 +523,7 @@ def parse_args(args):
key, fmt = int(tmp[0], base=16), tmp[1]
# The scaling
- scaling = [] # type: list
+ scaling: list[float] = []
for t in tmp[2:]:
# First try to convert to int, if that fails, then convert to a float
try:
@@ -527,34 +532,18 @@ def parse_args(args):
scaling.append(float(t))
if scaling:
- data_structs[key] = (struct.Struct(fmt),) + tuple(scaling)
+ data_structs[key] = (struct.Struct(fmt), *scaling)
else:
data_structs[key] = struct.Struct(fmt)
- # print(data_structs[key])
-
- return parsed_args, can_filters, data_structs
-
-
-def main(): # pragma: no cover
- parsed_args, can_filters, data_structs = parse_args(sys.argv[1:])
- config = {"single_handle": True}
- if can_filters:
- config["can_filters"] = can_filters
- if parsed_args.interface:
- config["interface"] = parsed_args.interface
- if parsed_args.bitrate:
- config["bitrate"] = parsed_args.bitrate
- if parsed_args.fd:
- config["fd"] = True
- if parsed_args.data_bitrate:
- config["data_bitrate"] = parsed_args.data_bitrate
+ return parsed_args, data_structs
- # Create a CAN-Bus interface
- bus = can.Bus(parsed_args.channel, **config)
- # print('Connected to {}: {}'.format(bus.__class__.__name__, bus.channel_info))
- curses.wrapper(CanViewer, bus, data_structs)
+def main() -> None:
+ parsed_args, data_structs = _parse_viewer_args(sys.argv[1:])
+ bus = create_bus_from_namespace(parsed_args)
+ _set_logging_level_from_namespace(parsed_args)
+ curses.wrapper(CanViewer, bus, data_structs) # type: ignore[attr-defined,unused-ignore]
if __name__ == "__main__":
diff --git a/doc/api.rst b/doc/api.rst
index 193d1c707..50095589c 100644
--- a/doc/api.rst
+++ b/doc/api.rst
@@ -1,7 +1,7 @@
Library API
===========
-The main objects are the :class:`~can.BusABC` and the :class:`~can.Message`.
+The main objects are the :class:`~can.Bus` and the :class:`~can.Message`.
A form of CAN interface is also required.
.. hint::
@@ -10,35 +10,17 @@ A form of CAN interface is also required.
.. toctree::
- :maxdepth: 1
+ :maxdepth: 2
bus
message
- listeners
+ notifier
+ file_io
asyncio
bcm
+ errors
bit_timing
+ utils
internal-api
-Utilities
----------
-
-
-.. autofunction:: can.detect_available_configs
-
-
-.. _notifier:
-
-Notifier
---------
-
-The Notifier object is used as a message distributor for a bus.
-
-.. autoclass:: can.Notifier
- :members:
-
-Errors
-------
-
-.. autoclass:: can.CanError
diff --git a/doc/bcm.rst b/doc/bcm.rst
index 549b06edd..94cde0e60 100644
--- a/doc/bcm.rst
+++ b/doc/bcm.rst
@@ -42,3 +42,7 @@ which inherits from :class:`~can.broadcastmanager.CyclicTask`.
.. autoclass:: can.RestartableCyclicTaskABC
:members:
+
+.. autoclass:: can.broadcastmanager.ThreadBasedCyclicSendTask
+ :members:
+
diff --git a/doc/bit_timing.rst b/doc/bit_timing.rst
index e1d2feeeb..bf7aad486 100644
--- a/doc/bit_timing.rst
+++ b/doc/bit_timing.rst
@@ -1,49 +1,136 @@
Bit Timing Configuration
========================
-The CAN protocol allows the bitrate, sample point and number of samples to be
-optimized for a given application. You can read more on Wikipedia_, Kvaser_
-and other sources.
-
-In most cases the recommended settings for a predefined set of common
-bitrates will work just fine. In some cases it may however be necessary to specify
-custom settings. The :class:`can.BitTiming` class can be used for this purpose to
-specify them in a relatively interface agnostic manner.
-
-It is also possible to specify the same settings for a CAN 2.0 bus
+The CAN protocol, specified in ISO 11898, allows the bitrate, sample point
+and number of samples to be optimized for a given application. These
+parameters, known as bit timings, can be adjusted to meet the requirements
+of the communication system and the physical communication channel.
+
+These parameters include:
+
+* **tseg1**: The time segment 1 (TSEG1) is the amount of time from the end
+ of the sync segment until the sample point. It is expressed in time quanta (TQ).
+* **tseg2**: The time segment 2 (TSEG2) is the amount of time from the
+ sample point until the end of the bit. It is expressed in TQ.
+* **sjw**: The synchronization jump width (SJW) is the maximum number
+ of TQ that the controller can resynchronize every bit.
+* **sample point**: The sample point is defined as the point in time
+ within a bit where the bus controller samples the bus for dominant or
+ recessive levels. It is typically expressed as a percentage of the bit time.
+ The sample point depends on the bus length and propagation time as well
+ as the information processing time of the nodes.
+
+.. figure:: images/bit_timing_light.svg
+ :align: center
+ :class: only-light
+
+.. figure:: images/bit_timing_dark.svg
+ :align: center
+ :class: only-dark
+
+ Bit Timing and Sample Point
+
+
+For example, consider a bit with a total duration of 8 TQ and a sample
+point at 75%. The values for TSEG1, TSEG2 and SJW would be 5, 2, and 2,
+respectively. The sample point would be 6 TQ after the start of the bit,
+leaving 2 TQ for the information processing by the bus nodes.
+
+.. note::
+ The values for TSEG1, TSEG2 and SJW are chosen such that the
+ sample point is at least 50% of the total bit time. This ensures that
+ there is sufficient time for the signal to stabilize before it is sampled.
+
+.. note::
+ In CAN FD, the arbitration (nominal) phase and the data phase can have
+ different bit rates. As a result, there are two separate sample points
+ to consider.
+
+Another important parameter is **f_clock**: The CAN system clock frequency
+in Hz. This frequency is used to derive the TQ size from the bit rate.
+The relationship is ``f_clock = (tseg1+tseg2+1) * bitrate * brp``.
+The bit rate prescaler value **brp** is usually determined by the controller
+and is chosen to ensure that the resulting bit time is an integer value.
+Typical CAN clock frequencies are 8-80 MHz.
+
+In most cases, the recommended settings for a predefined set of common
+bit rates will work just fine. In some cases, however, it may be necessary
+to specify custom bit timings. The :class:`~can.BitTiming` and
+:class:`~can.BitTimingFd` classes can be used for this purpose to specify
+bit timings in a relatively interface agnostic manner.
+
+:class:`~can.BitTiming` or :class:`~can.BitTimingFd` can also help you to
+produce an overview of possible bit timings for your desired bit rate:
+
+ >>> import contextlib
+ >>> import can
+ ...
+ >>> timings = set()
+ >>> for sample_point in range(50, 100):
+ ... with contextlib.suppress(ValueError):
+ ... timings.add(
+ ... can.BitTiming.from_sample_point(
+ ... f_clock=8_000_000,
+ ... bitrate=250_000,
+ ... sample_point=sample_point,
+ ... )
+ ... )
+ ...
+ >>> for timing in sorted(timings, key=lambda x: x.sample_point):
+ ... print(timing)
+ BR: 250_000 bit/s, SP: 50.00%, BRP: 2, TSEG1: 7, TSEG2: 8, SJW: 4, BTR: C176h, CLK: 8MHz
+ BR: 250_000 bit/s, SP: 56.25%, BRP: 2, TSEG1: 8, TSEG2: 7, SJW: 4, BTR: C167h, CLK: 8MHz
+ BR: 250_000 bit/s, SP: 62.50%, BRP: 2, TSEG1: 9, TSEG2: 6, SJW: 4, BTR: C158h, CLK: 8MHz
+ BR: 250_000 bit/s, SP: 68.75%, BRP: 2, TSEG1: 10, TSEG2: 5, SJW: 4, BTR: C149h, CLK: 8MHz
+ BR: 250_000 bit/s, SP: 75.00%, BRP: 2, TSEG1: 11, TSEG2: 4, SJW: 4, BTR: C13Ah, CLK: 8MHz
+ BR: 250_000 bit/s, SP: 81.25%, BRP: 2, TSEG1: 12, TSEG2: 3, SJW: 3, BTR: 812Bh, CLK: 8MHz
+ BR: 250_000 bit/s, SP: 87.50%, BRP: 2, TSEG1: 13, TSEG2: 2, SJW: 2, BTR: 411Ch, CLK: 8MHz
+ BR: 250_000 bit/s, SP: 93.75%, BRP: 2, TSEG1: 14, TSEG2: 1, SJW: 1, BTR: 010Dh, CLK: 8MHz
+
+
+It is possible to specify CAN 2.0 bit timings
using the config file:
-
.. code-block:: none
[default]
- bitrate=1000000
f_clock=8000000
- tseg1=5
- tseg2=2
- sjw=1
- nof_samples=1
-
-
-.. code-block:: none
-
- [default]
brp=1
tseg1=5
tseg2=2
sjw=1
nof_samples=1
+The same is possible for CAN FD:
.. code-block:: none
[default]
- btr0=0x00
- btr1=0x14
+ f_clock=80000000
+ nom_brp=1
+ nom_tseg1=119
+ nom_tseg2=40
+ nom_sjw=40
+ data_brp=1
+ data_tseg1=29
+ data_tseg2=10
+ data_sjw=10
+A :class:`dict` of the relevant config parameters can be easily obtained by calling
+``dict(timing)`` or ``{**timing}`` where ``timing`` is the :class:`~can.BitTiming` or
+:class:`~can.BitTimingFd` instance.
-.. autoclass:: can.BitTiming
+Check :doc:`configuration` for more information about saving and loading configurations.
-.. _Wikipedia: https://en.wikipedia.org/wiki/CAN_bus#Bit_timing
-.. _Kvaser: https://www.kvaser.com/about-can/the-can-protocol/can-bit-timing/
+.. autoclass:: can.BitTiming
+ :class-doc-from: both
+ :show-inheritance:
+ :members:
+ :member-order: bysource
+
+.. autoclass:: can.BitTimingFd
+ :class-doc-from: both
+ :show-inheritance:
+ :members:
+ :member-order: bysource
diff --git a/doc/bus.rst b/doc/bus.rst
index 5c1e95606..f63c244c2 100644
--- a/doc/bus.rst
+++ b/doc/bus.rst
@@ -3,42 +3,42 @@
Bus
---
-The :class:`~can.BusABC` class, as the name suggests, provides an abstraction of a CAN bus.
-The bus provides a wrapper around a physical or virtual CAN Bus.
-An interface specific instance of the :class:`~can.BusABC` is created by the :class:`~can.Bus`
-class, for example::
+The :class:`~can.BusABC` class provides a wrapper around a physical or virtual CAN Bus.
+
+An interface specific instance is created by calling the :func:`~can.Bus`
+function with a particular ``interface``, for example::
vector_bus = can.Bus(interface='vector', ...)
-That bus is then able to handle the interface specific software/hardware interactions
-and implements the :class:`~can.BusABC` API.
+The created bus is then able to handle the interface specific software/hardware interactions
+while giving the user the same top level API.
A thread safe bus wrapper is also available, see `Thread safe bus`_.
-Autoconfig Bus
-''''''''''''''
-
-.. autoclass:: can.Bus
- :members:
- :undoc-members:
-
-
-API
-'''
-
-.. autoclass:: can.BusABC
- :members:
- :undoc-members:
-
- .. automethod:: __iter__
Transmitting
''''''''''''
Writing individual messages to the bus is done by calling the :meth:`~can.BusABC.send` method
-and passing a :class:`~can.Message` instance. Periodic sending is controlled by the
-:ref:`broadcast manager `.
+and passing a :class:`~can.Message` instance.
+
+.. code-block:: python
+ :emphasize-lines: 8
+ with can.Bus() as bus:
+ msg = can.Message(
+ arbitration_id=0xC0FFEE,
+ data=[0, 25, 0, 1, 3, 1, 4, 1],
+ is_extended_id=True
+ )
+ try:
+ bus.send(msg)
+ print(f"Message sent on {bus.channel_info}")
+ except can.CanError:
+ print("Message NOT sent")
+
+
+Periodic sending is controlled by the :ref:`broadcast manager `.
Receiving
'''''''''
@@ -46,22 +46,55 @@ Receiving
Reading from the bus is achieved by either calling the :meth:`~can.BusABC.recv` method or
by directly iterating over the bus::
- for msg in bus:
- print(msg.data)
+ with can.Bus() as bus:
+ for msg in bus:
+ print(msg.data)
-Alternatively the :class:`~can.Listener` api can be used, which is a list of :class:`~can.Listener`
-subclasses that receive notifications when new messages arrive.
+Alternatively the :ref:`listeners_doc` api can be used, which is a list of various
+:class:`~can.Listener` implementations that receive and handle messages from a :class:`~can.Notifier`.
Filtering
'''''''''
Message filtering can be set up for each bus. Where the interface supports it, this is carried
-out in the hardware or kernel layer - not in Python.
+out in the hardware or kernel layer - not in Python. All messages that match at least one filter
+are returned.
+
+Example defining two filters, one to pass 11-bit ID ``0x451``, the other to pass 29-bit ID ``0xA0000``:
+
+.. code-block:: python
+
+ filters = [
+ {"can_id": 0x451, "can_mask": 0x7FF, "extended": False},
+ {"can_id": 0xA0000, "can_mask": 0x1FFFFFFF, "extended": True},
+ ]
+ bus = can.interface.Bus(channel="can0", interface="socketcan", can_filters=filters)
+
+
+See :meth:`~can.BusABC.set_filters` for the implementation.
+
+Bus API
+'''''''
+
+.. autofunction:: can.Bus
+
+.. autoclass:: can.BusABC
+ :class-doc-from: class
+ :members:
+ :inherited-members:
+
+.. autoclass:: can.BusState
+ :members:
+ :undoc-members:
+
+.. autoclass:: can.bus.CanProtocol
+ :members:
+ :undoc-members:
Thread safe bus
----------------
+'''''''''''''''
This thread safe version of the :class:`~can.BusABC` class can be used by multiple threads at once.
Sending and receiving is locked separately to avoid unnecessary delays.
@@ -69,6 +102,8 @@ Conflicting calls are executed by blocking until the bus is accessible.
It can be used exactly like the normal :class:`~can.BusABC`:
+.. code-block:: python
+
# 'socketcan' is only an example interface, it works with all the others too
my_bus = can.ThreadSafeBus(interface='socketcan', channel='vcan0')
my_bus.send(...)
diff --git a/doc/changelog.d/.gitignore b/doc/changelog.d/.gitignore
new file mode 100644
index 000000000..b56b00acb
--- /dev/null
+++ b/doc/changelog.d/.gitignore
@@ -0,0 +1,11 @@
+# Ignore everything...
+*
+!.gitignore
+
+# ...except markdown news fragments
+!*.security.md
+!*.removed.md
+!*.deprecated.md
+!*.added.md
+!*.changed.md
+!*.fixed.md
diff --git a/doc/changelog.d/1815.added.md b/doc/changelog.d/1815.added.md
new file mode 100644
index 000000000..65756fb41
--- /dev/null
+++ b/doc/changelog.d/1815.added.md
@@ -0,0 +1 @@
+Added support for replaying CAN log files multiple times or infinitely in the player script via the new --loop/-l argument.
diff --git a/doc/changelog.d/1815.removed.md b/doc/changelog.d/1815.removed.md
new file mode 100644
index 000000000..61b4e9b1d
--- /dev/null
+++ b/doc/changelog.d/1815.removed.md
@@ -0,0 +1 @@
+Removed the unused --file_name/-f argument from the player CLI.
diff --git a/doc/changelog.d/1938.fixed.md b/doc/changelog.d/1938.fixed.md
new file mode 100644
index 000000000..f9aad1089
--- /dev/null
+++ b/doc/changelog.d/1938.fixed.md
@@ -0,0 +1 @@
+Keep a reference to asyncio tasks in `can.Notifier` as recommended by [python documentation](https://docs.python.org/3/library/asyncio-task.html#asyncio.create_task).
diff --git a/doc/changelog.d/1987.added.md b/doc/changelog.d/1987.added.md
new file mode 100644
index 000000000..398add3e3
--- /dev/null
+++ b/doc/changelog.d/1987.added.md
@@ -0,0 +1 @@
+Add [python-can-coe](https://c0d3.sh/smarthome/python-can-coe) interface plugin to the documentation.
diff --git a/doc/changelog.d/1995.added.md b/doc/changelog.d/1995.added.md
new file mode 100644
index 000000000..81e39d0df
--- /dev/null
+++ b/doc/changelog.d/1995.added.md
@@ -0,0 +1 @@
+Added hardware filter support for SeeedBus during initialization, with a software fallback.
\ No newline at end of file
diff --git a/doc/changelog.d/1996.removed.md b/doc/changelog.d/1996.removed.md
new file mode 100644
index 000000000..77458ad75
--- /dev/null
+++ b/doc/changelog.d/1996.removed.md
@@ -0,0 +1 @@
+Remove support for end-of-life Python 3.9.
\ No newline at end of file
diff --git a/doc/changelog.d/2009.changed.md b/doc/changelog.d/2009.changed.md
new file mode 100644
index 000000000..6e68198a1
--- /dev/null
+++ b/doc/changelog.d/2009.changed.md
@@ -0,0 +1 @@
+Improved datetime parsing and added support for “double-defined” datetime strings (such as, e.g., `"30 15:06:13.191 pm 2017"`) for ASCReader class.
\ No newline at end of file
diff --git a/doc/conf.py b/doc/conf.py
index 568a5641d..5e413361c 100755
--- a/doc/conf.py
+++ b/doc/conf.py
@@ -6,15 +6,18 @@
# -- Imports -------------------------------------------------------------------
-import sys
+import ctypes
import os
+import sys
+from importlib.metadata import version as get_version
+from unittest.mock import MagicMock
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
sys.path.insert(0, os.path.abspath(".."))
-import can # pylint: disable=wrong-import-position
+from can import ctypesutil # pylint: disable=wrong-import-position
# -- General configuration -----------------------------------------------------
@@ -24,9 +27,10 @@
# |version| and |release|, also used in various other places throughout the
# built documents.
#
+# The full version, including alpha/beta/rc tags.
+release: str = get_version("python-can")
# The short X.Y version.
-version = can.__version__.split("-")[0]
-release = can.__version__
+version = ".".join(release.split(".")[:2])
# General information about the project.
project = "python-can"
@@ -45,11 +49,12 @@
"sphinx.ext.viewcode",
"sphinx.ext.graphviz",
"sphinxcontrib.programoutput",
- "sphinx_autodoc_typehints",
+ "sphinx_inline_tabs",
+ "sphinx_copybutton",
]
# Now, you can use the alias name as a new role, e.g. :issue:`123`.
-extlinks = {"issue": ("https://github.com/hardbyte/python-can/issues/%s/", "issue ")}
+extlinks = {"issue": ("https://github.com/hardbyte/python-can/issues/%s/", "issue #%s")}
intersphinx_mapping = {"python": ("https://docs.python.org/3/", None)}
@@ -63,7 +68,7 @@
graphviz_output_format = "png" # 'svg'
# The suffix of source filenames.
-source_suffix = ".rst"
+source_suffix = {".rst": "restructuredtext"}
# The encoding of source files.
# source_encoding = 'utf-8-sig'
@@ -111,11 +116,41 @@
# Keep cached intersphinx inventories indefinitely
intersphinx_cache_limit = -1
+# location of typehints
+autodoc_typehints = "description"
+
+# disable specific warnings
+nitpick_ignore = [
+ # Ignore warnings for type aliases. Remove once Sphinx supports PEP613
+ ("py:class", "OpenTextModeUpdating"),
+ ("py:class", "OpenTextModeWriting"),
+ ("py:class", "OpenBinaryModeUpdating"),
+ ("py:class", "OpenBinaryModeWriting"),
+ ("py:class", "OpenTextModeReading"),
+ ("py:class", "OpenBinaryModeReading"),
+ ("py:class", "BusConfig"),
+ ("py:class", "can.typechecking.BusConfig"),
+ ("py:class", "can.typechecking.CanFilter"),
+ ("py:class", "can.typechecking.CanFilterExtended"),
+ ("py:class", "can.typechecking.AutoDetectedConfig"),
+ ("py:class", "can.util.T1"),
+ ("py:class", "can.util.T2"),
+ ("py:class", "~P1"),
+ # intersphinx fails to reference some builtins
+ ("py:class", "asyncio.events.AbstractEventLoop"),
+ ("py:class", "_thread.lock"),
+]
+
+# mock windows specific attributes
+autodoc_mock_imports = ["win32com", "pythoncom"]
+ctypes.windll = MagicMock()
+ctypesutil.HRESULT = ctypes.c_long
+
# -- Options for HTML output --------------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
-html_theme = "default"
+html_theme = "furo"
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
diff --git a/doc/configuration.rst b/doc/configuration.rst
index 0ce8f85a7..2951a63b1 100644
--- a/doc/configuration.rst
+++ b/doc/configuration.rst
@@ -1,3 +1,5 @@
+.. _configuration:
+
Configuration
=============
@@ -11,7 +13,7 @@ In Code
-------
The ``can`` object exposes an ``rc`` dictionary which can be used to set
-the **interface** and **channel** before importing from ``can.interfaces``.
+the **interface** and **channel**.
::
@@ -19,7 +21,7 @@ the **interface** and **channel** before importing from ``can.interfaces``.
can.rc['interface'] = 'socketcan'
can.rc['channel'] = 'vcan0'
can.rc['bitrate'] = 500000
- from can.interfaces.interface import Bus
+ from can.interface import Bus
bus = Bus()
@@ -28,13 +30,13 @@ You can also specify the interface and channel for each Bus instance::
import can
- bus = can.interface.Bus(bustype='socketcan', channel='vcan0', bitrate=500000)
+ bus = can.interface.Bus(interface='socketcan', channel='vcan0', bitrate=500000)
Configuration File
------------------
-On Linux systems the config file is searched in the following paths:
+On Linux and macOS systems the config file is searched in the following paths:
#. ``~/can.conf``
#. ``/etc/can.conf``
@@ -43,9 +45,9 @@ On Linux systems the config file is searched in the following paths:
On Windows systems the config file is searched in the following paths:
-#. ``~/can.conf``
+#. ``%USERPROFILE%/can.conf``
#. ``can.ini`` (current working directory)
-#. ``$APPDATA/can.ini``
+#. ``%APPDATA%/can.ini``
The configuration file sets the default interface and channel:
@@ -79,10 +81,10 @@ The configuration can also contain additional sections (or context):
::
- from can.interfaces.interface import Bus
+ from can.interface import Bus
- hs_bus = Bus(context='HS')
- ms_bus = Bus(context='MS')
+ hs_bus = Bus(config_context='HS')
+ ms_bus = Bus(config_context='MS')
Environment Variables
---------------------
@@ -100,6 +102,7 @@ For example:
``CAN_INTERFACE=socketcan CAN_CONFIG={"receive_own_messages": true, "fd": true}``
+.. _interface names:
Interface Names
---------------
@@ -109,31 +112,51 @@ Lookup table of interface names:
+---------------------+-------------------------------------+
| Name | Documentation |
+=====================+=====================================+
-| ``"socketcan"`` | :doc:`interfaces/socketcan` |
+| ``"canalystii"`` | :doc:`interfaces/canalystii` |
+---------------------+-------------------------------------+
-| ``"kvaser"`` | :doc:`interfaces/kvaser` |
+| ``"cantact"`` | :doc:`interfaces/cantact` |
+---------------------+-------------------------------------+
-| ``"serial"`` | :doc:`interfaces/serial` |
+| ``"etas"`` | :doc:`interfaces/etas` |
+---------------------+-------------------------------------+
-| ``"slcan"`` | :doc:`interfaces/slcan` |
+| ``"gs_usb"`` | :doc:`interfaces/gs_usb` |
++---------------------+-------------------------------------+
+| ``"iscan"`` | :doc:`interfaces/iscan` |
+---------------------+-------------------------------------+
| ``"ixxat"`` | :doc:`interfaces/ixxat` |
+---------------------+-------------------------------------+
-| ``"pcan"`` | :doc:`interfaces/pcan` |
+| ``"kvaser"`` | :doc:`interfaces/kvaser` |
+---------------------+-------------------------------------+
-| ``"usb2can"`` | :doc:`interfaces/usb2can` |
+| ``"neousys"`` | :doc:`interfaces/neousys` |
++---------------------+-------------------------------------+
+| ``"neovi"`` | :doc:`interfaces/neovi` |
+---------------------+-------------------------------------+
| ``"nican"`` | :doc:`interfaces/nican` |
+---------------------+-------------------------------------+
-| ``"iscan"`` | :doc:`interfaces/iscan` |
+| ``"nixnet"`` | :doc:`interfaces/nixnet` |
+---------------------+-------------------------------------+
-| ``"neovi"`` | :doc:`interfaces/neovi` |
+| ``"pcan"`` | :doc:`interfaces/pcan` |
+---------------------+-------------------------------------+
-| ``"vector"`` | :doc:`interfaces/vector` |
+| ``"robotell"`` | :doc:`interfaces/robotell` |
+---------------------+-------------------------------------+
-| ``"virtual"`` | :doc:`interfaces/virtual` |
+| ``"seeedstudio"`` | :doc:`interfaces/seeedstudio` |
+---------------------+-------------------------------------+
-| ``"canalystii"`` | :doc:`interfaces/canalystii` |
+| ``"serial"`` | :doc:`interfaces/serial` |
++---------------------+-------------------------------------+
+| ``"slcan"`` | :doc:`interfaces/slcan` |
++---------------------+-------------------------------------+
+| ``"socketcan"`` | :doc:`interfaces/socketcan` |
++---------------------+-------------------------------------+
+| ``"socketcand"`` | :doc:`interfaces/socketcand` |
+---------------------+-------------------------------------+
| ``"systec"`` | :doc:`interfaces/systec` |
+---------------------+-------------------------------------+
+| ``"udp_multicast"`` | :doc:`interfaces/udp_multicast` |
++---------------------+-------------------------------------+
+| ``"usb2can"`` | :doc:`interfaces/usb2can` |
++---------------------+-------------------------------------+
+| ``"vector"`` | :doc:`interfaces/vector` |
++---------------------+-------------------------------------+
+| ``"virtual"`` | :doc:`interfaces/virtual` |
++---------------------+-------------------------------------+
+
+Additional interface types can be added via the :ref:`plugin interface`.
diff --git a/doc/development.rst b/doc/development.rst
index 8bad5c58e..40604c346 100644
--- a/doc/development.rst
+++ b/doc/development.rst
@@ -1,57 +1,29 @@
Developer's Overview
====================
+Quick Start for Contributors
+----------------------------
+* Fork the repository on GitHub and clone your fork.
+* Create a new branch for your changes.
+* Set up your development environment.
+* Make your changes, add/update tests and documentation as needed.
+* Run `tox` to check your changes.
+* Push your branch and open a pull request.
Contributing
------------
-Contribute to source code, documentation, examples and report issues:
-https://github.com/hardbyte/python-can
-
-There is also a `python-can `__
-mailing list for development discussion.
-
-Some more information about the internals of this library can be found
-in the chapter :ref:`internalapi`.
-There is also additional information on extending the ``can.io`` module.
-
-
-
-Building & Installing
----------------------
-
-The following assumes that the commands are executed from the root of the repository:
-
-- The project can be built and installed with ``python setup.py build`` and
- ``python setup.py install``.
-- The unit tests can be run with ``python setup.py test``. The tests can be run with ``python2``,
- ``python3``, ``pypy`` or ``pypy3`` to test with other python versions, if they are installed.
- Maybe, you need to execute ``pip3 install python-can[test]`` (or only ``pip`` for Python 2),
- if some dependencies are missing.
-- The docs can be built with ``sphinx-build doc/ doc/_build``. Appending ``-n`` to the command
- makes Sphinx complain about more subtle problems.
-
-
-Creating a new interface/backend
---------------------------------
-
-These steps are a guideline on how to add a new backend to python-can.
-
-- Create a module (either a ``*.py`` or an entire subdirectory depending
- on the complexity) inside ``can.interfaces``
-- Implement the central part of the backend: the bus class that extends
- :class:`can.BusABC`.
- See :ref:`businternals` for more info on this one!
-- Register your backend bus class in ``can.interface.BACKENDS`` and
- ``can.interfaces.VALID_INTERFACES`` in ``can.interfaces.__init__.py``.
-- Add docs where appropriate. At a minimum add to ``doc/interfaces.rst`` and add
- a new interface specific document in ``doc/interface/*``.
-- Update ``doc/scripts.rst`` accordingly.
-- Add tests in ``test/*`` where appropriate.
+Welcome! Thank you for your interest in python-can. Whether you want to fix a bug,
+add a feature, improve documentation, write examples, help solve issues,
+or simply report a problem, your contribution is valued.
+Contributions are made via the `python-can GitHub repository `_.
+If you have questions, feel free to open an issue or start a discussion on GitHub.
+If you're new to the codebase, see the next section for an overview of the code structure.
+For more about the internals, see :ref:`internalapi` and information on extending the ``can.io`` module.
Code Structure
---------------
+^^^^^^^^^^^^^^
The modules in ``python-can`` are:
@@ -64,30 +36,246 @@ The modules in ``python-can`` are:
+---------------------------------+------------------------------------------------------+
|:doc:`message ` | Contains the interface independent Message object. |
+---------------------------------+------------------------------------------------------+
-|:doc:`io ` | Contains a range of file readers and writers. |
+|:doc:`io ` | Contains a range of file readers and writers. |
+---------------------------------+------------------------------------------------------+
|:doc:`broadcastmanager ` | Contains interface independent broadcast manager |
| | code. |
+---------------------------------+------------------------------------------------------+
+Step-by-Step Contribution Guide
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+1. **Fork and Clone the Repository**
+
+ * Fork the python-can repository on GitHub to your own account.
+ * Clone your fork:
+
+ .. code-block:: shell
+
+ git clone https://github.com//python-can.git
+ cd python-can
+
+ * Create a new branch for your work:
+
+ .. code-block:: shell
+
+ git checkout -b my-feature-branch
+
+ * Ensure your branch is up to date with the latest changes from the main repository.
+ First, add the main repository as a remote (commonly named `upstream`) if you haven't already:
+
+ .. code-block:: shell
+
+ git remote add upstream https://github.com/hardbyte/python-can.git
+
+ Then, regularly fetch and rebase from the main branch:
+
+ .. code-block:: shell
+
+ git fetch upstream
+ git rebase upstream/main
+
+2. **Set Up Your Development Environment**
+
+ We recommend using `uv `__ to install development tools and run CLI utilities.
+ `uv` is a modern Python packaging tool that can quickly create virtual environments and manage dependencies,
+ including downloading required Python versions automatically. The `uvx` command allows you to run CLI tools
+ in isolated environments, separate from your global Python installation. This is useful for installing and
+ running Python applications (such as tox) without affecting your project's dependencies or environment.
+
+ **Install tox (if not already available):**
+
+
+ .. code-block:: shell
+
+ uv tool install tox --with tox-uv
+
+
+ **Quickly running your local python-can code**
+
+ To run a local script (e.g., `snippet.py`) using your current python-can code,
+ you can use either the traditional `virtualenv` and `pip` workflow or the modern `uv` tool.
+
+ **Traditional method (virtualenv + pip):**
+
+ Create a virtual environment and install the package in editable mode.
+ This allows changes to your local code to be reflected immediately, without reinstalling.
+
+ .. code-block:: shell
+
+ # Create a new virtual environment
+ python -m venv .venv
+
+ # Activate the environment
+ .venv\Scripts\activate # On Windows
+ source .venv/bin/activate # On Unix/macOS
+
+ # Upgrade pip and install python-can in editable mode with development dependencies
+ python -m pip install --upgrade pip
+ pip install -e .[dev]
+
+ # Run your script
+ python snippet.py
+
+ **Modern method (uv):**
+
+ With `uv`, you can run your script directly:
+
+ .. code-block:: shell
+
+ uv run snippet.py
+
+ When ``uv run ...`` is called inside a project,
+ `uv` automatically sets up the environment and symlinks local packages.
+ No editable install is needed—changes to your code are reflected immediately.
+
+3. **Make Your Changes**
+
+ * Edit code, documentation, or tests as needed.
+ * If you fix a bug or add a feature, add or update tests in the ``test/`` directory.
+ * If your change affects users, update documentation in ``doc/`` and relevant docstrings.
+
+4. **Test Your Changes**
+
+ This project uses `tox `__ to automate all checks (tests, lint, type, docs).
+ Tox will set up isolated environments and run the right tools for you.
+
+ To run all checks:
+
+ .. code-block:: shell
+
+ tox
+
+ To run a specific check, use:
+
+ .. code-block:: shell
+
+ tox -e lint # Run code style and lint checks (black, ruff, pylint)
+ tox -e type # Run type checks (mypy)
+ tox -e docs # Build and test documentation (sphinx)
+ tox -e py # Run tests (pytest)
+
+ To run all checks in parallel (where supported), you can use:
+
+ .. code-block:: shell
+
+ tox p
+
+ Some environments require specific Python versions.
+ If you use `uv`, it will automatically download and manage these for you.
+
+
+
+5. **Add a News Fragment for the Changelog**
+
+ This project uses `towncrier `__ to manage the changelog in
+ ``CHANGELOG.md``. For every user-facing change (new feature, bugfix, deprecation, etc.), you
+ must add a news fragment:
+
+ * News fragments are short files describing your change, stored in ``doc/changelog.d``.
+ * Name each fragment ``..md``, where ```` is one of:
+ ``added``, ``changed``, ``deprecated``, ``removed``, ``fixed``, or ``security``.
+ * Example (for a feature added in PR #1234):
+
+ .. code-block:: shell
+
+ echo "Added support for CAN FD." > doc/changelog.d/1234.added.md
+
+ * Or use the towncrier CLI:
+
+ .. code-block:: shell
+
+ uvx towncrier create --dir doc/changelog.d -c "Added support for CAN FD." 1234.added.md
+
+ * For changes not tied to an issue/PR, the fragment name must start with a plus symbol
+ (e.g., ``+mychange.added.md``). Towncrier calls these "orphan fragments".
+
+ .. note:: You do not need to manually update ``CHANGELOG.md``—maintainers will build the
+ changelog at release time.
+
+6. **(Optional) Build Source Distribution and Wheels**
+
+ If you want to manually build the source distribution (sdist) and wheels for python-can,
+ you can use `uvx` to run the build and twine tools:
+
+ .. code-block:: shell
+
+ uv build
+ uvx twine check --strict dist/*
+
+7. **Push and Submit Your Contribution**
+
+ * Push your branch:
+
+ .. code-block:: shell
+
+ git push origin my-feature-branch
+
+ * Open a pull request from your branch to the ``main`` branch of the main python-can repository on GitHub.
+
+ Please be patient — maintainers review contributions as time allows.
+
+Creating a new interface/backend
+--------------------------------
+
+.. attention::
+ Please note: Pull requests that attempt to add new hardware interfaces directly to the
+ python-can codebase will not be accepted. Instead, we encourage contributors to create
+ plugins by publishing a Python package containing your :class:`can.BusABC` subclass and
+ using it within the python-can API. We will mention your package in this documentation
+ and add it as an optional dependency. For current best practices, please refer to
+ :ref:`plugin interface`.
+
+ The following guideline is retained for informational purposes only and is not valid for new
+ contributions.
+
+These steps are a guideline on how to add a new backend to python-can.
+
+* Create a module (either a ``*.py`` or an entire subdirectory depending
+ on the complexity) inside ``can.interfaces``. See ``can/interfaces/socketcan`` for a reference implementation.
+* Implement the central part of the backend: the bus class that extends
+ :class:`can.BusABC`.
+ See :ref:`businternals` for more info on this one!
+* Register your backend bus class in ``BACKENDS`` in the file ``can.interfaces.__init__.py``.
+* Add docs where appropriate. At a minimum add to ``doc/interfaces.rst`` and add
+ a new interface specific document in ``doc/interface/*``.
+ It should document the supported platforms and also the hardware/software it requires.
+ A small snippet of how to install the dependencies would also be useful to get people started without much friction.
+* Also, don't forget to document your classes, methods and function with docstrings.
+* Add tests in ``test/*`` where appropriate. For example, see ``test/back2back_test.py`` and add a test case like ``BasicTestSocketCan`` for your new interface.
Creating a new Release
----------------------
-- Release from the ``master`` branch.
-- Update the library version in ``__init__.py`` using `semantic versioning `__.
-- Check if any deprecations are pending.
-- Run all tests and examples against available hardware.
-- Update `CONTRIBUTORS.txt` with any new contributors.
-- For larger changes update ``doc/history.rst``.
-- Sanity check that documentation has stayed inline with code.
-- Create a temporary virtual environment. Run ``python setup.py install`` and ``python setup.py test``.
-- Create and upload the distribution: ``python setup.py sdist bdist_wheel``.
-- Sign the packages with gpg ``gpg --detach-sign -a dist/python_can-X.Y.Z-py3-none-any.whl``.
-- Upload with twine ``twine upload dist/python-can-X.Y.Z*``.
-- In a new virtual env check that the package can be installed with pip: ``pip install python-can==X.Y.Z``.
-- Create a new tag in the repository.
-- Check the release on
+Releases are automated via GitHub Actions. To create a new release:
+
+* Build the changelog with towncrier:
+
+
+ * Collect all news fragments and update ``CHANGELOG.md`` by running:
+
+ .. code-block:: shell
+
+ uvx towncrier build --yes --version vX.Y.Z
+
+ (Replace ``vX.Y.Z`` with the new version number. **The version must exactly match the tag you will create for the release.**)
+ This will add all news fragments to the changelog and remove the fragments by default.
+
+ .. note:: You can generate the changelog for prereleases, but keep the news
+ fragments so they are included in the final release. To do this, replace ``--yes`` with ``--keep``.
+ This will update ``CHANGELOG.md`` but leave the fragments in place for future builds.
+
+ * Review ``CHANGELOG.md`` for accuracy and completeness.
+
+* Ensure all tests pass and documentation is up-to-date.
+* Update ``CONTRIBUTORS.txt`` with any new contributors.
+* For larger changes, update ``doc/history.rst``.
+* Create a new tag and GitHub release (e.g., ``vX.Y.Z``) targeting the ``main``
+ branch. Add release notes and publish.
+* The CI workflow will automatically build, check, and upload the release to PyPI
+ and other platforms.
+
+* You can monitor the release status on:
`PyPi `__,
`Read the Docs `__ and
- `GitHub `__.
+ `GitHub Releases `__.
diff --git a/doc/doc-requirements.txt b/doc/doc-requirements.txt
deleted file mode 100644
index a63beee71..000000000
--- a/doc/doc-requirements.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-sphinx>=1.8.1
-sphinxcontrib-programoutput
-sphinx-autodoc-typehints==1.6.0
diff --git a/doc/errors.rst b/doc/errors.rst
new file mode 100644
index 000000000..bc954738a
--- /dev/null
+++ b/doc/errors.rst
@@ -0,0 +1,8 @@
+.. _errors:
+
+Error Handling
+==============
+
+.. automodule:: can.exceptions
+ :members:
+ :show-inheritance:
diff --git a/doc/listeners.rst b/doc/file_io.rst
similarity index 57%
rename from doc/listeners.rst
rename to doc/file_io.rst
index fcdc32f52..329ccac53 100644
--- a/doc/listeners.rst
+++ b/doc/file_io.rst
@@ -1,67 +1,20 @@
-Listeners
-=========
+File IO
+=======
-Listener
---------
-The Listener class is an "abstract" base class for any objects which wish to
-register to receive notifications of new messages on the bus. A Listener can
-be used in two ways; the default is to **call** the Listener with a new
-message, or by calling the method **on_message_received**.
-
-Listeners are registered with :ref:`notifier` object(s) which ensure they are
-notified whenever a new message is received.
-
-Subclasses of Listener that do not override **on_message_received** will cause
-:class:`NotImplementedError` to be thrown when a message is received on
-the CAN bus.
-
-.. autoclass:: can.Listener
- :members:
-
-There are some listeners that already ship together with `python-can`
-and are listed below.
-Some of them allow messages to be written to files, and the corresponding file
-readers are also documented here.
-
-.. note ::
-
- Please note that writing and the reading a message might not always yield a
- completely unchanged message again, since some properties are not (yet)
- supported by some file formats.
-
-
-BufferedReader
---------------
-
-.. autoclass:: can.BufferedReader
- :members:
-
-.. autoclass:: can.AsyncBufferedReader
- :members:
-
-
-RedirectReader
---------------
-
-.. autoclass:: can.RedirectReader
- :members:
-
-
-Logger
-------
-
-The :class:`can.Logger` uses the following :class:`can.Listener` types to
-create log files with different file types of the messages received.
-
-.. autoclass:: can.Logger
- :members:
+Reading and Writing Files
+-------------------------
+.. autofunction:: can.LogReader
+.. autofunction:: can.Logger
+.. autodata:: can.io.logger.MESSAGE_WRITERS
+.. autodata:: can.io.player.MESSAGE_READERS
Printer
-------
.. autoclass:: can.Printer
+ :show-inheritance:
:members:
@@ -69,9 +22,11 @@ CSVWriter
---------
.. autoclass:: can.CSVWriter
+ :show-inheritance:
:members:
.. autoclass:: can.CSVReader
+ :show-inheritance:
:members:
@@ -79,9 +34,11 @@ SqliteWriter
------------
.. autoclass:: can.SqliteWriter
+ :show-inheritance:
:members:
.. autoclass:: can.SqliteReader
+ :show-inheritance:
:members:
@@ -121,6 +78,7 @@ engineered from existing log files. One description of the format can be found `
.. autoclass:: can.ASCWriter
+ :show-inheritance:
:members:
ASCReader reads CAN data from ASCII log files .asc,
@@ -129,24 +87,27 @@ as further references can-utils can be used:
`log2asc `_.
.. autoclass:: can.ASCReader
+ :show-inheritance:
:members:
Log (.log can-utils Logging format)
-----------------------------------
-CanutilsLogWriter logs CAN data to an ASCII log file compatible with `can-utils `
+CanutilsLogWriter logs CAN data to an ASCII log file compatible with `can-utils `_
As specification following references can-utils can be used:
`asc2log `_,
`log2asc `_.
.. autoclass:: can.CanutilsLogWriter
+ :show-inheritance:
:members:
**CanutilsLogReader** reads CAN data from ASCII log files .log
.. autoclass:: can.CanutilsLogReader
+ :show-inheritance:
:members:
@@ -161,9 +122,83 @@ The data is stored in a compressed format which makes it very compact.
.. note:: Channels will be converted to integers.
.. autoclass:: can.BLFWriter
+ :show-inheritance:
:members:
The following class can be used to read messages from BLF file:
.. autoclass:: can.BLFReader
+ :show-inheritance:
+ :members:
+
+
+MF4 (Measurement Data Format v4)
+--------------------------------
+
+Implements support for MF4 (Measurement Data Format v4) which is a proprietary
+format from ASAM (Association for Standardization of Automation and Measuring Systems), widely used in
+many automotive software (Vector CANape, ETAS INCA, dSPACE ControlDesk, etc.).
+
+The data is stored in a compressed format which makes it compact.
+
+.. note:: MF4 support has to be installed as an extra with for example ``pip install python-can[mf4]``.
+
+.. note:: Channels will be converted to integers.
+
+.. note:: MF4Writer does not suppport the append mode.
+
+
+.. autoclass:: can.MF4Writer
+ :show-inheritance:
+ :members:
+
+The MDF format is very flexible regarding the internal structure and it is used to handle data from multiple sources, not just CAN bus logging.
+MDF4Writer will always create a fixed internal file structure where there will be three channel groups (for standard, error and remote frames).
+Using this fixed file structure allows for a simple implementation of MDF4Writer and MF4Reader classes.
+Therefor MF4Reader can only replay files created with MF4Writer.
+
+The following class can be used to read messages from MF4 file:
+
+.. autoclass:: can.MF4Reader
+ :show-inheritance:
+ :members:
+
+
+TRC
+----
+
+Implements basic support for the TRC file format.
+
+
+.. note::
+ Comments and contributions are welcome on what file versions might be relevant.
+
+.. autoclass:: can.TRCWriter
+ :show-inheritance:
+ :members:
+
+The following class can be used to read messages from TRC file:
+
+.. autoclass:: can.TRCReader
+ :show-inheritance:
+ :members:
+
+
+Rotating Loggers
+----------------
+
+.. autoclass:: can.io.BaseRotatingLogger
+ :show-inheritance:
:members:
+
+.. autoclass:: can.SizedRotatingLogger
+ :show-inheritance:
+ :members:
+
+
+Replaying Files
+---------------
+
+.. autoclass:: can.MessageSync
+ :members:
+
diff --git a/doc/history.rst b/doc/history.rst
index caed67baa..73371af4c 100644
--- a/doc/history.rst
+++ b/doc/history.rst
@@ -1,5 +1,5 @@
-History and Roadmap
-===================
+History
+=======
Background
----------
@@ -46,10 +46,38 @@ The CAN viewer terminal script was contributed by Kristian Sloth Lauszus in 2018
The CANalyst-II interface was contributed by Shaoyu Meng in 2018.
+@deonvdw added support for the Robotell interface in 2019.
+
+Felix Divo and Karl Ding added type hints for the core library and many
+interfaces leading up to the 4.0 release.
+
+Eric Evenchick added support for the CANtact devices in 2020.
+
+Felix Divo added an interprocess virtual bus interface in 2020.
+
+@jxltom added the gs_usb interface in 2020 supporting Geschwister Schneider USB/CAN devices
+and bytewerk.org candleLight USB CAN devices such as candlelight, canable, cantact, etc.
+
+@jaesc added the nixnet interface in 2021 supporting NI-XNET devices from National Instruments.
+
+Tuukka Pasanen @illuusio added the neousys interface in 2021.
+
+Francisco Javier Burgos Maciá @fjburgos added ixxat FD support.
+
+@domologic contributed a socketcand interface in 2021.
+
+Felix N @felixn contributed the ETAS interface in 2021.
+
+Felix Divo unified exception handling across every interface in the lead up to
+the 4.0 release.
+
+Felix Divo prepared the python-can 4.0 release.
+
+
Support for CAN within Python
-----------------------------
-Python natively supports the CAN protocol from version 3.3 on, if running on Linux:
+Python natively supports the CAN protocol from version 3.3 on, if running on Linux (with a sufficiently new kernel):
============== ============================================================== ====
Python version Feature Link
@@ -58,4 +86,5 @@ Python version Feature
3.4 Broadcast Management (BCM) commands are natively supported `Docs `__
3.5 CAN FD support `Docs `__
3.7 Support for CAN ISO-TP `Docs `__
+3.9 Native support for joining CAN filters `Docs `__
============== ============================================================== ====
diff --git a/doc/images/bit_timing_dark.svg b/doc/images/bit_timing_dark.svg
new file mode 100644
index 000000000..cc54a3f51
--- /dev/null
+++ b/doc/images/bit_timing_dark.svg
@@ -0,0 +1,96 @@
+
\ No newline at end of file
diff --git a/doc/images/bit_timing_light.svg b/doc/images/bit_timing_light.svg
new file mode 100644
index 000000000..eb021ea34
--- /dev/null
+++ b/doc/images/bit_timing_light.svg
@@ -0,0 +1,92 @@
+
\ No newline at end of file
diff --git a/doc/images/viewer_changed_bytes_highlighting.png b/doc/images/viewer_changed_bytes_highlighting.png
new file mode 100644
index 000000000..53e838488
Binary files /dev/null and b/doc/images/viewer_changed_bytes_highlighting.png differ
diff --git a/doc/index.rst b/doc/index.rst
index f24831c7c..402a485e7 100644
--- a/doc/index.rst
+++ b/doc/index.rst
@@ -8,22 +8,22 @@ different hardware devices, and a suite of utilities for sending and receiving
messages on a CAN bus.
**python-can** runs any where Python runs; from high powered computers
-with commercial `CAN to usb` devices right down to low powered devices running
+with commercial `CAN to USB` devices right down to low powered devices running
linux such as a BeagleBone or RaspberryPi.
More concretely, some example uses of the library:
-- Passively logging what occurs on a CAN bus. For example monitoring a
- commercial vehicle using its **OBD-II** port.
+* Passively logging what occurs on a CAN bus. For example monitoring a
+ commercial vehicle using its `OBD-II port `__.
-- Testing of hardware that interacts via CAN. Modules found in
- modern cars, motocycles, boats, and even wheelchairs have had components tested
+* Testing of hardware that interacts via CAN. Modules found in
+ modern cars, motorcycles, boats, and even wheelchairs have had components tested
from Python using this library.
-- Prototyping new hardware modules or software algorithms in-the-loop. Easily
+* Prototyping new hardware modules or software algorithms in-the-loop. Easily
interact with an existing bus.
-- Creating virtual modules to prototype CAN bus communication.
+* Creating virtual modules to prototype CAN bus communication.
Brief example of the library in action: connecting to a CAN bus, creating and sending a message:
@@ -37,12 +37,15 @@ Brief example of the library in action: connecting to a CAN bus, creating and se
Contents:
.. toctree::
- :maxdepth: 2
+ :maxdepth: 1
installation
configuration
api
interfaces
+ virtual-interfaces
+ plugin-interface
+ other-tools
scripts
development
history
diff --git a/doc/installation.rst b/doc/installation.rst
index a70f7d5ea..822de2ce0 100644
--- a/doc/installation.rst
+++ b/doc/installation.rst
@@ -2,15 +2,31 @@ Installation
============
-Install ``can`` with ``pip``:
-::
+Install the ``can`` package from PyPi with ``pip`` or similar::
$ pip install python-can
-As most likely you will want to interface with some hardware, you may
-also have to install platform dependencies. Be sure to check any other
-specifics for your hardware in :doc:`interfaces`.
+
+
+.. warning::
+ As most likely you will want to interface with some hardware, you may
+ also have to install platform dependencies. Be sure to check any other
+ specifics for your hardware in :doc:`interfaces`.
+
+ Many interfaces can install their dependencies at the same time as ``python-can``,
+ for instance the interface ``serial`` includes the ``pyserial`` dependency which can
+ be installed with the ``serial`` extra::
+
+ $ pip install python-can[serial]
+
+
+Pre-releases
+------------
+
+The latest pre-release can be installed with::
+
+ pip install --upgrade --pre python-can
GNU/Linux dependencies
@@ -29,25 +45,24 @@ Kvaser
To install ``python-can`` using the Kvaser CANLib SDK as the backend:
-1. Install the `latest stable release of
- Python `__.
+1. Install `Kvaser's latest Windows CANLib drivers `__.
-2. Install `Kvaser's latest Windows CANLib
- drivers `__.
-
-3. Test that Kvaser's own tools work to ensure the driver is properly
+2. Test that Kvaser's own tools work to ensure the driver is properly
installed and that the hardware is working.
PCAN
~~~~
-Download and install the latest driver for your interface from
-`PEAK-System's download page `__.
+Download and install the latest driver for your interface:
+
+- `Windows `__ (also supported on *Cygwin*)
+- `Linux `__ (`also works without `__, see also :ref:`pcandoc linux installation`)
+- `macOS `__
Note that PCANBasic API timestamps count seconds from system startup. To
convert these to epoch times, the uptime library is used. If it is not
available, the times are returned as number of seconds from system
-startup. To install the uptime library, run ``pip install uptime``.
+startup. To install the uptime library, run ``pip install python-can[pcan]``.
This library can take advantage of the `Python for Windows Extensions
`__ library if installed.
@@ -57,10 +72,10 @@ the CPU intensive polling that will otherwise have be used.
IXXAT
~~~~~
-To install ``python-can`` using the IXXAT VCI V3 SDK as the backend:
+To install ``python-can`` using the IXXAT VCI V3 or V4 SDK as the backend:
-1. Install `IXXAT's latest Windows VCI V3 SDK
- drivers `__.
+1. Install `IXXAT's latest Windows VCI V3 SDK or VCI V4 SDK (Win10)
+ drivers `__.
2. Test that IXXAT's own tools (i.e. MiniMon) work to ensure the driver
is properly installed and that the hardware is working.
@@ -69,7 +84,7 @@ NI-CAN
~~~~~~
Download and install the NI-CAN drivers from
-`National Instruments `__.
+`National Instruments `__.
Currently the driver only supports 32-bit Python on Windows.
@@ -90,6 +105,30 @@ To install ``python-can`` using the XL Driver Library as the backend:
3. Use Vector Hardware Configuration to assign a channel to your application.
+CANtact
+~~~~~~~
+
+CANtact is supported on Linux, Windows, and macOS.
+To install ``python-can`` using the CANtact driver backend:
+
+``python3 -m pip install "python-can[cantact]"``
+
+If ``python-can`` is already installed, the CANtact backend can be installed separately:
+
+``pip install cantact``
+
+Additional CANtact documentation is available at `cantact.io `__.
+
+CanViewer
+~~~~~~~~~
+
+``python-can`` has support for showing a simple CAN viewer terminal application
+by running ``python -m can.viewer``. On Windows, this depends on the
+`windows-curses library `__ which can
+be installed with:
+
+``python -m pip install "python-can[viewer]"``
+
Installing python-can in development mode
-----------------------------------------
@@ -99,6 +138,7 @@ reinstall. Download or clone the source repository then:
::
- python setup.py develop
-
+ # install in editable mode
+ cd
+ python3 -m pip install -e .
diff --git a/doc/interfaces.rst b/doc/interfaces.rst
index bd7a0d1df..6645ec338 100644
--- a/doc/interfaces.rst
+++ b/doc/interfaces.rst
@@ -1,47 +1,43 @@
-CAN Interface Modules
----------------------
+.. _can interface modules:
+
+Hardware Interfaces
+===================
**python-can** hides the low-level, device-specific interfaces to controller
area network adapters in interface dependant modules. However as each hardware
device is different, you should carefully go through your interface's
documentation.
-The available interfaces are:
+.. note::
+ The *Interface Names* are listed in :doc:`configuration`.
+
+
+The following hardware interfaces are included in python-can:
.. toctree::
:maxdepth: 1
- interfaces/socketcan
+ interfaces/canalystii
+ interfaces/cantact
+ interfaces/etas
+ interfaces/gs_usb
+ interfaces/iscan
+ interfaces/ixxat
interfaces/kvaser
+ interfaces/neousys
+ interfaces/neovi
+ interfaces/nican
+ interfaces/nixnet
+ interfaces/pcan
+ interfaces/robotell
+ interfaces/seeedstudio
interfaces/serial
interfaces/slcan
- interfaces/robotell
- interfaces/ixxat
- interfaces/pcan
+ interfaces/socketcan
+ interfaces/socketcand
+ interfaces/systec
interfaces/usb2can
- interfaces/nican
- interfaces/iscan
- interfaces/neovi
interfaces/vector
- interfaces/virtual
- interfaces/canalystii
- interfaces/systec
- interfaces/seeedstudio
-
-Additional interfaces can be added via a plugin interface. An external package
-can register a new interface by using the ``can.interface`` entry point in its setup.py.
-
-The format of the entry point is ``interface_name=module:classname`` where
-``classname`` is a concrete :class:`can.BusABC` implementation.
-
-::
-
- entry_points={
- 'can.interface': [
- "interface_name=module:classname",
- ]
- },
-
-The *Interface Names* are listed in :doc:`configuration`.
+Additional interface types can be added via the :ref:`plugin interface`, or by installing a third party package that utilises the :ref:`plugin interface`.
diff --git a/doc/interfaces/canalystii.rst b/doc/interfaces/canalystii.rst
index 687f61fcc..b48782259 100644
--- a/doc/interfaces/canalystii.rst
+++ b/doc/interfaces/canalystii.rst
@@ -1,14 +1,34 @@
CANalyst-II
===========
-CANalyst-II(+) is a USB to CAN Analyzer. The controlcan library is originally developed by
-`ZLG ZHIYUAN Electronics`_.
+CANalyst-II is a USB to CAN Analyzer device produced by Chuangxin Technology.
+Install: ``pip install "python-can[canalystii]"``
+
+Supported platform
+------------------
+
+Windows, Linux and Mac.
+
+.. note::
+
+ The backend driver depends on `pyusb `_ so a ``pyusb`` backend driver library such as ``libusb`` must be installed. On Windows a tool such as `Zadig `_ can be used to set the Canalyst-II USB device driver to ``libusb-win32``.
+
+Limitations
+-----------
+
+Multiple Channels
+^^^^^^^^^^^^^^^^^
+
+The USB protocol transfers messages grouped by channel. Messages received on channel 0 and channel 1 may be returned by software out of order between the two channels (although inside each channel, all messages are in order). The timestamp field of each message comes from the hardware and shows the exact time each message was received. To compare ordering of messages on channel 0 vs channel 1, sort the received messages by the timestamp field first.
+
+Backend Driver
+--------------
+
+The backend driver module `canalystii ` must be installed to use this interface. This open source driver is unofficial and based on reverse engineering. Earlier versions of python-can required a binary library from the vendor for this functionality.
Bus
---
.. autoclass:: can.interfaces.canalystii.CANalystIIBus
-
-.. _ZLG ZHIYUAN Electronics: http://www.zlg.com/can/can/product/id/42.html
diff --git a/doc/interfaces/cantact.rst b/doc/interfaces/cantact.rst
new file mode 100644
index 000000000..dc9667218
--- /dev/null
+++ b/doc/interfaces/cantact.rst
@@ -0,0 +1,8 @@
+CANtact CAN Interface
+=====================
+
+Interface for CANtact devices from Linklayer Labs
+
+.. autoclass:: can.interfaces.cantact.CantactBus
+ :show-inheritance:
+ :members:
diff --git a/doc/interfaces/etas.rst b/doc/interfaces/etas.rst
new file mode 100644
index 000000000..7986142be
--- /dev/null
+++ b/doc/interfaces/etas.rst
@@ -0,0 +1,46 @@
+ETAS
+====
+
+This interface adds support for CAN interfaces by `ETAS`_.
+The ETAS BOA_ (Basic Open API) is used.
+
+Installation
+------------
+
+Install the "ETAS ECU and Bus Interfaces – Distribution Package".
+
+.. warning::
+ Only Windows is supported by this interface.
+
+ The Linux kernel v5.13 (and greater) natively supports ETAS ES581.4, ES582.1 and ES584.1
+ USB modules. To use these under Linux, please refer to the :ref:`SocketCAN` interface
+ documentation.
+
+
+Configuration
+-------------
+
+The simplest configuration file would be::
+
+ [default]
+ interface = etas
+ channel = ETAS://ETH/ES910:abcd/CAN:1
+
+Channels are the URIs used by the underlying API.
+
+To find available URIs, use :meth:`~can.detect_available_configs`::
+
+ configs = can.interface.detect_available_configs(interfaces="etas")
+ for c in configs:
+ print(c)
+
+
+Bus
+---
+
+.. autoclass:: can.interfaces.etas.EtasBus
+ :members:
+
+
+.. _ETAS: https://www.etas.com/
+.. _BOA: https://www.etas.com/de/downloadcenter/18102.php
diff --git a/doc/interfaces/gs_usb.rst b/doc/interfaces/gs_usb.rst
new file mode 100755
index 000000000..8bab07c6f
--- /dev/null
+++ b/doc/interfaces/gs_usb.rst
@@ -0,0 +1,80 @@
+.. _gs_usb:
+
+Geschwister Schneider and candleLight
+=====================================
+
+Windows/Linux/Mac CAN driver based on usbfs or WinUSB WCID for Geschwister Schneider USB/CAN devices
+and candleLight USB CAN interfaces.
+
+Install: ``pip install "python-can[gs-usb]"``
+
+Usage: pass device ``index`` or ``channel`` (starting from 0) if using automatic device detection:
+
+::
+
+ import can
+ import usb
+ dev = usb.core.find(idVendor=0x1D50, idProduct=0x606F)
+
+ bus = can.Bus(interface="gs_usb", channel=dev.product, index=0, bitrate=250000)
+ bus = can.Bus(interface="gs_usb", channel=0, bitrate=250000) # same
+
+Alternatively, pass ``bus`` and ``address`` to open a specific device. The parameters can be got by ``pyusb`` as shown below:
+
+.. code-block:: python
+
+ import usb
+ import can
+
+ dev = usb.core.find(idVendor=0x1D50, idProduct=0x606F)
+ bus = can.Bus(
+ interface="gs_usb",
+ channel=dev.product,
+ bus=dev.bus,
+ address=dev.address,
+ bitrate=250000
+ )
+
+
+Supported devices
+-----------------
+
+Geschwister Schneider USB/CAN devices and bytewerk.org candleLight USB CAN interfaces such as candleLight, canable, cantact, etc.
+
+
+Supported platform
+------------------
+
+Windows, Linux and Mac.
+
+.. note::
+
+ The backend driver depends on `pyusb `_ so a ``pyusb`` backend driver library such as
+ ``libusb`` must be installed.
+
+ On Windows a tool such as `Zadig `_ can be used to set the USB device driver to
+ ``libusbK``.
+
+
+Supplementary Info
+------------------
+
+The firmware implementation for Geschwister Schneider USB/CAN devices and candleLight USB CAN can be found in `candle-usb/candleLight_fw `_.
+The Linux kernel driver can be found in `linux/drivers/net/can/usb/gs_usb.c `_.
+
+The ``gs_usb`` interface in ``python-can`` relies on upstream ``gs_usb`` package, which can be found in
+`https://pypi.org/project/gs-usb/ `_ or
+`https://github.com/jxltom/gs_usb `_.
+
+The ``gs_usb`` package uses ``pyusb`` as backend, which brings better cross-platform compatibility.
+
+Note: The bitrate ``10K``, ``20K``, ``50K``, ``83.333K``, ``100K``, ``125K``, ``250K``, ``500K``, ``800K`` and ``1M`` are supported in this interface, as implemented in the upstream ``gs_usb`` package's ``set_bitrate`` method.
+
+.. warning::
+ Message filtering is not supported in Geschwister Schneider USB/CAN devices and bytewerk.org candleLight USB CAN interfaces.
+
+Bus
+---
+
+.. autoclass:: can.interfaces.gs_usb.GsUsbBus
+ :members:
diff --git a/doc/interfaces/ixxat.rst b/doc/interfaces/ixxat.rst
index 9ab79ffcf..1337bf738 100644
--- a/doc/interfaces/ixxat.rst
+++ b/doc/interfaces/ixxat.rst
@@ -1,46 +1,129 @@
.. _ixxatdoc:
-IXXAT Virtual CAN Interface
-===========================
+IXXAT Virtual Communication Interface
+=====================================
-Interface to `IXXAT `__ Virtual CAN Interface V3 SDK. Works on Windows.
+Interface to `IXXAT `__ Virtual Communication Interface V3 SDK. Works on Windows.
The Linux ECI SDK is currently unsupported, however on Linux some devices are
supported with :doc:`socketcan`.
-The :meth:`~can.interfaces.ixxat.canlib.IXXATBus.send_periodic` method is supported
+The :meth:`~can.BusABC.send_periodic` method is supported
natively through the on-board cyclic transmit list.
Modifying cyclic messages is not possible. You will need to stop it, and then
start a new periodic message.
+Configuration
+-------------
+The simplest configuration file would be::
+
+ [default]
+ interface = ixxat
+ channel = 0
+
+Python-can will search for the first IXXAT device available and open the first channel.
+``interface`` and ``channel`` parameters are interpreted by frontend ``can.interfaces.interface``
+module, while the following parameters are optional and are interpreted by IXXAT implementation.
+
+* ``receive_own_messages`` (default False) Enable self-reception of sent messages.
+* ``unique_hardware_id`` (default first device) Unique hardware ID of the IXXAT device.
+* ``extended`` (default True) Allow usage of extended IDs.
+* ``fd`` (default False) Enable CAN-FD capabilities.
+* ``rx_fifo_size`` (default 16 for CAN, 1024 for CAN-FD) Number of RX mailboxes.
+* ``tx_fifo_size`` (default 16 for CAN, 128 for CAN-FD) Number of TX mailboxes.
+* ``bitrate`` (default 500000) Channel bitrate.
+* ``data_bitrate`` (defaults to 2Mbps) Channel data bitrate (only canfd, to use when message bitrate_switch is used).
+* ``sjw_abr`` (optional, only canfd) Bus timing value sample jump width (arbitration).
+* ``tseg1_abr`` (optional, only canfd) Bus timing value tseg1 (arbitration).
+* ``tseg2_abr`` (optional, only canfd) Bus timing value tseg2 (arbitration).
+* ``sjw_dbr`` (optional, only used if baudrate switch enabled) Bus timing value sample jump width (data).
+* ``tseg1_dbr`` (optional, only used if baudrate switch enabled) Bus timing value tseg1 (data).
+* ``tseg2_dbr`` (optional, only used if baudrate switch enabled) Bus timing value tseg2 (data).
+* ``ssp_dbr`` (optional, only used if baudrate switch enabled) Secondary sample point (data).
+
+
+
+Filtering
+---------
+
+The CAN filters act as an allow list in IXXAT implementation, that is if you
+supply a non-empty filter list you must explicitly state EVERY frame you want
+to receive (including RTR field).
+The can_id/mask must be specified according to IXXAT behaviour, that is
+bit 0 of can_id/mask parameters represents the RTR field in CAN frame. See IXXAT
+VCI documentation, section "Message filters" for more info.
+
+List available devices
+----------------------
+
+In case you have connected multiple IXXAT devices, you have to select them by using their unique hardware id.
+The function :meth:`~can.detect_available_configs` can be used to generate a list of :class:`~can.BusABC` constructors
+(including the channel number and unique hardware ID number for the connected devices).
+
+ .. testsetup:: ixxat
+
+ from unittest.mock import Mock
+ import can
+ assert hasattr(can, "detect_available_configs")
+ can.detect_available_configs = Mock(
+ "interface",
+ return_value=[{'interface': 'ixxat', 'channel': 0, 'unique_hardware_id': 'HW441489'}, {'interface': 'ixxat', 'channel': 0, 'unique_hardware_id': 'HW107422'}, {'interface': 'ixxat', 'channel': 1, 'unique_hardware_id': 'HW107422'}],
+ )
+
+ .. doctest:: ixxat
+
+ >>> import can
+ >>> configs = can.detect_available_configs("ixxat")
+ >>> for config in configs:
+ ... print(config)
+ {'interface': 'ixxat', 'channel': 0, 'unique_hardware_id': 'HW441489'}
+ {'interface': 'ixxat', 'channel': 0, 'unique_hardware_id': 'HW107422'}
+ {'interface': 'ixxat', 'channel': 1, 'unique_hardware_id': 'HW107422'}
+
+
+You may also get a list of all connected IXXAT devices using the function ``get_ixxat_hwids()`` as demonstrated below:
+
+ .. testsetup:: ixxat2
+
+ from unittest.mock import Mock
+ import can.interfaces.ixxat
+ assert hasattr(can.interfaces.ixxat, "get_ixxat_hwids")
+ can.interfaces.ixxat.get_ixxat_hwids = Mock(side_effect=lambda: ['HW441489', 'HW107422'])
+
+ .. doctest:: ixxat2
+
+ >>> from can.interfaces.ixxat import get_ixxat_hwids
+ >>> for hwid in get_ixxat_hwids():
+ ... print("Found IXXAT with hardware id '%s'." % hwid)
+ Found IXXAT with hardware id 'HW441489'.
+ Found IXXAT with hardware id 'HW107422'.
+
+
Bus
---
.. autoclass:: can.interfaces.ixxat.IXXATBus
:members:
-.. autoclass:: can.interfaces.ixxat.canlib.CyclicSendTask
+Implementation based on vcinpl.dll
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. autoclass:: can.interfaces.ixxat.canlib_vcinpl.IXXATBus
:members:
+.. autoclass:: can.interfaces.ixxat.canlib_vcinpl.CyclicSendTask
+ :members:
-Configuration file
-------------------
-The simplest configuration file would be::
+Implementation based on vcinpl2.dll
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- [default]
- interface = ixxat
- channel = 0
+.. autoclass:: can.interfaces.ixxat.canlib_vcinpl2.IXXATBus
+ :members:
-Python-can will search for the first IXXAT device available and open the first channel.
-``interface`` and ``channel`` parameters are interpreted by frontend ``can.interfaces.interface``
-module, while the following parameters are optional and are interpreted by IXXAT implementation.
+.. autoclass:: can.interfaces.ixxat.canlib_vcinpl2.CyclicSendTask
+ :members:
-* ``bitrate`` (default 500000) Channel bitrate
-* ``UniqueHardwareId`` (default first device) Unique hardware ID of the IXXAT device
-* ``rxFifoSize`` (default 16) Number of RX mailboxes
-* ``txFifoSize`` (default 16) Number of TX mailboxes
-* ``extended`` (default False) Allow usage of extended IDs
Internals
@@ -50,18 +133,12 @@ The IXXAT :class:`~can.BusABC` object is a fairly straightforward interface
to the IXXAT VCI library. It can open a specific device ID or use the
first one found.
-The frame exchange *do not involve threads* in the background but is
+The frame exchange *does not involve threads* in the background but is
explicitly instantiated by the caller.
- ``recv()`` is a blocking call with optional timeout.
- ``send()`` is not blocking but may raise a VCIError if the TX FIFO is full
-RX and TX FIFO sizes are configurable with ``rxFifoSize`` and ``txFifoSize``
-options, defaulting at 16 for both.
+RX and TX FIFO sizes are configurable with ``rx_fifo_size`` and ``tx_fifo_size``
+options, defaulting to 16 for both.
-The CAN filters act as a "whitelist" in IXXAT implementation, that is if you
-supply a non-empty filter list you must explicitly state EVERY frame you want
-to receive (including RTR field).
-The can_id/mask must be specified according to IXXAT behaviour, that is
-bit 0 of can_id/mask parameters represents the RTR field in CAN frame. See IXXAT
-VCI documentation, section "Message filters" for more info.
diff --git a/doc/interfaces/kvaser.rst b/doc/interfaces/kvaser.rst
index a4a51ad09..f2c93f85b 100644
--- a/doc/interfaces/kvaser.rst
+++ b/doc/interfaces/kvaser.rst
@@ -20,7 +20,7 @@ Internals
The Kvaser :class:`~can.Bus` object with a physical CAN Bus can be operated in two
modes; ``single_handle`` mode with one shared bus handle used for both reading and
writing to the CAN bus, or with two separate bus handles.
-Two separate handles are needed if receiving and sending messages are done in
+Two separate handles are needed if receiving and sending messages in
different threads (see `Kvaser documentation
`_).
@@ -40,9 +40,11 @@ in the ``recv`` method. If a message does not match any of the filters,
Custom methods
-~~~~~~~~~~~~~~~~~
+~~~~~~~~~~~~~~
This section contains Kvaser driver specific methods.
.. automethod:: can.interfaces.kvaser.canlib.KvaserBus.get_stats
+.. autoclass:: can.interfaces.kvaser.structures.BusStatistics
+ :members:
diff --git a/doc/interfaces/neousys.rst b/doc/interfaces/neousys.rst
new file mode 100644
index 000000000..97a37868c
--- /dev/null
+++ b/doc/interfaces/neousys.rst
@@ -0,0 +1,13 @@
+Neousys CAN Interface
+=====================
+
+This kind of interface can be found for example on Neousys POC-551VTC
+One needs to have correct drivers and DLL (Share object for Linux) from
+`Neousys `_.
+
+Beware this is only tested on Linux kernel higher than v5.3. This should be drop in
+with Windows but you have to replace with correct named DLL
+
+.. autoclass:: can.interfaces.neousys.NeousysBus
+ :show-inheritance:
+ :members:
diff --git a/doc/interfaces/neovi.rst b/doc/interfaces/neovi.rst
index dbb753479..bc711d86b 100644
--- a/doc/interfaces/neovi.rst
+++ b/doc/interfaces/neovi.rst
@@ -1,9 +1,9 @@
-NEOVI Interface
-==================
+Intrepid Control Systems neoVI
+==============================
-.. warning::
+.. note::
- This ``ICS NeoVI`` documentation is a work in progress. Feedback and revisions
+ This ``ICS neoVI`` documentation is a work in progress. Feedback and revisions
are most welcome!
@@ -14,16 +14,16 @@ wrapper on Windows.
Installation
------------
-This neovi interface requires the installation of the ICS neoVI DLL and python-ics
+This neoVI interface requires the installation of the ICS neoVI DLL and ``python-ics``
package.
- Download and install the Intrepid Product Drivers
`Intrepid Product Drivers `__
-- Install python-ics
+- Install ``python-can`` with the ``neovi`` extras:
.. code-block:: bash
- pip install python-ics
+ pip install python-can[neovi]
Configuration
@@ -42,5 +42,6 @@ Bus
---
.. autoclass:: can.interfaces.ics_neovi.NeoViBus
-
-
+.. autoexception:: can.interfaces.ics_neovi.ICSApiError
+.. autoexception:: can.interfaces.ics_neovi.ICSInitializationError
+.. autoexception:: can.interfaces.ics_neovi.ICSOperationError
diff --git a/doc/interfaces/nican.rst b/doc/interfaces/nican.rst
index b2214371f..6e802a3d4 100644
--- a/doc/interfaces/nican.rst
+++ b/doc/interfaces/nican.rst
@@ -1,7 +1,7 @@
-NI-CAN
-======
+National Instruments NI-CAN
+===========================
-This interface adds support for CAN controllers by `National Instruments`_.
+This interface adds support for NI-CAN controllers by `National Instruments`_.
.. warning::
@@ -21,6 +21,7 @@ Bus
.. autoclass:: can.interfaces.nican.NicanBus
.. autoexception:: can.interfaces.nican.NicanError
+.. autoexception:: can.interfaces.nican.NicanInitializationError
.. _National Instruments: http://www.ni.com/can/
diff --git a/doc/interfaces/nixnet.rst b/doc/interfaces/nixnet.rst
new file mode 100644
index 000000000..5a17e7e8d
--- /dev/null
+++ b/doc/interfaces/nixnet.rst
@@ -0,0 +1,21 @@
+National Instruments NI-XNET
+============================
+
+This interface adds support for NI-XNET CAN controllers by `National Instruments`_.
+
+
+.. note::
+
+ NI-XNET only supports windows platforms.
+
+
+Bus
+---
+
+.. autoclass:: can.interfaces.nixnet.NiXNETcanBus
+ :show-inheritance:
+ :member-order: bysource
+ :members:
+
+
+.. _National Instruments: http://www.ni.com/can/
diff --git a/doc/interfaces/pcan.rst b/doc/interfaces/pcan.rst
index 9bbaec9cb..48e7dba05 100644
--- a/doc/interfaces/pcan.rst
+++ b/doc/interfaces/pcan.rst
@@ -3,13 +3,7 @@
PCAN Basic API
==============
-Interface to `Peak-System `__'s PCAN-Basic API.
-
-Windows driver: https://www.peak-system.com/Downloads.76.0.html?&L=1
-
-Linux driver: https://www.peak-system.com/fileadmin/media/linux/index.htm#download and https://www.peak-system.com/Downloads.76.0.html?&L=1 (PCAN-Basic API (Linux))
-
-Mac driver: http://www.mac-can.com
+Interface to `Peak-System `__'s PCAN-Basic API.
Configuration
-------------
@@ -21,18 +15,12 @@ Here is an example configuration file for using `PCAN-USB = 3.4 supports the PCAN adapters natively via :doc:`/interfaces/socketcan`, refer to: :ref:`socketcan-pcan`.
+Beginning with version 3.4, Linux kernels support the PCAN adapters natively via :doc:`/interfaces/socketcan`, refer to: :ref:`socketcan-pcan`.
Bus
---
.. autoclass:: can.interfaces.pcan.PcanBus
+ :members:
diff --git a/doc/interfaces/robotell.rst b/doc/interfaces/robotell.rst
index 064e21725..65b9dfff6 100644
--- a/doc/interfaces/robotell.rst
+++ b/doc/interfaces/robotell.rst
@@ -1,7 +1,7 @@
.. _robotell:
-Chinese CAN-USB interface (mfg. Robotell etc.)
-==============================================
+Robotell CAN-USB interface
+==========================
An USB to CAN adapter sold on Aliexpress, etc. with the manufacturer name Robotell printed on the case.
There is also a USB stick version with a clear case. If the description or screenshots refer to ``EmbededDebug`` or ``EmbededConfig``
@@ -18,11 +18,6 @@ For example use ``/dev/ttyUSB0@115200`` or ``COM4@9600`` for local serial ports
``socket://192.168.254.254:5000`` or ``rfc2217://192.168.254.254:5000`` for remote ports.
-Supported devices
------------------
-
-.. todo:: Document this.
-
Bus
---
@@ -30,8 +25,3 @@ Bus
.. autoclass:: can.interfaces.robotell.robotellBus
:members:
-
-Internals
----------
-
-.. todo:: Document the internals of robotell interface.
diff --git a/doc/interfaces/seeedstudio.rst b/doc/interfaces/seeedstudio.rst
index 5c86fa688..173944e0d 100644
--- a/doc/interfaces/seeedstudio.rst
+++ b/doc/interfaces/seeedstudio.rst
@@ -1,9 +1,8 @@
.. _seeeddoc:
-USB-CAN Analyzer
-================
-...by Seeed Studio
+Seeed Studio USB-CAN Analyzer
+=============================
SKU: 114991193
@@ -13,21 +12,15 @@ Links:
- https://github.com/SeeedDocument/USB-CAN_Analyzer
- https://copperhilltech.com/blog/usbcan-analyzer-usb-to-can-bus-serial-protocol-definition/
-^^^^^^^^^^
Installation
------------
-This interface has additional dependencies which can be installed using pip and the optional extra [seeedstudio]. That will install an additional packages if not already available:
- - pyserial
+This interface has additional dependencies which can be installed using pip and the optional extra ``seeedstudio``. That will include the dependency ``pyserial``::
-::
-
- pip3 install python-can[seeedstudio]
+ pip install python-can[seeedstudio]
-^^^^^^^^^^
-
Interface
---------
@@ -38,13 +31,12 @@ Interface
A bus example::
- bus = can.interface.Bus(bustype='seeedstudio', channel='/dev/ttyUSB0', bitrate=500000)
+ bus = can.interface.Bus(interface='seeedstudio', channel='/dev/ttyUSB0', bitrate=500000)
-^^^^^^^^^^
-Parameters
-----------
+Configuration
+-------------
::
SeeedBus(channel,
@@ -52,9 +44,10 @@ Parameters
timeout=0.1,
frame_type='STD',
operation_mode='normal',
- bitrate=500000)
+ bitrate=500000,
+ can_filters=None)
-ChANNEL
+CHANNEL
The serial port created by the USB device when connected.
TIMEOUT
@@ -83,3 +76,17 @@ BITRATE
- 20000
- 10000
- 5000
+
+CAN_FILTERS
+ A list of can filter dictionaries. Defaults to None (i.e. no filtering).
+ Each filter dictionary should have the following keys:
+ - ``can_id``: The CAN ID to filter on.
+ - ``can_mask``: The mask to apply to the ID.
+
+ Example: ``[{"can_id": 0x11, "can_mask": 0x21},]``
+
+ If one filter is provided, it will be used by the high-performance
+ hardware filter. If zero or more than one filter is provided,
+ software-based filtering will be used.
+
+
diff --git a/doc/interfaces/serial.rst b/doc/interfaces/serial.rst
index 413d9cfd1..566ec7755 100644
--- a/doc/interfaces/serial.rst
+++ b/doc/interfaces/serial.rst
@@ -21,6 +21,8 @@ Bus
.. autoclass:: can.interfaces.serial.serial_can.SerialBus
+ .. automethod:: _recv_internal
+
Internals
---------
The frames that will be sent and received over the serial interface consist of
@@ -28,7 +30,9 @@ six parts. The start and the stop byte for the frame, the timestamp, DLC,
arbitration ID and the payload. The payload has a variable length of between
0 and 8 bytes, the other parts are fixed. Both, the timestamp and the
arbitration ID will be interpreted as 4 byte unsigned integers. The DLC is
-also an unsigned integer with a length of 1 byte.
+also an unsigned integer with a length of 1 byte. Extended (29-bit)
+identifiers are encoded by adding 0x80000000 to the ID. For example, a
+29-bit CAN ID of 0x123 is encoded with an arbitration ID of 0x80000123.
Serial frame format
^^^^^^^^^^^^^^^^^^^
@@ -98,5 +102,23 @@ Examples of serial frames
+----------------+---------------------+------+---------------------+--------------+
| Start of frame | Timestamp | DLC | Arbitration ID | End of frame |
+================+=====================+======+=====================+==============+
-| 0xAA | 0x66 0x73 0x00 0x00 | 0x00 | 0x01 0x00 0x00 0x00 | 0xBBS |
+| 0xAA | 0x66 0x73 0x00 0x00 | 0x00 | 0x01 0x00 0x00 0x00 | 0xBB |
++----------------+---------------------+------+---------------------+--------------+
+
+.. rubric:: Extended Frame CAN message with 0 byte payload with an 29-bit CAN ID
+
++----------------+---------+
+| CAN message |
++----------------+---------+
+| Arbitration ID | Payload |
++================+=========+
+| 0x80000001 (1) | None |
++----------------+---------+
+
++----------------+---------------------+------+---------------------+--------------+
+| Serial frame |
++----------------+---------------------+------+---------------------+--------------+
+| Start of frame | Timestamp | DLC | Arbitration ID | End of frame |
++================+=====================+======+=====================+==============+
+| 0xAA | 0x66 0x73 0x00 0x00 | 0x00 | 0x01 0x00 0x00 0x80 | 0xBB |
+----------------+---------------------+------+---------------------+--------------+
diff --git a/doc/interfaces/socketcan.rst b/doc/interfaces/socketcan.rst
index bdd934ca7..c55a93bc5 100644
--- a/doc/interfaces/socketcan.rst
+++ b/doc/interfaces/socketcan.rst
@@ -1,16 +1,27 @@
+.. _SocketCAN:
+
SocketCAN
=========
-The full documentation for socketcan can be found in the kernel docs at
-`networking/can.txt `_.
+The SocketCAN documentation can be found in the `Linux kernel docs`_ in the
+``networking`` directory. Quoting from the SocketCAN Linux documentation:
+ The socketcan package is an implementation of CAN protocols
+ (Controller Area Network) for Linux. CAN is a networking technology
+ which has widespread use in automation, embedded devices, and
+ automotive fields. While there have been other CAN implementations
+ for Linux based on character devices, SocketCAN uses the Berkeley
+ socket API, the Linux network stack and implements the CAN device
+ drivers as network interfaces. The CAN socket API has been designed
+ as similar as possible to the TCP/IP protocols to allow programmers,
+ familiar with network programming, to easily learn how to use CAN
+ sockets.
-.. note::
+.. important::
- Versions before 2.2 had two different implementations named
- ``socketcan_ctypes`` and ``socketcan_native``. These are now
- deprecated and the aliases to ``socketcan`` will be removed in
- version 4.0. 3.x releases raise a DeprecationWarning.
+ `python-can` versions before 2.2 had two different implementations named
+ ``socketcan_ctypes`` and ``socketcan_native``. These were removed in
+ version 4.0.0 after a deprecation period.
Socketcan Quickstart
@@ -48,12 +59,35 @@ existing ``can0`` interface with a bitrate of 1MB:
sudo ip link set can0 up type can bitrate 1000000
+CAN over Serial / SLCAN
+~~~~~~~~~~~~~~~~~~~~~~~
+
+SLCAN adapters can be used directly via :doc:`/interfaces/slcan`, or
+via :doc:`/interfaces/socketcan` with some help from the ``slcand`` utility
+which can be found in the `can-utils `_ package.
+
+To create a socketcan interface for an SLCAN adapter run the following:
+
+.. code-block:: bash
+
+ slcand -f -o -c -s5 /dev/ttyAMA0
+ ip link set up slcan0
+
+Names of the interfaces created by ``slcand`` match the ``slcan\d+`` regex.
+If a custom name is required, it can be specified as the last argument. E.g.:
+
+.. code-block:: bash
+
+ slcand -f -o -c -s5 /dev/ttyAMA0 can0
+ ip link set up can0
+
.. _socketcan-pcan:
PCAN
~~~~
-Kernels >= 3.4 supports the PCAN adapters natively via :doc:`/interfaces/socketcan`, so there is no need to install any drivers. The CAN interface can be brought like so:
+Kernels >= 3.4 supports the PCAN adapters natively via :doc:`/interfaces/socketcan`,
+so there is no need to install any drivers. The CAN interface can be brought like so:
::
@@ -61,12 +95,22 @@ Kernels >= 3.4 supports the PCAN adapters natively via :doc:`/interfaces/socketc
sudo modprobe peak_pci
sudo ip link set can0 up type can bitrate 500000
+Intrepid
+~~~~~~~~
+
+The Intrepid Control Systems, Inc provides several devices (e.g. ValueCAN) as well
+as Linux module and user-space daemon to make it possible to use them via SocketCAN.
+
+Refer to below repositories for installation instructions:
+
+- `Intrepid kernel module`_
+- `Intrepid user-space daemon`_
+
Send Test Message
^^^^^^^^^^^^^^^^^
-The `can-utils `_ library for linux
-includes a script `cansend` which is useful to send known payloads. For
-example to send a message on `vcan0`:
+The `can-utils`_ library for Linux includes a `cansend` tool which is useful to
+send known payloads. For example to send a message on `vcan0`:
.. code-block:: bash
@@ -133,12 +177,12 @@ To spam a bus:
import time
import can
- bustype = 'socketcan'
+ interface = 'socketcan'
channel = 'vcan0'
def producer(id):
""":param id: Spam the bus with messages including the data id."""
- bus = can.interface.Bus(channel=channel, bustype=bustype)
+ bus = can.Bus(channel=channel, interface=interface)
for i in range(10):
msg = can.Message(arbitration_id=0xc0ffee, data=[id, i, 0, 1, 3, 1, 4, 1], is_extended_id=False)
bus.send(msg)
@@ -170,8 +214,7 @@ function:
import can
- can_interface = 'vcan0'
- bus = can.interface.Bus(can_interface, bustype='socketcan')
+ bus = can.Bus(channel='vcan0', interface='socketcan')
message = bus.recv()
By default, this performs a blocking read, which means ``bus.recv()`` won't
@@ -204,30 +247,47 @@ socket api. This allows the cyclic transmission of CAN messages at given interva
The overhead for periodic message sending is extremely low as all the heavy lifting occurs
within the linux kernel.
-send_periodic()
-~~~~~~~~~~~~~~~
+The :class:`~can.BusABC` initialized for `socketcan` interface transparently handles
+scheduling of CAN messages to Linux BCM via :meth:`~can.BusABC.send_periodic`:
+
+.. code-block:: python
-An example that uses the send_periodic is included in ``python-can/examples/cyclic.py``
+ with can.interface.Bus(interface="socketcan", channel="can0") as bus:
+ task = bus.send_periodic(...)
-The object returned can be used to halt, alter or cancel the periodic message task.
+More examples that uses :meth:`~can.BusABC.send_periodic` are included
+in ``python-can/examples/cyclic.py``.
+
+The `task` object returned by :meth:`~can.BusABC.send_periodic` can be used to halt,
+alter or cancel the periodic message task:
.. autoclass:: can.interfaces.socketcan.CyclicSendTask
+ :members:
+
+Buffer Sizes
+------------
+Currently, the sending buffer size cannot be adjusted by this library.
+However, `this issue `__ describes how to change it via the command line/shell.
Bus
---
-.. autoclass:: can.interfaces.socketcan.SocketcanBus
+The :class:`~can.interfaces.socketcan.SocketcanBus` specializes :class:`~can.BusABC`
+to ensure usage of SocketCAN Linux API. The most important differences are:
- .. method:: recv(timeout=None)
+- usage of SocketCAN BCM for periodic messages scheduling;
+- filtering of CAN messages on Linux kernel level;
+- usage of nanosecond timings from the kernel.
+
+.. autoclass:: can.interfaces.socketcan.SocketcanBus
+ :members:
+ :inherited-members:
- Block waiting for a message from the Bus.
- :param float timeout:
- seconds to wait for a message or None to wait indefinitely
+.. External references
- :rtype: can.Message or None
- :return:
- None on timeout or a :class:`can.Message` object.
- :raises can.CanError:
- if an error occurred while reading
+.. _Linux kernel docs: https://www.kernel.org/doc/Documentation/networking/can.txt
+.. _Intrepid kernel module: https://github.com/intrepidcs/intrepid-socketcan-kernel-module
+.. _Intrepid user-space daemon: https://github.com/intrepidcs/icsscand
+.. _can-utils: https://github.com/linux-can/can-utils
diff --git a/doc/interfaces/socketcand.rst b/doc/interfaces/socketcand.rst
new file mode 100644
index 000000000..f861c81b9
--- /dev/null
+++ b/doc/interfaces/socketcand.rst
@@ -0,0 +1,155 @@
+.. _socketcand_doc:
+
+socketcand Interface
+====================
+`Socketcand `__ is part of the
+`Linux-CAN `__ project, providing a
+Network-to-CAN bridge as a Linux damon. It implements a specific
+`TCP/IP based communication protocol `__
+to transfer CAN frames and control commands.
+
+The main advantage compared to UDP-based protocols (e.g. virtual interface)
+is, that TCP guarantees delivery and that the message order is kept.
+
+Here is a small example dumping all can messages received by a socketcand
+daemon running on a remote Raspberry Pi:
+
+.. code-block:: python
+
+ import can
+
+ bus = can.interface.Bus(interface='socketcand', host="10.0.16.15", port=29536, channel="can0")
+
+ # loop until Ctrl-C
+ try:
+ while True:
+ msg = bus.recv()
+ print(msg)
+ except KeyboardInterrupt:
+ pass
+
+The output may look like this::
+
+ Timestamp: 1637791111.209224 ID: 000006fd X Rx DLC: 8 c4 10 e3 2d 96 ff 25 6b
+ Timestamp: 1637791111.233951 ID: 000001ad X Rx DLC: 4 4d 47 c7 64
+ Timestamp: 1637791111.409415 ID: 000005f7 X Rx DLC: 8 86 de e6 0f 42 55 5d 39
+ Timestamp: 1637791111.434377 ID: 00000665 X Rx DLC: 8 97 96 51 0f 23 25 fc 28
+ Timestamp: 1637791111.609763 ID: 0000031d X Rx DLC: 8 16 27 d8 3d fe d8 31 24
+ Timestamp: 1637791111.634630 ID: 00000587 X Rx DLC: 8 4e 06 85 23 6f 81 2b 65
+
+
+This interface also supports :meth:`~can.detect_available_configs`.
+
+.. code-block:: python
+
+ import can
+ import can.interfaces.socketcand
+
+ cfg = can.interfaces.socketcand._detect_available_configs()
+ if cfg:
+ bus = can.Bus(**cfg[0])
+
+The socketcand daemon broadcasts UDP beacons every 3 seconds. The default
+detection method waits for slightly more than 3 seconds to receive the beacon
+packet. If you want to increase the timeout, you can use
+:meth:`can.interfaces.socketcand.detect_beacon` directly. Below is an example
+which detects the beacon and uses the configuration to create a socketcand bus.
+
+.. code-block:: python
+
+ import can
+ import can.interfaces.socketcand
+
+ cfg = can.interfaces.socketcand.detect_beacon(6000)
+ if cfg:
+ bus = can.Bus(**cfg[0])
+
+Bus
+---
+
+.. autoclass:: can.interfaces.socketcand.SocketCanDaemonBus
+ :show-inheritance:
+ :member-order: bysource
+ :members:
+
+.. autofunction:: can.interfaces.socketcand.detect_beacon
+
+Socketcand Quickstart
+---------------------
+
+The following section will show how to get the stuff installed on a Raspberry Pi with a MCP2515-based
+CAN interface, e.g. available from `Waveshare `__.
+However, it will also work with any other socketcan device.
+
+Install CAN Interface for a MCP2515 based interface on a Raspberry Pi
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Add the following lines to ``/boot/config.txt``.
+Please take care on the frequency of the crystal on your MCP2515 board::
+
+ dtparam=spi=on
+ dtoverlay=mcp2515-can0,oscillator=12000000,interrupt=25,spimaxfrequency=1000000
+
+Reboot after ``/boot/config.txt`` has been modified.
+
+
+Enable socketcan for can0
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Create config file for systemd-networkd to start the socketcan interface automatically:
+
+.. code-block:: bash
+
+ cat >/etc/systemd/network/80-can.network <<'EOT'
+ [Match]
+ Name=can0
+ [CAN]
+ BitRate=250K
+ RestartSec=100ms
+ EOT
+
+Enable ``systemd-networkd`` on reboot and start it immediately (if it was not already startet):
+
+.. code-block:: bash
+
+ sudo systemctl enable systemd-networkd
+ sudo systemctl start systemd-networkd
+
+
+Build socketcand from source
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. code-block:: bash
+
+ # autoconf is needed to build socketcand
+ sudo apt-get install -y autoconf
+ # clone & build sources
+ git clone https://github.com/linux-can/socketcand.git
+ cd socketcand
+ ./autogen.sh
+ ./configure
+ make
+
+
+Install socketcand
+~~~~~~~~~~~~~~~~~~
+.. code-block:: bash
+
+ make install
+
+
+Run socketcand
+~~~~~~~~~~~~~~
+.. code-block:: bash
+
+ ./socketcand -v -i can0
+
+During start, socketcand will prompt its IP address and port it listens to::
+
+ Verbose output activated
+
+ Using network interface 'eth0'
+ Listen adress is 10.0.16.15
+ Broadcast adress is 10.0.255.255
+ creating broadcast thread...
+ binding socket to 10.0.16.15:29536
diff --git a/doc/interfaces/systec.rst b/doc/interfaces/systec.rst
index 0aa4d9444..6b04fdfe0 100644
--- a/doc/interfaces/systec.rst
+++ b/doc/interfaces/systec.rst
@@ -28,12 +28,6 @@ The interface supports following devices:
- USB-CANmodul1 G4,
- USB-CANmodul2 G4.
-Bus
----
-
-.. autoclass:: can.interfaces.systec.ucanbus.UcanBus
- :members:
-
Configuration
-------------
@@ -57,6 +51,14 @@ Optional parameters:
* ``state`` (default BusState.ACTIVE) BusState of the channel
* ``receive_own_messages`` (default False) If messages transmitted should also be received back
+
+Bus
+---
+
+.. autoclass:: can.interfaces.systec.ucanbus.UcanBus
+ :members:
+
+
Internals
---------
diff --git a/doc/interfaces/udp_multicast.rst b/doc/interfaces/udp_multicast.rst
new file mode 100644
index 000000000..b2a049d83
--- /dev/null
+++ b/doc/interfaces/udp_multicast.rst
@@ -0,0 +1,74 @@
+.. _udp_multicast_doc:
+
+Multicast IP Interface
+======================
+
+This module implements transport of CAN and CAN FD messages over UDP via Multicast IPv4 and IPv6.
+This virtual interface allows for communication between multiple processes and even hosts.
+This differentiates it from the :ref:`virtual_interface_doc` interface,
+which can only passes messages within a single process but does not require a network stack.
+
+It runs on UDP to have the lowest possible latency (as opposed to using TCP), and because
+normal IP multicast is inherently unreliable, as the recipients are unknown.
+This enables ad-hoc networks that do not require a central server but is also a so-called
+*unreliable network*. In practice however, local area networks (LANs) should most often be
+sufficiently reliable for this interface to function properly.
+
+.. note::
+ For an overview over the different virtual buses in this library and beyond, please refer
+ to the section :ref:`virtual_interfaces_doc`. It also describes important limitations
+ of this interface.
+
+Please refer to the `Bus class documentation`_ below for configuration options and useful resources
+for specifying multicast IP addresses.
+
+Installation
+-------------------
+
+The Multicast IP Interface depends on the **msgpack** python library,
+which is automatically installed with the `multicast` extra keyword::
+
+ $ pip install python-can[multicast]
+
+
+Supported Platforms
+-------------------
+
+It should work on most Unix systems (including Linux with kernel 2.6.22+ and macOS) but currently not on Windows.
+
+Example
+-------
+
+This example should print a single line indicating that a CAN message was successfully sent
+from ``bus_1`` to ``bus_2``:
+
+.. code-block:: python
+
+ import time
+ import can
+ from can.interfaces.udp_multicast import UdpMulticastBus
+
+ # The bus can be created using the can.Bus wrapper class or using UdpMulticastBus directly
+ with can.Bus(channel=UdpMulticastBus.DEFAULT_GROUP_IPv6, interface='udp_multicast') as bus_1, \
+ UdpMulticastBus(channel=UdpMulticastBus.DEFAULT_GROUP_IPv6) as bus_2:
+
+ # register a callback on the second bus that prints messages to the standard out
+ notifier = can.Notifier(bus_2, [can.Printer()])
+
+ # create and send a message with the first bus, which should arrive at the second one
+ message = can.Message(arbitration_id=0x123, data=[1, 2, 3])
+ bus_1.send(message)
+
+ # give the notifier enough time to get triggered by the second bus
+ time.sleep(2.0)
+
+ # clean-up
+ notifier.stop()
+
+
+Bus Class Documentation
+-----------------------
+
+.. autoclass:: can.interfaces.udp_multicast.UdpMulticastBus
+ :members:
+ :exclude-members: send
diff --git a/doc/interfaces/usb2can.rst b/doc/interfaces/usb2can.rst
index e2e8d7517..1ac9dd61f 100644
--- a/doc/interfaces/usb2can.rst
+++ b/doc/interfaces/usb2can.rst
@@ -1,36 +1,35 @@
USB2CAN Interface
=================
-OVERVIEW
---------
-
The `USB2CAN `_ is a cheap CAN interface based on an ARM7 chip (STR750FV2).
There is support for this device on Linux through the :doc:`socketcan` interface and for Windows using this
``usb2can`` interface.
-
-WINDOWS SUPPORT
----------------
-
Support though windows is achieved through a DLL very similar to the way the PCAN functions. The API is called CANAL
(CAN Abstraction Layer) which is a separate project designed to be used with VSCP which is a socket like messaging system
-that is not only cross platform but also supports other types of devices. This device can be used through one of three ways
-1)Through python-can
-2)CANAL API either using the DLL and C/C++ or through the python wrapper that has been added to this project
-3)VSCP
-Using python-can is strongly suggested as with little extra work the same interface can be used on both Windows and Linux.
+that is not only cross platform but also supports other types of devices.
+
+
+Installation
+------------
+
+1. To install on Windows download the USB2CAN Windows driver. It is compatible with XP, Vista, Win7, Win8/8.1. (Written against driver version v1.0.2.1)
+
+2. Install the appropriate version of `pywin32 `_ (win32com)
+
+3. Download the USB2CAN CANAL DLL from the USB2CAN website.
+ Place this in either the same directory you are running usb2can.py from or your DLL folder in your python install.
+ Note that only a 32-bit version is currently available, so this only works in a 32-bit Python environment.
+
+
+Internals
+---------
-WINDOWS INSTALL
----------------
+This interface originally written against CANAL DLL version ``v1.0.6``.
- 1. To install on Windows download the USB2CAN Windows driver. It is compatible with XP, Vista, Win7, Win8/8.1. (Written against driver version v1.0.2.1)
- 2. Install the appropriate version of `pywin32 `_ (win32com)
- 3. Download the USB2CAN CANAL DLL from the USB2CAN website. Place this in either the same directory you are running usb2can.py from or your DLL folder in your python install.
- Note that only a 32-bit version is currently available, so this only works in a 32-bit Python environment.
- (Written against CANAL DLL version v1.0.6)
Interface Layout
-----------------
+~~~~~~~~~~~~~~~~
- ``usb2canabstractionlayer.py``
This file is only a wrapper for the CANAL API that the interface expects. There are also a couple of constants here to try and make dealing with the
@@ -50,20 +49,26 @@ Interface Layout
Interface Specific Items
------------------------
-There are a few things that are kinda strange about this device and are not overly obvious about the code or things that are not done being implemented in the DLL.
-
-1. You need the Serial Number to connect to the device under Windows. This is part of the "setup string" that configures the device. There are a few options for how to get this.
- 1. Use usb2canWin.py to find the serial number
- 2. Look on the device and enter it either through a prompt/barcode scanner/hardcode it.(Not recommended)
- 3. Reprogram the device serial number to something and do that for all the devices you own. (Really Not Recommended, can no longer use multiple devices on one computer)
+There are a few things that are kinda strange about this device and are not overly obvious about the code or things that
+are not done being implemented in the DLL.
+
+1. You need the Serial Number to connect to the device under Windows. This is part of the "setup string" that configures the device. There are a few options for how to get this.
+
+ 1. Use ``usb2canWin.py`` to find the serial number.
+ 2. Look on the device and enter it either through a prompt/barcode scanner/hardcode it. (Not recommended)
+ 3. Reprogram the device serial number to something and do that for all the devices you own. (Really Not Recommended, can no longer use multiple devices on one computer)
-2. In usb2canabstractionlayer.py there is a structure called CanalMsg which has a unsigned byte array of size 8. In the usb2canInterface file it passes in an unsigned byte array of
- size 8 also which if you pass less than 8 bytes in it stuffs it with extra zeros. So if the data "01020304" is sent the message would look like "0102030400000000".
- There is also a part of this structure called sizeData which is the actual length of the data that was sent not the stuffed message (in this case would be 4).
- What then happens is although a message of size 8 is sent to the device only the length of information so the first 4 bytes of information would be sent. This
- is done because the DLL expects a length of 8 and nothing else. So to make it compatible that has to be sent through the wrapper. If usb2canInterface sent an
- array of length 4 with sizeData of 4 as well the array would throw an incompatible data type error. There is a Wireshark file posted in Issue #36 that demonstrates
- that the bus is only sending the data and not the extra zeros.
+2. In ``usb2canabstractionlayer.py`` there is a structure called ``CanalMsg`` which has a unsigned byte array of size 8.
+ In the ``usb2canInterface`` file it passes in an unsigned byte array of size 8 also which if you pass less than 8
+ bytes in it stuffs it with extra zeros. So if the data ``"01020304"`` is sent the message would look like
+ ``"0102030400000000"``.
+
+ There is also a part of this structure called ``sizeData`` which is the actual length of the data that was sent not
+ the stuffed message (in this case would be 4). What then happens is although a message of size 8 is sent to the device
+ only the first 4 bytes of information would be sent. This is done because the DLL expects a length of 8 and nothing
+ else. So to make it compatible that has to be sent through the wrapper. If ``usb2canInterface`` sent an
+ array of length 4 with sizeData of 4 as well the array would throw an incompatible data type error.
+
3. The masking features have not been implemented currently in the CANAL interface in the version currently on the USB2CAN website.
@@ -79,10 +84,16 @@ Bus
.. autoclass:: can.interfaces.usb2can.Usb2canBus
+Exceptions
+----------
+
+.. autoexception:: can.interfaces.usb2can.usb2canabstractionlayer.CanalError
-Internals
----------
+
+Miscellaneous
+-------------
.. autoclass:: can.interfaces.usb2can.Usb2CanAbstractionLayer
:members:
:undoc-members:
+
diff --git a/doc/interfaces/vector.rst b/doc/interfaces/vector.rst
index dcd45f1bf..d3e2bed45 100644
--- a/doc/interfaces/vector.rst
+++ b/doc/interfaces/vector.rst
@@ -3,8 +3,11 @@ Vector
This interface adds support for CAN controllers by `Vector`_. Only Windows is supported.
+Configuration
+-------------
+
By default this library uses the channel configuration for CANalyzer.
-To use a different application, open Vector Hardware Config program and create
+To use a different application, open **Vector Hardware Configuration** program and create
a new application and assign the channels you may want to use.
Specify the application name as ``app_name='Your app name'`` when constructing
the bus or in a config file.
@@ -12,24 +15,107 @@ the bus or in a config file.
Channel should be given as a list of channels starting at 0.
Here is an example configuration file connecting to CAN 1 and CAN 2 for an
-application named "python-can"::
+application named "python-can":
+
+::
[default]
interface = vector
channel = 0, 1
app_name = python-can
-If you are using Python 2.7 it is recommended to install pywin32_, otherwise a
-slow and CPU intensive polling will be used when waiting for new messages.
-Bus
----
+VectorBus
+---------
.. autoclass:: can.interfaces.vector.VectorBus
+ :show-inheritance:
+ :member-order: bysource
+ :members:
+ set_filters,
+ recv,
+ send,
+ send_periodic,
+ stop_all_periodic_tasks,
+ flush_tx_buffer,
+ reset,
+ shutdown,
+ popup_vector_hw_configuration,
+ get_application_config,
+ set_application_config
+
+Exceptions
+----------
.. autoexception:: can.interfaces.vector.VectorError
+ :show-inheritance:
+.. autoexception:: can.interfaces.vector.VectorInitializationError
+ :show-inheritance:
+.. autoexception:: can.interfaces.vector.VectorOperationError
+ :show-inheritance:
+
+Miscellaneous
+-------------
+
+.. autofunction:: can.interfaces.vector.get_channel_configs
+
+.. autoclass:: can.interfaces.vector.VectorChannelConfig
+ :show-inheritance:
+ :class-doc-from: class
+
+.. autoclass:: can.interfaces.vector.canlib.VectorBusParams
+ :show-inheritance:
+ :class-doc-from: class
+
+.. autoclass:: can.interfaces.vector.canlib.VectorCanParams
+ :show-inheritance:
+ :class-doc-from: class
+
+.. autoclass:: can.interfaces.vector.canlib.VectorCanFdParams
+ :show-inheritance:
+ :class-doc-from: class
+
+.. autoclass:: can.interfaces.vector.xldefine.XL_HardwareType
+ :show-inheritance:
+ :member-order: bysource
+ :members:
+ :undoc-members:
+
+.. autoclass:: can.interfaces.vector.xldefine.XL_ChannelCapabilities
+ :show-inheritance:
+ :member-order: bysource
+ :members:
+ :undoc-members:
+
+.. autoclass:: can.interfaces.vector.xldefine.XL_BusCapabilities
+ :show-inheritance:
+ :member-order: bysource
+ :members:
+ :undoc-members:
+
+.. autoclass:: can.interfaces.vector.xldefine.XL_BusTypes
+ :show-inheritance:
+ :member-order: bysource
+ :members:
+ :undoc-members:
+
+.. autoclass:: can.interfaces.vector.xldefine.XL_OutputMode
+ :show-inheritance:
+ :member-order: bysource
+ :members:
+ :undoc-members:
+
+.. autoclass:: can.interfaces.vector.xldefine.XL_CANFD_BusParams_CanOpMode
+ :show-inheritance:
+ :member-order: bysource
+ :members:
+ :undoc-members:
+.. autoclass:: can.interfaces.vector.xldefine.XL_Status
+ :show-inheritance:
+ :member-order: bysource
+ :members:
+ :undoc-members:
.. _Vector: https://vector.com/
-.. _pywin32: https://sourceforge.net/projects/pywin32/
diff --git a/doc/interfaces/virtual.rst b/doc/interfaces/virtual.rst
index ed6681a57..bdadcb08d 100644
--- a/doc/interfaces/virtual.rst
+++ b/doc/interfaces/virtual.rst
@@ -1,23 +1,67 @@
+.. _virtual_interface_doc:
+
Virtual
=======
-The virtual interface can be used as a way to write OS and driver independent
-tests.
+The virtual interface can be used as a way to write OS and driver independent tests.
+Any `VirtualBus` instances connecting to the same channel (from within the same Python
+process) will receive each others messages.
-A virtual CAN bus that can be used for automatic tests. Any Bus instances
-connecting to the same channel (in the same python program) will get each
-others messages.
+If messages shall be sent across process or host borders, consider using the
+:ref:`udp_multicast_doc` and refer to :ref:`virtual_interfaces_doc`
+for a comparison and general discussion of different virtual interfaces.
+Example
+-------
.. code-block:: python
-
+
import can
- bus1 = can.interface.Bus('test', bustype='virtual')
- bus2 = can.interface.Bus('test', bustype='virtual')
+ bus1 = can.interface.Bus('test', interface='virtual')
+ bus2 = can.interface.Bus('test', interface='virtual')
msg1 = can.Message(arbitration_id=0xabcde, data=[1,2,3])
bus1.send(msg1)
msg2 = bus2.recv()
- assert msg1 == msg2
+ #assert msg1 == msg2
+ assert msg1.arbitration_id == msg2.arbitration_id
+ assert msg1.data == msg2.data
+ assert msg1.timestamp != msg2.timestamp
+
+.. code-block:: python
+
+ import can
+
+ bus1 = can.interface.Bus('test', interface='virtual', preserve_timestamps=True)
+ bus2 = can.interface.Bus('test', interface='virtual')
+
+ msg1 = can.Message(timestamp=1639740470.051948, arbitration_id=0xabcde, data=[1,2,3])
+
+ # Messages sent on bus1 will have their timestamps preserved when received
+ # on bus2
+ bus1.send(msg1)
+ msg2 = bus2.recv()
+
+ assert msg1.arbitration_id == msg2.arbitration_id
+ assert msg1.data == msg2.data
+ assert msg1.timestamp == msg2.timestamp
+
+ # Messages sent on bus2 will not have their timestamps preserved when
+ # received on bus1
+ bus2.send(msg1)
+ msg3 = bus1.recv()
+
+ assert msg1.arbitration_id == msg3.arbitration_id
+ assert msg1.data == msg3.data
+ assert msg1.timestamp != msg3.timestamp
+
+
+Bus Class Documentation
+-----------------------
+
+.. autoclass:: can.interfaces.virtual.VirtualBus
+ :members:
+
+ .. automethod:: _detect_available_configs
diff --git a/doc/internal-api.rst b/doc/internal-api.rst
index c43db3394..9e544f052 100644
--- a/doc/internal-api.rst
+++ b/doc/internal-api.rst
@@ -7,6 +7,15 @@ Here we document the odds and ends that are more helpful for creating your own i
or listeners but generally shouldn't be required to interact with python-can.
+BusABC
+------
+
+The :class:`~can.BusABC` class, as the name suggests, provides an abstraction of a CAN bus.
+The bus provides a wrapper around a physical or virtual CAN Bus.
+
+An interface specific instance of the :class:`~can.BusABC` is created by the :class:`~can.Bus`
+class, see :ref:`bus` for the user facing API.
+
.. _businternals:
@@ -48,7 +57,7 @@ They **might** implement the following:
and thus might not provide message filtering:
-Concrete instances are usually created by :class:`can.Bus` which takes the users
+Concrete instances are usually created by :func:`can.Bus` which takes the users
configuration into account.
@@ -57,23 +66,32 @@ Bus Internals
Several methods are not documented in the main :class:`can.BusABC`
as they are primarily useful for library developers as opposed to
-library users. This is the entire ABC bus class with all internal
-methods:
+library users.
-.. autoclass:: can.BusABC
- :private-members:
- :special-members:
- :noindex:
+.. automethod:: can.BusABC.__init__
+
+.. automethod:: can.BusABC.__iter__
+
+.. automethod:: can.BusABC.__str__
+.. autoattribute:: can.BusABC.__weakref__
+
+.. automethod:: can.BusABC._recv_internal
+
+.. automethod:: can.BusABC._apply_filters
+
+.. automethod:: can.BusABC._send_periodic_internal
+
+.. automethod:: can.BusABC._detect_available_configs
About the IO module
-------------------
-Handling of the different file formats is implemented in :mod:`can.io`.
+Handling of the different file formats is implemented in ``can.io``.
Each file/IO type is within a separate module and ideally implements both a *Reader* and a *Writer*.
-The reader usually extends :class:`can.io.generic.BaseIOHandler`, while
-the writer often additionally extends :class:`can.Listener`,
+The reader extends :class:`can.io.generic.MessageReader`, while the writer extends
+:class:`can.io.generic.MessageWriter`, a subclass of the :class:`can.Listener`,
to be able to be passed directly to a :class:`can.Notifier`.
@@ -86,9 +104,9 @@ Ideally add both reading and writing support for the new file format, although t
1. Create a new module: *can/io/canstore.py*
(*or* simply copy some existing one like *can/io/csv.py*)
-2. Implement a reader ``CanstoreReader`` (which often extends :class:`can.io.generic.BaseIOHandler`, but does not have to).
+2. Implement a reader ``CanstoreReader`` which extends :class:`can.io.generic.MessageReader`.
Besides from a constructor, only ``__iter__(self)`` needs to be implemented.
-3. Implement a writer ``CanstoreWriter`` (which often extends :class:`can.io.generic.BaseIOHandler` and :class:`can.Listener`, but does not have to).
+3. Implement a writer ``CanstoreWriter`` which extends :class:`can.io.generic.MessageWriter`.
Besides from a constructor, only ``on_message_received(self, msg)`` needs to be implemented.
4. Add a case to ``can.io.player.LogReader``'s ``__new__()``.
5. Document the two new classes (and possibly additional helpers) with docstrings and comments.
@@ -108,7 +126,10 @@ IO Utilities
.. automodule:: can.io.generic
+ :show-inheritance:
:members:
+ :private-members:
+ :member-order: bysource
diff --git a/doc/message.rst b/doc/message.rst
index 921748cb9..e0003cfe5 100644
--- a/doc/message.rst
+++ b/doc/message.rst
@@ -15,7 +15,7 @@ Message
>>> test.dlc
5
>>> print(test)
- Timestamp: 0.000000 ID: 00000000 010 DLC: 5 01 02 03 04 05
+ Timestamp: 0.000000 ID: 00000000 X Rx DL: 5 01 02 03 04 05
The :attr:`~can.Message.arbitration_id` field in a CAN message may be either
@@ -44,7 +44,7 @@ Message
2\ :sup:`29` - 1 for 29-bit identifiers).
>>> print(Message(is_extended_id=False, arbitration_id=100))
- Timestamp: 0.000000 ID: 0064 S DLC: 0
+ Timestamp: 0.000000 ID: 064 S Rx DL: 0
.. attribute:: data
@@ -56,7 +56,7 @@ Message
>>> example_data = bytearray([1, 2, 3])
>>> print(Message(data=example_data))
- Timestamp: 0.000000 ID: 00000000 X DLC: 3 01 02 03
+ Timestamp: 0.000000 ID: 00000000 X Rx DL: 3 01 02 03
A :class:`~can.Message` can also be created with bytes, or lists of ints:
@@ -106,9 +106,9 @@ Message
Previously this was exposed as `id_type`.
>>> print(Message(is_extended_id=False))
- Timestamp: 0.000000 ID: 0000 S DLC: 0
+ Timestamp: 0.000000 ID: 000 S Rx DL: 0
>>> print(Message(is_extended_id=True))
- Timestamp: 0.000000 ID: 00000000 X DLC: 0
+ Timestamp: 0.000000 ID: 00000000 X Rx DL: 0
.. note::
@@ -124,7 +124,7 @@ Message
This boolean parameter indicates if the message is an error frame or not.
>>> print(Message(is_error_frame=True))
- Timestamp: 0.000000 ID: 00000000 X E DLC: 0
+ Timestamp: 0.000000 ID: 00000000 X Rx E DL: 0
.. attribute:: is_remote_frame
@@ -135,7 +135,7 @@ Message
modifies the bit in the CAN message's flags field indicating this.
>>> print(Message(is_remote_frame=True))
- Timestamp: 0.000000 ID: 00000000 X R DLC: 0
+ Timestamp: 0.000000 ID: 00000000 X Rx R DL: 0
.. attribute:: is_fd
@@ -145,6 +145,13 @@ Message
Indicates that this message is a CAN FD message.
+ .. attribute:: is_rx
+
+ :type: bool
+
+ Indicates whether this message is a transmitted (Tx) or received (Rx) frame
+
+
.. attribute:: bitrate_switch
:type: bool
@@ -167,17 +174,17 @@ Message
>>> from can import Message
>>> test = Message()
>>> print(test)
- Timestamp: 0.000000 ID: 00000000 X DLC: 0
+ Timestamp: 0.000000 ID: 00000000 X Rx DL: 0
>>> test2 = Message(data=[1, 2, 3, 4, 5])
>>> print(test2)
- Timestamp: 0.000000 ID: 00000000 X DLC: 5 01 02 03 04 05
+ Timestamp: 0.000000 ID: 00000000 X Rx DL: 5 01 02 03 04 05
The fields in the printed message are (in order):
- timestamp,
- arbitration ID,
- flags,
- - dlc,
+ - data length (DL),
- and data.
@@ -193,3 +200,5 @@ Message
Each of the bytes in the data field (when present) are represented as
two-digit hexadecimal numbers.
+
+ .. automethod:: equals
diff --git a/doc/notifier.rst b/doc/notifier.rst
new file mode 100644
index 000000000..e1b160a6e
--- /dev/null
+++ b/doc/notifier.rst
@@ -0,0 +1,87 @@
+Notifier and Listeners
+======================
+
+.. _notifier:
+
+Notifier
+--------
+
+The Notifier object is used as a message distributor for a bus. The Notifier
+uses an event loop or creates a thread to read messages from the bus and
+distributes them to listeners.
+
+.. autoclass:: can.Notifier
+ :members:
+
+.. _listeners_doc:
+
+Listener
+--------
+
+The Listener class is an "abstract" base class for any objects which wish to
+register to receive notifications of new messages on the bus. A Listener can
+be used in two ways; the default is to **call** the Listener with a new
+message, or by calling the method **on_message_received**.
+
+Listeners are registered with :ref:`notifier` object(s) which ensure they are
+notified whenever a new message is received.
+
+.. literalinclude:: ../examples/print_notifier.py
+ :language: python
+ :linenos:
+ :emphasize-lines: 8,9
+
+
+Subclasses of Listener that do not override **on_message_received** will cause
+:class:`NotImplementedError` to be thrown when a message is received on
+the CAN bus.
+
+.. autoclass:: can.Listener
+ :members:
+
+There are some listeners that already ship together with `python-can`
+and are listed below.
+Some of them allow messages to be written to files, and the corresponding file
+readers are also documented here.
+
+.. note ::
+
+ Please note that writing and the reading a message might not always yield a
+ completely unchanged message again, since some properties are not (yet)
+ supported by some file formats.
+
+.. note ::
+
+ Additional file formats for both reading/writing log files can be added via
+ a plugin reader/writer. An external package can register a new reader
+ by using the ``can.io.message_reader`` entry point. Similarly, a writer can
+ be added using the ``can.io.message_writer`` entry point.
+
+ The format of the entry point is ``reader_name=module:classname`` where ``classname``
+ is a concrete implementation of :class:`~can.io.generic.MessageReader` or
+ :class:`~can.io.generic.MessageWriter`.
+
+ ::
+
+ entry_points={
+ 'can.io.message_reader': [
+ '.asc = my_package.io.asc:ASCReader'
+ ]
+ },
+
+
+BufferedReader
+--------------
+
+.. autoclass:: can.BufferedReader
+ :members:
+
+.. autoclass:: can.AsyncBufferedReader
+ :members:
+
+
+RedirectReader
+--------------
+
+.. autoclass:: can.RedirectReader
+ :members:
diff --git a/doc/other-tools.rst b/doc/other-tools.rst
new file mode 100644
index 000000000..607db6c8a
--- /dev/null
+++ b/doc/other-tools.rst
@@ -0,0 +1,79 @@
+Other CAN Bus Tools
+===================
+
+In order to keep the project maintainable, the scope of the package is limited to providing common
+abstractions to different hardware devices, and a basic suite of utilities for sending and
+receiving messages on a CAN bus. Other tools are available that either extend the functionality
+of python-can, or provide complementary features that python-can users might find useful.
+
+Some of these tools are listed below for convenience.
+
+CAN Message protocols (implemented in Python)
+---------------------------------------------
+
+#. SAE J1939 Message Protocol
+ * The `can-j1939`_ module provides an implementation of the CAN SAE J1939 standard for Python,
+ including J1939-22. `can-j1939`_ uses python-can to provide support for multiple hardware
+ interfaces.
+#. CIA CANopen
+ * The `canopen`_ module provides an implementation of the CIA CANopen protocol, aiming to be
+ used for automation and testing purposes
+#. ISO 15765-2 (ISO TP)
+ * The `can-isotp`_ module provides an implementation of the ISO TP CAN protocol for sending
+ data packets via a CAN transport layer.
+
+#. UDS
+ * The `python-uds`_ module is a communication protocol agnostic implementation of the Unified
+ Diagnostic Services (UDS) protocol defined in ISO 14229-1, although it does have extensions
+ for performing UDS over CAN utilising the ISO TP protocol. This module has not been updated
+ for some time.
+ * The `uds`_ module is another tool that implements the UDS protocol, although it does have
+ extensions for performing UDS over CAN utilising the ISO TP protocol. This module has not
+ been updated for some time.
+#. XCP
+ * The `pyxcp`_ module implements the Universal Measurement and Calibration Protocol (XCP).
+ The purpose of XCP is to adjust parameters and acquire current values of internal
+ variables in an ECU.
+
+.. _can-j1939: https://github.com/juergenH87/python-can-j1939
+.. _canopen: https://canopen.readthedocs.io/en/latest/
+.. _can-isotp: https://can-isotp.readthedocs.io/en/latest/
+.. _python-uds: https://python-uds.readthedocs.io/en/latest/index.html
+.. _uds: https://uds.readthedocs.io/en/latest/
+.. _pyxcp: https://pyxcp.readthedocs.io/en/latest/
+
+CAN Frame Parsing tools etc. (implemented in Python)
+----------------------------------------------------
+
+#. CAN Message / Database scripting
+ * The `cantools`_ package provides multiple methods for interacting with can message database
+ files, and using these files to monitor live buses with a command line monitor tool.
+#. CAN Message / Log Decoding
+ * The `canmatrix`_ module provides methods for converting between multiple popular message
+ frame definition file formats (e.g. .DBC files, .KCD files, .ARXML files etc.).
+ * The `pretty_j1939`_ module can be used to post-process CAN logs of J1939 traffic into human
+ readable terminal prints or into a JSON file for consumption elsewhere in your scripts.
+
+.. _cantools: https://cantools.readthedocs.io/en/latest/
+.. _canmatrix: https://canmatrix.readthedocs.io/en/latest/
+.. _pretty_j1939: https://github.com/nmfta-repo/pretty_j1939
+
+Other CAN related tools, programs etc.
+--------------------------------------
+
+#. Micropython CAN class
+ * A `CAN class`_ is available for the original micropython pyboard, with much of the same
+ functionality as is available with python-can (but with a different API!).
+#. ASAM MDF Files
+ * The `asammdf`_ module provides many methods for processing ASAM (Association for
+ Standardization of Automation and Measuring Systems) MDF (Measurement Data Format) files.
+
+.. _`CAN class`: https://docs.micropython.org/en/latest/library/pyb.CAN.html
+.. _`asammdf`: https://asammdf.readthedocs.io/en/master/
+
+|
+|
+
+.. note::
+ See also the available plugins for python-can in :ref:`plugin interface`.
+
diff --git a/doc/plugin-interface.rst b/doc/plugin-interface.rst
new file mode 100644
index 000000000..612148033
--- /dev/null
+++ b/doc/plugin-interface.rst
@@ -0,0 +1,99 @@
+
+.. _plugin interface:
+
+Plugin Interface
+================
+
+External packages can register new interfaces by using the ``can.interface`` entry point
+in its project configuration. The format of the entry point depends on your project
+configuration format (*pyproject.toml*, *setup.cfg* or *setup.py*).
+
+In the following example ``module`` defines the location of your bus class inside your
+package e.g. ``my_package.subpackage.bus_module`` and ``classname`` is the name of
+your :class:`can.BusABC` subclass.
+
+.. tab:: pyproject.toml (PEP 621)
+
+ .. code-block:: toml
+
+ # Note the quotes around can.interface in order to escape the dot .
+ [project.entry-points."can.interface"]
+ interface_name = "module:classname"
+
+.. tab:: setup.cfg
+
+ .. code-block:: ini
+
+ [options.entry_points]
+ can.interface =
+ interface_name = module:classname
+
+.. tab:: setup.py
+
+ .. code-block:: python
+
+ from setuptools import setup
+
+ setup(
+ # ...,
+ entry_points = {
+ 'can.interface': [
+ 'interface_name = module:classname'
+ ]
+ }
+ )
+
+The ``interface_name`` can be used to
+create an instance of the bus in the **python-can** API:
+
+.. code-block:: python
+
+ import can
+
+ bus = can.Bus(interface="interface_name", channel=0)
+
+
+
+Example Interface Plugins
+-------------------------
+
+The table below lists interface drivers that can be added by installing additional packages that utilise the plugin API. These modules are optional dependencies of python-can.
+
+.. note::
+ The packages listed below are maintained by other authors. Any issues should be reported in their corresponding repository and **not** in the python-can repository.
+
++----------------------------+----------------------------------------------------------+
+| Name | Description |
++============================+==========================================================+
+| `python-can-canine`_ | CAN Driver for the CANine CAN interface |
++----------------------------+----------------------------------------------------------+
+| `python-can-cvector`_ | Cython based version of the 'VectorBus' |
++----------------------------+----------------------------------------------------------+
+| `python-can-remote`_ | CAN over network bridge |
++----------------------------+----------------------------------------------------------+
+| `python-can-sontheim`_ | CAN Driver for Sontheim CAN interfaces (e.g. CANfox) |
++----------------------------+----------------------------------------------------------+
+| `zlgcan`_ | Python wrapper for zlgcan-driver-rs |
++----------------------------+----------------------------------------------------------+
+| `python-can-cando`_ | Python wrapper for Netronics' CANdo and CANdoISO |
++----------------------------+----------------------------------------------------------+
+| `python-can-candle`_ | A full-featured driver for candleLight |
++----------------------------+----------------------------------------------------------+
+| `python-can-coe`_ | A CAN-over-Ethernet interface for Technische Alternative |
++----------------------------+----------------------------------------------------------+
+| `RP1210`_ | CAN channels in RP1210 Vehicle Diagnostic Adapters |
++----------------------------+----------------------------------------------------------+
+| `python-can-damiao`_ | Interface for Damiao USB-CAN adapters |
++----------------------------+----------------------------------------------------------+
+
+.. _python-can-canine: https://github.com/tinymovr/python-can-canine
+.. _python-can-cvector: https://github.com/zariiii9003/python-can-cvector
+.. _python-can-remote: https://github.com/christiansandberg/python-can-remote
+.. _python-can-sontheim: https://github.com/MattWoodhead/python-can-sontheim
+.. _zlgcan: https://github.com/jesses2025smith/zlgcan-driver
+.. _python-can-cando: https://github.com/belliriccardo/python-can-cando
+.. _python-can-candle: https://github.com/BIRLab/python-can-candle
+.. _python-can-coe: https://c0d3.sh/smarthome/python-can-coe
+.. _RP1210: https://github.com/dfieschko/RP1210
+.. _python-can-damiao: https://github.com/gaoyichuan/python-can-damiao
+
diff --git a/doc/pycanlib.pml b/doc/pycanlib.pml
index 0ddcf25e5..907fadabb 100644
--- a/doc/pycanlib.pml
+++ b/doc/pycanlib.pml
@@ -1,4 +1,4 @@
-/* This promela model was used to verify the concurrent design of the bus object. */
+/* This promela model was used to verify a past design of the bus object. */
bool lock = false;
diff --git a/doc/scripts.rst b/doc/scripts.rst
index a63f1b108..1d730a74b 100644
--- a/doc/scripts.rst
+++ b/doc/scripts.rst
@@ -1,9 +1,9 @@
-Scripts
-=======
+Command Line Tools
+==================
-The following modules are callable from python-can.
+The following modules are callable from ``python-can``.
-They can be called for example by ``python -m can.logger`` or ``can_logger.py`` (if installed using pip).
+They can be called for example by ``python -m can.logger`` or ``can_logger`` (if installed using pip).
can.logger
----------
@@ -12,12 +12,14 @@ Command line help, called with ``--help``:
.. command-output:: python -m can.logger -h
+ :shell:
can.player
----------
.. command-output:: python -m can.player -h
+ :shell:
can.viewer
@@ -28,7 +30,21 @@ A screenshot of the application can be seen below:
.. image:: images/viewer.png
:width: 100%
-The first column is the number of times a frame with the particular ID that has been received, next is the timestamp of the frame relative to the first received message. The third column is the time between the current frame relative to the previous one. Next is the length of the frame, the data and then the decoded data converted according to the ``-d`` argument. The top red row indicates an error frame.
+The first column is the number of times a frame with the particular ID that has been received, next is the timestamp of the frame relative to the first received message. The third column is the time between the current frame relative to the previous one. Next is the length of the frame, the data and then the decoded data converted according to the ``-d`` argument. The top red row indicates an error frame.
+There are several keyboard shortcuts that can be used with the viewer script, they function as follows:
+
+* ESCAPE - Quit the viewer script
+* q - as ESCAPE
+* c - Clear the stored frames
+* s - Sort the stored frames
+* h - Toggle highlighting of changed bytes in the data field - see the below image
+* SPACE - Pause the viewer
+* UP/DOWN - Scroll the viewer
+
+.. image:: images/viewer_changed_bytes_highlighting.png
+ :width: 50%
+
+A byte in the data field is highlighted blue if the value is different from the last time the message was received.
Command line arguments
^^^^^^^^^^^^^^^^^^^^^^
@@ -38,4 +54,20 @@ By default the ``can.viewer`` uses the :doc:`/interfaces/socketcan` interface. A
The full usage page can be seen below:
.. command-output:: python -m can.viewer -h
+ :shell:
+
+
+can.bridge
+----------
+
+A small application that can be used to connect two can buses:
+
+.. command-output:: python -m can.bridge -h
+ :shell:
+
+
+can.logconvert
+--------------
+.. command-output:: python -m can.logconvert -h
+ :shell:
diff --git a/doc/utils.rst b/doc/utils.rst
new file mode 100644
index 000000000..9c742e2fb
--- /dev/null
+++ b/doc/utils.rst
@@ -0,0 +1,10 @@
+Utilities
+---------
+
+
+.. autofunction:: can.detect_available_configs
+
+.. autofunction:: can.cli.add_bus_arguments
+
+.. autofunction:: can.cli.create_bus_from_namespace
+
diff --git a/doc/virtual-interfaces.rst b/doc/virtual-interfaces.rst
new file mode 100644
index 000000000..70ac601fa
--- /dev/null
+++ b/doc/virtual-interfaces.rst
@@ -0,0 +1,77 @@
+
+.. _virtual_interfaces_doc:
+
+Virtual Interfaces
+==================
+
+There are quite a few implementations for CAN networks that do not require physical
+CAN hardware. The built in virtual interfaces are:
+
+.. toctree::
+ :maxdepth: 1
+
+ interfaces/virtual
+ interfaces/udp_multicast
+
+
+Comparison
+----------
+
+The following table compares some known virtual interfaces:
+
++----------------------------------------------------+-----------------------------------------------------------------------+---------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------+
+| **Name** | **Availability** | **Applicability** | **Implementation** |
+| | +-----------+-------------+-------------+--------------------+---------------------------------------------+---------------------------------------------------------------------+
+| | | **Within | **Between | **Via (IP) | **Without Central | **Transport | **Serialization |
+| | | Process** | Processes** | Networks** | Server** | Technology** | Format** |
++----------------------------------------------------+-----------------------------------------------------------------------+-----------+-------------+-------------+--------------------+---------------------------------------------+---------------------------------------------------------------------+
+| ``virtual`` (this) | *included* | ✓ | ✗ | ✗ | ✓ | Singleton & Mutex | none |
+| | | | | | | (reliable) | |
++----------------------------------------------------+-----------------------------------------------------------------------+-----------+-------------+-------------+--------------------+---------------------------------------------+---------------------------------------------------------------------+
+| ``udp_multicast`` (:ref:`doc `) | *included* | ✓ | ✓ | ✓ | ✓ | UDP via IP multicast | custom using `msgpack `__ |
+| | | | | | | (unreliable) | |
++----------------------------------------------------+-----------------------------------------------------------------------+-----------+-------------+-------------+--------------------+---------------------------------------------+---------------------------------------------------------------------+
+| *christiansandberg/ | `external `__ | ✓ | ✓ | ✓ | ✗ | Websockets via TCP/IP | custom binary |
+| python-can-remote* | | | | | | (reliable) | |
++----------------------------------------------------+-----------------------------------------------------------------------+-----------+-------------+-------------+--------------------+---------------------------------------------+---------------------------------------------------------------------+
+| *windelbouwman/ | `external `__ | ✓ | ✓ | ✓ | ✗ | `ZeroMQ `__ via TCP/IP | custom binary [#f1]_ |
+| virtualcan* | | | | | | (reliable) | |
++----------------------------------------------------+-----------------------------------------------------------------------+-----------+-------------+-------------+--------------------+---------------------------------------------+---------------------------------------------------------------------+
+
+.. [#f1]
+ The only option in this list that implements interoperability with other languages
+ out of the box. For the others (except the first intra-process one), other programs written
+ in potentially different languages could effortlessly interface with the bus
+ once they mimic the serialization format. The last one, however, has already implemented
+ the entire bus functionality in *C++* and *Rust*, besides the Python variant.
+
+Common Limitations
+------------------
+
+**Guaranteed delivery** and **message ordering** is one major point of difference:
+While in a physical CAN network, a message is either sent or in queue (or an explicit error occurred),
+this may not be the case for virtual networks.
+The ``udp_multicast`` bus for example, drops this property for the benefit of lower
+latencies by using unreliable UDP/IP instead of reliable TCP/IP (and because normal IP multicast
+is inherently unreliable, as the recipients are unknown by design). The other three buses faithfully
+model a physical CAN network in this regard: They ensure that all recipients actually receive
+(and acknowledge each message), much like in a physical CAN network. They also ensure that
+messages are relayed in the order they have arrived at the central server and that messages
+arrive at the recipients exactly once. Both is not guaranteed to hold for the best-effort
+``udp_multicast`` bus as it uses UDP/IP as a transport layer.
+
+**Central servers** are, however, required by interfaces 3 and 4 (the external tools) to provide
+these guarantees of message delivery and message ordering. The central servers receive and distribute
+the CAN messages to all other bus participants, unlike in a real physical CAN network.
+The first intra-process ``virtual`` interface only runs within one Python process, effectively the
+Python instance of :class:`~can.interfaces.virtual.VirtualBus` acts as a central server.
+Notably the ``udp_multicast`` bus does not require a central server.
+
+**Arbitration and throughput** are two interrelated functions/properties of CAN networks which
+are typically abstracted in virtual interfaces. In all four interfaces, an unlimited amount
+of messages can be sent per unit of time (given the computational power of the machines and
+networks that are involved). In a real CAN/CAN FD networks, however, throughput is usually much
+more restricted and prioritization of arbitration IDs is thus an important feature once the bus
+is starting to get saturated. None of the interfaces presented above support any sort of throttling
+or ID arbitration under high loads.
+
diff --git a/examples/asyncio_demo.py b/examples/asyncio_demo.py
old mode 100644
new mode 100755
index b2c84b9d1..6befbe7a9
--- a/examples/asyncio_demo.py
+++ b/examples/asyncio_demo.py
@@ -5,57 +5,51 @@
"""
import asyncio
+from typing import TYPE_CHECKING
+
import can
+if TYPE_CHECKING:
+ from can.notifier import MessageRecipient
+
-def print_message(msg):
+def print_message(msg: can.Message) -> None:
"""Regular callback function. Can also be a coroutine."""
print(msg)
-async def main():
+async def main() -> None:
"""The main function that runs in the loop."""
- bus = can.Bus("vcan0", bustype="virtual", receive_own_messages=True)
- reader = can.AsyncBufferedReader()
- logger = can.Logger("logfile.asc")
-
- listeners = [
- print_message, # Callback function
- reader, # AsyncBufferedReader() listener
- logger, # Regular Listener object
- ]
- # Create Notifier with an explicit loop to use for scheduling of callbacks
- loop = asyncio.get_event_loop()
- notifier = can.Notifier(bus, listeners, loop=loop)
- # Start sending first message
- bus.send(can.Message(arbitration_id=0))
-
- print("Bouncing 10 messages...")
- for _ in range(10):
- # Wait for next message from AsyncBufferedReader
- msg = await reader.get_message()
- # Delay response
- await asyncio.sleep(0.5)
- msg.arbitration_id += 1
- bus.send(msg)
- # Wait for last message to arrive
- await reader.get_message()
- print("Done!")
-
- # Clean-up
- notifier.stop()
- bus.shutdown()
-
-
-if __name__ == "__main":
- try:
- # Get the default event loop
- LOOP = asyncio.get_event_loop()
- # Run until main coroutine finishes
- LOOP.run_until_complete(main())
- finally:
- LOOP.close()
-
- # or on Python 3.7+ simply
- # asyncio.run(main())
+ with can.Bus(
+ interface="virtual", channel="my_channel_0", receive_own_messages=True
+ ) as bus:
+ reader = can.AsyncBufferedReader()
+ logger = can.Logger("logfile.asc")
+
+ listeners: list[MessageRecipient] = [
+ print_message, # Callback function
+ reader, # AsyncBufferedReader() listener
+ logger, # Regular Listener object
+ ]
+ # Create Notifier with an explicit loop to use for scheduling of callbacks
+ with can.Notifier(bus, listeners, loop=asyncio.get_running_loop()):
+ # Start sending first message
+ bus.send(can.Message(arbitration_id=0))
+
+ print("Bouncing 10 messages...")
+ for _ in range(10):
+ # Wait for next message from AsyncBufferedReader
+ msg = await reader.get_message()
+ # Delay response
+ await asyncio.sleep(0.5)
+ msg.arbitration_id += 1
+ bus.send(msg)
+
+ # Wait for last message to arrive
+ await reader.get_message()
+ print("Done!")
+
+
+if __name__ == "__main__":
+ asyncio.run(main())
diff --git a/examples/crc.py b/examples/crc.py
new file mode 100755
index 000000000..fff3dce25
--- /dev/null
+++ b/examples/crc.py
@@ -0,0 +1,82 @@
+#!/usr/bin/env python
+
+"""
+This example exercises the periodic task's multiple message sending capabilities
+to send a message containing a counter and a checksum.
+
+Expects a vcan0 interface:
+
+ python3 -m examples.crc
+
+"""
+
+import logging
+import time
+
+import can
+
+logging.basicConfig(level=logging.INFO)
+
+
+def crc_send(bus):
+ """
+ Sends periodic messages every 1 s with no explicit timeout. Modifies messages
+ after 8 seconds, sends for 10 more seconds, then stops.
+ """
+ msg = can.Message(arbitration_id=0x12345678, data=[1, 2, 3, 4, 5, 6, 7, 0])
+ messages = build_crc_msgs(msg)
+
+ print(
+ "Starting to send a message with updating counter and checksum every 1 s for 8 s"
+ )
+ task = bus.send_periodic(messages, 1)
+ assert isinstance(task, can.CyclicSendTaskABC)
+ time.sleep(8)
+
+ msg = can.Message(arbitration_id=0x12345678, data=[8, 9, 10, 11, 12, 13, 14, 0])
+ messages = build_crc_msgs(msg)
+
+ print("Sending modified message data every 1 s for 10 s")
+ task.modify_data(messages)
+ time.sleep(10)
+ task.stop()
+ print("stopped cyclic send")
+
+
+def build_crc_msgs(msg):
+ """
+ Using the input message as base, create 16 messages with SAE J1939 SPN 3189 counters
+ and SPN 3188 checksums placed in the final byte.
+ """
+ messages = []
+
+ for counter in range(16):
+ checksum = compute_xbr_checksum(msg, counter)
+ msg.data[7] = counter + (checksum << 4)
+ messages.append(
+ can.Message(arbitration_id=msg.arbitration_id, data=msg.data[:])
+ )
+
+ return messages
+
+
+def compute_xbr_checksum(message, counter):
+ """
+ Computes an XBR checksum per SAE J1939 SPN 3188.
+ """
+ checksum = sum(message.data[:7])
+ checksum += sum(message.arbitration_id.to_bytes(length=4, byteorder="big"))
+ checksum += counter & 0x0F
+ xbr_checksum = ((checksum >> 4) + checksum) & 0x0F
+
+ return xbr_checksum
+
+
+if __name__ == "__main__":
+ for interface, channel in [("socketcan", "vcan0")]:
+ print(f"Carrying out crc test with {interface} interface")
+
+ with can.Bus(interface=interface, channel=channel, bitrate=500000) as BUS:
+ crc_send(BUS)
+
+ time.sleep(2)
diff --git a/examples/cyclic.py b/examples/cyclic.py
index 573465d78..bdd69eef2 100755
--- a/examples/cyclic.py
+++ b/examples/cyclic.py
@@ -114,7 +114,9 @@ def main():
arbitration_id=0x00, data=[0, 0, 0, 0, 0, 0], is_extended_id=False
)
- with can.Bus(interface="virtual") as bus:
+ # this uses the default configuration (for example from environment variables, or a
+ # config file) see https://python-can.readthedocs.io/en/stable/configuration.html
+ with can.Bus() as bus:
bus.send(reset_msg)
simple_periodic_send(bus)
diff --git a/examples/cyclic_checksum.py b/examples/cyclic_checksum.py
new file mode 100644
index 000000000..763fcd72b
--- /dev/null
+++ b/examples/cyclic_checksum.py
@@ -0,0 +1,63 @@
+#!/usr/bin/env python
+
+"""
+This example demonstrates how to send a periodic message containing
+an automatically updating counter and checksum.
+
+Expects a virtual interface:
+
+ python3 -m examples.cyclic_checksum
+"""
+
+import logging
+import time
+
+import can
+
+logging.basicConfig(level=logging.INFO)
+
+
+def cyclic_checksum_send(bus: can.BusABC) -> None:
+ """
+ Sends periodic messages every 1 s with no explicit timeout.
+ The message's counter and checksum is updated before each send.
+ Sleeps for 10 seconds then stops the task.
+ """
+ message = can.Message(arbitration_id=0x78, data=[0, 1, 2, 3, 4, 5, 6, 0])
+ print("Starting to send an auto-updating message every 100ms for 3 s")
+ task = bus.send_periodic(msgs=message, period=0.1, modifier_callback=update_message)
+ time.sleep(3)
+ task.stop()
+ print("stopped cyclic send")
+
+
+def update_message(message: can.Message) -> None:
+ counter = increment_counter(message)
+ checksum = compute_xbr_checksum(message, counter)
+ message.data[7] = (checksum << 4) + counter
+
+
+def increment_counter(message: can.Message) -> int:
+ counter = message.data[7] & 0x0F
+ counter += 1
+ counter %= 16
+
+ return counter
+
+
+def compute_xbr_checksum(message: can.Message, counter: int) -> int:
+ """
+ Computes an XBR checksum as per SAE J1939 SPN 3188.
+ """
+ checksum = sum(message.data[:7])
+ checksum += sum(message.arbitration_id.to_bytes(length=4, byteorder="big"))
+ checksum += counter & 0x0F
+ xbr_checksum = ((checksum >> 4) + checksum) & 0x0F
+
+ return xbr_checksum
+
+
+if __name__ == "__main__":
+ with can.Bus(channel=0, interface="virtual", receive_own_messages=True) as _bus:
+ with can.Notifier(bus=_bus, listeners=[print]):
+ cyclic_checksum_send(_bus)
diff --git a/examples/cyclic_multiple.py b/examples/cyclic_multiple.py
old mode 100644
new mode 100755
index 64f0862d7..43dc0cd17
--- a/examples/cyclic_multiple.py
+++ b/examples/cyclic_multiple.py
@@ -133,9 +133,7 @@ def cyclic_multiple_send_modify(bus):
for interface, channel in [("socketcan", "vcan0")]:
print(f"Carrying out cyclic multiple tests with {interface} interface")
- with can.Bus( # type: ignore
- interface=interface, channel=channel, bitrate=500000
- ) as BUS:
+ with can.Bus(interface=interface, channel=channel, bitrate=500000) as BUS:
cyclic_multiple_send(BUS)
cyclic_multiple_send_modify(BUS)
diff --git a/examples/print_notifier.py b/examples/print_notifier.py
new file mode 100755
index 000000000..e6e11dbec
--- /dev/null
+++ b/examples/print_notifier.py
@@ -0,0 +1,21 @@
+#!/usr/bin/env python
+
+import time
+
+import can
+
+
+def main():
+ with can.Bus(interface="virtual", receive_own_messages=True) as bus:
+ print_listener = can.Printer()
+ with can.Notifier(bus, listeners=[print_listener]):
+ # using Notifier as a context manager automatically calls `Notifier.stop()`
+ # at the end of the `with` block
+ bus.send(can.Message(arbitration_id=1, is_extended_id=True))
+ bus.send(can.Message(arbitration_id=2, is_extended_id=True))
+ bus.send(can.Message(arbitration_id=1, is_extended_id=False))
+ time.sleep(1.0)
+
+
+if __name__ == "__main__":
+ main()
diff --git a/examples/receive_all.py b/examples/receive_all.py
index 7ff532079..e9410e49f 100755
--- a/examples/receive_all.py
+++ b/examples/receive_all.py
@@ -1,7 +1,7 @@
#!/usr/bin/env python
"""
-Shows how the receive messages via polling.
+Shows how to receive messages via polling.
"""
import can
@@ -11,14 +11,14 @@
def receive_all():
"""Receives all messages and prints them to the console until Ctrl+C is pressed."""
- with can.interface.Bus(
- bustype="pcan", channel="PCAN_USBBUS1", bitrate=250000
- ) as bus:
- # bus = can.interface.Bus(bustype='ixxat', channel=0, bitrate=250000)
- # bus = can.interface.Bus(bustype='vector', app_name='CANalyzer', channel=0, bitrate=250000)
-
+ # this uses the default configuration (for example from environment variables, or a
+ # config file) see https://python-can.readthedocs.io/en/stable/configuration.html
+ with can.Bus() as bus:
# set to read-only, only supported on some interfaces
- bus.state = BusState.PASSIVE
+ try:
+ bus.state = BusState.PASSIVE
+ except NotImplementedError:
+ pass
try:
while True:
diff --git a/examples/virtual_can_demo.py b/examples/send_multiple.py
similarity index 75%
rename from examples/virtual_can_demo.py
rename to examples/send_multiple.py
index b3fdefc09..9123e1bc8 100755
--- a/examples/virtual_can_demo.py
+++ b/examples/send_multiple.py
@@ -4,19 +4,22 @@
This demo creates multiple processes of producers to spam a socketcan bus.
"""
-from time import sleep
from concurrent.futures import ProcessPoolExecutor
+from time import sleep
import can
-def producer(thread_id: int, message_count: int = 16):
+def producer(thread_id: int, message_count: int = 16) -> None:
"""Spam the bus with messages including the data id.
:param thread_id: the id of the thread/process
- :param message_count: the number of messages that shall be send
+ :param message_count: the number of messages that shall be sent
"""
- with can.Bus(bustype="socketcan", channel="vcan0") as bus: # type: ignore
+
+ # this uses the default configuration (for example from environment variables, or a
+ # config file) see https://python-can.readthedocs.io/en/stable/configuration.html
+ with can.Bus() as bus:
for i in range(message_count):
msg = can.Message(
arbitration_id=0x0CF02200 + thread_id,
diff --git a/examples/send_one.py b/examples/send_one.py
index 49a4f1ee1..41b3a3cd0 100755
--- a/examples/send_one.py
+++ b/examples/send_one.py
@@ -12,13 +12,12 @@ def send_one():
# this uses the default configuration (for example from the config file)
# see https://python-can.readthedocs.io/en/stable/configuration.html
- with can.interface.Bus() as bus:
-
+ with can.Bus() as bus:
# Using specific buses works similar:
- # bus = can.interface.Bus(bustype='socketcan', channel='vcan0', bitrate=250000)
- # bus = can.interface.Bus(bustype='pcan', channel='PCAN_USBBUS1', bitrate=250000)
- # bus = can.interface.Bus(bustype='ixxat', channel=0, bitrate=250000)
- # bus = can.interface.Bus(bustype='vector', app_name='CANalyzer', channel=0, bitrate=250000)
+ # bus = can.Bus(interface='socketcan', channel='vcan0', bitrate=250000)
+ # bus = can.Bus(interface='pcan', channel='PCAN_USBBUS1', bitrate=250000)
+ # bus = can.Bus(interface='ixxat', channel=0, bitrate=250000)
+ # bus = can.Bus(interface='vector', app_name='CANalyzer', channel=0, bitrate=250000)
# ...
msg = can.Message(
diff --git a/examples/serial_com.py b/examples/serial_com.py
index 60aeec4ce..9f203b2e0 100755
--- a/examples/serial_com.py
+++ b/examples/serial_com.py
@@ -18,8 +18,8 @@
com0com: http://com0com.sourceforge.net/
"""
-import time
import threading
+import time
import can
@@ -42,15 +42,14 @@ def receive(bus, stop_event):
while not stop_event.is_set():
rx_msg = bus.recv(1)
if rx_msg is not None:
- print("rx: {}".format(rx_msg))
+ print(f"rx: {rx_msg}")
print("Stopped receiving messages")
def main():
- """Controles the sender and receiver."""
- with can.interface.Bus(bustype="serial", channel="/dev/ttyS10") as server:
- with can.interface.Bus(bustype="serial", channel="/dev/ttyS11") as client:
-
+ """Controls the sender and receiver."""
+ with can.Bus(interface="serial", channel="/dev/ttyS10") as server:
+ with can.Bus(interface="serial", channel="/dev/ttyS11") as client:
tx_msg = can.Message(
arbitration_id=0x01,
data=[0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88],
diff --git a/examples/simple_log_converter.py b/examples/simple_log_converter.py
index f01546375..20e8fba75 100755
--- a/examples/simple_log_converter.py
+++ b/examples/simple_log_converter.py
@@ -17,7 +17,6 @@ def main():
with can.LogReader(sys.argv[1]) as reader:
with can.Logger(sys.argv[2]) as writer:
-
for msg in reader:
writer.on_message_received(msg)
diff --git a/examples/vcan_filtered.py b/examples/vcan_filtered.py
index fa6c71547..22bca706c 100755
--- a/examples/vcan_filtered.py
+++ b/examples/vcan_filtered.py
@@ -11,21 +11,18 @@
def main():
"""Send some messages to itself and apply filtering."""
- with can.Bus(bustype="virtual", receive_own_messages=True) as bus:
-
+ with can.Bus(interface="virtual", receive_own_messages=True) as bus:
can_filters = [{"can_id": 1, "can_mask": 0xF, "extended": True}]
bus.set_filters(can_filters)
- # print all incoming messages, wich includes the ones sent,
+ # print all incoming messages, which includes the ones sent,
# since we set receive_own_messages to True
# assign to some variable so it does not garbage collected
- notifier = can.Notifier(bus, [can.Printer()]) # pylint: disable=unused-variable
-
- bus.send(can.Message(arbitration_id=1, is_extended_id=True))
- bus.send(can.Message(arbitration_id=2, is_extended_id=True))
- bus.send(can.Message(arbitration_id=1, is_extended_id=False))
-
- time.sleep(1.0)
+ with can.Notifier(bus, [can.Printer()]): # pylint: disable=unused-variable
+ bus.send(can.Message(arbitration_id=1, is_extended_id=True))
+ bus.send(can.Message(arbitration_id=2, is_extended_id=True))
+ bus.send(can.Message(arbitration_id=1, is_extended_id=False))
+ time.sleep(1.0)
if __name__ == "__main__":
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 000000000..94bf60823
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,256 @@
+[build-system]
+requires = ["setuptools >= 77.0", "setuptools_scm>=8"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "python-can"
+dynamic = ["readme", "version"]
+description = "Controller Area Network interface module for Python"
+authors = [{ name = "python-can contributors" }]
+dependencies = [
+ "wrapt >= 1.10, < 3",
+ "packaging >= 23.1",
+ "typing_extensions>=3.10.0.0",
+]
+requires-python = ">=3.10"
+license = "LGPL-3.0-only"
+classifiers = [
+ "Development Status :: 5 - Production/Stable",
+ "Environment :: Console",
+ "Intended Audience :: Developers",
+ "Intended Audience :: Education",
+ "Intended Audience :: Information Technology",
+ "Intended Audience :: Manufacturing",
+ "Intended Audience :: Telecommunications Industry",
+ "Natural Language :: English",
+ "Operating System :: MacOS",
+ "Operating System :: Microsoft :: Windows",
+ "Operating System :: POSIX :: Linux",
+ "Programming Language :: Python",
+ "Programming Language :: Python :: 3.10",
+ "Programming Language :: Python :: 3.11",
+ "Programming Language :: Python :: 3.12",
+ "Programming Language :: Python :: 3.13",
+ "Programming Language :: Python :: 3.14",
+ "Programming Language :: Python :: Implementation :: CPython",
+ "Programming Language :: Python :: Implementation :: PyPy",
+ "Topic :: Software Development :: Embedded Systems",
+ "Topic :: Software Development :: Embedded Systems :: Controller Area Network (CAN)",
+ "Topic :: System :: Hardware :: Hardware Drivers",
+ "Topic :: System :: Logging",
+ "Topic :: System :: Monitoring",
+ "Topic :: System :: Networking",
+ "Topic :: Utilities",
+]
+
+[project.scripts]
+can_logconvert = "can.logconvert:main"
+can_logger = "can.logger:main"
+can_player = "can.player:main"
+can_viewer = "can.viewer:main"
+can_bridge = "can.bridge:main"
+
+[project.urls]
+homepage = "https://github.com/hardbyte/python-can"
+documentation = "https://python-can.readthedocs.io"
+repository = "https://github.com/hardbyte/python-can"
+changelog = "https://github.com/hardbyte/python-can/blob/develop/CHANGELOG.md"
+
+[project.optional-dependencies]
+pywin32 = ["pywin32>=305; platform_system == 'Windows' and platform_python_implementation == 'CPython'"]
+seeedstudio = ["pyserial>=3.0"]
+serial = ["pyserial~=3.0"]
+neovi = ["filelock", "python-ics>=2.12"]
+canalystii = ["canalystii>=0.1.0"]
+cantact = ["cantact>=0.0.7"]
+cvector = ["python-can-cvector"]
+gs-usb = ["gs-usb>=0.2.1"]
+nixnet = ["nixnet>=0.3.2"]
+pcan = ["uptime~=3.0.1"]
+remote = ["python-can-remote"]
+sontheim = ["python-can-sontheim>=0.1.2"]
+canine = ["python-can-canine>=0.2.2"]
+zlgcan = ["zlgcan"]
+candle = ["python-can-candle>=1.2.2"]
+rp1210 = ["rp1210>=1.0.1"]
+damiao = ["python-can-damiao"]
+viewer = [
+ "windows-curses; platform_system == 'Windows' and platform_python_implementation=='CPython'"
+]
+mf4 = ["asammdf>=6.0.0"]
+multicast = ["msgpack~=1.1.0"]
+
+[dependency-groups]
+docs = [
+ "sphinx>=5.2.3",
+ "sphinxcontrib-programoutput",
+ "sphinx-inline-tabs",
+ "sphinx-copybutton",
+ "furo",
+]
+lint = [
+ "pylint==4.0.*",
+ "ruff==0.14.*",
+ "black==25.11.*",
+ "mypy==1.19.*",
+]
+test = [
+ "pytest==9.0.*",
+ "pytest-timeout==2.4.*",
+ "pytest-modern==0.7.*;platform_system!='Windows'",
+ "coveralls==4.0.*",
+ "pytest-cov==7.0.*",
+ "coverage==7.12.*",
+ "hypothesis==6.*",
+ "parameterized==0.9.*",
+]
+dev = [
+ {include-group = "docs"},
+ {include-group = "lint"},
+ {include-group = "test"},
+]
+
+[tool.setuptools.dynamic]
+readme = { file = "README.rst" }
+[tool.setuptools.package-data]
+"*" = ["README.rst", "CONTRIBUTORS.txt", "LICENSE.txt", "CHANGELOG.md"]
+doc = ["*.*"]
+examples = ["*.py"]
+can = ["py.typed"]
+
+[tool.setuptools.packages.find]
+include = ["can*"]
+
+[tool.setuptools_scm]
+# can be empty if no extra settings are needed, presence enables setuptools_scm
+
+[tool.mypy]
+warn_return_any = true
+warn_unused_configs = true
+ignore_missing_imports = true
+no_implicit_optional = true
+disallow_incomplete_defs = true
+warn_redundant_casts = true
+warn_unused_ignores = true
+exclude = [
+ "^build",
+ "^doc/conf.py$",
+ "^test",
+ "^can/interfaces/etas",
+ "^can/interfaces/gs_usb",
+ "^can/interfaces/ics_neovi",
+ "^can/interfaces/iscan",
+ "^can/interfaces/ixxat",
+ "^can/interfaces/kvaser",
+ "^can/interfaces/nican",
+ "^can/interfaces/neousys",
+ "^can/interfaces/pcan",
+ "^can/interfaces/socketcan",
+ "^can/interfaces/systec",
+ "^can/interfaces/usb2can",
+]
+
+[tool.ruff]
+line-length = 100
+
+[tool.ruff.lint]
+extend-select = [
+ "A", # flake8-builtins
+ "B", # flake8-bugbear
+ "C4", # flake8-comprehensions
+ "F", # pyflakes
+ "E", # pycodestyle errors
+ "I", # isort
+ "N", # pep8-naming
+ "PGH", # pygrep-hooks
+ "PL", # pylint
+ "RUF", # ruff-specific rules
+ "T20", # flake8-print
+ "TCH", # flake8-type-checking
+ "UP", # pyupgrade
+ "W", # pycodestyle warnings
+ "YTT", # flake8-2020
+]
+ignore = [
+ "B026", # star-arg-unpacking-after-keyword-arg
+ "PLR", # pylint refactor
+]
+
+[tool.ruff.lint.per-file-ignores]
+"can/interfaces/*" = [
+ "E501", # Line too long
+ "F403", # undefined-local-with-import-star
+ "F405", # undefined-local-with-import-star-usage
+ "N", # pep8-naming
+ "PGH003", # blanket-type-ignore
+ "RUF012", # mutable-class-default
+]
+"can/cli.py" = ["T20"] # flake8-print
+"can/logger.py" = ["T20"] # flake8-print
+"can/player.py" = ["T20"] # flake8-print
+"can/bridge.py" = ["T20"] # flake8-print
+"can/viewer.py" = ["T20"] # flake8-print
+"examples/*" = ["T20"] # flake8-print
+
+[tool.ruff.lint.isort]
+known-first-party = ["can"]
+
+[tool.pylint]
+extension-pkg-allow-list = ["curses"]
+disable = [
+ "cyclic-import",
+ "duplicate-code",
+ "fixme",
+ "invalid-name",
+ "missing-class-docstring",
+ "missing-function-docstring",
+ "missing-module-docstring",
+ "no-else-raise",
+ "no-else-return",
+ "too-few-public-methods",
+ "too-many-arguments",
+ "too-many-branches",
+ "too-many-instance-attributes",
+ "too-many-locals",
+ "too-many-positional-arguments",
+ "too-many-public-methods",
+ "too-many-statements",
+]
+
+[tool.towncrier]
+directory = "doc/changelog.d"
+filename = "CHANGELOG.md"
+start_string = "\n"
+underlines = ["", "", ""]
+title_format = "## Version [{version}](https://github.com/hardbyte/python-can/tree/{version}) - {project_date}"
+issue_format = "[#{issue}](https://github.com/hardbyte/python-can/issues/{issue})"
+
+[[tool.towncrier.type]]
+directory = "security"
+name = "Security"
+showcontent = true
+
+[[tool.towncrier.type]]
+directory = "removed"
+name = "Removed"
+showcontent = true
+
+[[tool.towncrier.type]]
+directory = "deprecated"
+name = "Deprecated"
+showcontent = true
+
+[[tool.towncrier.type]]
+directory = "added"
+name = "Added"
+showcontent = true
+
+[[tool.towncrier.type]]
+directory = "changed"
+name = "Changed"
+showcontent = true
+
+[[tool.towncrier.type]]
+directory = "fixed"
+name = "Fixed"
+showcontent = true
diff --git a/requirements-lint.txt b/requirements-lint.txt
deleted file mode 100644
index d0b374c20..000000000
--- a/requirements-lint.txt
+++ /dev/null
@@ -1,4 +0,0 @@
-pylint==2.3.1
-black==19.3b0
-mypy==0.740
-mypy-extensions==0.4.1
diff --git a/scripts/can_logger.py b/scripts/can_logger.py
deleted file mode 100644
index 4202448e6..000000000
--- a/scripts/can_logger.py
+++ /dev/null
@@ -1,11 +0,0 @@
-#!/usr/bin/env python
-
-"""
-See :mod:`can.logger`.
-"""
-
-from can.logger import main
-
-
-if __name__ == "__main__":
- main()
diff --git a/scripts/can_player.py b/scripts/can_player.py
deleted file mode 100644
index 1fe44175d..000000000
--- a/scripts/can_player.py
+++ /dev/null
@@ -1,11 +0,0 @@
-#!/usr/bin/env python
-
-"""
-See :mod:`can.player`.
-"""
-
-from can.player import main
-
-
-if __name__ == "__main__":
- main()
diff --git a/scripts/can_viewer.py b/scripts/can_viewer.py
deleted file mode 100644
index eef990b0e..000000000
--- a/scripts/can_viewer.py
+++ /dev/null
@@ -1,11 +0,0 @@
-#!/usr/bin/env python
-
-"""
-See :mod:`can.viewer`.
-"""
-
-from can.viewer import main
-
-
-if __name__ == "__main__":
- main()
diff --git a/setup.cfg b/setup.cfg
deleted file mode 100644
index a0e8d5b6a..000000000
--- a/setup.cfg
+++ /dev/null
@@ -1,25 +0,0 @@
-[aliases]
-test=pytest
-
-[metadata]
-license_file = LICENSE.txt
-
-[tool:pytest]
-addopts = -v --timeout=300 --cov=can --cov-config=setup.cfg
-
-[coverage:run]
-# we could also use branch coverage
-branch = False
-# already specified by call to pytest using --cov=can
-#source = can
-
-[coverage:report]
-# two digits after decimal point
-precision = 3
-show_missing = True
-exclude_lines =
- # Have to re-enable the standard pragma, see https://coverage.readthedocs.io/en/coverage-4.5.1a/config.html#syntax
- pragma: no cover
-
- # Don't complain if non-runnable code isn't run:
- if __name__ == .__main__.:
diff --git a/setup.py b/setup.py
deleted file mode 100644
index 8327b1432..000000000
--- a/setup.py
+++ /dev/null
@@ -1,116 +0,0 @@
-#!/usr/bin/env python
-
-"""
-python-can requires the setuptools package to be installed.
-"""
-
-# pylint: disable=invalid-name
-
-from __future__ import absolute_import
-
-from os import listdir
-from os.path import isfile, join
-import re
-import logging
-import sys
-from setuptools import setup, find_packages
-
-logging.basicConfig(level=logging.WARNING)
-
-with open("can/__init__.py", "r") as fd:
- version = re.search(
- r'^__version__\s*=\s*[\'"]([^\'"]*)[\'"]', fd.read(), re.MULTILINE
- ).group(1)
-
-with open("README.rst", "r") as f:
- long_description = f.read()
-
-# Dependencies
-extras_require = {
- "seeedstudio": ["pyserial>=3.0"],
- "serial": ["pyserial~=3.0"],
- "neovi": ["python-ics>=2.12", "filelock"],
-}
-
-tests_require = [
- "pytest~=5.3",
- "pytest-timeout~=1.3",
- "pytest-cov~=2.8",
- # coveragepy==5.0 fails with `Safety level may not be changed inside a transaction`
- # on python 3.6 on MACOS
- "coverage<5",
- "codecov~=2.0",
- "hypothesis~=4.56",
-] + extras_require["serial"]
-
-extras_require["test"] = tests_require
-
-# Check for 'pytest-runner' only if setup.py was invoked with 'test'.
-# This optimizes setup.py for cases when pytest-runner is not needed,
-# using the approach that is suggested upstream.
-#
-# See https://pypi.org/project/pytest-runner/#conditional-requirement
-needs_pytest = {"pytest", "test", "ptr"}.intersection(sys.argv)
-pytest_runner = ["pytest-runner"] if needs_pytest else []
-
-setup(
- # Description
- name="python-can",
- url="https://github.com/hardbyte/python-can",
- description="Controller Area Network interface module for Python",
- long_description=long_description,
- classifiers=[
- # a list of all available ones: https://pypi.org/classifiers/
- "Programming Language :: Python",
- "Programming Language :: Python :: 3.6",
- "Programming Language :: Python :: 3.7",
- "Programming Language :: Python :: Implementation :: CPython",
- "Programming Language :: Python :: Implementation :: PyPy",
- "License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)",
- "Operating System :: MacOS",
- "Operating System :: POSIX :: Linux",
- "Operating System :: Microsoft :: Windows",
- "Development Status :: 5 - Production/Stable",
- "Environment :: Console",
- "Intended Audience :: Developers",
- "Intended Audience :: Education",
- "Intended Audience :: Information Technology",
- "Intended Audience :: Manufacturing",
- "Intended Audience :: Telecommunications Industry",
- "Natural Language :: English",
- "Topic :: System :: Logging",
- "Topic :: System :: Monitoring",
- "Topic :: System :: Networking",
- "Topic :: System :: Hardware :: Hardware Drivers",
- "Topic :: Utilities",
- ],
- # Code
- version=version,
- packages=find_packages(exclude=["test*", "doc", "scripts", "examples"]),
- scripts=list(filter(isfile, (join("scripts/", f) for f in listdir("scripts/")))),
- # Author
- author="Brian Thorne",
- author_email="brian@thorne.link",
- # License
- license="LGPL v3",
- # Package data
- package_data={
- "": ["README.rst", "CONTRIBUTORS.txt", "LICENSE.txt", "CHANGELOG.txt"],
- "doc": ["*.*"],
- "examples": ["*.py"],
- },
- # Installation
- # see https://www.python.org/dev/peps/pep-0345/#version-specifiers
- python_requires=">=3.6",
- install_requires=[
- "wrapt~=1.10",
- "aenum",
- 'windows-curses;platform_system=="Windows"',
- "filelock",
- "mypy_extensions >= 0.4.0, < 0.5.0",
- 'pywin32;platform_system=="Windows"',
- ],
- setup_requires=pytest_runner,
- extras_require=extras_require,
- tests_require=tests_require,
-)
diff --git a/test/__init__.py b/test/__init__.py
index 394a0a067..4265cc3e6 100644
--- a/test/__init__.py
+++ b/test/__init__.py
@@ -1,2 +1 @@
#!/usr/bin/env python
-# coding: utf-8
diff --git a/test/back2back_test.py b/test/back2back_test.py
index b707988ec..ce7c39e2a 100644
--- a/test/back2back_test.py
+++ b/test/back2back_test.py
@@ -1,31 +1,39 @@
#!/usr/bin/env python
-# coding: utf-8
"""
-This module tests two virtual buses attached to each other.
+This module tests two buses attached to each other.
"""
-import sys
+import random
import unittest
-from time import sleep
from multiprocessing.dummy import Pool as ThreadPool
+from time import sleep, time
import pytest
-import random
import can
+from can import CanInterfaceNotImplementedError
+from can.interfaces.udp_multicast import UdpMulticastBus
+from can.interfaces.udp_multicast.utils import is_msgpack_installed
-from .config import *
+from .config import (
+ IS_CI,
+ IS_OSX,
+ IS_PYPY,
+ TEST_CAN_FD,
+ TEST_INTERFACE_SOCKETCAN,
+)
class Back2BackTestCase(unittest.TestCase):
- """
- Use two interfaces connected to the same CAN bus and test them against
- each other.
+ """Use two interfaces connected to the same CAN bus and test them against each other.
+
+ This very class declaration runs the test on the *virtual* interface but subclasses can be created for
+ other buses.
"""
BITRATE = 500000
- TIMEOUT = 0.1
+ TIMEOUT = 1.0 if IS_PYPY else 0.1
INTERFACE_1 = "virtual"
CHANNEL_1 = "virtual_channel_0"
@@ -35,14 +43,14 @@ class Back2BackTestCase(unittest.TestCase):
def setUp(self):
self.bus1 = can.Bus(
channel=self.CHANNEL_1,
- bustype=self.INTERFACE_1,
+ interface=self.INTERFACE_1,
bitrate=self.BITRATE,
fd=TEST_CAN_FD,
single_handle=True,
)
self.bus2 = can.Bus(
channel=self.CHANNEL_2,
- bustype=self.INTERFACE_2,
+ interface=self.INTERFACE_2,
bitrate=self.BITRATE,
fd=TEST_CAN_FD,
single_handle=True,
@@ -52,7 +60,9 @@ def tearDown(self):
self.bus1.shutdown()
self.bus2.shutdown()
- def _check_received_message(self, recv_msg, sent_msg):
+ def _check_received_message(
+ self, recv_msg: can.Message, sent_msg: can.Message
+ ) -> None:
self.assertIsNotNone(
recv_msg, "No message was received on %s" % self.INTERFACE_2
)
@@ -66,7 +76,7 @@ def _check_received_message(self, recv_msg, sent_msg):
if not sent_msg.is_remote_frame:
self.assertSequenceEqual(recv_msg.data, sent_msg.data)
- def _send_and_receive(self, msg):
+ def _send_and_receive(self, msg: can.Message) -> None:
# Send with bus 1, receive with bus 2
self.bus1.send(msg)
recv_msg = self.bus2.recv(self.TIMEOUT)
@@ -78,12 +88,19 @@ def _send_and_receive(self, msg):
# Add 1 to arbitration ID to make it a different message
msg.arbitration_id += 1
self.bus2.send(msg)
+ # Some buses may receive their own messages. Remove it from the queue
+ self.bus2.recv(0)
recv_msg = self.bus1.recv(self.TIMEOUT)
self._check_received_message(recv_msg, msg)
def test_no_message(self):
+ """Tests that there is no message being received if none was sent."""
self.assertIsNone(self.bus1.recv(0.1))
+ def test_multiple_shutdown(self):
+ """Tests whether shutting down ``bus1`` twice does not throw any errors."""
+ self.bus1.shutdown()
+
@unittest.skipIf(
IS_CI,
"the timing sensitive behaviour cannot be reproduced reliably on a CI server",
@@ -98,7 +115,7 @@ def test_timestamp(self):
self.assertTrue(
1.75 <= delta_time <= 2.25,
"Time difference should have been 2s +/- 250ms."
- "But measured {}".format(delta_time),
+ f"But measured {delta_time}",
)
def test_standard_message(self):
@@ -125,14 +142,76 @@ def test_dlc_less_than_eight(self):
msg = can.Message(is_extended_id=False, arbitration_id=0x300, data=[4, 5, 6])
self._send_and_receive(msg)
- @unittest.skipUnless(TEST_CAN_FD, "Don't test CAN-FD")
+ @unittest.skip(
+ "TODO: how shall this be treated if sending messages locally? should be done uniformly"
+ )
+ def test_message_is_rx(self):
+ """Verify that received messages have is_rx set to `False` while messages
+ received on the other virtual interfaces have is_rx set to `True`.
+ """
+ msg = can.Message(
+ is_extended_id=False, arbitration_id=0x300, data=[2, 1, 3], is_rx=False
+ )
+ self.bus1.send(msg)
+ # Some buses may receive their own messages. Remove it from the queue
+ self.bus1.recv(0)
+ self_recv_msg = self.bus2.recv(self.TIMEOUT)
+ self.assertIsNotNone(self_recv_msg)
+ self.assertTrue(self_recv_msg.is_rx)
+
+ @unittest.skip(
+ "TODO: how shall this be treated if sending messages locally? should be done uniformly"
+ )
+ def test_message_is_rx_receive_own_messages(self):
+ """The same as `test_message_direction` but testing with `receive_own_messages=True`."""
+ with can.Bus(
+ channel=self.CHANNEL_2,
+ interface=self.INTERFACE_2,
+ bitrate=self.BITRATE,
+ fd=TEST_CAN_FD,
+ single_handle=True,
+ receive_own_messages=True,
+ ) as bus3:
+ msg = can.Message(
+ is_extended_id=False, arbitration_id=0x300, data=[2, 1, 3], is_rx=False
+ )
+ bus3.send(msg)
+ self_recv_msg_bus3 = bus3.recv(self.TIMEOUT)
+ self.assertTrue(self_recv_msg_bus3.is_rx)
+
+ def test_unique_message_instances(self):
+ """Verify that we have a different instances of message for each bus even with
+ `receive_own_messages=True`.
+ """
+ with can.Bus(
+ channel=self.CHANNEL_2,
+ interface=self.INTERFACE_2,
+ bitrate=self.BITRATE,
+ fd=TEST_CAN_FD,
+ single_handle=True,
+ receive_own_messages=True,
+ ) as bus3:
+ msg = can.Message(
+ is_extended_id=False, arbitration_id=0x300, data=[2, 1, 3]
+ )
+ bus3.send(msg)
+ recv_msg_bus1 = self.bus1.recv(self.TIMEOUT)
+ recv_msg_bus2 = self.bus2.recv(self.TIMEOUT)
+ self_recv_msg_bus3 = bus3.recv(self.TIMEOUT)
+
+ self._check_received_message(recv_msg_bus1, recv_msg_bus2)
+ self._check_received_message(recv_msg_bus2, self_recv_msg_bus3)
+
+ recv_msg_bus1.data[0] = 4
+ self.assertNotEqual(recv_msg_bus1.data, recv_msg_bus2.data)
+ self.assertEqual(recv_msg_bus2.data, self_recv_msg_bus3.data)
+
def test_fd_message(self):
msg = can.Message(
is_fd=True, is_extended_id=True, arbitration_id=0x56789, data=[0xFF] * 64
)
self._send_and_receive(msg)
- @unittest.skipUnless(TEST_CAN_FD, "Don't test CAN-FD")
def test_fd_message_with_brs(self):
msg = can.Message(
is_fd=True,
@@ -143,21 +222,148 @@ def test_fd_message_with_brs(self):
)
self._send_and_receive(msg)
+ def test_fileno(self):
+ """Test is the values returned by fileno() are valid."""
+ try:
+ fileno = self.bus1.fileno()
+ except NotImplementedError:
+ pass # allow it to be left non-implemented
+ else:
+ self.assertIsNotNone(fileno)
+ self.assertTrue(fileno == -1 or fileno > 0)
+
+ def test_timestamp_is_absolute(self):
+ """Tests that the timestamp that is returned is an absolute one."""
+ self.bus2.send(can.Message())
+ # Some buses may receive their own messages. Remove it from the queue
+ self.bus2.recv(0)
+ message = self.bus1.recv(self.TIMEOUT)
+ # The allowed delta is still quite large to make this work on the CI server
+ self.assertAlmostEqual(message.timestamp, time(), delta=self.TIMEOUT)
+
+ def test_sub_second_timestamp_resolution(self):
+ """Tests that the timestamp that is returned has sufficient resolution.
+
+ The property that the timestamp has resolution below seconds is
+ checked on two messages to reduce the probability of both having
+ a timestamp of exactly a full second by accident to a negligible
+ level.
+
+ This is a regression test that was added for #1021.
+ """
+ self.bus2.send(can.Message())
+ sleep(0.01)
+ self.bus2.send(can.Message())
+
+ recv_msg_1 = self.bus1.recv(self.TIMEOUT)
+ recv_msg_2 = self.bus1.recv(self.TIMEOUT)
+
+ sub_second_fraction_1 = recv_msg_1.timestamp % 1
+ sub_second_fraction_2 = recv_msg_2.timestamp % 1
+ self.assertGreater(sub_second_fraction_1 + sub_second_fraction_2, 0)
+
+ # Some buses may receive their own messages. Remove it from the queue
+ self.bus2.recv(0)
+ self.bus2.recv(0)
+
+ def test_send_periodic_duration(self):
+ """
+ Verify that send_periodic only transmits for the specified duration.
+
+ Regression test for #1713.
+ """
+ for duration, period in [(0.01, 0.003), (0.1, 0.011), (1, 0.4)]:
+ messages = []
+
+ self.bus2.send_periodic(can.Message(), period, duration)
+ while (msg := self.bus1.recv(period + self.TIMEOUT)) is not None:
+ messages.append(msg)
+
+ delta_t = messages[-1].timestamp - messages[0].timestamp
+ assert delta_t < duration + 0.05
+
@unittest.skipUnless(TEST_INTERFACE_SOCKETCAN, "skip testing of socketcan")
class BasicTestSocketCan(Back2BackTestCase):
-
INTERFACE_1 = "socketcan"
CHANNEL_1 = "vcan0"
INTERFACE_2 = "socketcan"
CHANNEL_2 = "vcan0"
+# this doesn't even work on Travis CI for macOS; for example, see
+# https://travis-ci.org/github/hardbyte/python-can/jobs/745389871
+@unittest.skipIf(
+ IS_CI and IS_OSX,
+ "not supported for macOS CI",
+)
+@unittest.skipUnless(
+ is_msgpack_installed(raise_exception=False),
+ "msgpack not installed",
+)
+class BasicTestUdpMulticastBusIPv4(Back2BackTestCase):
+ INTERFACE_1 = "udp_multicast"
+ CHANNEL_1 = UdpMulticastBus.DEFAULT_GROUP_IPv4
+ INTERFACE_2 = "udp_multicast"
+ CHANNEL_2 = UdpMulticastBus.DEFAULT_GROUP_IPv4
+
+ def test_unique_message_instances(self):
+ with self.assertRaises(CanInterfaceNotImplementedError):
+ super().test_unique_message_instances()
+
+
+# this doesn't even work for loopback multicast addresses on Travis CI; for example, see
+# https://travis-ci.org/github/hardbyte/python-can/builds/745065503
+@unittest.skipIf(
+ IS_CI and IS_OSX,
+ "not supported for macOS CI",
+)
+@unittest.skipUnless(
+ is_msgpack_installed(raise_exception=False),
+ "msgpack not installed",
+)
+class BasicTestUdpMulticastBusIPv6(Back2BackTestCase):
+ HOST_LOCAL_MCAST_GROUP_IPv6 = "ff11:7079:7468:6f6e:6465:6d6f:6d63:6173"
+
+ INTERFACE_1 = "udp_multicast"
+ CHANNEL_1 = HOST_LOCAL_MCAST_GROUP_IPv6
+ INTERFACE_2 = "udp_multicast"
+ CHANNEL_2 = HOST_LOCAL_MCAST_GROUP_IPv6
+
+ def test_unique_message_instances(self):
+ with self.assertRaises(CanInterfaceNotImplementedError):
+ super().test_unique_message_instances()
+
+
+TEST_INTERFACE_ETAS = False
+try:
+ bus_class = can.interface._get_class_for_interface("etas")
+ TEST_INTERFACE_ETAS = True
+except CanInterfaceNotImplementedError:
+ pass
+
+
+@unittest.skipUnless(TEST_INTERFACE_ETAS, "skip testing of etas interface")
+class BasicTestEtas(Back2BackTestCase):
+ if TEST_INTERFACE_ETAS:
+ configs = can.interface.detect_available_configs(interfaces="etas")
+
+ INTERFACE_1 = "etas"
+ CHANNEL_1 = configs[0]["channel"]
+ INTERFACE_2 = "etas"
+ CHANNEL_2 = configs[2]["channel"]
+
+ def test_unique_message_instances(self):
+ self.skipTest(
+ "creating a second instance of a channel with differing self-reception settings is not supported"
+ )
+
+
@unittest.skipUnless(TEST_INTERFACE_SOCKETCAN, "skip testing of socketcan")
class SocketCanBroadcastChannel(unittest.TestCase):
def setUp(self):
- self.broadcast_bus = can.Bus(channel="", bustype="socketcan")
- self.regular_bus = can.Bus(channel="vcan0", bustype="socketcan")
+ self.broadcast_bus = can.Bus(channel="", interface="socketcan")
+ self.regular_bus = can.Bus(channel="vcan0", interface="socketcan")
def tearDown(self):
self.broadcast_bus.shutdown()
@@ -179,20 +385,20 @@ class TestThreadSafeBus(Back2BackTestCase):
def setUp(self):
self.bus1 = can.ThreadSafeBus(
channel=self.CHANNEL_1,
- bustype=self.INTERFACE_1,
+ interface=self.INTERFACE_1,
bitrate=self.BITRATE,
fd=TEST_CAN_FD,
single_handle=True,
)
self.bus2 = can.ThreadSafeBus(
channel=self.CHANNEL_2,
- bustype=self.INTERFACE_2,
+ interface=self.INTERFACE_2,
bitrate=self.BITRATE,
fd=TEST_CAN_FD,
single_handle=True,
)
- @pytest.mark.timeout(5.0)
+ @pytest.mark.timeout(180.0 if IS_PYPY else 5.0)
def test_concurrent_writes(self):
sender_pool = ThreadPool(100)
receiver_pool = ThreadPool(100)
@@ -210,7 +416,7 @@ def sender(msg):
self.bus1.send(msg)
def receiver(_):
- return self.bus2.recv(timeout=2.0)
+ return self.bus2.recv()
sender_pool.map_async(sender, workload)
for msg in receiver_pool.map(receiver, len(workload) * [None]):
@@ -223,7 +429,7 @@ def receiver(_):
receiver_pool.close()
receiver_pool.join()
- @pytest.mark.timeout(5.0)
+ @pytest.mark.timeout(180.0 if IS_PYPY else 5.0)
def test_filtered_bus(self):
sender_pool = ThreadPool(100)
receiver_pool = ThreadPool(100)
@@ -251,7 +457,7 @@ def sender(msg):
self.bus1.send(msg)
def receiver(_):
- return self.bus2.recv(timeout=2.0)
+ return self.bus2.recv()
sender_pool.map_async(sender, workload)
received_msgs = receiver_pool.map(receiver, 500 * [None])
diff --git a/test/config.py b/test/config.py
index 3a9072712..d308a8cc8 100644
--- a/test/config.py
+++ b/test/config.py
@@ -1,35 +1,35 @@
#!/usr/bin/env python
-# coding: utf-8
"""
This module contains various configuration for the tests.
Some tests are skipped when run on a CI server because they are not
-reproducible, see #243 (https://github.com/hardbyte/python-can/issues/243).
+reproducible, see for example #243 and #940.
"""
import platform
from os import environ as environment
-def env(name): # type: bool
+def env(name: str) -> bool:
return environment.get(name, "").lower() in ("yes", "true", "t", "1")
-# ############################## Continuos integration
+# ############################## Continuous integration
# see here for the environment variables that are set on the CI servers:
# - https://docs.travis-ci.com/user/environment-variables/
-# - https://www.appveyor.com/docs/environment-variables/
+# - https://docs.github.com/en/actions/reference/environment-variables#default-environment-variables
IS_TRAVIS = env("TRAVIS")
-IS_APPVEYOR = env("APPVEYOR")
+IS_GITHUB_ACTIONS = env("GITHUB_ACTIONS")
-IS_CI = IS_TRAVIS or IS_APPVEYOR or env("CI") or env("CONTINUOUS_INTEGRATION")
+IS_CI = IS_TRAVIS or IS_GITHUB_ACTIONS or env("CI") or env("CONTINUOUS_INTEGRATION")
-if IS_APPVEYOR and IS_TRAVIS:
- raise EnvironmentError(
- "IS_APPVEYOR and IS_TRAVIS cannot be both True at the same time"
+if IS_TRAVIS and IS_GITHUB_ACTIONS:
+ raise OSError(
+ f"only one of IS_TRAVIS ({IS_TRAVIS}) and IS_GITHUB_ACTIONS ({IS_GITHUB_ACTIONS}) may be True at the "
+ "same time"
)
@@ -40,17 +40,20 @@ def env(name): # type: bool
IS_LINUX = "linux" in _sys
IS_OSX = "darwin" in _sys
IS_UNIX = IS_LINUX or IS_OSX
+del _sys
if (IS_WINDOWS and IS_LINUX) or (IS_LINUX and IS_OSX) or (IS_WINDOWS and IS_OSX):
- raise EnvironmentError(
- "only one of IS_WINDOWS ({}), IS_LINUX ({}) and IS_OSX ({}) ".format(
- IS_WINDOWS, IS_LINUX, IS_OSX
- )
- + "can be True at the same time "
- + '(platform.system() == "{}")'.format(platform.system())
+ raise OSError(
+ f"only one of IS_WINDOWS ({IS_WINDOWS}), IS_LINUX ({IS_LINUX}) and IS_OSX ({IS_OSX}) "
+ f'can be True at the same time (platform.system() == "{platform.system()}")'
)
+# ############################## Implementations
+
+IS_PYPY = platform.python_implementation() == "PyPy"
+
+
# ############################## What tests to run
TEST_CAN_FD = True
diff --git a/test/conftest.py b/test/conftest.py
new file mode 100644
index 000000000..c54238be1
--- /dev/null
+++ b/test/conftest.py
@@ -0,0 +1,24 @@
+import pytest
+
+from can.interfaces import virtual
+
+
+@pytest.fixture(autouse=True)
+def check_unclosed_virtual_channel():
+ """
+ Pytest fixture for detecting leaked virtual CAN channels.
+
+ - The fixture yields control to the test.
+ - After the test completes, it acquires `virtual.channels_lock` and asserts
+ that `virtual.channels` is empty.
+ - If a test leaves behind any unclosed virtual CAN channels, the assertion
+ will fail, surfacing resource leaks early.
+
+ This helps maintain test isolation and prevents subtle bugs caused by
+ leftover state between tests.
+ """
+
+ yield
+
+ with virtual.channels_lock:
+ assert len(virtual.channels) == 0
diff --git a/test/contextmanager_test.py b/test/contextmanager_test.py
index 95785b128..fe87f33b0 100644
--- a/test/contextmanager_test.py
+++ b/test/contextmanager_test.py
@@ -1,11 +1,11 @@
#!/usr/bin/env python
-# coding: utf-8
"""
This module tests the context manager of Bus and Notifier classes
"""
import unittest
+
import can
@@ -17,9 +17,10 @@ def setUp(self):
)
def test_open_buses(self):
- with can.Bus(interface="virtual") as bus_send, can.Bus(
- interface="virtual"
- ) as bus_recv:
+ with (
+ can.Bus(interface="virtual") as bus_send,
+ can.Bus(interface="virtual") as bus_recv,
+ ):
bus_send.send(self.msg_send)
msg_recv = bus_recv.recv()
@@ -27,9 +28,10 @@ def test_open_buses(self):
self.assertTrue(msg_recv)
def test_use_closed_bus(self):
- with can.Bus(interface="virtual") as bus_send, can.Bus(
- interface="virtual"
- ) as bus_recv:
+ with (
+ can.Bus(interface="virtual") as bus_send,
+ can.Bus(interface="virtual") as bus_recv,
+ ):
bus_send.send(self.msg_send)
# Receiving a frame after bus has been closed should raise a CanException
diff --git a/test/data/__init__.py b/test/data/__init__.py
index 394a0a067..4265cc3e6 100644
--- a/test/data/__init__.py
+++ b/test/data/__init__.py
@@ -1,2 +1 @@
#!/usr/bin/env python
-# coding: utf-8
diff --git a/test/data/example_data.py b/test/data/example_data.py
index 773212c32..b78420e4e 100644
--- a/test/data/example_data.py
+++ b/test/data/example_data.py
@@ -1,5 +1,4 @@
#!/usr/bin/env python
-# coding: utf-8
"""
This module contains some example data, like messages of different
@@ -34,48 +33,59 @@ def sort_messages(messages):
[
Message(
# empty
+ timestamp=1e-4,
),
Message(
# only data
- data=[0x00, 0x42]
+ timestamp=2e-4,
+ data=[0x00, 0x42],
),
Message(
# no data
+ timestamp=3e-4,
arbitration_id=0xAB,
is_extended_id=False,
),
Message(
# no data
+ timestamp=4e-4,
arbitration_id=0x42,
is_extended_id=True,
),
Message(
# no data
- arbitration_id=0xABCDEF
+ timestamp=5e-4,
+ arbitration_id=0xABCDEF,
),
Message(
# empty data
- data=[]
+ timestamp=6e-4,
+ data=[],
),
Message(
# empty data
- data=[0xFF, 0xFE, 0xFD]
+ timestamp=7e-4,
+ data=[0xFF, 0xFE, 0xFD],
),
Message(
# with channel as integer
- channel=0
+ timestamp=8e-4,
+ channel=0,
),
Message(
# with channel as integer
- channel=42
+ timestamp=9e-4,
+ channel=42,
),
Message(
# with channel as string
- channel="vcan0"
+ timestamp=10e-4,
+ channel="vcan0",
),
Message(
# with channel as string
- channel="awesome_channel"
+ timestamp=11e-4,
+ channel="awesome_channel",
),
Message(
arbitration_id=0xABCDEF,
@@ -110,10 +120,10 @@ def sort_messages(messages):
TEST_MESSAGES_CAN_FD = sort_messages(
[
- Message(is_fd=True, data=range(64)),
- Message(is_fd=True, data=range(8)),
- Message(is_fd=True, bitrate_switch=True),
- Message(is_fd=True, error_state_indicator=True),
+ Message(timestamp=12e-4, is_fd=True, data=range(64)),
+ Message(timestamp=13e-4, is_fd=True, data=range(8)),
+ Message(timestamp=14e-4, is_fd=True, data=range(8), bitrate_switch=True),
+ Message(timestamp=15e-4, is_fd=True, data=range(8), error_state_indicator=True),
]
)
@@ -150,7 +160,7 @@ def sort_messages(messages):
TEST_MESSAGES_ERROR_FRAMES = sort_messages(
[
- Message(is_error_frame=True),
+ Message(is_error_frame=True, timestamp=TEST_TIME),
Message(is_error_frame=True, timestamp=TEST_TIME + 0.170),
Message(is_error_frame=True, timestamp=TEST_TIME + 17.157),
]
@@ -180,7 +190,7 @@ def generate_message(arbitration_id):
Generates a new message with the given ID, some random data
and a non-extended ID.
"""
- data = bytearray([random.randrange(0, 2 ** 8 - 1) for _ in range(8)])
+ data = bytearray([random.randrange(0, 2**8 - 1) for _ in range(8)])
return Message(
arbitration_id=arbitration_id,
data=data,
diff --git a/test/data/ip_link_list.json b/test/data/ip_link_list.json
new file mode 100644
index 000000000..a96313b43
--- /dev/null
+++ b/test/data/ip_link_list.json
@@ -0,0 +1,91 @@
+[
+ {
+ "ifindex": 1,
+ "ifname": "lo",
+ "flags": [
+ "LOOPBACK",
+ "UP",
+ "LOWER_UP"
+ ],
+ "mtu": 65536,
+ "qdisc": "noqueue",
+ "operstate": "UNKNOWN",
+ "linkmode": "DEFAULT",
+ "group": "default",
+ "txqlen": 1000,
+ "link_type": "loopback",
+ "address": "00:00:00:00:00:00",
+ "broadcast": "00:00:00:00:00:00"
+ },
+ {
+ "ifindex": 2,
+ "ifname": "eth0",
+ "flags": [
+ "NO-CARRIER",
+ "BROADCAST",
+ "MULTICAST",
+ "UP"
+ ],
+ "mtu": 1500,
+ "qdisc": "fq_codel",
+ "operstate": "DOWN",
+ "linkmode": "DEFAULT",
+ "group": "default",
+ "txqlen": 1000,
+ "link_type": "ether",
+ "address": "11:22:33:44:55:66",
+ "broadcast": "ff:ff:ff:ff:ff:ff"
+ },
+ {
+ "ifindex": 3,
+ "ifname": "wlan0",
+ "flags": [
+ "BROADCAST",
+ "MULTICAST",
+ "UP",
+ "LOWER_UP"
+ ],
+ "mtu": 1500,
+ "qdisc": "noqueue",
+ "operstate": "UP",
+ "linkmode": "DORMANT",
+ "group": "default",
+ "txqlen": 1000,
+ "link_type": "ether",
+ "address": "11:22:33:44:55:66",
+ "broadcast": "ff:ff:ff:ff:ff:ff"
+ },
+ {
+ "ifindex": 48,
+ "ifname": "vcan0",
+ "flags": [
+ "NOARP",
+ "UP",
+ "LOWER_UP"
+ ],
+ "mtu": 72,
+ "qdisc": "noqueue",
+ "operstate": "UNKNOWN",
+ "linkmode": "DEFAULT",
+ "group": "default",
+ "txqlen": 1000,
+ "link_type": "can"
+ },
+ {
+ "ifindex": 50,
+ "ifname": "mycustomCan123",
+ "flags": [
+ "NOARP",
+ "UP",
+ "LOWER_UP"
+ ],
+ "mtu": 72,
+ "qdisc": "noqueue",
+ "operstate": "UNKNOWN",
+ "linkmode": "DEFAULT",
+ "group": "default",
+ "txqlen": 1000,
+ "link_type": "can"
+ },
+ {}
+]
\ No newline at end of file
diff --git a/test/data/issue_1256.asc b/test/data/issue_1256.asc
new file mode 100644
index 000000000..c3eb55199
--- /dev/null
+++ b/test/data/issue_1256.asc
@@ -0,0 +1,1461 @@
+date Tue May 27 04:09:35.000 pm 2014
+base hex timestamps absolute
+internal events logged
+// version 10.0.1
+ 0.019968 1 64 Rx d 4 64 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.029964 1 64 Rx d 4 6C 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.039943 1 64 Rx d 4 74 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.039977 1 11 Rx d 8 4A 28 F6 07 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 0.049949 1 64 Rx d 4 7C 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.059945 1 64 Rx d 4 84 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.059976 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 0.060015 1 66 Rx d 1 02 Length = 0 BitCount = 0 ID = 102
+ 0.069970 1 11 Rx d 8 84 29 F9 0A 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 0.070001 1 64 Rx d 4 8C 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.079951 1 64 Rx d 4 94 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.089947 1 64 Rx d 4 9C 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.099951 1 64 Rx d 4 A4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.099982 1 11 Rx d 8 BD 2A CD 11 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 0.109949 1 64 Rx d 4 AC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.109983 1 10 Rx d 8 10 27 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 0.110014 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 0.110032 1 65 Rx d 3 01 00 00 Length = 0 BitCount = 0 ID = 101
+ 0.110053 1 64 Rx d 4 B4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.129997 1 64 Rx d 4 BC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.130036 1 11 Rx d 8 F5 2B 4D 22 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 0.139949 1 64 Rx d 4 C4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.149954 1 64 Rx d 4 CC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.159951 1 64 Rx d 4 D4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.159983 1 11 Rx d 8 2C 2D 20 1D 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 0.160095 1 66 Rx d 1 04 Length = 0 BitCount = 0 ID = 102
+ 0.160132 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 0.169955 1 64 Rx d 4 DC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.180007 1 64 Rx d 4 E4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.189956 1 64 Rx d 4 EC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.189991 1 11 Rx d 8 62 2E 64 16 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 0.199956 1 64 Rx d 4 F4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.209970 1 64 Rx d 4 FC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.210004 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 0.210026 1 65 Rx d 3 19 00 00 Length = 0 BitCount = 0 ID = 101
+ 0.210084 1 10 Rx d 8 F3 28 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 0.219957 1 64 Rx d 4 04 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.219987 1 11 Rx d 8 95 2F 99 05 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 0.229990 1 64 Rx d 4 0C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.240004 1 64 Rx d 4 14 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.249954 1 64 Rx d 4 1C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.249988 1 11 Rx d 8 C7 30 D7 18 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 0.259976 1 64 Rx d 4 24 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.260138 1 66 Rx d 1 02 Length = 0 BitCount = 0 ID = 102
+ 0.260170 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 0.269974 1 64 Rx d 4 2C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.279956 1 64 Rx d 4 34 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.279989 1 11 Rx d 8 F6 31 DD 2C 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 0.289959 1 64 Rx d 4 3C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.299963 1 64 Rx d 4 44 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.309957 1 64 Rx d 4 4C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.309989 1 11 Rx d 8 22 33 F1 14 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 0.310012 1 10 Rx d 8 D5 2A 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 0.310075 1 12 Rx d 4 01 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 0.310097 1 65 Rx d 3 32 00 00 Length = 0 BitCount = 0 ID = 101
+ 0.319936 1 64 Rx d 4 54 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.329956 1 64 Rx d 4 5C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.339973 1 64 Rx d 4 64 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.339993 1 11 Rx d 8 4B 34 F6 07 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 0.349918 1 64 Rx d 4 6C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.359922 1 64 Rx d 4 74 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.359957 1 66 Rx d 1 04 Length = 0 BitCount = 0 ID = 102
+ 0.360032 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 0.360102 1 64 Rx d 4 7C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.360114 1 11 Rx d 8 71 35 F9 0A 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 0.380012 1 64 Rx d 4 84 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.389965 1 64 Rx d 4 8C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.399981 1 64 Rx d 4 94 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.400017 1 11 Rx d 8 93 36 CD 11 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 0.409967 1 64 Rx d 4 9C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.410001 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 0.410024 1 65 Rx d 3 19 00 00 Length = 0 BitCount = 0 ID = 101
+ 0.410086 1 10 Rx d 8 B5 2C 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 0.419955 1 64 Rx d 4 A4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.429968 1 64 Rx d 4 AC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.430001 1 11 Rx d 8 B2 37 4D 22 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 0.439986 1 64 Rx d 4 B4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.440148 1 64 Rx d 4 BC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.459928 1 64 Rx d 4 C4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.459970 1 11 Rx d 8 CC 38 20 1D 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 0.459991 1 66 Rx d 1 02 Length = 0 BitCount = 0 ID = 102
+ 0.460048 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 0.469963 1 64 Rx d 4 CC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.479988 1 64 Rx d 4 D4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.489926 1 64 Rx d 4 DC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.489959 1 11 Rx d 8 E2 39 64 16 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 0.499927 1 64 Rx d 4 E4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.509930 1 64 Rx d 4 EC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.509963 1 10 Rx d 8 91 2E 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 0.510027 1 65 Rx d 3 01 00 00 Length = 0 BitCount = 0 ID = 101
+ 0.510057 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 0.519946 1 64 Rx d 4 F4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.519980 1 11 Rx d 8 F2 3A 99 05 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 0.529932 1 64 Rx d 4 FC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.540023 1 64 Rx d 4 04 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.549926 1 64 Rx d 4 0C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.549958 1 11 Rx d 8 FE 3B D7 18 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 0.559975 1 64 Rx d 4 14 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.560137 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 0.560200 1 66 Rx d 1 04 Length = 0 BitCount = 0 ID = 102
+ 0.560231 1 64 Rx d 4 1C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.579988 1 64 Rx d 4 24 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.580022 1 11 Rx d 8 05 3D DD 2C 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 0.589973 1 64 Rx d 4 2C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.599972 1 64 Rx d 4 34 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.609972 1 64 Rx d 4 3C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.610004 1 11 Rx d 8 06 3E F1 14 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 0.610115 1 65 Rx d 3 19 00 00 Length = 0 BitCount = 0 ID = 101
+ 0.610151 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 0.610162 1 10 Rx d 8 69 30 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 0.610188 1 64 Rx d 4 44 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.629991 1 64 Rx d 4 4C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.639991 1 64 Rx d 4 54 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.640026 1 11 Rx d 8 01 3F F6 07 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 0.649975 1 64 Rx d 4 5C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.659977 1 64 Rx d 4 64 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.660010 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 0.660144 1 66 Rx d 1 02 Length = 0 BitCount = 0 ID = 102
+ 0.669992 1 11 Rx d 8 F6 3F F9 0A 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 0.670076 1 64 Rx d 4 6C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.680000 1 64 Rx d 4 74 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.689982 1 64 Rx d 4 7C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.690146 1 64 Rx d 4 84 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.690159 1 11 Rx d 8 E5 40 CD 11 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 0.709978 1 64 Rx d 4 8C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.710013 1 10 Rx d 8 3B 32 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 0.710079 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 0.710100 1 65 Rx d 3 32 00 00 Length = 0 BitCount = 0 ID = 101
+ 0.720010 1 64 Rx d 4 94 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.729980 1 64 Rx d 4 9C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.730013 1 11 Rx d 8 CD 41 4D 22 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 0.739981 1 64 Rx d 4 A4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.749983 1 64 Rx d 4 AC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.759997 1 64 Rx d 4 B4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.760030 1 11 Rx d 8 AF 42 20 1D 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 0.760052 1 66 Rx d 1 04 Length = 0 BitCount = 0 ID = 102
+ 0.760113 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 0.769999 1 64 Rx d 4 BC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.779998 1 64 Rx d 4 C4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.789982 1 64 Rx d 4 CC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.790003 1 11 Rx d 8 8A 43 64 16 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 0.799976 1 64 Rx d 4 D4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.809974 1 64 Rx d 4 DC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.810125 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 0.810139 1 65 Rx d 3 19 00 00 Length = 0 BitCount = 0 ID = 101
+ 0.810168 1 10 Rx d 8 07 34 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 0.819974 1 64 Rx d 4 E4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.820007 1 11 Rx d 8 5D 44 99 05 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 0.829974 1 64 Rx d 4 EC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.839975 1 64 Rx d 4 F4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.849974 1 64 Rx d 4 FC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.850006 1 11 Rx d 8 29 45 D7 18 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 0.860028 1 64 Rx d 4 04 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.860065 1 66 Rx d 1 02 Length = 0 BitCount = 0 ID = 102
+ 0.860138 1 12 Rx d 4 01 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 0.860201 1 64 Rx d 4 0C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.880033 1 64 Rx d 4 14 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.880170 1 11 Rx d 8 EE 45 DD 2C 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 0.889961 1 64 Rx d 4 1C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.900008 1 64 Rx d 4 24 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.909943 1 64 Rx d 4 2C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.909976 1 11 Rx d 8 AA 46 F1 14 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 0.910071 1 10 Rx d 8 CB 35 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 0.910101 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 0.910113 1 65 Rx d 3 01 00 00 Length = 0 BitCount = 0 ID = 101
+ 0.919950 1 64 Rx d 4 34 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.929950 1 64 Rx d 4 3C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.939955 1 64 Rx d 4 44 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.940093 1 11 Rx d 8 5F 47 F6 07 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 0.940105 1 64 Rx d 4 4C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.959949 1 64 Rx d 4 54 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.959982 1 66 Rx d 1 04 Length = 0 BitCount = 0 ID = 102
+ 0.960053 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 0.969947 1 64 Rx d 4 5C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.969981 1 11 Rx d 8 0B 48 F9 0A 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 0.979953 1 64 Rx d 4 64 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.990010 1 64 Rx d 4 6C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 0.999991 1 64 Rx d 4 74 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.000156 1 11 Rx d 8 AF 48 CD 11 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 1.009977 1 64 Rx d 4 7C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.010014 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 1.010037 1 65 Rx d 3 19 00 00 Length = 0 BitCount = 0 ID = 101
+ 1.010107 1 10 Rx d 8 86 37 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 1.019975 1 64 Rx d 4 64 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.030073 1 64 Rx d 4 6C 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.030111 1 11 Rx d 8 4B 49 4D 22 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 1.040047 1 64 Rx d 4 74 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.050030 1 64 Rx d 4 7C 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.060044 1 64 Rx d 4 84 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.060181 1 11 Rx d 8 DE 49 20 1D 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 1.060194 1 66 Rx d 1 02 Length = 0 BitCount = 0 ID = 102
+ 1.060223 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 1.060283 1 64 Rx d 4 8C 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.080019 1 64 Rx d 4 94 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.089998 1 64 Rx d 4 9C 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.090034 1 11 Rx d 8 68 4A 64 16 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 1.100056 1 64 Rx d 4 A4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.110002 1 64 Rx d 4 AC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.110041 1 65 Rx d 3 32 00 00 Length = 0 BitCount = 0 ID = 101
+ 1.110098 1 10 Rx d 8 37 39 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 1.110132 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 1.110145 1 11 Rx d 8 EA 4A 99 05 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 1.110155 1 64 Rx d 4 B4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.130015 1 64 Rx d 4 BC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.140014 1 64 Rx d 4 C4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.150012 1 64 Rx d 4 CC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.150061 1 11 Rx d 8 62 4B D7 18 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 1.150160 1 64 Rx d 4 D4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.150173 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 1.150238 1 66 Rx d 1 04 Length = 0 BitCount = 0 ID = 102
+ 1.169969 1 64 Rx d 4 DC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.179968 1 64 Rx d 4 E4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.180014 1 11 Rx d 8 D1 4B DD 2C 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 1.189955 1 64 Rx d 4 EC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.200037 1 64 Rx d 4 F4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.209998 1 64 Rx d 4 FC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.210021 1 11 Rx d 8 37 4C F1 14 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 1.210151 1 65 Rx d 3 19 00 00 Length = 0 BitCount = 0 ID = 101
+ 1.210196 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 1.210251 1 10 Rx d 8 DE 3A 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 1.220057 1 64 Rx d 4 04 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.230061 1 64 Rx d 4 0C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.240062 1 64 Rx d 4 14 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.240099 1 11 Rx d 8 93 4C F6 07 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 1.250061 1 64 Rx d 4 1C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.260053 1 64 Rx d 4 24 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.260090 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 1.260113 1 66 Rx d 1 02 Length = 0 BitCount = 0 ID = 102
+ 1.270063 1 11 Rx d 8 E6 4C F9 0A 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 1.270179 1 64 Rx d 4 2C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.270193 1 64 Rx d 4 34 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.289924 1 64 Rx d 4 3C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.300009 1 64 Rx d 4 44 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.300037 1 11 Rx d 8 2F 4D CD 11 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 1.309979 1 64 Rx d 4 4C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.310113 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 1.310183 1 10 Rx d 8 78 3C 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 1.310217 1 65 Rx d 3 01 00 00 Length = 0 BitCount = 0 ID = 101
+ 1.310249 1 64 Rx d 4 54 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.329968 1 64 Rx d 4 5C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.330021 1 11 Rx d 8 6F 4D 4D 22 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 1.339962 1 64 Rx d 4 64 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.349962 1 64 Rx d 4 6C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.359966 1 64 Rx d 4 74 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.359992 1 11 Rx d 8 A5 4D 20 1D 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 1.360009 1 66 Rx d 1 04 Length = 0 BitCount = 0 ID = 102
+ 1.360074 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 1.370015 1 64 Rx d 4 7C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.380032 1 64 Rx d 4 84 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.390025 1 64 Rx d 4 8C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.390058 1 11 Rx d 8 D1 4D 64 16 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 1.400054 1 64 Rx d 4 94 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.400094 1 64 Rx d 4 9C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.400116 1 65 Rx d 3 19 00 00 Length = 0 BitCount = 0 ID = 101
+ 1.400176 1 10 Rx d 8 06 3E 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 1.400209 1 12 Rx d 4 01 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 1.420035 1 11 Rx d 8 F4 4D 99 05 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 1.420068 1 64 Rx d 4 A4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.430012 1 64 Rx d 4 AC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.439963 1 64 Rx d 4 B4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.449976 1 64 Rx d 4 BC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.450009 1 11 Rx d 8 0C 4E D7 18 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 1.459963 1 64 Rx d 4 C4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.459986 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 1.460057 1 66 Rx d 1 02 Length = 0 BitCount = 0 ID = 102
+ 1.469973 1 64 Rx d 4 CC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.480036 1 64 Rx d 4 D4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.480071 1 11 Rx d 8 1B 4E DD 2C 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 1.489976 1 64 Rx d 4 DC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.500035 1 64 Rx d 4 E4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.509978 1 64 Rx d 4 EC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.510010 1 11 Rx d 8 20 4E F1 14 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 1.510100 1 65 Rx d 3 32 00 00 Length = 0 BitCount = 0 ID = 101
+ 1.510131 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 1.510142 1 10 Rx d 8 86 3F 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 1.519982 1 64 Rx d 4 F4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.530039 1 64 Rx d 4 FC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.540022 1 64 Rx d 4 04 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.540051 1 11 Rx d 8 1B 4E F6 07 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 1.550046 1 64 Rx d 4 0C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.560021 1 64 Rx d 4 14 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.560057 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 1.560181 1 66 Rx d 1 04 Length = 0 BitCount = 0 ID = 102
+ 1.570020 1 11 Rx d 8 0C 4E F9 0A 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 1.570138 1 64 Rx d 4 1C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.580022 1 64 Rx d 4 24 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.590043 1 64 Rx d 4 2C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.600024 1 64 Rx d 4 34 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.600055 1 11 Rx d 8 F4 4D CD 11 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 1.610019 1 64 Rx d 4 3C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.610179 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 1.610191 1 10 Rx d 8 F7 40 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 1.610217 1 65 Rx d 3 19 00 00 Length = 0 BitCount = 0 ID = 101
+ 1.620027 1 64 Rx d 4 44 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.630024 1 64 Rx d 4 4C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.630055 1 11 Rx d 8 D1 4D 4D 22 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 1.640032 1 64 Rx d 4 54 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.650055 1 64 Rx d 4 5C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.650094 1 64 Rx d 4 64 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.650119 1 11 Rx d 8 A5 4D 20 1D 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 1.650135 1 66 Rx d 1 02 Length = 0 BitCount = 0 ID = 102
+ 1.650190 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 1.670103 1 64 Rx d 4 6C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.680104 1 64 Rx d 4 74 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.690059 1 64 Rx d 4 7C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.690097 1 11 Rx d 8 6F 4D 64 16 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 1.690212 1 64 Rx d 4 84 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.710033 1 64 Rx d 4 8C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.710070 1 65 Rx d 3 01 00 00 Length = 0 BitCount = 0 ID = 101
+ 1.710139 1 10 Rx d 8 59 42 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 1.710189 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 1.720025 1 11 Rx d 8 2F 4D 99 05 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 1.720057 1 64 Rx d 4 94 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.730027 1 64 Rx d 4 9C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.730186 1 64 Rx d 4 A4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.750028 1 64 Rx d 4 AC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.750060 1 11 Rx d 8 E6 4C D7 18 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 1.760049 1 64 Rx d 4 B4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.760080 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 1.760095 1 66 Rx d 1 04 Length = 0 BitCount = 0 ID = 102
+ 1.770032 1 64 Rx d 4 BC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.780053 1 64 Rx d 4 C4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.780087 1 11 Rx d 8 93 4C DD 2C 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 1.790032 1 64 Rx d 4 CC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.800013 1 64 Rx d 4 D4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.810033 1 64 Rx d 4 DC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.810068 1 11 Rx d 8 37 4C F1 14 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 1.810178 1 65 Rx d 3 19 00 00 Length = 0 BitCount = 0 ID = 101
+ 1.810211 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 1.810263 1 10 Rx d 8 AB 43 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 1.810292 1 64 Rx d 4 E4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.830028 1 64 Rx d 4 EC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.840037 1 64 Rx d 4 F4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.840069 1 11 Rx d 8 D1 4B F6 07 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 1.850034 1 64 Rx d 4 FC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.860036 1 64 Rx d 4 04 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.860070 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 1.860091 1 66 Rx d 1 02 Length = 0 BitCount = 0 ID = 102
+ 1.870040 1 11 Rx d 8 62 4B F9 0A 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 1.870173 1 64 Rx d 4 0C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.880039 1 64 Rx d 4 14 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.890037 1 64 Rx d 4 1C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.900074 1 64 Rx d 4 24 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.900111 1 11 Rx d 8 EA 4A CD 11 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 1.900134 1 64 Rx d 4 2C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.900151 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 1.900246 1 10 Rx d 8 EB 44 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 1.900276 1 65 Rx d 3 32 00 00 Length = 0 BitCount = 0 ID = 101
+ 1.920089 1 64 Rx d 4 34 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.930090 1 64 Rx d 4 3C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.930127 1 11 Rx d 8 68 4A 4D 22 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 1.940093 1 64 Rx d 4 44 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.940132 1 64 Rx d 4 4C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.960058 1 64 Rx d 4 54 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.960096 1 11 Rx d 8 DE 49 20 1D 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 1.960118 1 66 Rx d 1 04 Length = 0 BitCount = 0 ID = 102
+ 1.960187 1 12 Rx d 4 01 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 1.970038 1 64 Rx d 4 5C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.980044 1 64 Rx d 4 64 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.990002 1 64 Rx d 4 6C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 1.990149 1 11 Rx d 8 4B 49 64 16 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 2.000000 1 64 Rx d 4 74 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.010062 1 64 Rx d 4 7C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.010100 1 65 Rx d 3 19 00 00 Length = 0 BitCount = 0 ID = 101
+ 2.010143 1 10 Rx d 8 1A 46 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 2.010182 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 2.020003 1 64 Rx d 4 64 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.020035 1 11 Rx d 8 AF 48 99 05 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 2.030002 1 64 Rx d 4 6C 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.040047 1 64 Rx d 4 74 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.050003 1 64 Rx d 4 7C 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.050137 1 11 Rx d 8 0B 48 D7 18 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 2.060035 1 64 Rx d 4 84 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.060072 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 2.060166 1 66 Rx d 1 02 Length = 0 BitCount = 0 ID = 102
+ 2.070114 1 64 Rx d 4 8C 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.080034 1 64 Rx d 4 94 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.080071 1 11 Rx d 8 5F 47 DD 2C 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 2.090050 1 64 Rx d 4 9C 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.100064 1 64 Rx d 4 A4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.110044 1 64 Rx d 4 AC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.110208 1 11 Rx d 8 AA 46 F1 14 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 2.110260 1 10 Rx d 8 36 47 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 2.110289 1 65 Rx d 3 01 00 00 Length = 0 BitCount = 0 ID = 101
+ 2.110316 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 2.110327 1 64 Rx d 4 B4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.130053 1 64 Rx d 4 BC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.140028 1 64 Rx d 4 C4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.140060 1 11 Rx d 8 EE 45 F6 07 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 2.150070 1 64 Rx d 4 CC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.150102 1 64 Rx d 4 D4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.150125 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 2.150231 1 66 Rx d 1 04 Length = 0 BitCount = 0 ID = 102
+ 2.170064 1 64 Rx d 4 DC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.170211 1 11 Rx d 8 29 45 F9 0A 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 2.180053 1 64 Rx d 4 E4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.190065 1 64 Rx d 4 EC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.200058 1 64 Rx d 4 F4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.200095 1 11 Rx d 8 5D 44 CD 11 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 2.210053 1 64 Rx d 4 FC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.210089 1 65 Rx d 3 19 00 00 Length = 0 BitCount = 0 ID = 101
+ 2.210158 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 2.210227 1 10 Rx d 8 3F 48 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 2.220056 1 64 Rx d 4 04 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.230054 1 64 Rx d 4 0C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.230215 1 11 Rx d 8 8A 43 4D 22 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 2.230267 1 64 Rx d 4 14 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.250051 1 64 Rx d 4 1C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.260053 1 64 Rx d 4 24 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.260089 1 11 Rx d 8 AF 42 20 1D 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 2.260111 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 2.260127 1 66 Rx d 1 02 Length = 0 BitCount = 0 ID = 102
+ 2.270057 1 64 Rx d 4 2C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.280069 1 64 Rx d 4 34 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.290077 1 64 Rx d 4 3C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.290234 1 11 Rx d 8 CD 41 64 16 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 2.300073 1 64 Rx d 4 44 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.310053 1 64 Rx d 4 4C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.310096 1 10 Rx d 8 34 49 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 2.310167 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 2.310239 1 65 Rx d 3 32 00 00 Length = 0 BitCount = 0 ID = 101
+ 2.310268 1 64 Rx d 4 54 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.310280 1 11 Rx d 8 E5 40 99 05 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 2.330060 1 64 Rx d 4 5C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.340074 1 64 Rx d 4 64 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.350083 1 64 Rx d 4 6C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.350234 1 11 Rx d 8 F6 3F D7 18 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 2.350288 1 64 Rx d 4 74 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.350300 1 66 Rx d 1 04 Length = 0 BitCount = 0 ID = 102
+ 2.350330 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 2.370081 1 64 Rx d 4 7C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.380078 1 64 Rx d 4 84 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.380119 1 11 Rx d 8 01 3F DD 2C 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 2.390063 1 64 Rx d 4 8C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.400062 1 64 Rx d 4 94 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.400097 1 64 Rx d 4 9C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.400120 1 11 Rx d 8 06 3E F1 14 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 2.400136 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 2.400236 1 65 Rx d 3 19 00 00 Length = 0 BitCount = 0 ID = 101
+ 2.400266 1 10 Rx d 8 14 4A 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 2.420096 1 64 Rx d 4 A4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.430063 1 64 Rx d 4 AC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.440083 1 64 Rx d 4 B4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.440116 1 11 Rx d 8 05 3D F6 07 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 2.440230 1 64 Rx d 4 BC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.460066 1 64 Rx d 4 C4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.460101 1 66 Rx d 1 02 Length = 0 BitCount = 0 ID = 102
+ 2.460172 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 2.470079 1 11 Rx d 8 FE 3B F9 0A 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 2.470111 1 64 Rx d 4 CC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.480072 1 64 Rx d 4 D4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.480232 1 64 Rx d 4 DC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.500067 1 64 Rx d 4 E4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.500100 1 11 Rx d 8 F2 3A CD 11 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 2.510082 1 64 Rx d 4 EC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.510117 1 10 Rx d 8 E0 4A 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 2.510181 1 65 Rx d 3 01 00 00 Length = 0 BitCount = 0 ID = 101
+ 2.510237 1 12 Rx d 4 01 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 2.520174 1 64 Rx d 4 F4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.520211 1 64 Rx d 4 FC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.520234 1 11 Rx d 8 E2 39 4D 22 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 2.540030 1 64 Rx d 4 04 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.550072 1 64 Rx d 4 0C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.560027 1 64 Rx d 4 14 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.560060 1 11 Rx d 8 CC 38 20 1D 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 2.560141 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 2.560196 1 66 Rx d 1 04 Length = 0 BitCount = 0 ID = 102
+ 2.560227 1 64 Rx d 4 1C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.580070 1 64 Rx d 4 24 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.590075 1 64 Rx d 4 2C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.590111 1 11 Rx d 8 B2 37 64 16 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 2.600069 1 64 Rx d 4 34 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.610070 1 64 Rx d 4 3C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.610104 1 65 Rx d 3 19 00 00 Length = 0 BitCount = 0 ID = 101
+ 2.610168 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 2.610189 1 10 Rx d 8 96 4B 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 2.620075 1 64 Rx d 4 44 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.620108 1 11 Rx d 8 93 36 99 05 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 2.630077 1 64 Rx d 4 4C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.640065 1 64 Rx d 4 54 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.650071 1 64 Rx d 4 5C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.650103 1 11 Rx d 8 71 35 D7 18 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 2.650124 1 64 Rx d 4 64 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.650141 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 2.650240 1 66 Rx d 1 02 Length = 0 BitCount = 0 ID = 102
+ 2.670078 1 64 Rx d 4 6C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.680091 1 64 Rx d 4 74 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.680126 1 11 Rx d 8 4B 34 DD 2C 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 2.690092 1 64 Rx d 4 7C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.690126 1 64 Rx d 4 84 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.710092 1 64 Rx d 4 8C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.710128 1 11 Rx d 8 22 33 F1 14 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 2.710154 1 10 Rx d 8 37 4C 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 2.710214 1 65 Rx d 3 32 00 00 Length = 0 BitCount = 0 ID = 101
+ 2.710259 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 2.720071 1 64 Rx d 4 94 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.730075 1 64 Rx d 4 9C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.730236 1 64 Rx d 4 A4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.730256 1 11 Rx d 8 F6 31 F6 07 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 2.750078 1 64 Rx d 4 AC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.760095 1 64 Rx d 4 B4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.760128 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 2.760150 1 66 Rx d 1 04 Length = 0 BitCount = 0 ID = 102
+ 2.770101 1 64 Rx d 4 BC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.770139 1 11 Rx d 8 C7 30 F9 0A 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 2.770253 1 64 Rx d 4 C4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.790118 1 64 Rx d 4 CC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.800075 1 64 Rx d 4 D4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.800113 1 11 Rx d 8 95 2F CD 11 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 2.810084 1 64 Rx d 4 DC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.810116 1 65 Rx d 3 19 00 00 Length = 0 BitCount = 0 ID = 101
+ 2.810185 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 2.810272 1 10 Rx d 8 C1 4C 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 2.810301 1 64 Rx d 4 E4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.830087 1 64 Rx d 4 EC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.830122 1 11 Rx d 8 62 2E 4D 22 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 2.840105 1 64 Rx d 4 F4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.850098 1 64 Rx d 4 FC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.860076 1 64 Rx d 4 04 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.860114 1 11 Rx d 8 2C 2D 20 1D 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 2.860136 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 2.860153 1 66 Rx d 1 02 Length = 0 BitCount = 0 ID = 102
+ 2.870100 1 64 Rx d 4 0C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.880131 1 64 Rx d 4 14 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.890145 1 64 Rx d 4 1C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.890182 1 11 Rx d 8 F5 2B 64 16 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 2.900088 1 64 Rx d 4 24 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.900125 1 64 Rx d 4 2C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.900150 1 10 Rx d 8 34 4D 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 2.900213 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 2.900283 1 65 Rx d 3 01 00 00 Length = 0 BitCount = 0 ID = 101
+ 2.920086 1 64 Rx d 4 34 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.920229 1 11 Rx d 8 BD 2A 99 05 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 2.930105 1 64 Rx d 4 3C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.940094 1 64 Rx d 4 44 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.940128 1 64 Rx d 4 4C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.940151 1 11 Rx d 8 84 29 D7 18 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 2.960131 1 64 Rx d 4 54 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.960153 1 66 Rx d 1 04 Length = 0 BitCount = 0 ID = 102
+ 2.960199 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 2.970084 1 64 Rx d 4 5C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.980091 1 64 Rx d 4 64 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 2.980263 1 11 Rx d 8 4A 28 DD 2C 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 2.980317 1 64 Rx d 4 6C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.000106 1 64 Rx d 4 74 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.010158 1 64 Rx d 4 7C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.010195 1 11 Rx d 8 10 27 F1 14 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 3.010218 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 3.010234 1 65 Rx d 3 19 00 00 Length = 0 BitCount = 0 ID = 101
+ 3.010278 1 10 Rx d 8 91 4D 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 3.020129 1 64 Rx d 4 64 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.030126 1 64 Rx d 4 6C 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.040128 1 64 Rx d 4 74 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.040267 1 11 Rx d 8 D6 25 F6 07 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 3.050098 1 64 Rx d 4 7C 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.060086 1 64 Rx d 4 84 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.060119 1 66 Rx d 1 02 Length = 0 BitCount = 0 ID = 102
+ 3.060193 1 12 Rx d 4 01 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 3.060269 1 11 Rx d 8 9C 24 F9 0A 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 3.060280 1 64 Rx d 4 8C 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.080052 1 64 Rx d 4 94 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.090013 1 64 Rx d 4 9C 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.100011 1 64 Rx d 4 A4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.100139 1 11 Rx d 8 63 23 CD 11 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 3.110014 1 64 Rx d 4 AC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.110044 1 65 Rx d 3 32 00 00 Length = 0 BitCount = 0 ID = 101
+ 3.110104 1 10 Rx d 8 D7 4D 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 3.110134 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 3.120011 1 64 Rx d 4 B4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.130110 1 64 Rx d 4 BC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.130139 1 11 Rx d 8 2B 22 4D 22 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 3.140015 1 64 Rx d 4 C4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.150013 1 64 Rx d 4 CC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.160153 1 64 Rx d 4 D4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.160290 1 11 Rx d 8 F4 20 20 1D 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 3.160342 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 3.160395 1 66 Rx d 1 04 Length = 0 BitCount = 0 ID = 102
+ 3.170068 1 64 Rx d 4 DC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.180094 1 64 Rx d 4 E4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.190101 1 64 Rx d 4 EC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.190134 1 11 Rx d 8 BE 1F 64 16 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 3.190157 1 64 Rx d 4 F4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.210102 1 64 Rx d 4 FC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.210135 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 3.210157 1 10 Rx d 8 06 4E 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 3.210223 1 65 Rx d 3 19 00 00 Length = 0 BitCount = 0 ID = 101
+ 3.220098 1 11 Rx d 8 8B 1E 99 05 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 3.220219 1 64 Rx d 4 04 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.230103 1 64 Rx d 4 0C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.230137 1 64 Rx d 4 14 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.250083 1 64 Rx d 4 1C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.250118 1 11 Rx d 8 59 1D D7 18 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 3.260090 1 64 Rx d 4 24 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.260122 1 66 Rx d 1 02 Length = 0 BitCount = 0 ID = 102
+ 3.260194 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 3.270103 1 64 Rx d 4 2C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.280074 1 64 Rx d 4 34 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.280241 1 11 Rx d 8 2A 1C DD 2C 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 3.290127 1 64 Rx d 4 3C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.300105 1 64 Rx d 4 44 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.310145 1 64 Rx d 4 4C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.310178 1 11 Rx d 8 FE 1A F1 14 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 3.310201 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 3.310217 1 65 Rx d 3 01 00 00 Length = 0 BitCount = 0 ID = 101
+ 3.310282 1 10 Rx d 8 1D 4E 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 3.310326 1 64 Rx d 4 54 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.330117 1 64 Rx d 4 5C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.340106 1 64 Rx d 4 64 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.340272 1 11 Rx d 8 D5 19 F6 07 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 3.350133 1 64 Rx d 4 6C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.360104 1 64 Rx d 4 74 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.360136 1 66 Rx d 1 04 Length = 0 BitCount = 0 ID = 102
+ 3.360206 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 3.370111 1 11 Rx d 8 AF 18 F9 0A 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 3.370143 1 64 Rx d 4 7C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.380073 1 64 Rx d 4 84 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.390099 1 64 Rx d 4 8C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.400128 1 64 Rx d 4 94 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.400301 1 11 Rx d 8 8D 17 CD 11 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 3.400355 1 64 Rx d 4 9C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.400367 1 65 Rx d 3 19 00 00 Length = 0 BitCount = 0 ID = 101
+ 3.400394 1 10 Rx d 8 1D 4E 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 3.400422 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 3.420127 1 64 Rx d 4 A4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.430111 1 64 Rx d 4 AC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.430143 1 11 Rx d 8 6E 16 4D 22 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 3.440133 1 64 Rx d 4 B4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.440164 1 64 Rx d 4 BC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.460133 1 64 Rx d 4 C4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.460291 1 11 Rx d 8 54 15 20 1D 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 3.460343 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 3.460396 1 66 Rx d 1 02 Length = 0 BitCount = 0 ID = 102
+ 3.470130 1 64 Rx d 4 CC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.480128 1 64 Rx d 4 D4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.480160 1 64 Rx d 4 DC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.480184 1 11 Rx d 8 3E 14 64 16 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 3.500107 1 64 Rx d 4 E4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.510123 1 64 Rx d 4 EC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.510160 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 3.510183 1 10 Rx d 8 06 4E 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 3.510246 1 65 Rx d 3 32 00 00 Length = 0 BitCount = 0 ID = 101
+ 3.520133 1 11 Rx d 8 2E 13 99 05 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 3.520256 1 64 Rx d 4 F4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.520336 1 64 Rx d 4 FC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.540135 1 64 Rx d 4 04 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.550123 1 64 Rx d 4 0C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.550154 1 11 Rx d 8 22 12 D7 18 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 3.560132 1 64 Rx d 4 14 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.560163 1 66 Rx d 1 04 Length = 0 BitCount = 0 ID = 102
+ 3.560234 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 3.560312 1 64 Rx d 4 1C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.580132 1 64 Rx d 4 24 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.580289 1 11 Rx d 8 1B 11 DD 2C 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 3.590114 1 64 Rx d 4 2C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.600140 1 64 Rx d 4 34 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.610137 1 64 Rx d 4 3C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.610168 1 11 Rx d 8 1A 10 F1 14 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 3.610191 1 12 Rx d 4 01 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 3.610209 1 65 Rx d 3 19 00 00 Length = 0 BitCount = 0 ID = 101
+ 3.610267 1 10 Rx d 8 D7 4D 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 3.620042 1 64 Rx d 4 44 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.630075 1 64 Rx d 4 4C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.640082 1 64 Rx d 4 54 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.640213 1 11 Rx d 8 1F 0F F6 07 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 3.650082 1 64 Rx d 4 5C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.650118 1 64 Rx d 4 64 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.650142 1 66 Rx d 1 02 Length = 0 BitCount = 0 ID = 102
+ 3.650202 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 3.670166 1 11 Rx d 8 2A 0E F9 0A 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 3.670202 1 64 Rx d 4 6C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.680120 1 64 Rx d 4 74 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.690128 1 64 Rx d 4 7C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.690160 1 64 Rx d 4 84 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.690184 1 11 Rx d 8 3B 0D CD 11 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 3.710127 1 64 Rx d 4 8C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.710271 1 65 Rx d 3 01 00 00 Length = 0 BitCount = 0 ID = 101
+ 3.710304 1 10 Rx d 8 91 4D 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 3.710332 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 3.720163 1 64 Rx d 4 94 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.730129 1 64 Rx d 4 9C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.730166 1 11 Rx d 8 53 0C 4D 22 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 3.730283 1 64 Rx d 4 A4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.750126 1 64 Rx d 4 AC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.760173 1 64 Rx d 4 B4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.760210 1 11 Rx d 8 71 0B 20 1D 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 3.760233 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 3.760249 1 66 Rx d 1 04 Length = 0 BitCount = 0 ID = 102
+ 3.770116 1 64 Rx d 4 BC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.770268 1 64 Rx d 4 C4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.790150 1 64 Rx d 4 CC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.790184 1 11 Rx d 8 96 0A 64 16 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 3.800152 1 64 Rx d 4 D4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.810126 1 64 Rx d 4 DC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.810151 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 3.810225 1 10 Rx d 8 34 4D 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 3.810258 1 65 Rx d 3 19 00 00 Length = 0 BitCount = 0 ID = 101
+ 3.810288 1 11 Rx d 8 C3 09 99 05 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 3.810300 1 64 Rx d 4 E4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.830121 1 64 Rx d 4 EC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.840131 1 64 Rx d 4 F4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.850150 1 64 Rx d 4 FC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.850182 1 11 Rx d 8 F7 08 D7 18 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 3.850304 1 64 Rx d 4 04 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.850318 1 66 Rx d 1 02 Length = 0 BitCount = 0 ID = 102
+ 3.850348 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 3.870134 1 64 Rx d 4 0C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.880155 1 64 Rx d 4 14 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.880187 1 11 Rx d 8 32 08 DD 2C 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 3.890156 1 64 Rx d 4 1C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.890314 1 64 Rx d 4 24 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.900151 1 64 Rx d 4 2C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.900184 1 11 Rx d 8 76 07 F1 14 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 3.900206 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 3.900308 1 65 Rx d 3 32 00 00 Length = 0 BitCount = 0 ID = 101
+ 3.900337 1 10 Rx d 8 C1 4C 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 3.920150 1 64 Rx d 4 34 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.930141 1 64 Rx d 4 3C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.940146 1 64 Rx d 4 44 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.940177 1 11 Rx d 8 C1 06 F6 07 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 3.940289 1 64 Rx d 4 4C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.960155 1 64 Rx d 4 54 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.960321 1 66 Rx d 1 04 Length = 0 BitCount = 0 ID = 102
+ 3.960353 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 3.970143 1 11 Rx d 8 15 06 F9 0A 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 3.970175 1 64 Rx d 4 5C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.980155 1 64 Rx d 4 64 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 3.980187 1 64 Rx d 4 6C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.000161 1 64 Rx d 4 74 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.000193 1 11 Rx d 8 71 05 CD 11 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 4.010222 1 64 Rx d 4 7C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.010262 1 65 Rx d 3 19 00 00 Length = 0 BitCount = 0 ID = 101
+ 4.010319 1 10 Rx d 8 37 4C 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 4.010350 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 4.020171 1 64 Rx d 4 64 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.020337 1 64 Rx d 4 6C 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.020350 1 11 Rx d 8 D5 04 4D 22 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 4.040172 1 64 Rx d 4 74 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.050149 1 64 Rx d 4 7C 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.060159 1 64 Rx d 4 84 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.060196 1 11 Rx d 8 42 04 20 1D 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 4.060314 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 4.060367 1 66 Rx d 1 02 Length = 0 BitCount = 0 ID = 102
+ 4.060397 1 64 Rx d 4 8C 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.080148 1 64 Rx d 4 94 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.090164 1 64 Rx d 4 9C 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.090198 1 11 Rx d 8 B8 03 64 16 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 4.100207 1 64 Rx d 4 A4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.110147 1 64 Rx d 4 AC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.110185 1 10 Rx d 8 96 4B 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 4.110267 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 4.110291 1 65 Rx d 3 01 00 00 Length = 0 BitCount = 0 ID = 101
+ 4.120175 1 64 Rx d 4 B4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.120209 1 11 Rx d 8 36 03 99 05 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 4.130179 1 64 Rx d 4 BC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.140158 1 64 Rx d 4 C4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.140314 1 64 Rx d 4 CC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.140327 1 11 Rx d 8 BE 02 D7 18 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 4.150166 1 64 Rx d 4 D4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.150201 1 66 Rx d 1 04 Length = 0 BitCount = 0 ID = 102
+ 4.150271 1 12 Rx d 4 01 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 4.170105 1 64 Rx d 4 DC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.180168 1 64 Rx d 4 E4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.180203 1 11 Rx d 8 4F 02 DD 2C 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 4.190075 1 64 Rx d 4 EC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.190107 1 64 Rx d 4 F4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.210114 1 64 Rx d 4 FC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.210252 1 11 Rx d 8 E9 01 F1 14 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 4.210265 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 4.210307 1 65 Rx d 3 19 00 00 Length = 0 BitCount = 0 ID = 101
+ 4.210336 1 10 Rx d 8 E0 4A 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 4.220109 1 64 Rx d 4 04 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.230170 1 64 Rx d 4 0C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.230205 1 64 Rx d 4 14 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.230222 1 11 Rx d 8 8D 01 F6 07 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 4.250120 1 64 Rx d 4 1C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.260111 1 64 Rx d 4 24 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.260144 1 66 Rx d 1 02 Length = 0 BitCount = 0 ID = 102
+ 4.260213 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 4.270185 1 11 Rx d 8 3A 01 F9 0A 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 4.270317 1 64 Rx d 4 2C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.270392 1 64 Rx d 4 34 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.290125 1 64 Rx d 4 3C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.300176 1 64 Rx d 4 44 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.300208 1 11 Rx d 8 F1 00 CD 11 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 4.310134 1 64 Rx d 4 4C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.310165 1 10 Rx d 8 14 4A 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 4.310231 1 65 Rx d 3 32 00 00 Length = 0 BitCount = 0 ID = 101
+ 4.310286 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 4.310347 1 64 Rx d 4 54 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.330186 1 64 Rx d 4 5C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.330343 1 11 Rx d 8 B1 00 4D 22 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 4.340151 1 64 Rx d 4 64 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.350181 1 64 Rx d 4 6C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.360178 1 64 Rx d 4 74 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.360210 1 11 Rx d 8 7B 00 20 1D 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 4.360232 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 4.360249 1 66 Rx d 1 04 Length = 0 BitCount = 0 ID = 102
+ 4.370158 1 64 Rx d 4 7C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.380181 1 64 Rx d 4 84 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.390169 1 64 Rx d 4 8C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.390287 1 11 Rx d 8 4F 00 64 16 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 4.390342 1 64 Rx d 4 94 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.400204 1 64 Rx d 4 9C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.400241 1 65 Rx d 3 19 00 00 Length = 0 BitCount = 0 ID = 101
+ 4.400310 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 4.400388 1 10 Rx d 8 34 49 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 4.420206 1 64 Rx d 4 A4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.420243 1 11 Rx d 8 2C 00 99 05 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 4.430163 1 64 Rx d 4 AC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.440152 1 64 Rx d 4 B4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.440184 1 64 Rx d 4 BC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.440208 1 11 Rx d 8 14 00 D7 18 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 4.460180 1 64 Rx d 4 C4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.460345 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 4.460388 1 66 Rx d 1 02 Length = 0 BitCount = 0 ID = 102
+ 4.470164 1 64 Rx d 4 CC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.480182 1 64 Rx d 4 D4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.480216 1 11 Rx d 8 05 00 DD 2C 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 4.480327 1 64 Rx d 4 DC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.500107 1 64 Rx d 4 E4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.510152 1 64 Rx d 4 EC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.510187 1 11 Rx d 8 00 00 F1 14 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 4.510205 1 10 Rx d 8 3F 48 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 4.510259 1 65 Rx d 3 01 00 00 Length = 0 BitCount = 0 ID = 101
+ 4.510290 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 4.520188 1 64 Rx d 4 F4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.520347 1 64 Rx d 4 FC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.540146 1 64 Rx d 4 04 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.540175 1 11 Rx d 8 05 00 F6 07 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 4.550167 1 64 Rx d 4 0C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.560189 1 64 Rx d 4 14 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.560224 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 4.560343 1 66 Rx d 1 04 Length = 0 BitCount = 0 ID = 102
+ 4.560373 1 64 Rx d 4 1C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.560385 1 11 Rx d 8 14 00 F9 0A 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 4.580185 1 64 Rx d 4 24 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.590144 1 64 Rx d 4 2C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.600191 1 64 Rx d 4 34 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.600219 1 11 Rx d 8 2C 00 CD 11 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 4.600293 1 64 Rx d 4 3C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.600307 1 65 Rx d 3 19 00 00 Length = 0 BitCount = 0 ID = 101
+ 4.600335 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 4.600346 1 10 Rx d 8 36 47 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 4.620191 1 64 Rx d 4 44 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.630170 1 64 Rx d 4 4C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.630202 1 11 Rx d 8 4F 00 4D 22 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 4.640194 1 64 Rx d 4 54 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.640338 1 64 Rx d 4 5C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.650180 1 64 Rx d 4 64 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.650215 1 11 Rx d 8 7B 00 20 1D 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 4.650237 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 4.650349 1 66 Rx d 1 02 Length = 0 BitCount = 0 ID = 102
+ 4.670204 1 64 Rx d 4 6C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.680196 1 64 Rx d 4 74 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.690196 1 64 Rx d 4 7C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.690216 1 11 Rx d 8 B1 00 64 16 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 4.690288 1 64 Rx d 4 84 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.710150 1 64 Rx d 4 8C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.710187 1 10 Rx d 8 1A 46 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 4.710208 1 12 Rx d 4 01 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 4.710224 1 65 Rx d 3 32 00 00 Length = 0 BitCount = 0 ID = 101
+ 4.720179 1 64 Rx d 4 94 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.720293 1 11 Rx d 8 F1 00 99 05 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 4.730133 1 64 Rx d 4 9C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.730167 1 64 Rx d 4 A4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.750198 1 64 Rx d 4 AC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.750232 1 11 Rx d 8 3A 01 D7 18 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 4.760140 1 64 Rx d 4 B4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.760173 1 66 Rx d 1 04 Length = 0 BitCount = 0 ID = 102
+ 4.760240 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 4.770140 1 64 Rx d 4 BC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.770174 1 64 Rx d 4 C4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.770197 1 11 Rx d 8 8D 01 DD 2C 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 4.790183 1 64 Rx d 4 CC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.800136 1 64 Rx d 4 D4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.810198 1 64 Rx d 4 DC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.810231 1 11 Rx d 8 E9 01 F1 14 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 4.810306 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 4.810320 1 65 Rx d 3 19 00 00 Length = 0 BitCount = 0 ID = 101
+ 4.810345 1 10 Rx d 8 EB 44 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 4.810374 1 64 Rx d 4 E4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.830181 1 64 Rx d 4 EC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.840222 1 64 Rx d 4 F4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.840254 1 11 Rx d 8 4F 02 F6 07 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 4.850262 1 64 Rx d 4 FC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.850399 1 64 Rx d 4 04 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.850413 1 66 Rx d 1 02 Length = 0 BitCount = 0 ID = 102
+ 4.850442 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 4.870188 1 11 Rx d 8 BE 02 F9 0A 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 4.870319 1 64 Rx d 4 0C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.880199 1 64 Rx d 4 14 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.890186 1 64 Rx d 4 1C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.900200 1 64 Rx d 4 24 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.900232 1 11 Rx d 8 36 03 CD 11 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 4.900255 1 64 Rx d 4 2C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.900274 1 10 Rx d 8 AB 43 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 4.900333 1 65 Rx d 3 01 00 00 Length = 0 BitCount = 0 ID = 101
+ 4.900379 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 4.920200 1 64 Rx d 4 34 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.930189 1 64 Rx d 4 3C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.930226 1 11 Rx d 8 B8 03 4D 22 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 4.930343 1 64 Rx d 4 44 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.940195 1 64 Rx d 4 4C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.960198 1 64 Rx d 4 54 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.960231 1 11 Rx d 8 42 04 20 1D 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 4.960253 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 4.960364 1 66 Rx d 1 04 Length = 0 BitCount = 0 ID = 102
+ 4.970188 1 64 Rx d 4 5C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.980200 1 64 Rx d 4 64 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.980360 1 64 Rx d 4 6C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 4.980377 1 11 Rx d 8 D5 04 64 16 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 5.000197 1 64 Rx d 4 74 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.010190 1 64 Rx d 4 7C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.010223 1 65 Rx d 3 19 00 00 Length = 0 BitCount = 0 ID = 101
+ 5.010289 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 5.010310 1 10 Rx d 8 59 42 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 5.020239 1 64 Rx d 4 64 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.020276 1 11 Rx d 8 71 05 99 05 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 5.020367 1 64 Rx d 4 6C 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.040200 1 64 Rx d 4 74 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.050214 1 64 Rx d 4 7C 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.050249 1 11 Rx d 8 15 06 D7 18 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 5.060174 1 64 Rx d 4 84 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.060206 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 5.060338 1 66 Rx d 1 02 Length = 0 BitCount = 0 ID = 102
+ 5.060374 1 64 Rx d 4 8C 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.080201 1 64 Rx d 4 94 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.080233 1 11 Rx d 8 C1 06 DD 2C 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 5.090209 1 64 Rx d 4 9C 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.100201 1 64 Rx d 4 A4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.100357 1 64 Rx d 4 AC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.100370 1 11 Rx d 8 76 07 F1 14 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 5.100377 1 65 Rx d 3 32 00 00 Length = 0 BitCount = 0 ID = 101
+ 5.100404 1 10 Rx d 8 F7 40 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 5.100433 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 5.120199 1 64 Rx d 4 B4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.130213 1 64 Rx d 4 BC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.140201 1 64 Rx d 4 C4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.140232 1 11 Rx d 8 32 08 F6 07 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 5.140341 1 64 Rx d 4 CC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.150214 1 64 Rx d 4 D4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.150251 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 5.150351 1 66 Rx d 1 04 Length = 0 BitCount = 0 ID = 102
+ 5.170256 1 11 Rx d 8 F7 08 F9 0A 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 5.170292 1 64 Rx d 4 DC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.180234 1 64 Rx d 4 E4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.190222 1 64 Rx d 4 EC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.190259 1 64 Rx d 4 F4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.190284 1 11 Rx d 8 C3 09 CD 11 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 5.210201 1 64 Rx d 4 FC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.210237 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 5.210344 1 10 Rx d 8 86 3F 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 5.210373 1 65 Rx d 3 19 00 00 Length = 0 BitCount = 0 ID = 101
+ 5.220196 1 64 Rx d 4 04 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.230215 1 64 Rx d 4 0C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.230373 1 11 Rx d 8 96 0A 4D 22 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 5.230426 1 64 Rx d 4 14 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.250211 1 64 Rx d 4 1C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.260116 1 64 Rx d 4 24 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.260139 1 11 Rx d 8 71 0B 20 1D 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 5.260154 1 66 Rx d 1 02 Length = 0 BitCount = 0 ID = 102
+ 5.260198 1 12 Rx d 4 01 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 5.270165 1 64 Rx d 4 2C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.270200 1 64 Rx d 4 34 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.290162 1 64 Rx d 4 3C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.290299 1 11 Rx d 8 53 0C 64 16 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 5.300164 1 64 Rx d 4 44 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.310223 1 64 Rx d 4 4C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.310257 1 65 Rx d 3 01 00 00 Length = 0 BitCount = 0 ID = 101
+ 5.310301 1 10 Rx d 8 06 3E 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 5.310340 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 5.310404 1 11 Rx d 8 3B 0D 99 05 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 5.310415 1 64 Rx d 4 54 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.330168 1 64 Rx d 4 5C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.340163 1 64 Rx d 4 64 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.350165 1 64 Rx d 4 6C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.350300 1 11 Rx d 8 2A 0E D7 18 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 5.350353 1 64 Rx d 4 74 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.350365 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 5.350373 1 66 Rx d 1 04 Length = 0 BitCount = 0 ID = 102
+ 5.370212 1 64 Rx d 4 7C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.380203 1 64 Rx d 4 84 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.380237 1 11 Rx d 8 1F 0F DD 2C 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 5.390213 1 64 Rx d 4 8C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.400203 1 64 Rx d 4 94 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.400242 1 64 Rx d 4 9C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.400266 1 11 Rx d 8 1A 10 F1 14 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 5.400283 1 65 Rx d 3 19 00 00 Length = 0 BitCount = 0 ID = 101
+ 5.400347 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 5.400410 1 10 Rx d 8 78 3C 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 5.420202 1 64 Rx d 4 A4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.430213 1 64 Rx d 4 AC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.440203 1 64 Rx d 4 B4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.440238 1 11 Rx d 8 1B 11 F6 07 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 5.440352 1 64 Rx d 4 BC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.460203 1 64 Rx d 4 C4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.460238 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 5.460344 1 66 Rx d 1 02 Length = 0 BitCount = 0 ID = 102
+ 5.470230 1 11 Rx d 8 22 12 F9 0A 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 5.470257 1 64 Rx d 4 CC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.480180 1 64 Rx d 4 D4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.480355 1 64 Rx d 4 DC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.500216 1 64 Rx d 4 E4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.500252 1 11 Rx d 8 2E 13 CD 11 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 5.510235 1 64 Rx d 4 EC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.510269 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 5.510291 1 10 Rx d 8 DE 3A 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 5.510349 1 65 Rx d 3 32 00 00 Length = 0 BitCount = 0 ID = 101
+ 5.510403 1 64 Rx d 4 F4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.520203 1 64 Rx d 4 FC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.520240 1 11 Rx d 8 3E 14 4D 22 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 5.540232 1 64 Rx d 4 04 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.550219 1 64 Rx d 4 0C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.560240 1 64 Rx d 4 14 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.560273 1 11 Rx d 8 54 15 20 1D 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 5.560385 1 66 Rx d 1 04 Length = 0 BitCount = 0 ID = 102
+ 5.560417 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 5.560477 1 64 Rx d 4 1C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.580241 1 64 Rx d 4 24 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.590253 1 64 Rx d 4 2C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.590290 1 11 Rx d 8 6E 16 64 16 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 5.600261 1 64 Rx d 4 34 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.600398 1 64 Rx d 4 3C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.600412 1 65 Rx d 3 19 00 00 Length = 0 BitCount = 0 ID = 101
+ 5.600439 1 10 Rx d 8 37 39 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 5.600467 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 5.620237 1 11 Rx d 8 8D 17 99 05 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 5.620368 1 64 Rx d 4 44 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.630250 1 64 Rx d 4 4C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.640286 1 64 Rx d 4 54 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.640323 1 64 Rx d 4 5C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.640346 1 11 Rx d 8 AF 18 D7 18 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 5.650275 1 64 Rx d 4 64 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.650312 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 5.650411 1 66 Rx d 1 02 Length = 0 BitCount = 0 ID = 102
+ 5.670301 1 64 Rx d 4 6C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.680244 1 64 Rx d 4 74 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.680281 1 11 Rx d 8 D5 19 DD 2C 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 5.680398 1 64 Rx d 4 7C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.690241 1 64 Rx d 4 84 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.710227 1 64 Rx d 4 8C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.710266 1 11 Rx d 8 FE 1A F1 14 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 5.710289 1 65 Rx d 3 01 00 00 Length = 0 BitCount = 0 ID = 101
+ 5.710355 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 5.710408 1 10 Rx d 8 86 37 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 5.720247 1 64 Rx d 4 94 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.730242 1 64 Rx d 4 9C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.730400 1 64 Rx d 4 A4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.730413 1 11 Rx d 8 2A 1C F6 07 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 5.750231 1 64 Rx d 4 AC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.760248 1 64 Rx d 4 B4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.760281 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 5.760303 1 66 Rx d 1 04 Length = 0 BitCount = 0 ID = 102
+ 5.770228 1 11 Rx d 8 59 1D F9 0A 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 5.770350 1 64 Rx d 4 BC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.770373 1 64 Rx d 4 C4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.790239 1 64 Rx d 4 CC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.800150 1 64 Rx d 4 D4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.800188 1 11 Rx d 8 8B 1E CD 11 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 5.810189 1 64 Rx d 4 DC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.810224 1 12 Rx d 4 01 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 5.810337 1 10 Rx d 8 CB 35 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 5.810367 1 65 Rx d 3 19 00 00 Length = 0 BitCount = 0 ID = 101
+ 5.810396 1 64 Rx d 4 E4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.830234 1 64 Rx d 4 EC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.830270 1 11 Rx d 8 BE 1F 4D 22 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 5.840299 1 64 Rx d 4 F4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.850194 1 64 Rx d 4 FC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.850341 1 64 Rx d 4 04 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.850354 1 11 Rx d 8 F4 20 20 1D 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 5.850362 1 66 Rx d 1 02 Length = 0 BitCount = 0 ID = 102
+ 5.850392 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 5.870185 1 64 Rx d 4 0C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.880196 1 64 Rx d 4 14 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.890274 1 64 Rx d 4 1C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.890311 1 11 Rx d 8 2B 22 64 16 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 5.890425 1 64 Rx d 4 24 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.900288 1 64 Rx d 4 2C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.900326 1 65 Rx d 3 32 00 00 Length = 0 BitCount = 0 ID = 101
+ 5.900394 1 10 Rx d 8 07 34 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 5.900429 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 5.920258 1 11 Rx d 8 63 23 99 05 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 5.920295 1 64 Rx d 4 34 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.930234 1 64 Rx d 4 3C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.940252 1 64 Rx d 4 44 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.940284 1 64 Rx d 4 4C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.940307 1 11 Rx d 8 9C 24 D7 18 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 5.960253 1 64 Rx d 4 54 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.960285 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 5.960389 1 66 Rx d 1 04 Length = 0 BitCount = 0 ID = 102
+ 5.970257 1 64 Rx d 4 5C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.980257 1 64 Rx d 4 64 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 5.980424 1 11 Rx d 8 D6 25 DD 2C 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 5.980476 1 64 Rx d 4 6C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.000260 1 64 Rx d 4 74 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.010259 1 64 Rx d 4 7C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.010291 1 11 Rx d 8 10 27 F1 14 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 6.010316 1 65 Rx d 3 19 00 00 Length = 0 BitCount = 0 ID = 101
+ 6.010375 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 6.010396 1 10 Rx d 8 3B 32 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 6.010437 1 64 Rx d 4 64 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.020264 1 64 Rx d 4 6C 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.040254 1 64 Rx d 4 74 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.040431 1 11 Rx d 8 4A 28 F6 07 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 6.050267 1 64 Rx d 4 7C 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.060287 1 64 Rx d 4 84 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.060329 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 6.060459 1 66 Rx d 1 02 Length = 0 BitCount = 0 ID = 102
+ 6.060490 1 11 Rx d 8 84 29 F9 0A 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 6.060501 1 64 Rx d 4 8C 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.080264 1 64 Rx d 4 94 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.090264 1 64 Rx d 4 9C 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.100264 1 64 Rx d 4 A4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.100426 1 11 Rx d 8 BD 2A CD 11 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 6.100478 1 64 Rx d 4 AC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.100490 1 10 Rx d 8 69 30 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 6.100516 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 6.100527 1 65 Rx d 3 01 00 00 Length = 0 BitCount = 0 ID = 101
+ 6.120259 1 64 Rx d 4 B4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.130240 1 64 Rx d 4 BC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.130278 1 11 Rx d 8 F5 2B 4D 22 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 6.140262 1 64 Rx d 4 C4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.140294 1 64 Rx d 4 CC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.150266 1 64 Rx d 4 D4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.150298 1 11 Rx d 8 2C 2D 20 1D 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 6.150320 1 66 Rx d 1 04 Length = 0 BitCount = 0 ID = 102
+ 6.150390 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 6.170276 1 64 Rx d 4 DC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.180295 1 64 Rx d 4 E4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.180332 1 64 Rx d 4 EC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.180356 1 11 Rx d 8 62 2E 64 16 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 6.190293 1 64 Rx d 4 F4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.210248 1 64 Rx d 4 FC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.210286 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 6.210397 1 65 Rx d 3 19 00 00 Length = 0 BitCount = 0 ID = 101
+ 6.210437 1 10 Rx d 8 91 2E 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 6.220267 1 64 Rx d 4 04 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.220301 1 11 Rx d 8 95 2F 99 05 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 6.230228 1 64 Rx d 4 0C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.230392 1 64 Rx d 4 14 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.250275 1 64 Rx d 4 1C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.250312 1 11 Rx d 8 C7 30 D7 18 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 6.260277 1 64 Rx d 4 24 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.260314 1 66 Rx d 1 02 Length = 0 BitCount = 0 ID = 102
+ 6.260390 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 6.260402 1 64 Rx d 4 2C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.270300 1 64 Rx d 4 34 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.270338 1 11 Rx d 8 F6 31 DD 2C 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 6.290288 1 64 Rx d 4 3C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.300282 1 64 Rx d 4 44 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.310272 1 64 Rx d 4 4C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.310305 1 11 Rx d 8 22 33 F1 14 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 6.310417 1 10 Rx d 8 B5 2C 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 6.310449 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 6.310511 1 65 Rx d 3 32 00 00 Length = 0 BitCount = 0 ID = 101
+ 6.310539 1 64 Rx d 4 54 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.330273 1 64 Rx d 4 5C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.340288 1 64 Rx d 4 64 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.340319 1 11 Rx d 8 4B 34 F6 07 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 6.350201 1 64 Rx d 4 6C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.350238 1 64 Rx d 4 74 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.350258 1 66 Rx d 1 04 Length = 0 BitCount = 0 ID = 102
+ 6.350266 1 12 Rx d 4 01 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 6.370218 1 64 Rx d 4 7C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.370357 1 11 Rx d 8 71 35 F9 0A 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 6.380217 1 64 Rx d 4 84 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.390218 1 64 Rx d 4 8C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.400189 1 64 Rx d 4 94 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.400212 1 11 Rx d 8 93 36 CD 11 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 6.400228 1 64 Rx d 4 9C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.400243 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 6.400303 1 65 Rx d 3 19 00 00 Length = 0 BitCount = 0 ID = 101
+ 6.400334 1 10 Rx d 8 D5 2A 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 6.420281 1 64 Rx d 4 A4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.430259 1 64 Rx d 4 AC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.430419 1 11 Rx d 8 B2 37 4D 22 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 6.430471 1 64 Rx d 4 B4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.440281 1 64 Rx d 4 BC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.460278 1 64 Rx d 4 C4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.460316 1 11 Rx d 8 CC 38 20 1D 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 6.460339 1 66 Rx d 1 02 Length = 0 BitCount = 0 ID = 102
+ 6.460410 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 6.470284 1 64 Rx d 4 CC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.480284 1 64 Rx d 4 D4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.480317 1 64 Rx d 4 DC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.480340 1 11 Rx d 8 E2 39 64 16 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 6.500285 1 64 Rx d 4 E4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.510262 1 64 Rx d 4 EC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.510296 1 10 Rx d 8 F3 28 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 6.510359 1 65 Rx d 3 01 00 00 Length = 0 BitCount = 0 ID = 101
+ 6.510415 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 6.510427 1 64 Rx d 4 F4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.510436 1 11 Rx d 8 F2 3A 99 05 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 6.520278 1 64 Rx d 4 FC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.540273 1 64 Rx d 4 04 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.550261 1 64 Rx d 4 0C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.550299 1 11 Rx d 8 FE 3B D7 18 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 6.560258 1 64 Rx d 4 14 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.560405 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 6.560469 1 66 Rx d 1 04 Length = 0 BitCount = 0 ID = 102
+ 6.560500 1 64 Rx d 4 1C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.580285 1 64 Rx d 4 24 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.580323 1 11 Rx d 8 05 3D DD 2C 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 6.590290 1 64 Rx d 4 2C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.600283 1 64 Rx d 4 34 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.600320 1 64 Rx d 4 3C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.600343 1 11 Rx d 8 06 3E F1 14 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 6.600359 1 65 Rx d 3 19 00 00 Length = 0 BitCount = 0 ID = 101
+ 6.600416 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 6.600427 1 10 Rx d 8 10 27 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 6.620260 1 64 Rx d 4 44 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.630273 1 64 Rx d 4 4C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.640290 1 64 Rx d 4 54 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.640326 1 11 Rx d 8 01 3F F6 07 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 6.640439 1 64 Rx d 4 5C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.650286 1 64 Rx d 4 64 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.650319 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 6.650449 1 66 Rx d 1 02 Length = 0 BitCount = 0 ID = 102
+ 6.670354 1 11 Rx d 8 F6 3F F9 0A 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 6.670389 1 64 Rx d 4 6C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.680295 1 64 Rx d 4 74 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.680459 1 64 Rx d 4 7C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.690274 1 64 Rx d 4 84 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.690306 1 11 Rx d 8 E5 40 CD 11 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 6.710273 1 64 Rx d 4 8C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.710311 1 10 Rx d 8 2D 25 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 6.710380 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 6.710451 1 65 Rx d 3 32 00 00 Length = 0 BitCount = 0 ID = 101
+ 6.720295 1 64 Rx d 4 94 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.730276 1 64 Rx d 4 9C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.730308 1 11 Rx d 8 CD 41 4D 22 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 6.730420 1 64 Rx d 4 A4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.750294 1 64 Rx d 4 AC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.760296 1 64 Rx d 4 B4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.760330 1 11 Rx d 8 AF 42 20 1D 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 6.760352 1 66 Rx d 1 04 Length = 0 BitCount = 0 ID = 102
+ 6.760414 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 6.760434 1 64 Rx d 4 BC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.770281 1 64 Rx d 4 C4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.790280 1 64 Rx d 4 CC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.790318 1 11 Rx d 8 8A 43 64 16 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 6.800301 1 64 Rx d 4 D4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.810282 1 64 Rx d 4 DC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.810447 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 6.810510 1 65 Rx d 3 19 00 00 Length = 0 BitCount = 0 ID = 101
+ 6.810539 1 10 Rx d 8 4B 23 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 6.810567 1 64 Rx d 4 E4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.810579 1 11 Rx d 8 5D 44 99 05 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 6.830296 1 64 Rx d 4 EC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.840298 1 64 Rx d 4 F4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.850278 1 64 Rx d 4 FC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.850309 1 11 Rx d 8 29 45 D7 18 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 6.850404 1 64 Rx d 4 04 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.850417 1 66 Rx d 1 02 Length = 0 BitCount = 0 ID = 102
+ 6.850450 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 6.870283 1 64 Rx d 4 0C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.870861 1 64 Rx d 4 14 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.870893 1 11 Rx d 8 EE 45 DD 2C 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 6.890260 1 64 Rx d 4 1C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.890295 1 64 Rx d 4 24 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.900196 1 64 Rx d 4 2C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.900215 1 11 Rx d 8 AA 46 F1 14 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 6.900225 1 10 Rx d 8 6B 21 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 6.900260 1 12 Rx d 4 01 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 6.900326 1 65 Rx d 3 01 00 00 Length = 0 BitCount = 0 ID = 101
+ 6.920201 1 64 Rx d 4 34 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.930203 1 64 Rx d 4 3C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.930351 1 64 Rx d 4 44 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.930363 1 11 Rx d 8 5F 47 F6 07 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 6.940201 1 64 Rx d 4 4C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.960203 1 64 Rx d 4 54 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.960231 1 66 Rx d 1 04 Length = 0 BitCount = 0 ID = 102
+ 6.960293 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 6.970202 1 64 Rx d 4 5C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.970229 1 11 Rx d 8 0B 48 F9 0A 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 6.980204 1 64 Rx d 4 64 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 6.980229 1 64 Rx d 4 6C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.000335 1 64 Rx d 4 74 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.000507 1 11 Rx d 8 AF 48 CD 11 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 7.010287 1 64 Rx d 4 7C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.010320 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 7.010343 1 65 Rx d 3 19 00 00 Length = 0 BitCount = 0 ID = 101
+ 7.010400 1 10 Rx d 8 8F 1F 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 7.010457 1 64 Rx d 4 64 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.020304 1 64 Rx d 4 6C 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.020339 1 11 Rx d 8 4B 49 4D 22 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 7.040311 1 64 Rx d 4 74 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.050320 1 64 Rx d 4 7C 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.060309 1 64 Rx d 4 84 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.060477 1 11 Rx d 8 DE 49 20 1D 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 7.060529 1 66 Rx d 1 02 Length = 0 BitCount = 0 ID = 102
+ 7.060560 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 7.060620 1 64 Rx d 4 8C 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.080310 1 64 Rx d 4 94 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.090297 1 64 Rx d 4 9C 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.090329 1 11 Rx d 8 68 4A 64 16 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 7.100292 1 64 Rx d 4 A4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.100312 1 64 Rx d 4 AC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.100328 1 65 Rx d 3 32 00 00 Length = 0 BitCount = 0 ID = 101
+ 7.100387 1 10 Rx d 8 B7 1D 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 7.100419 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 7.120312 1 11 Rx d 8 EA 4A 99 05 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 7.120444 1 64 Rx d 4 B4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.130326 1 64 Rx d 4 BC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.140333 1 64 Rx d 4 C4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.140370 1 64 Rx d 4 CC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.140394 1 11 Rx d 8 62 4B D7 18 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 7.150338 1 64 Rx d 4 D4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.150376 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 7.150480 1 66 Rx d 1 04 Length = 0 BitCount = 0 ID = 102
+ 7.170318 1 64 Rx d 4 DC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.180302 1 64 Rx d 4 E4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.180442 1 11 Rx d 8 D1 4B DD 2C 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 7.180498 1 64 Rx d 4 EC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.190295 1 64 Rx d 4 F4 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.210313 1 64 Rx d 4 FC 00 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.210347 1 11 Rx d 8 37 4C F1 14 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 7.210370 1 65 Rx d 3 19 00 00 Length = 0 BitCount = 0 ID = 101
+ 7.210430 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 7.210497 1 10 Rx d 8 E5 1B 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 7.220304 1 64 Rx d 4 04 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.230303 1 64 Rx d 4 0C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.230336 1 64 Rx d 4 14 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.230360 1 11 Rx d 8 93 4C F6 07 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 7.250319 1 64 Rx d 4 1C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.260301 1 64 Rx d 4 24 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.260335 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 7.260357 1 66 Rx d 1 02 Length = 0 BitCount = 0 ID = 102
+ 7.260418 1 11 Rx d 8 E6 4C F9 0A 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 7.260497 1 64 Rx d 4 2C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.270301 1 64 Rx d 4 34 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.290306 1 64 Rx d 4 3C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.300306 1 64 Rx d 4 44 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.300341 1 11 Rx d 8 2F 4D CD 11 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 7.310325 1 64 Rx d 4 4C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.310486 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 7.310548 1 10 Rx d 8 19 1A 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 7.310577 1 65 Rx d 3 01 00 00 Length = 0 BitCount = 0 ID = 101
+ 7.310605 1 64 Rx d 4 54 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.330337 1 64 Rx d 4 5C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.330375 1 11 Rx d 8 6F 4D 4D 22 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 7.340304 1 64 Rx d 4 64 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.350330 1 64 Rx d 4 6C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.350362 1 64 Rx d 4 74 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.350386 1 11 Rx d 8 A5 4D 20 1D 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 7.350404 1 66 Rx d 1 04 Length = 0 BitCount = 0 ID = 102
+ 7.350467 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 7.370323 1 64 Rx d 4 7C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.380343 1 64 Rx d 4 84 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.390331 1 64 Rx d 4 8C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.390368 1 11 Rx d 8 D1 4D 64 16 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 7.390484 1 64 Rx d 4 94 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.400313 1 64 Rx d 4 9C 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.400345 1 65 Rx d 3 19 00 00 Length = 0 BitCount = 0 ID = 101
+ 7.400406 1 10 Rx d 8 55 18 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 7.400462 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 7.420308 1 11 Rx d 8 F4 4D 99 05 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 7.420344 1 64 Rx d 4 A4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.430307 1 64 Rx d 4 AC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.430471 1 64 Rx d 4 B4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.440263 1 64 Rx d 4 BC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.440286 1 11 Rx d 8 0C 4E D7 18 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 7.460271 1 64 Rx d 4 C4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.460305 1 12 Rx d 4 01 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 7.460395 1 66 Rx d 1 02 Length = 0 BitCount = 0 ID = 102
+ 7.470270 1 64 Rx d 4 CC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.480274 1 64 Rx d 4 D4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.480307 1 11 Rx d 8 1B 4E DD 2C 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 7.480398 1 64 Rx d 4 DC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.500279 1 64 Rx d 4 E4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.510321 1 64 Rx d 4 EC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.510356 1 11 Rx d 8 20 4E F1 14 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 7.510371 1 65 Rx d 3 32 00 00 Length = 0 BitCount = 0 ID = 101
+ 7.510413 1 12 Rx d 4 00 00 00 00 Length = 0 BitCount = 0 ID = 18
+ 7.510426 1 10 Rx d 8 9A 16 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 7.510455 1 64 Rx d 4 F4 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.520273 1 64 Rx d 4 FC 01 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.540273 1 64 Rx d 4 04 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.540306 1 11 Rx d 8 1B 4E F6 07 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 7.550279 1 64 Rx d 4 0C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.560279 1 64 Rx d 4 14 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.560427 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 7.560491 1 66 Rx d 1 04 Length = 0 BitCount = 0 ID = 102
+ 7.560522 1 11 Rx d 8 0C 4E F9 0A 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 7.560534 1 64 Rx d 4 1C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.580317 1 64 Rx d 4 24 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.590327 1 64 Rx d 4 2C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.600338 1 64 Rx d 4 34 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.600371 1 11 Rx d 8 F4 4D CD 11 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 7.600492 1 64 Rx d 4 3C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.600510 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 7.600518 1 10 Rx d 8 E9 14 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 7.600546 1 65 Rx d 3 19 00 00 Length = 0 BitCount = 0 ID = 101
+ 7.620313 1 64 Rx d 4 44 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.630335 1 64 Rx d 4 4C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.630369 1 11 Rx d 8 D1 4D 4D 22 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 7.640340 1 64 Rx d 4 54 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.640372 1 64 Rx d 4 5C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.650332 1 64 Rx d 4 64 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.650364 1 11 Rx d 8 A5 4D 20 1D 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 7.650386 1 66 Rx d 1 02 Length = 0 BitCount = 0 ID = 102
+ 7.650450 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 7.670400 1 64 Rx d 4 6C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.680343 1 64 Rx d 4 74 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.680511 1 64 Rx d 4 7C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.680525 1 11 Rx d 8 6F 4D 64 16 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 7.690328 1 64 Rx d 4 84 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.710318 1 64 Rx d 4 8C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.710351 1 65 Rx d 3 01 00 00 Length = 0 BitCount = 0 ID = 101
+ 7.710419 1 10 Rx d 8 42 13 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 7.710479 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 7.720345 1 11 Rx d 8 2F 4D 99 05 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 7.720376 1 64 Rx d 4 94 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.720401 1 64 Rx d 4 9C 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.730346 1 64 Rx d 4 A4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.750372 1 64 Rx d 4 AC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.750536 1 11 Rx d 8 E6 4C D7 18 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 7.760370 1 64 Rx d 4 B4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.760408 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 7.760431 1 66 Rx d 1 04 Length = 0 BitCount = 0 ID = 102
+ 7.760479 1 64 Rx d 4 BC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.770375 1 64 Rx d 4 C4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.770413 1 11 Rx d 8 93 4C DD 2C 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 7.790333 1 64 Rx d 4 CC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.800344 1 64 Rx d 4 D4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.810334 1 64 Rx d 4 DC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.810496 1 11 Rx d 8 37 4C F1 14 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 7.810548 1 65 Rx d 3 19 00 00 Length = 0 BitCount = 0 ID = 101
+ 7.810577 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 7.810629 1 10 Rx d 8 A8 11 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 7.810658 1 64 Rx d 4 E4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.830335 1 64 Rx d 4 EC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.840350 1 64 Rx d 4 F4 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.840382 1 11 Rx d 8 D1 4B F6 07 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 7.850350 1 64 Rx d 4 FC 02 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.850381 1 64 Rx d 4 04 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.850410 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 7.850429 1 66 Rx d 1 02 Length = 0 BitCount = 0 ID = 102
+ 7.870348 1 11 Rx d 8 62 4B F9 0A 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 7.870470 1 64 Rx d 4 0C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.880353 1 64 Rx d 4 14 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.890353 1 64 Rx d 4 1C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.890391 1 64 Rx d 4 24 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.890416 1 11 Rx d 8 EA 4A CD 11 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 7.900349 1 64 Rx d 4 2C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.900381 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
+ 7.900501 1 10 Rx d 8 1A 10 00 00 00 00 00 00 Length = 0 BitCount = 0 ID = 16
+ 7.900533 1 65 Rx d 3 32 00 00 Length = 0 BitCount = 0 ID = 101
+ 7.920354 1 64 Rx d 4 34 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.930328 1 64 Rx d 4 3C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.930488 1 11 Rx d 8 68 4A 4D 22 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 7.930546 1 64 Rx d 4 44 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.940352 1 64 Rx d 4 4C 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.960354 1 64 Rx d 4 54 03 00 00 Length = 0 BitCount = 0 ID = 100
+ 7.960389 1 11 Rx d 8 DE 49 20 1D 00 00 00 00 Length = 0 BitCount = 0 ID = 17
+ 7.960411 1 66 Rx d 1 04 Length = 0 BitCount = 0 ID = 102
+ 7.960498 1 12 Rx d 4 00 01 00 00 Length = 0 BitCount = 0 ID = 18
diff --git a/test/data/issue_1299.asc b/test/data/issue_1299.asc
new file mode 100644
index 000000000..43c29302e
--- /dev/null
+++ b/test/data/issue_1299.asc
@@ -0,0 +1,11 @@
+date Thu Apr 28 10:44:52.480 am 2022
+base hex timestamps absolute
+internal events logged
+// version 12.0.0
+Begin TriggerBlock Thu Apr 28 10:44:52.480 am 2022
+ 0.000000 Start of measurement
+ 13.258199 1 180 Tx d 8 6A 00 00 00 00 00 00 00 Length = 244016 BitCount = 125 ID = 384
+ 13.258433 1 221 Tx d 8 C2 4A 05 81 00 00 15 10 Length = 228016 BitCount = 117 ID = 545
+ 13.258671 1 3FF Tx d D 55 AA 01 02 03 04 05 06 Length = 232016 BitCount = 119 ID = 1023
+ 13.258907 1 F4 Tx d 8 8A 1A 0D F2 13 00 00 07 Length = 230016 BitCount = 118 ID = 244
+End TriggerBlock
diff --git a/test/data/issue_1905.blf b/test/data/issue_1905.blf
new file mode 100644
index 000000000..a896a6d7c
Binary files /dev/null and b/test/data/issue_1905.blf differ
diff --git a/test/data/logfile.asc b/test/data/logfile.asc
index 8582cbf05..13274a4c4 100644
--- a/test/data/logfile.asc
+++ b/test/data/logfile.asc
@@ -1,28 +1,39 @@
-date Sam Sep 30 15:06:13.191 2017
-base hex timestamps absolute
-internal events logged
-// version 9.0.0
-Begin Triggerblock Sam Sep 30 15:06:13.191 2017
- 0.000000 Start of measurement
- 0.015991 CAN 1 Status:chip status error passive - TxErr: 132 RxErr: 0
- 0.015991 CAN 2 Status:chip status error active
- 1.015991 1 Statistic: D 0 R 0 XD 0 XR 0 E 0 O 0 B 0.00%
- 1.015991 2 Statistic: D 0 R 0 XD 0 XR 0 E 0 O 0 B 0.00%
- 2.015992 1 Statistic: D 0 R 0 XD 0 XR 0 E 0 O 0 B 0.00%
- 3.098426 1 18EBFF00x Rx d 8 01 A0 0F A6 60 3B D1 40 Length = 273910 BitCount = 141 ID = 418119424x
- 3.148421 1 18EBFF00x Rx d 8 02 1F DE 80 25 DF C0 2B Length = 271910 BitCount = 140 ID = 418119424x
- 3.197693 1 18EBFF00x Rx d 8 03 E1 00 4B FF FF 3C 0F Length = 283910 BitCount = 146 ID = 418119424x
- 3.248765 1 18EBFF00x Rx d 8 04 00 4B FF FF FF FF FF Length = 283910 BitCount = 146 ID = 418119424x
- 3.297743 1 J1939TP FEE3p 6 0 0 - Rx d 23 A0 0F A6 60 3B D1 40 1F DE 80 25 DF C0 2B E1 00 4B FF FF 3C 0F 00 4B FF FF FF FF FF FF FF FF FF FF FF FF
- 17.876707 CAN 1 Status:chip status error passive - TxErr: 131 RxErr: 0
- 17.876708 1 6F9 Rx d 8 05 0C 00 00 00 00 00 00 Length = 240015 BitCount = 124 ID = 1785
- 17.876976 1 6F8 Rx d 8 FF 00 0C FE 00 00 00 00 Length = 239910 BitCount = 124 ID = 1784
- 18.015997 1 Statistic: D 2 R 0 XD 0 XR 0 E 0 O 0 B 0.04%
- 20.105214 2 18EBFF00x Rx d 8 01 A0 0F A6 60 3B D1 40 Length = 273925 BitCount = 141 ID = 418119424x
- 20.155119 2 18EBFF00x Rx d 8 02 1F DE 80 25 DF C0 2B Length = 272152 BitCount = 140 ID = 418119424x
- 20.204671 2 18EBFF00x Rx d 8 03 E1 00 4B FF FF 3C 0F Length = 283910 BitCount = 146 ID = 418119424x
- 20.248887 2 18EBFF00x Rx d 8 04 00 4B FF FF FF FF FF Length = 283925 BitCount = 146 ID = 418119424x
- 20.305233 2 J1939TP FEE3p 6 0 0 - Rx d 23 A0 0F A6 60 3B D1 40 1F DE 80 25 DF C0 2B E1 00 4B FF FF 3C 0F 00 4B FF FF FF FF FF FF FF FF FF FF FF FF
- 113.016026 1 Statistic: D 0 R 0 XD 0 XR 0 E 0 O 0 B 0.00%
- 113.016026 2 Statistic: D 0 R 0 XD 0 XR 0 E 0 O 0 B 0.00%
-End TriggerBlock
+date Sam Sep 30 15:06:13.191 2017
+base hex timestamps absolute
+internal events logged
+// version 9.0.0
+//0.000000 previous log file: logfile_errorframes.asc
+Begin Triggerblock Sam Sep 30 15:06:13.191 2017
+ 0.000000 Start of measurement
+ 0.015991 CAN 1 Status:chip status error passive - TxErr: 132 RxErr: 0
+ 0.015991 CAN 2 Status:chip status error active
+ 1.015991 1 Statistic: D 0 R 0 XD 0 XR 0 E 0 O 0 B 0.00%
+ 1.015991 2 Statistic: D 0 R 0 XD 0 XR 0 E 0 O 0 B 0.00%
+ 2.015992 1 Statistic: D 0 R 0 XD 0 XR 0 E 0 O 0 B 0.00%
+ 2.501000 1 ErrorFrame
+ 2.501010 1 ErrorFrame ECC: 10100010
+ 2.501020 2 ErrorFrame Flags = 0xe CodeExt = 0x20a2 Code = 0x82 ID = 0 DLC = 0 Position = 5 Length = 11300
+ 2.510001 2 100 Tx r
+ 2.520002 3 200 Tx r Length = 1704000 BitCount = 145 ID = 88888888x
+ 2.584921 4 300 Tx r 8 Length = 1704000 BitCount = 145 ID = 88888888x
+ 3.098426 1 18EBFF00x Rx d 8 01 A0 0F A6 60 3B D1 40 Length = 273910 BitCount = 141 ID = 418119424x
+ 3.148421 1 18EBFF00x Rx d 8 02 1F DE 80 25 DF C0 2B Length = 271910 BitCount = 140 ID = 418119424x
+ 3.197693 1 18EBFF00x Rx d 8 03 E1 00 4B FF FF 3C 0F Length = 283910 BitCount = 146 ID = 418119424x
+ 3.248765 1 18EBFF00x Rx d 8 04 00 4B FF FF FF FF FF Length = 283910 BitCount = 146 ID = 418119424x
+ 3.297743 1 J1939TP FEE3p 6 0 0 - Rx d 23 A0 0F A6 60 3B D1 40 1F DE 80 25 DF C0 2B E1 00 4B FF FF 3C 0F 00 4B FF FF FF FF FF FF FF FF FF FF FF FF
+ 17.876707 CAN 1 Status:chip status error passive - TxErr: 131 RxErr: 0
+ 17.876708 1 6F9 Rx d 8 05 0C 00 00 00 00 00 00 Length = 240015 BitCount = 124 ID = 1785
+ 17.876976 1 6F8 Rx d 8 FF 00 0C FE 00 00 00 00 Length = 239910 BitCount = 124 ID = 1784
+ 18.015997 1 Statistic: D 2 R 0 XD 0 XR 0 E 0 O 0 B 0.04%
+ 20.105214 2 18EBFF00x Rx d 8 01 A0 0F A6 60 3B D1 40 Length = 273925 BitCount = 141 ID = 418119424x
+ 20.155119 2 18EBFF00x Rx d 8 02 1F DE 80 25 DF C0 2B Length = 272152 BitCount = 140 ID = 418119424x
+ 20.204671 2 18EBFF00x Rx d 8 03 E1 00 4B FF FF 3C 0F Length = 283910 BitCount = 146 ID = 418119424x
+ 20.248887 2 18EBFF00x Rx d 8 04 00 4B FF FF FF FF FF Length = 283925 BitCount = 146 ID = 418119424x
+ 20.305233 2 J1939TP FEE3p 6 0 0 - Rx d 23 A0 0F A6 60 3B D1 40 1F DE 80 25 DF C0 2B E1 00 4B FF FF 3C 0F 00 4B FF FF FF FF FF FF FF FF FF FF FF FF
+ 30.005071 CANFD 2 Rx 300 Generic_Name_12 1 0 8 8 01 02 03 04 05 06 07 08 102203 133 303000 e0006659 46500250 4b140250 20011736 2001040d
+ 30.300981 CANFD 3 Tx 50005x 0 0 5 0 140000 73 200050 7a60 46500250 460a0250 20011736 20010205
+ 30.506898 CANFD 4 Rx 4EE 0 0 f 64 01 02 03 04 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 64 1331984 11 0 46500250 460a0250 20011736 20010205
+ 30.806898 CANFD 5 Tx ErrorFrame Not Acknowledge error, dominant error flag fffe c7 31ca Arb. 556 44 0 0 f 64 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 1331984 11 0 46500250 460a0250 20011736 20010205
+ 113.016026 1 Statistic: D 0 R 0 XD 0 XR 0 E 0 O 0 B 0.00%
+ 113.016026 2 Statistic: D 0 R 0 XD 0 XR 0 E 0 O 0 B 0.00%
+End TriggerBlock
diff --git a/test/data/logfile_errorframes.asc b/test/data/logfile_errorframes.asc
new file mode 100644
index 000000000..6f751bfac
--- /dev/null
+++ b/test/data/logfile_errorframes.asc
@@ -0,0 +1,21 @@
+date Sam Sep 30 15:06:13.191 2017
+base hex timestamps absolute
+internal events logged
+// version 9.0.0
+Begin Triggerblock Sam Sep 30 15:06:13.191 2017
+ 0.000000 Start of measurement
+ 0.015991 CAN 1 Status:chip status error passive - TxErr: 132 RxErr: 0
+ 0.015991 CAN 2 Status:chip status error active
+ 2.501000 1 ErrorFrame
+ 2.501010 1 ErrorFrame ECC: 10100010
+ 2.501020 2 ErrorFrame Flags = 0xe CodeExt = 0x20a2 Code = 0x82 ID = 0 DLC = 0 Position = 5 Length = 11300
+ 2.520002 3 200 Tx r Length = 1704000 BitCount = 145 ID = 88888888x
+ 2.584921 4 300 Tx r 8 Length = 1704000 BitCount = 145 ID = 88888888x
+ 3.098426 1 18EBFF00x Rx d 8 01 A0 0F A6 60 3B D1 40 Length = 273910 BitCount = 141 ID = 418119424x
+ 3.197693 1 18EBFF00x Rx d 8 03 E1 00 4B FF FF 3C 0F Length = 283910 BitCount = 146 ID = 418119424x
+ 17.876976 1 6F8 Rx d 8 FF 00 0C FE 00 00 00 00 Length = 239910 BitCount = 124 ID = 1784
+ 20.105214 2 18EBFF00x Rx d 8 01 A0 0F A6 60 3B D1 40 Length = 273925 BitCount = 141 ID = 418119424x
+ 20.155119 2 18EBFF00x Rx d 8 02 1F DE 80 25 DF C0 2B Length = 272152 BitCount = 140 ID = 418119424x
+ 20.204671 2 18EBFF00x Rx d 8 03 E1 00 4B FF FF 3C 0F Length = 283910 BitCount = 146 ID = 418119424x
+ 20.248887 2 18EBFF00x Rx d 8 04 00 4B FF FF FF FF FF Length = 283925 BitCount = 146 ID = 418119424x
+End TriggerBlock
diff --git a/test/data/single_frame.asc b/test/data/single_frame.asc
new file mode 100644
index 000000000..cae9d1b4d
--- /dev/null
+++ b/test/data/single_frame.asc
@@ -0,0 +1,7 @@
+date Sat Sep 30 15:06:13.191 2017
+base hex timestamps absolute
+internal events logged
+Begin Triggerblock Sat Sep 30 15:06:13.191 2017
+ 0.000000 Start of measurement
+ 0.000000 1 123x Rx d 40 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F 20 21 22 23 24 25 26 27 28 29 2A 2B 2C 2D 2E 2F 30 31 32 33 34 35 36 37 38 39 3A 3B 3C 3D 3E 3F
+End TriggerBlock
diff --git a/test/data/single_frame_us_locale.asc b/test/data/single_frame_us_locale.asc
new file mode 100644
index 000000000..f6bfcc3db
--- /dev/null
+++ b/test/data/single_frame_us_locale.asc
@@ -0,0 +1,7 @@
+date Sat Sep 30 15:06:13.191 2017
+base hex timestamps absolute
+internal events logged
+Begin Triggerblock Sat Sep 30 15:06:13.191 2017
+ 0.000000 Start of measurement
+ 0.000000 1 123x Rx d 1 68
+End TriggerBlock
diff --git a/test/data/test_CanErrorFrames.asc b/test/data/test_CanErrorFrames.asc
new file mode 100644
index 000000000..0d400c18c
--- /dev/null
+++ b/test/data/test_CanErrorFrames.asc
@@ -0,0 +1,11 @@
+date Sam Sep 30 15:06:13.191 2017
+base hex timestamps absolute
+internal events logged
+// version 9.0.0
+Begin Triggerblock Sam Sep 30 15:06:13.191 2017
+ 0.000000 Start of measurement
+ 2.501000 1 ErrorFrame
+ 3.501000 1 ErrorFrame ECC: 10100010
+ 4.501000 2 ErrorFrame Flags = 0xe CodeExt = 0x20a2 Code = 0x82 ID = 0 DLC = 0 Position = 5 Length = 11300
+ 30.806898 CANFD 5 Tx ErrorFrame Not Acknowledge error, dominant error flag fffe c7 31ca Arb. 556 44 0 0 f 64 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 1331984 11 0 46500250 460a0250 20011736 20010205
+End TriggerBlock
diff --git a/test/data/test_CanFdMessage.asc b/test/data/test_CanFdMessage.asc
new file mode 100644
index 000000000..51fbcb1ce
--- /dev/null
+++ b/test/data/test_CanFdMessage.asc
@@ -0,0 +1,10 @@
+date Sam Sep 30 15:06:13.191 2017
+base hex timestamps absolute
+internal events logged
+// version 9.0.0
+Begin Triggerblock Sam Sep 30 15:06:13.191 2017
+ 0.000000 Start of measurement
+ 30.005021 CANFD 1 Rx 300 1 0 8 8 11 c2 03 04 05 06 07 08 102203 133 303000 e0006659 46500250 4b140250 20011736 2001040d
+ 30.005041 CANFD 2 Tx 1C4D80A7x 0 1 8 8 12 c2 03 04 05 06 07 08 102203 133 303000 e0006659 46500250 4b140250 20011736 2001040d
+ 30.005071 CANFD 3 Rx 30a Generic_Name_12 1 1 8 8 01 02 03 04 05 06 07 08 102203 133 303000 e0006659 46500250 4b140250 20011736 2001040d
+End TriggerBlock
diff --git a/test/data/test_CanFdMessage64.asc b/test/data/test_CanFdMessage64.asc
new file mode 100644
index 000000000..ab34ee7ae
--- /dev/null
+++ b/test/data/test_CanFdMessage64.asc
@@ -0,0 +1,9 @@
+date Sam Sep 30 15:06:13.191 2017
+base hex timestamps absolute
+internal events logged
+// version 9.0.0
+Begin Triggerblock Sam Sep 30 15:06:13.191 2017
+ 0.000000 Start of measurement
+ 30.506898 CANFD 4 Rx 4EE 0 1 f 64 A1 02 03 04 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 64 1331984 11 0 46500250 460a0250 20011736 20010205
+ 31.506898 CANFD 4 Rx 1C4D80A7x AlphaNumericName_2 1 0 f 64 b1 02 03 04 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 64 1331984 11 0 46500250 460a0250 20011736 20010205
+End TriggerBlock
diff --git a/test/data/test_CanFdRemoteMessage.asc b/test/data/test_CanFdRemoteMessage.asc
new file mode 100644
index 000000000..7c78f5d06
--- /dev/null
+++ b/test/data/test_CanFdRemoteMessage.asc
@@ -0,0 +1,8 @@
+date Sam Sep 30 15:06:13.191 2017
+base hex timestamps absolute
+internal events logged
+// version 9.0.0
+Begin Triggerblock Sam Sep 30 15:06:13.191 2017
+ 0.000000 Start of measurement
+ 30.300981 CANFD 3 Tx 50005x 0 1 5 0 140000 73 200050 7a60 46500250 460a0250 20011736 20010205
+End TriggerBlock
diff --git a/test/data/test_CanMessage.asc b/test/data/test_CanMessage.asc
new file mode 100644
index 000000000..881f16132
--- /dev/null
+++ b/test/data/test_CanMessage.asc
@@ -0,0 +1,9 @@
+date Sam Sep 30 15:06:13.191 2017
+base hex timestamps absolute
+internal events logged
+// version 9.0.0
+Begin Triggerblock Sat Sep 30 10:06:13.191 PM 2017
+ 0.000000 Start of measurement
+ 2.5010 2 C8 Tx d 8 09 08 07 06 05 04 03 02
+ 17.876708 1 6F9 Rx d 8 05 0C 00 00 00 00 00 00 Length = 240015 BitCount = 124 ID = 1785
+End TriggerBlock
diff --git a/test/data/test_CanMessage.asc.gz b/test/data/test_CanMessage.asc.gz
new file mode 100644
index 000000000..25375d1b8
Binary files /dev/null and b/test/data/test_CanMessage.asc.gz differ
diff --git a/test/data/test_CanMessage.trc b/test/data/test_CanMessage.trc
new file mode 100644
index 000000000..8b1361808
--- /dev/null
+++ b/test/data/test_CanMessage.trc
@@ -0,0 +1,23 @@
+;$FILEVERSION=2.1
+;$STARTTIME=43008.920986006946
+;$COLUMNS=N,O,T,B,I,d,R,L,D
+;
+; C:\Users\User\Desktop\python-can\test\data\test_CanMessage.trc
+; Start time: 30.09.2017 22:06:13.191.000
+; Generated by PEAK-Converter Version 2.2.4.136
+; Data imported from C:\Users\User\Desktop\python-can\test\data\test_CanMessage.asc
+;-------------------------------------------------------------------------------
+; Bus Name Connection Protocol
+; N/A N/A N/A N/A
+;-------------------------------------------------------------------------------
+; Message Time Type ID Rx/Tx
+; Number Offset | Bus [hex] | Reserved
+; | [ms] | | | | | Data Length Code
+; | | | | | | | | Data [hex] ...
+; | | | | | | | | |
+;---+-- ------+------ +- +- --+----- +- +- +--- +- -- -- -- -- -- -- --
+;Begin Triggerblock Sat Sep 30 10:06:13.191 PM 2017
+; 0.000000 Start of measurement
+ 1 2501.000 DT 2 00C8 Tx - 8 09 08 07 06 05 04 03 02
+ 2 17876.708 DT 1 06F9 Rx - 8 05 0C 00 00 00 00 00 00
+;End TriggerBlock
diff --git a/test/data/test_CanMessage_V1_0_BUS1.trc b/test/data/test_CanMessage_V1_0_BUS1.trc
new file mode 100644
index 000000000..c3905ae47
--- /dev/null
+++ b/test/data/test_CanMessage_V1_0_BUS1.trc
@@ -0,0 +1,29 @@
+;##########################################################################
+; C:\NewFileName_BUS1.trc
+;
+; CAN activities imported from C:\test_CanMessage_V1_1.trc
+; Start time: 18.12.2021 14:28:07.062
+; PCAN-Net: N/A
+; Generated by PEAK-Converter Version 3.0.4.594
+;
+; Columns description:
+; ~~~~~~~~~~~~~~~~~~~~~
+; +-current number in actual sample
+; | +time offset of message (ms)
+; | | +ID of message (hex)
+; | | | +data length code
+; | | | | +data bytes (hex) ...
+; | | | | |
+;----+- ---+--- ----+--- + -+ -- -- ...
+ 1) 17535 00000100 8 00 00 00 00 00 00 00 00
+ 2) 17540 FFFFFFFF 4 00 00 00 08 -- -- -- -- BUSHEAVY
+ 3) 17700 00000100 8 00 00 00 00 00 00 00 00
+ 4) 17873 00000100 8 00 00 00 00 00 00 00 00
+ 5) 19295 0000 8 00 00 00 00 00 00 00 00
+ 6) 19500 0000 8 00 00 00 00 00 00 00 00
+ 7) 19705 0000 8 00 00 00 00 00 00 00 00
+ 8) 20592 00000100 8 00 00 00 00 00 00 00 00
+ 9) 20798 00000100 8 00 00 00 00 00 00 00 00
+ 10) 20956 00000100 8 00 00 00 00 00 00 00 00
+ 11) 21097 00000100 8 00 00 00 00 00 00 00 00
+ 12) 48937 0704 1 RTR
\ No newline at end of file
diff --git a/test/data/test_CanMessage_V1_1.trc b/test/data/test_CanMessage_V1_1.trc
new file mode 100644
index 000000000..9a9cc7574
--- /dev/null
+++ b/test/data/test_CanMessage_V1_1.trc
@@ -0,0 +1,26 @@
+;$FILEVERSION=1.1
+;$STARTTIME=44548.6028595139
+;
+; Start time: 18.12.2021 14:28:07.062.0
+; Generated by PCAN-View v5.0.0.814
+;
+; Message Number
+; | Time Offset (ms)
+; | | Type
+; | | | ID (hex)
+; | | | | Data Length
+; | | | | | Data Bytes (hex) ...
+; | | | | | |
+;---+-- ----+---- --+-- ----+--- + -+ -- -- -- -- -- -- --
+ 1) 17535.4 Tx 00000100 8 00 00 00 00 00 00 00 00
+ 2) 17540.3 Warng FFFFFFFF 4 00 00 00 08 BUSHEAVY
+ 3) 17700.3 Tx 00000100 8 00 00 00 00 00 00 00 00
+ 4) 17873.8 Tx 00000100 8 00 00 00 00 00 00 00 00
+ 5) 19295.4 Tx 0000 8 00 00 00 00 00 00 00 00
+ 6) 19500.6 Tx 0000 8 00 00 00 00 00 00 00 00
+ 7) 19705.2 Tx 0000 8 00 00 00 00 00 00 00 00
+ 8) 20592.7 Tx 00000100 8 00 00 00 00 00 00 00 00
+ 9) 20798.6 Tx 00000100 8 00 00 00 00 00 00 00 00
+ 10) 20956.0 Tx 00000100 8 00 00 00 00 00 00 00 00
+ 11) 21097.1 Tx 00000100 8 00 00 00 00 00 00 00 00
+ 12) 48937.6 Rx 0704 1 RTR
diff --git a/test/data/test_CanMessage_V1_3.trc b/test/data/test_CanMessage_V1_3.trc
new file mode 100644
index 000000000..96db1748c
--- /dev/null
+++ b/test/data/test_CanMessage_V1_3.trc
@@ -0,0 +1,35 @@
+;$FILEVERSION=1.3
+;$STARTTIME=44548.6028595139
+; C:\NewFileName_V1_3.trc
+;
+; Start time: 18.12.2021 14:28:07.062.1
+;
+; Generated by PEAK-Converter Version 3.0.4.594
+; Data imported from C:\test_CanMessage_V1_1.trc
+;-------------------------------------------------------------------------------
+; Bus Name Connection Protocol
+; N/A N/A N/A CAN
+;-------------------------------------------------------------------------------
+; Message Number
+; | Time Offset (ms)
+; | | Bus
+; | | | Type
+; | | | | ID (hex)
+; | | | | | Reserved
+; | | | | | | Data Length Code
+; | | | | | | | Data Bytes (hex) ...
+; | | | | | | | |
+; | | | | | | | |
+;---+-- ------+------ +- --+-- ----+--- +- -+-- -+ -- -- -- -- -- -- --
+ 1) 17535.400 1 Tx 00000100 - 8 00 00 00 00 00 00 00 00
+ 2) 17540.300 1 Warng FFFFFFFF - 4 00 00 00 08 BUSHEAVY
+ 3) 17700.300 1 Tx 00000100 - 8 00 00 00 00 00 00 00 00
+ 4) 17873.800 1 Tx 00000100 - 8 00 00 00 00 00 00 00 00
+ 5) 19295.400 1 Tx 0000 - 8 00 00 00 00 00 00 00 00
+ 6) 19500.600 1 Tx 0000 - 8 00 00 00 00 00 00 00 00
+ 7) 19705.200 1 Tx 0000 - 8 00 00 00 00 00 00 00 00
+ 8) 20592.700 1 Tx 00000100 - 8 00 00 00 00 00 00 00 00
+ 9) 20798.600 1 Tx 00000100 - 8 00 00 00 00 00 00 00 00
+ 10) 20956.000 1 Tx 00000100 - 8 00 00 00 00 00 00 00 00
+ 11) 21097.100 1 Tx 00000100 - 8 00 00 00 00 00 00 00 00
+ 12) 48937.600 1 Rx 0704 - 1 RTR
diff --git a/test/data/test_CanMessage_V2_0_BUS1.trc b/test/data/test_CanMessage_V2_0_BUS1.trc
new file mode 100644
index 000000000..c1af8abc1
--- /dev/null
+++ b/test/data/test_CanMessage_V2_0_BUS1.trc
@@ -0,0 +1,29 @@
+;$FILEVERSION=2.0
+;$STARTTIME=44548.6028595139
+;$COLUMNS=N,O,T,I,d,l,D
+;
+; C:\test_CanMessage_V2_0_BUS1.trc
+; Start time: 18.12.2021 14:28:07.062.001
+; Generated by PEAK-Converter Version 3.0.4.594
+; Data imported from C:\test_CanMessage_V1_1.trc
+;-------------------------------------------------------------------------------
+; Connection Bit rate
+; N/A N/A
+;-------------------------------------------------------------------------------
+; Message Time Type ID Rx/Tx
+; Number Offset | [hex] | Data Length
+; | [ms] | | | | Data [hex] ...
+; | | | | | | |
+;---+-- ------+------ +- --+----- +- +- +- -- -- -- -- -- -- --
+ 1 17535.400 DT 00000100 Tx 8 00 00 00 00 00 00 00 00
+ 2 17540.300 ST Rx 00 00 00 08
+ 3 17700.300 DT 00000100 Tx 8 00 00 00 00 00 00 00 00
+ 4 17873.800 DT 00000100 Tx 8 00 00 00 00 00 00 00 00
+ 5 19295.400 DT 0000 Tx 8 00 00 00 00 00 00 00 00
+ 6 19500.600 DT 0000 Tx 8 00 00 00 00 00 00 00 00
+ 7 19705.200 DT 0000 Tx 8 00 00 00 00 00 00 00 00
+ 8 20592.700 DT 00000100 Tx 8 00 00 00 00 00 00 00 00
+ 9 20798.600 DT 00000100 Tx 8 00 00 00 00 00 00 00 00
+ 10 20956.000 DT 00000100 Tx 8 00 00 00 00 00 00 00 00
+ 11 21097.100 DT 00000100 Tx 8 00 00 00 00 00 00 00 00
+ 12 48937.600 RR 0704 Rx 1
\ No newline at end of file
diff --git a/test/data/test_CanMessage_V2_1.trc b/test/data/test_CanMessage_V2_1.trc
new file mode 100644
index 000000000..0d259f084
--- /dev/null
+++ b/test/data/test_CanMessage_V2_1.trc
@@ -0,0 +1,30 @@
+;$FILEVERSION=2.1
+;$STARTTIME=44548.6028595139
+;$COLUMNS=N,O,T,B,I,d,R,L,D
+;
+; C:\test_CanMessage_V2_1.trc
+; Start time: 18.12.2021 14:28:07.062.001
+; Generated by PEAK-Converter Version 3.0.4.594
+; Data imported from C:\test_CanMessage_V1_1.trc
+;-------------------------------------------------------------------------------
+; Bus Name Connection Protocol
+; N/A N/A N/A N/A
+;-------------------------------------------------------------------------------
+; Message Time Type ID Rx/Tx
+; Number Offset | Bus [hex] | Reserved
+; | [ms] | | | | | Data Length Code
+; | | | | | | | | Data [hex] ...
+; | | | | | | | | |
+;---+-- ------+------ +- +- --+----- +- +- +--- +- -- -- -- -- -- -- --
+ 1 17535.400 DT 1 00000100 Tx - 8 00 00 00 00 00 00 00 00
+ 2 17540.300 ST 1 - Rx - 4 00 00 00 08
+ 3 17700.300 DT 1 00000100 Tx - 8 00 00 00 00 00 00 00 00
+ 4 17873.800 DT 1 00000100 Tx - 8 00 00 00 00 00 00 00 00
+ 5 19295.400 DT 1 0000 Tx - 8 00 00 00 00 00 00 00 00
+ 6 19500.600 DT 1 0000 Tx - 8 00 00 00 00 00 00 00 00
+ 7 19705.200 DT 1 0000 Tx - 8 00 00 00 00 00 00 00 00
+ 8 20592.700 DT 1 00000100 Tx - 8 00 00 00 00 00 00 00 00
+ 9 20798.600 DT 1 00000100 Tx - 8 00 00 00 00 00 00 00 00
+ 10 20956.000 DT 1 00000100 Tx - 8 00 00 00 00 00 00 00 00
+ 11 21097.100 DT 1 00000100 Tx - 8 00 00 00 00 00 00 00 00
+ 12 48937.600 RR 1 0704 Rx - 1
\ No newline at end of file
diff --git a/test/data/test_CanRemoteMessage.asc b/test/data/test_CanRemoteMessage.asc
new file mode 100644
index 000000000..4e6431576
--- /dev/null
+++ b/test/data/test_CanRemoteMessage.asc
@@ -0,0 +1,10 @@
+date Sam Sep 30 15:06:13.191 2017
+base hex timestamps absolute
+internal events logged
+// version 9.0.0
+Begin Triggerblock Sam Sep 30 15:06:13.191 2017
+ 0.000000 Start of measurement
+ 2.510001 2 100 Rx r
+ 2.520002 3 200 Tx r Length = 1704000 BitCount = 145 ID = 88888888x
+ 2.584921 4 300 Rx r 8 Length = 1704000 BitCount = 145 ID = 88888888x
+End TriggerBlock
diff --git a/test/listener_test.py b/test/listener_test.py
index 6d24df190..bbcbed56e 100644
--- a/test/listener_test.py
+++ b/test/listener_test.py
@@ -1,23 +1,19 @@
#!/usr/bin/env python
-# coding: utf-8
-"""
-"""
-
-import unittest
-import random
+""" """
+import asyncio
import logging
-import tempfile
import os
-from os.path import join, dirname
+import random
+import tempfile
+import unittest
+import warnings
+from os.path import dirname, join
import can
from .data.example_data import generate_message
-channel = "virtual_channel_0"
-can.rc["interface"] = "virtual"
-
logging.basicConfig(level=logging.DEBUG)
# makes the random number generator deterministic
@@ -55,10 +51,15 @@ def testClassesImportable(self):
class BusTest(unittest.TestCase):
def setUp(self):
+ # Save all can.rc defaults
+ self._can_rc = can.rc
+ can.rc = {"interface": "virtual"}
self.bus = can.interface.Bus()
def tearDown(self):
self.bus.shutdown()
+ # Restore the defaults
+ can.rc = self._can_rc
class ListenerTest(BusTest):
@@ -86,7 +87,7 @@ def testRemoveListenerFromNotifier(self):
def testPlayerTypeResolution(self):
def test_filetype_to_instance(extension, klass):
- print("testing: {}".format(extension))
+ print(f"testing: {extension}")
try:
if extension == ".blf":
delete = False
@@ -121,7 +122,7 @@ def testPlayerTypeResolutionUnsupportedFileTypes(self):
def testLoggerTypeResolution(self):
def test_filetype_to_instance(extension, klass):
- print("testing: {}".format(extension))
+ print(f"testing: {extension}")
try:
with tempfile.NamedTemporaryFile(
suffix=extension, delete=False
@@ -157,5 +158,22 @@ def testBufferedListenerReceives(self):
self.assertIsNotNone(a_listener.get_message(0.1))
+def test_deprecated_loop_arg(recwarn):
+ try:
+ loop = asyncio.get_running_loop()
+ except RuntimeError:
+ loop = asyncio.new_event_loop()
+
+ warnings.simplefilter("always")
+ can.AsyncBufferedReader(loop=loop)
+ assert len(recwarn) > 0
+ assert recwarn.pop(DeprecationWarning)
+ recwarn.clear()
+
+ # assert that no warning is shown when loop argument is not used
+ can.AsyncBufferedReader()
+ assert len(recwarn) == 0
+
+
if __name__ == "__main__":
unittest.main()
diff --git a/test/logformats_test.py b/test/logformats_test.py
index 3bc2695bb..f8a8de91d 100644
--- a/test/logformats_test.py
+++ b/test/logformats_test.py
@@ -1,5 +1,4 @@
#!/usr/bin/env python
-# coding: utf-8
"""
This test module test the separate reader/writer combinations of the can.io.*
@@ -11,30 +10,99 @@
comments.
TODO: correctly set preserves_channel and adds_default_channel
-TODO: implement CAN FD support testing
"""
-
+import locale
import logging
-import unittest
-import tempfile
import os
-from abc import abstractmethod, ABCMeta
+import tempfile
+import unittest
+from abc import ABCMeta, abstractmethod
+from contextlib import contextmanager
+from datetime import datetime
from itertools import zip_longest
+from pathlib import Path
+from unittest.mock import patch
-import can
+from parameterized import parameterized
+import can
+from can.io import blf
from .data.example_data import (
+ TEST_COMMENTS,
TEST_MESSAGES_BASE,
- TEST_MESSAGES_REMOTE_FRAMES,
- TEST_MESSAGES_ERROR_FRAMES,
TEST_MESSAGES_CAN_FD,
- TEST_COMMENTS,
+ TEST_MESSAGES_ERROR_FRAMES,
+ TEST_MESSAGES_REMOTE_FRAMES,
sort_messages,
)
from .message_helper import ComparingMessagesTestCase
logging.basicConfig(level=logging.DEBUG)
+try:
+ import asammdf
+except ModuleNotFoundError:
+ asammdf = None
+
+
+@contextmanager
+def override_locale(category: int, locale_str: str) -> None:
+ prev_locale = locale.getlocale(category)
+ locale.setlocale(category, locale_str)
+ yield
+ locale.setlocale(category, prev_locale)
+
+
+class ReaderWriterExtensionTest(unittest.TestCase):
+ def _get_suffix_case_variants(self, suffix):
+ return [
+ suffix.upper(),
+ suffix.lower(),
+ f"can.msg.ext{suffix}",
+ "".join([c.upper() if i % 2 else c for i, c in enumerate(suffix)]),
+ ]
+
+ def _test_extension(self, suffix):
+ WriterType = can.io.MESSAGE_WRITERS.get(suffix)
+ ReaderType = can.io.MESSAGE_READERS.get(suffix)
+ for suffix_variant in self._get_suffix_case_variants(suffix):
+ tmp_file = tempfile.NamedTemporaryFile(suffix=suffix_variant, delete=False)
+ tmp_file.close()
+ try:
+ if WriterType:
+ with can.Logger(tmp_file.name) as logger:
+ assert type(logger) == WriterType
+ if ReaderType:
+ with can.LogReader(tmp_file.name) as player:
+ assert type(player) == ReaderType
+ finally:
+ os.remove(tmp_file.name)
+
+ def test_extension_matching_asc(self):
+ self._test_extension(".asc")
+
+ def test_extension_matching_blf(self):
+ self._test_extension(".blf")
+
+ def test_extension_matching_csv(self):
+ self._test_extension(".csv")
+
+ def test_extension_matching_db(self):
+ self._test_extension(".db")
+
+ def test_extension_matching_log(self):
+ self._test_extension(".log")
+
+ def test_extension_matching_txt(self):
+ self._test_extension(".txt")
+
+ def test_extension_matching_mf4(self):
+ try:
+ self._test_extension(".mf4")
+ except NotImplementedError:
+ if asammdf is not None:
+ raise
+
class ReaderWriterTest(unittest.TestCase, ComparingMessagesTestCase, metaclass=ABCMeta):
"""Tests a pair of writer and reader by writing all data first and
@@ -69,6 +137,7 @@ def _setup_instance_helper(
allowed_timestamp_delta=0.0,
preserves_channel=True,
adds_default_channel=None,
+ assert_file_closed=True,
):
"""
:param Callable writer_constructor: the constructor of the writer class
@@ -110,7 +179,7 @@ def _setup_instance_helper(
]
assert (
"log_event" in attrs
- ), "cannot check comments with this writer: {}".format(writer_constructor)
+ ), f"cannot check comments with this writer: {writer_constructor}"
# get all test comments
self.original_comments = TEST_COMMENTS if check_comments else ()
@@ -119,6 +188,7 @@ def _setup_instance_helper(
self.reader_constructor = reader_constructor
self.binary_file = binary_file
self.test_append_enabled = test_append
+ self.assert_file_closed = assert_file_closed
ComparingMessagesTestCase.__init__(
self,
@@ -144,7 +214,7 @@ def test_path_like_explicit_stop(self):
self._write_all(writer)
self._ensure_fsync(writer)
writer.stop()
- if hasattr(writer.file, "closed"):
+ if self.assert_file_closed:
self.assertTrue(writer.file.closed)
print("reading all messages")
@@ -152,7 +222,7 @@ def test_path_like_explicit_stop(self):
read_messages = list(reader)
# redundant, but this checks if stop() can be called multiple times
reader.stop()
- if hasattr(writer.file, "closed"):
+ if self.assert_file_closed:
self.assertTrue(writer.file.closed)
# check if at least the number of messages matches
@@ -175,7 +245,7 @@ def test_path_like_context_manager(self):
self._write_all(writer)
self._ensure_fsync(writer)
w = writer
- if hasattr(w.file, "closed"):
+ if self.assert_file_closed:
self.assertTrue(w.file.closed)
# read all written messages
@@ -183,7 +253,7 @@ def test_path_like_context_manager(self):
with self.reader_constructor(self.test_file_name) as reader:
read_messages = list(reader)
r = reader
- if hasattr(r.file, "closed"):
+ if self.assert_file_closed:
self.assertTrue(r.file.closed)
# check if at least the number of messages matches;
@@ -206,7 +276,7 @@ def test_file_like_explicit_stop(self):
self._write_all(writer)
self._ensure_fsync(writer)
writer.stop()
- if hasattr(my_file, "closed"):
+ if self.assert_file_closed:
self.assertTrue(my_file.closed)
print("reading all messages")
@@ -215,7 +285,7 @@ def test_file_like_explicit_stop(self):
read_messages = list(reader)
# redundant, but this checks if stop() can be called multiple times
reader.stop()
- if hasattr(my_file, "closed"):
+ if self.assert_file_closed:
self.assertTrue(my_file.closed)
# check if at least the number of messages matches
@@ -239,7 +309,7 @@ def test_file_like_context_manager(self):
self._write_all(writer)
self._ensure_fsync(writer)
w = writer
- if hasattr(my_file, "closed"):
+ if self.assert_file_closed:
self.assertTrue(my_file.closed)
# read all written messages
@@ -248,7 +318,7 @@ def test_file_like_context_manager(self):
with self.reader_constructor(my_file) as reader:
read_messages = list(reader)
r = reader
- if hasattr(my_file, "closed"):
+ if self.assert_file_closed:
self.assertTrue(my_file.closed)
# check if at least the number of messages matches;
@@ -281,12 +351,12 @@ def test_append_mode(self):
# use append mode for second half
try:
writer = self.writer_constructor(self.test_file_name, append=True)
- except TypeError as e:
+ except ValueError as e:
# maybe "append" is not a formal parameter (this is the case for SqliteWriter)
try:
writer = self.writer_constructor(self.test_file_name)
except TypeError:
- # is the is still a problem, raise the initial error
+ # if it is still a problem, raise the initial error
raise e
with writer:
for message in second_part:
@@ -312,7 +382,7 @@ def _write_all(self, writer):
writer(msg)
def _ensure_fsync(self, io_handler):
- if hasattr(io_handler.file, "fileno"):
+ if hasattr(io_handler, "file") and hasattr(io_handler.file, "fileno"):
io_handler.file.flush()
os.fsync(io_handler.file.fileno())
@@ -334,20 +404,320 @@ def assertIncludesComments(self, filename):
class TestAscFileFormat(ReaderWriterTest):
"""Tests can.ASCWriter and can.ASCReader"""
+ FORMAT_START_OF_FILE_DATE = "%a %b %d %I:%M:%S.%f %p %Y"
+
def _setup_instance(self):
super()._setup_instance_helper(
can.ASCWriter,
can.ASCReader,
- check_fd=False,
+ check_fd=True,
check_comments=True,
preserves_channel=False,
adds_default_channel=0,
)
+ def _get_logfile_location(self, filename: str) -> Path:
+ my_dir = Path(__file__).parent
+ return my_dir / "data" / filename
+
+ def _read_log_file(self, filename, **kwargs):
+ logfile = self._get_logfile_location(filename)
+ with can.ASCReader(logfile, **kwargs) as reader:
+ return list(reader)
+
+ def test_read_absolute_time(self):
+ time_from_file = "Sat Sep 30 10:06:13.191 PM 2017"
+ start_time = datetime.strptime(
+ time_from_file, self.FORMAT_START_OF_FILE_DATE
+ ).timestamp()
+
+ expected_messages = [
+ can.Message(
+ timestamp=2.5010 + start_time,
+ arbitration_id=0xC8,
+ is_extended_id=False,
+ is_rx=False,
+ channel=1,
+ dlc=8,
+ data=[9, 8, 7, 6, 5, 4, 3, 2],
+ ),
+ can.Message(
+ timestamp=17.876708 + start_time,
+ arbitration_id=0x6F9,
+ is_extended_id=False,
+ channel=0,
+ dlc=0x8,
+ data=[5, 0xC, 0, 0, 0, 0, 0, 0],
+ ),
+ ]
+ actual = self._read_log_file("test_CanMessage.asc", relative_timestamp=False)
+ self.assertMessagesEqual(actual, expected_messages)
+
+ def test_read_can_message(self):
+ expected_messages = [
+ can.Message(
+ timestamp=2.5010,
+ arbitration_id=0xC8,
+ is_extended_id=False,
+ is_rx=False,
+ channel=1,
+ dlc=8,
+ data=[9, 8, 7, 6, 5, 4, 3, 2],
+ ),
+ can.Message(
+ timestamp=17.876708,
+ arbitration_id=0x6F9,
+ is_extended_id=False,
+ channel=0,
+ dlc=0x8,
+ data=[5, 0xC, 0, 0, 0, 0, 0, 0],
+ ),
+ ]
+ actual = self._read_log_file("test_CanMessage.asc")
+ self.assertMessagesEqual(actual, expected_messages)
+
+ def test_read_can_remote_message(self):
+ expected_messages = [
+ can.Message(
+ timestamp=2.510001,
+ arbitration_id=0x100,
+ is_extended_id=False,
+ channel=1,
+ is_remote_frame=True,
+ ),
+ can.Message(
+ timestamp=2.520002,
+ arbitration_id=0x200,
+ is_extended_id=False,
+ is_rx=False,
+ channel=2,
+ is_remote_frame=True,
+ ),
+ can.Message(
+ timestamp=2.584921,
+ arbitration_id=0x300,
+ is_extended_id=False,
+ channel=3,
+ dlc=8,
+ is_remote_frame=True,
+ ),
+ ]
+ actual = self._read_log_file("test_CanRemoteMessage.asc")
+ self.assertMessagesEqual(actual, expected_messages)
+
+ def test_read_can_fd_remote_message(self):
+ expected_messages = [
+ can.Message(
+ timestamp=30.300981,
+ arbitration_id=0x50005,
+ channel=2,
+ dlc=5,
+ is_rx=False,
+ is_fd=True,
+ is_remote_frame=True,
+ error_state_indicator=True,
+ )
+ ]
+ actual = self._read_log_file("test_CanFdRemoteMessage.asc")
+ self.assertMessagesEqual(actual, expected_messages)
+
+ def test_read_can_fd_message(self):
+ expected_messages = [
+ can.Message(
+ timestamp=30.005021,
+ arbitration_id=0x300,
+ is_extended_id=False,
+ channel=0,
+ dlc=8,
+ data=[0x11, 0xC2, 3, 4, 5, 6, 7, 8],
+ is_fd=True,
+ bitrate_switch=True,
+ ),
+ can.Message(
+ timestamp=30.005041,
+ arbitration_id=0x1C4D80A7,
+ channel=1,
+ dlc=8,
+ is_rx=False,
+ data=[0x12, 0xC2, 3, 4, 5, 6, 7, 8],
+ is_fd=True,
+ error_state_indicator=True,
+ ),
+ can.Message(
+ timestamp=30.005071,
+ arbitration_id=0x30A,
+ is_extended_id=False,
+ channel=2,
+ dlc=8,
+ data=[1, 2, 3, 4, 5, 6, 7, 8],
+ is_fd=True,
+ bitrate_switch=True,
+ error_state_indicator=True,
+ ),
+ ]
+ actual = self._read_log_file("test_CanFdMessage.asc")
+ self.assertMessagesEqual(actual, expected_messages)
+
+ def test_read_can_fd_message_64(self):
+ expected_messages = [
+ can.Message(
+ timestamp=30.506898,
+ arbitration_id=0x4EE,
+ is_extended_id=False,
+ channel=3,
+ dlc=64,
+ data=[0xA1, 2, 3, 4] + 59 * [0] + [0x64],
+ is_fd=True,
+ error_state_indicator=True,
+ ),
+ can.Message(
+ timestamp=31.506898,
+ arbitration_id=0x1C4D80A7,
+ channel=3,
+ dlc=64,
+ data=[0xB1, 2, 3, 4] + 59 * [0] + [0x64],
+ is_fd=True,
+ bitrate_switch=True,
+ ),
+ ]
+ actual = self._read_log_file("test_CanFdMessage64.asc")
+ self.assertMessagesEqual(actual, expected_messages)
+
+ def test_read_can_and_canfd_error_frames(self):
+ expected_messages = [
+ can.Message(timestamp=2.501000, channel=0, is_error_frame=True),
+ can.Message(timestamp=3.501000, channel=0, is_error_frame=True),
+ can.Message(timestamp=4.501000, channel=1, is_error_frame=True),
+ can.Message(
+ timestamp=30.806898,
+ channel=4,
+ is_rx=False,
+ is_error_frame=True,
+ is_fd=True,
+ ),
+ ]
+ actual = self._read_log_file("test_CanErrorFrames.asc")
+ self.assertMessagesEqual(actual, expected_messages)
+
+ def test_read_ignore_comments(self):
+ _msg_list = self._read_log_file("logfile.asc")
+
+ def test_read_no_triggerblock(self):
+ _msg_list = self._read_log_file("issue_1256.asc")
+
+ def test_read_can_dlc_greater_than_8(self):
+ _msg_list = self._read_log_file("issue_1299.asc")
+
+ def test_read_error_frame_channel(self):
+ # gh-issue 1578
+ err_frame = can.Message(is_error_frame=True, channel=4)
+
+ temp_file = tempfile.NamedTemporaryFile("w", delete=False)
+ temp_file.close()
+
+ try:
+ with can.ASCWriter(temp_file.name) as writer:
+ writer.on_message_received(err_frame)
+
+ with can.ASCReader(temp_file.name) as reader:
+ msg_list = list(reader)
+ assert len(msg_list) == 1
+ assert err_frame.equals(
+ msg_list[0], check_channel=True
+ ), f"{err_frame!r}!={msg_list[0]!r}"
+ finally:
+ os.unlink(temp_file.name)
+
+ def test_write_millisecond_handling(self):
+ now = datetime(
+ year=2017, month=9, day=30, hour=15, minute=6, second=13, microsecond=191456
+ )
+
+ # We temporarily set the locale to C to ensure test reproducibility
+ with override_locale(category=locale.LC_TIME, locale_str="C"):
+ # We mock datetime.now during ASCWriter __init__ for reproducibility
+ # Unfortunately, now() is a readonly attribute, so we mock datetime
+ with patch("can.io.asc.datetime") as mock_datetime:
+ mock_datetime.now.return_value = now
+ writer = can.ASCWriter(self.test_file_name)
+
+ msg = can.Message(
+ timestamp=now.timestamp(), arbitration_id=0x123, data=b"h"
+ )
+ writer.on_message_received(msg)
+
+ writer.stop()
+
+ actual_file = Path(self.test_file_name)
+ expected_file = self._get_logfile_location("single_frame_us_locale.asc")
+
+ self.assertEqual(expected_file.read_text(), actual_file.read_text())
+
+ def test_write(self):
+ now = datetime(
+ year=2017, month=9, day=30, hour=15, minute=6, second=13, microsecond=191456
+ )
+
+ # We temporarily set the locale to C to ensure test reproducibility
+ with override_locale(category=locale.LC_TIME, locale_str="C"):
+ # We mock datetime.now during ASCWriter __init__ for reproducibility
+ # Unfortunately, now() is a readonly attribute, so we mock datetime
+ with patch("can.io.asc.datetime") as mock_datetime:
+ mock_datetime.now.return_value = now
+ writer = can.ASCWriter(self.test_file_name)
+
+ msg = can.Message(
+ timestamp=now.timestamp(),
+ arbitration_id=0x123,
+ data=range(64),
+ )
+
+ with writer:
+ writer.on_message_received(msg)
+
+ actual_file = Path(self.test_file_name)
+ expected_file = self._get_logfile_location("single_frame.asc")
+
+ self.assertEqual(expected_file.read_text(), actual_file.read_text())
+
+ @parameterized.expand(
+ [
+ (
+ "May 27 04:09:35.000 pm 2014",
+ datetime(2014, 5, 27, 16, 9, 35, 0).timestamp(),
+ ),
+ (
+ "Mai 27 04:09:35.000 pm 2014",
+ datetime(2014, 5, 27, 16, 9, 35, 0).timestamp(),
+ ),
+ (
+ "Apr 28 10:44:52.480 2022",
+ datetime(2022, 4, 28, 10, 44, 52, 480000).timestamp(),
+ ),
+ (
+ "Sep 30 15:06:13.191 2017",
+ datetime(2017, 9, 30, 15, 6, 13, 191000).timestamp(),
+ ),
+ (
+ "Sep 30 15:06:13.191 pm 2017",
+ datetime(2017, 9, 30, 15, 6, 13, 191000).timestamp(),
+ ),
+ (
+ "Sep 30 15:06:13.191 am 2017",
+ datetime(2017, 9, 30, 15, 6, 13, 191000).timestamp(),
+ ),
+ ]
+ )
+ def test_datetime_to_timestamp(
+ self, datetime_string: str, expected_timestamp: float
+ ):
+ timestamp = can.ASCReader._datetime_to_timestamp(datetime_string)
+ self.assertAlmostEqual(timestamp, expected_timestamp)
+
class TestBlfFileFormat(ReaderWriterTest):
"""Tests can.BLFWriter and can.BLFReader.
-
+
Uses log files created by Toby Lorenz:
https://bitbucket.org/tobylorenz/vector_blf/src/master/src/Vector/BLF/tests/unittests/events_from_binlog/
"""
@@ -360,7 +730,6 @@ def _setup_instance(self):
check_fd=True,
check_comments=False,
test_append=True,
- allowed_timestamp_delta=1.0e-6,
preserves_channel=False,
adds_default_channel=0,
)
@@ -421,6 +790,7 @@ def test_can_fd_message_64(self):
channel=0x10,
dlc=64,
is_fd=True,
+ is_rx=False,
bitrate_switch=True,
error_state_indicator=True,
)
@@ -442,6 +812,42 @@ def test_can_error_frame_ext(self):
self.assertMessagesEqual(actual, [expected] * 2)
self.assertEqual(actual[0].channel, expected.channel)
+ def test_timestamp_to_systemtime(self):
+ self.assertAlmostEqual(
+ 1636485425.999,
+ blf.systemtime_to_timestamp(blf.timestamp_to_systemtime(1636485425.998908)),
+ places=3,
+ )
+ self.assertAlmostEqual(
+ 1636485426.0,
+ blf.systemtime_to_timestamp(blf.timestamp_to_systemtime(1636485425.999908)),
+ places=3,
+ )
+
+ def test_issue_1905(self):
+ expected = can.Message(
+ timestamp=1735654183.491113,
+ channel=6,
+ arbitration_id=0x6A9,
+ is_extended_id=False,
+ is_fd=True,
+ bitrate_switch=True,
+ error_state_indicator=False,
+ dlc=64,
+ data=bytearray(
+ b"\xff\xff\xff\xff\xff\xff\xff\xff"
+ b"\xff\xff\xff\xff\xff\xff\xff\xff"
+ b"\xff\xff\xff\xff\xff\xff\xff\xff"
+ b"\xff\xff\xff\xff\xff\xff\xff\xff"
+ b"\xff\xff\xff\xff\xff\xff\xff\xff"
+ b"\xff\xff\xff\xff\xff\xff\xff\xff"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00"
+ ),
+ )
+ msgs = self._read_log_file("issue_1905.blf")
+ self.assertMessageEqual(expected, msgs[0])
+
class TestCanutilsFileFormat(ReaderWriterTest):
"""Tests can.CanutilsLogWriter and can.CanutilsLogReader"""
@@ -450,7 +856,7 @@ def _setup_instance(self):
super()._setup_instance_helper(
can.CanutilsLogWriter,
can.CanutilsLogReader,
- check_fd=False,
+ check_fd=True,
test_append=True,
check_comments=False,
preserves_channel=False,
@@ -459,7 +865,7 @@ def _setup_instance(self):
class TestCsvFileFormat(ReaderWriterTest):
- """Tests can.ASCWriter and can.ASCReader"""
+ """Tests can.CSVWriter and can.CSVReader"""
def _setup_instance(self):
super()._setup_instance_helper(
@@ -473,6 +879,22 @@ def _setup_instance(self):
)
+@unittest.skipIf(asammdf is None, "MF4 is unavailable")
+class TestMF4FileFormat(ReaderWriterTest):
+ """Tests can.MF4Writer and can.MF4Reader"""
+
+ def _setup_instance(self):
+ super()._setup_instance_helper(
+ can.MF4Writer,
+ can.MF4Reader,
+ binary_file=True,
+ check_comments=False,
+ preserves_channel=False,
+ allowed_timestamp_delta=1e-4,
+ adds_default_channel=0,
+ )
+
+
class TestSqliteDatabaseFormat(ReaderWriterTest):
"""Tests can.SqliteWriter and can.SqliteReader"""
@@ -485,6 +907,7 @@ def _setup_instance(self):
check_comments=False,
preserves_channel=False,
adds_default_channel=None,
+ assert_file_closed=False,
)
@unittest.skip("not implemented")
@@ -520,14 +943,16 @@ def test_read_all(self):
class TestPrinter(unittest.TestCase):
- """Tests that can.Printer does not crash
+ """Tests that can.Printer does not crash.
TODO test append mode
"""
- # TODO add CAN FD messages
messages = (
- TEST_MESSAGES_BASE + TEST_MESSAGES_REMOTE_FRAMES + TEST_MESSAGES_ERROR_FRAMES
+ TEST_MESSAGES_BASE
+ + TEST_MESSAGES_REMOTE_FRAMES
+ + TEST_MESSAGES_ERROR_FRAMES
+ + TEST_MESSAGES_CAN_FD
)
def test_not_crashes_with_stdout(self):
@@ -536,14 +961,167 @@ def test_not_crashes_with_stdout(self):
printer(message)
def test_not_crashes_with_file(self):
- with tempfile.NamedTemporaryFile("w", delete=False) as temp_file:
+ with tempfile.NamedTemporaryFile("w") as temp_file:
with can.Printer(temp_file) as printer:
for message in self.messages:
printer(message)
+class TestTrcFileFormatBase(ReaderWriterTest):
+ """
+ Base class for Tests with can.TRCWriter and can.TRCReader
+
+ .. note::
+ This class is prevented from being executed as a test
+ case itself by a *del* statement in at the end of the file.
+ """
+
+ def _setup_instance(self):
+ super()._setup_instance_helper(
+ can.TRCWriter,
+ can.TRCReader,
+ check_remote_frames=False,
+ check_error_frames=False,
+ check_fd=False,
+ check_comments=False,
+ preserves_channel=False,
+ allowed_timestamp_delta=0.001,
+ adds_default_channel=0,
+ )
+
+ def _read_log_file(self, filename, **kwargs):
+ logfile = os.path.join(os.path.dirname(__file__), "data", filename)
+ with can.TRCReader(logfile, **kwargs) as reader:
+ return list(reader)
+
+
+class TestTrcFileFormatGen(TestTrcFileFormatBase):
+ """Generic tests for can.TRCWriter and can.TRCReader with different file versions"""
+
+ def test_can_message(self):
+ start_time = 1506809173.191 # 30.09.2017 22:06:13.191.000 as timestamp
+ expected_messages = [
+ can.Message(
+ timestamp=start_time + 2.5010,
+ arbitration_id=0xC8,
+ is_extended_id=False,
+ is_rx=False,
+ channel=1,
+ dlc=8,
+ data=[9, 8, 7, 6, 5, 4, 3, 2],
+ ),
+ can.Message(
+ timestamp=start_time + 17.876708,
+ arbitration_id=0x6F9,
+ is_extended_id=False,
+ channel=0,
+ dlc=0x8,
+ data=[5, 0xC, 0, 0, 0, 0, 0, 0],
+ ),
+ ]
+ actual = self._read_log_file("test_CanMessage.trc")
+ self.assertMessagesEqual(actual, expected_messages)
+
+ @parameterized.expand(
+ [
+ ("V1_0", "test_CanMessage_V1_0_BUS1.trc", False),
+ ("V1_1", "test_CanMessage_V1_1.trc", True),
+ ("V1_3", "test_CanMessage_V1_3.trc", True),
+ ("V2_0", "test_CanMessage_V2_0_BUS1.trc", True),
+ ("V2_1", "test_CanMessage_V2_1.trc", True),
+ ]
+ )
+ def test_can_message_versions(self, name, filename, is_rx_support):
+ with self.subTest(name):
+ if name == "V1_0":
+ # Version 1.0 does not support start time
+ start_time = 0
+ else:
+ start_time = (
+ 1639837687.062001 # 18.12.2021 14:28:07.062.001 as timestamp
+ )
+
+ def msg_std(timestamp):
+ msg = can.Message(
+ timestamp=timestamp + start_time,
+ arbitration_id=0x000,
+ is_extended_id=False,
+ channel=1,
+ dlc=8,
+ data=[0, 0, 0, 0, 0, 0, 0, 0],
+ )
+ if is_rx_support:
+ msg.is_rx = False
+ return msg
+
+ def msg_ext(timestamp):
+ msg = can.Message(
+ timestamp=timestamp + start_time,
+ arbitration_id=0x100,
+ is_extended_id=True,
+ channel=1,
+ dlc=8,
+ data=[0, 0, 0, 0, 0, 0, 0, 0],
+ )
+ if is_rx_support:
+ msg.is_rx = False
+ return msg
+
+ def msg_rtr(timestamp):
+ msg = can.Message(
+ timestamp=timestamp + start_time,
+ arbitration_id=0x704,
+ is_extended_id=False,
+ is_remote_frame=True,
+ channel=1,
+ dlc=1,
+ data=[],
+ )
+ if is_rx_support:
+ msg.is_rx = True
+ return msg
+
+ expected_messages = [
+ msg_ext(17.5354),
+ msg_ext(17.7003),
+ msg_ext(17.8738),
+ msg_std(19.2954),
+ msg_std(19.5006),
+ msg_std(19.7052),
+ msg_ext(20.5927),
+ msg_ext(20.7986),
+ msg_ext(20.9560),
+ msg_ext(21.0971),
+ msg_rtr(48.9376),
+ ]
+ actual = self._read_log_file(filename)
+ self.assertMessagesEqual(actual, expected_messages)
+
+ def test_not_supported_version(self):
+ with tempfile.NamedTemporaryFile(mode="w") as f:
+ with self.assertRaises(NotImplementedError):
+ writer = can.TRCWriter(f)
+ writer.file_version = can.TRCFileVersion.UNKNOWN
+ writer.on_message_received(can.Message())
+
+
+class TestTrcFileFormatV1_0(TestTrcFileFormatBase):
+ """Tests can.TRCWriter and can.TRCReader with file version 1.0"""
+
+ @staticmethod
+ def Writer(filename):
+ writer = can.TRCWriter(filename)
+ writer.file_version = can.TRCFileVersion.V1_0
+ return writer
+
+ def _setup_instance(self):
+ super()._setup_instance()
+ self.writer_constructor = TestTrcFileFormatV1_0.Writer
+
+
# this excludes the base class from being executed as a test case itself
del ReaderWriterTest
+del TestTrcFileFormatBase
if __name__ == "__main__":
diff --git a/test/message_helper.py b/test/message_helper.py
index 5f437dbde..d10e9195f 100644
--- a/test/message_helper.py
+++ b/test/message_helper.py
@@ -1,12 +1,9 @@
#!/usr/bin/env python
-# coding: utf-8
"""
This module contains a helper for writing test cases that need to compare messages.
"""
-from copy import copy
-
class ComparingMessagesTestCase:
"""
@@ -29,31 +26,14 @@ def assertMessageEqual(self, message_1, message_2):
Checks that two messages are equal, according to the given rules.
"""
- if message_1.equals(message_2, timestamp_delta=self.allowed_timestamp_delta):
- return
- elif self.preserves_channel:
- print("Comparing: message 1: {!r}".format(message_1))
- print(" message 2: {!r}".format(message_2))
- self.fail(
- "messages are unequal with allowed timestamp delta {}".format(
- self.allowed_timestamp_delta
- )
- )
- else:
- message_2 = copy(message_2) # make sure this method is pure
- message_2.channel = message_1.channel
- if message_1.equals(
- message_2, timestamp_delta=self.allowed_timestamp_delta
- ):
- return
- else:
- print("Comparing: message 1: {!r}".format(message_1))
- print(" message 2: {!r}".format(message_2))
- self.fail(
- "messages are unequal with allowed timestamp delta {} even when ignoring channels".format(
- self.allowed_timestamp_delta
- )
- )
+ if not message_1.equals(
+ message_2,
+ check_channel=self.preserves_channel,
+ timestamp_delta=self.allowed_timestamp_delta,
+ ):
+ print(f"Comparing: message 1: {message_1!r}")
+ print(f" message 2: {message_2!r}")
+ self.fail(f"messages are unequal: \n{message_1}\n{message_2}")
def assertMessagesEqual(self, messages_1, messages_2):
"""
diff --git a/test/network_test.py b/test/network_test.py
index 2ee4795fb..3a231dff7 100644
--- a/test/network_test.py
+++ b/test/network_test.py
@@ -1,25 +1,21 @@
#!/usr/bin/env python
-# coding: utf-8
-
-
-import unittest
-import threading
-import queue
-import random
+import contextlib
import logging
+import random
+import threading
+import unittest
-logging.getLogger(__file__).setLevel(logging.WARNING)
+import can
+from test.config import IS_PYPY
-# make a random bool:
-rbool = lambda: bool(round(random.random()))
+logging.getLogger(__file__).setLevel(logging.WARNING)
-import can
-channel = "vcan0"
-can.rc["interface"] = "virtual"
+# make a random bool:
+def rbool():
+ return random.choice([False, True])
-@unittest.skipIf("interface" not in can.rc, "Need a CAN interface")
class ControllerAreaNetworkTestCase(unittest.TestCase):
"""
This test ensures that what messages go in to the bus is what comes out.
@@ -40,77 +36,64 @@ class ControllerAreaNetworkTestCase(unittest.TestCase):
ids = list(range(num_messages))
data = list(
- bytearray([random.randrange(0, 2 ** 8 - 1) for a in range(random.randrange(9))])
+ bytearray([random.randrange(0, 2**8 - 1) for a in range(random.randrange(9))])
for b in range(num_messages)
)
- def producer(self, ready_event, msg_read):
- self.client_bus = can.interface.Bus(channel=channel)
- ready_event.wait()
- for i in range(self.num_messages):
- m = can.Message(
- arbitration_id=self.ids[i],
- is_remote_frame=self.remote_flags[i],
- is_error_frame=self.error_flags[i],
- is_extended_id=self.extended_flags[i],
- data=self.data[i],
- )
- # logging.debug("writing message: {}".format(m))
- if msg_read is not None:
- # Don't send until the other thread is ready
- msg_read.wait()
- msg_read.clear()
-
- self.client_bus.send(m)
+ def setUp(self):
+ # Save all can.rc defaults
+ self._can_rc = can.rc
+ can.rc = {"interface": "virtual"}
+
+ def tearDown(self):
+ # Restore the defaults
+ can.rc = self._can_rc
+
+ def producer(self, channel: str):
+ with can.interface.Bus(channel=channel) as client_bus:
+ for i in range(self.num_messages):
+ m = can.Message(
+ arbitration_id=self.ids[i],
+ is_remote_frame=self.remote_flags[i],
+ is_error_frame=self.error_flags[i],
+ is_extended_id=self.extended_flags[i],
+ data=self.data[i],
+ )
+ client_bus.send(m)
def testProducer(self):
"""Verify that we can send arbitrary messages on the bus"""
logging.debug("testing producer alone")
- ready = threading.Event()
- ready.set()
- self.producer(ready, None)
-
+ self.producer(channel="testProducer")
logging.debug("producer test complete")
def testProducerConsumer(self):
logging.debug("testing producer/consumer")
- ready = threading.Event()
- msg_read = threading.Event()
-
- self.server_bus = can.interface.Bus(channel=channel)
-
- t = threading.Thread(target=self.producer, args=(ready, msg_read))
- t.start()
-
- # Ensure there are no messages on the bus
- while True:
- m = self.server_bus.recv(timeout=0.5)
- if m is None:
- print("No messages... lets go")
- break
- else:
- self.fail("received messages before the test has started ...")
- ready.set()
- i = 0
- while i < self.num_messages:
- msg_read.set()
- msg = self.server_bus.recv(timeout=0.5)
- self.assertIsNotNone(msg, "Didn't receive a message")
- # logging.debug("Received message {} with data: {}".format(i, msg.data))
-
- self.assertEqual(msg.is_extended_id, self.extended_flags[i])
- if not msg.is_remote_frame:
- self.assertEqual(msg.data, self.data[i])
- self.assertEqual(msg.arbitration_id, self.ids[i])
-
- self.assertEqual(msg.is_error_frame, self.error_flags[i])
- self.assertEqual(msg.is_remote_frame, self.remote_flags[i])
-
- i += 1
- t.join()
-
- self.server_bus.flush_tx_buffer()
- self.server_bus.shutdown()
+ read_timeout = 2.0 if IS_PYPY else 0.5
+ channel = "testProducerConsumer"
+
+ with can.interface.Bus(channel=channel, interface="virtual") as server_bus:
+ t = threading.Thread(target=self.producer, args=(channel,))
+ t.start()
+
+ i = 0
+ while i < self.num_messages:
+ msg = server_bus.recv(timeout=read_timeout)
+ self.assertIsNotNone(msg, "Didn't receive a message")
+
+ self.assertEqual(msg.is_extended_id, self.extended_flags[i])
+ if not msg.is_remote_frame:
+ self.assertEqual(msg.data, self.data[i])
+ self.assertEqual(msg.arbitration_id, self.ids[i])
+
+ self.assertEqual(msg.is_error_frame, self.error_flags[i])
+ self.assertEqual(msg.is_remote_frame, self.remote_flags[i])
+
+ i += 1
+ t.join()
+
+ with contextlib.suppress(NotImplementedError):
+ server_bus.flush_tx_buffer()
if __name__ == "__main__":
diff --git a/test/notifier_test.py b/test/notifier_test.py
index 0a60bd25d..d8512a00b 100644
--- a/test/notifier_test.py
+++ b/test/notifier_test.py
@@ -1,57 +1,92 @@
#!/usr/bin/env python
-# coding: utf-8
-import unittest
-import time
import asyncio
+import time
+import unittest
import can
class NotifierTest(unittest.TestCase):
def test_single_bus(self):
- bus = can.Bus("test", bustype="virtual", receive_own_messages=True)
- reader = can.BufferedReader()
- notifier = can.Notifier(bus, [reader], 0.1)
- msg = can.Message()
- bus.send(msg)
- self.assertIsNotNone(reader.get_message(1))
- notifier.stop()
- bus.shutdown()
+ with can.Bus("test", interface="virtual", receive_own_messages=True) as bus:
+ reader = can.BufferedReader()
+ notifier = can.Notifier(bus, [reader], 0.1)
+ self.assertFalse(notifier.stopped)
+ msg = can.Message()
+ bus.send(msg)
+ self.assertIsNotNone(reader.get_message(1))
+ notifier.stop()
+ self.assertTrue(notifier.stopped)
def test_multiple_bus(self):
- bus1 = can.Bus(0, bustype="virtual", receive_own_messages=True)
- bus2 = can.Bus(1, bustype="virtual", receive_own_messages=True)
- reader = can.BufferedReader()
- notifier = can.Notifier([bus1, bus2], [reader], 0.1)
- msg = can.Message()
- bus1.send(msg)
- time.sleep(0.1)
- bus2.send(msg)
- recv_msg = reader.get_message(1)
- self.assertIsNotNone(recv_msg)
- self.assertEqual(recv_msg.channel, 0)
- recv_msg = reader.get_message(1)
- self.assertIsNotNone(recv_msg)
- self.assertEqual(recv_msg.channel, 1)
- notifier.stop()
- bus1.shutdown()
- bus2.shutdown()
+ with (
+ can.Bus(0, interface="virtual", receive_own_messages=True) as bus1,
+ can.Bus(1, interface="virtual", receive_own_messages=True) as bus2,
+ ):
+ reader = can.BufferedReader()
+ notifier = can.Notifier([bus1, bus2], [reader], 0.1)
+ self.assertFalse(notifier.stopped)
+ msg = can.Message()
+ bus1.send(msg)
+ time.sleep(0.1)
+ bus2.send(msg)
+ recv_msg = reader.get_message(1)
+ self.assertIsNotNone(recv_msg)
+ self.assertEqual(recv_msg.channel, 0)
+ recv_msg = reader.get_message(1)
+ self.assertIsNotNone(recv_msg)
+ self.assertEqual(recv_msg.channel, 1)
+ notifier.stop()
+ self.assertTrue(notifier.stopped)
+
+ def test_context_manager(self):
+ with can.Bus("test", interface="virtual", receive_own_messages=True) as bus:
+ reader = can.BufferedReader()
+ with can.Notifier(bus, [reader], 0.1) as notifier:
+ self.assertFalse(notifier.stopped)
+ msg = can.Message()
+ bus.send(msg)
+ self.assertIsNotNone(reader.get_message(1))
+ notifier.stop()
+ self.assertTrue(notifier.stopped)
+
+ def test_registry(self):
+ with can.Bus("test", interface="virtual", receive_own_messages=True) as bus:
+ reader = can.BufferedReader()
+ with can.Notifier(bus, [reader], 0.1) as notifier:
+ # creating a second notifier for the same bus must fail
+ self.assertRaises(ValueError, can.Notifier, bus, [reader], 0.1)
+
+ # find_instance must return the existing instance
+ self.assertEqual(can.Notifier.find_instances(bus), (notifier,))
+
+ # Notifier is stopped, find_instances() must return an empty tuple
+ self.assertEqual(can.Notifier.find_instances(bus), ())
+
+ # now the first notifier is stopped, a new notifier can be created without error:
+ with can.Notifier(bus, [reader], 0.1) as notifier:
+ # the next notifier call should fail again since there is an active notifier already
+ self.assertRaises(ValueError, can.Notifier, bus, [reader], 0.1)
+
+ # find_instance must return the existing instance
+ self.assertEqual(can.Notifier.find_instances(bus), (notifier,))
class AsyncNotifierTest(unittest.TestCase):
def test_asyncio_notifier(self):
- loop = asyncio.get_event_loop()
- bus = can.Bus("test", bustype="virtual", receive_own_messages=True)
- reader = can.AsyncBufferedReader()
- notifier = can.Notifier(bus, [reader], 0.1, loop=loop)
- msg = can.Message()
- bus.send(msg)
- future = asyncio.wait_for(reader.get_message(), 1.0)
- recv_msg = loop.run_until_complete(future)
- self.assertIsNotNone(recv_msg)
- notifier.stop()
- bus.shutdown()
+ async def run_it():
+ with can.Bus("test", interface="virtual", receive_own_messages=True) as bus:
+ reader = can.AsyncBufferedReader()
+ notifier = can.Notifier(
+ bus, [reader], 0.1, loop=asyncio.get_running_loop()
+ )
+ bus.send(can.Message())
+ recv_msg = await asyncio.wait_for(reader.get_message(), 0.5)
+ self.assertIsNotNone(recv_msg)
+ notifier.stop()
+
+ asyncio.run(run_it())
if __name__ == "__main__":
diff --git a/test/open_vcan.sh b/test/open_vcan.sh
index bd02ad752..b6f4676b7 100755
--- a/test/open_vcan.sh
+++ b/test/open_vcan.sh
@@ -5,3 +5,7 @@
modprobe vcan
ip link add dev vcan0 type vcan
ip link set up vcan0 mtu 72
+ip link add dev vxcan0 type vcan
+ip link set up vxcan0 mtu 72
+ip link add dev slcan0 type vcan
+ip link set up slcan0 mtu 72
diff --git a/test/serial_test.py b/test/serial_test.py
index d0e11f974..409485112 100644
--- a/test/serial_test.py
+++ b/test/serial_test.py
@@ -1,5 +1,4 @@
#!/usr/bin/env python
-# coding: utf-8
"""
This module is testing the serial interface.
@@ -13,8 +12,12 @@
import can
from can.interfaces.serial.serial_can import SerialBus
+from .config import IS_PYPY
from .message_helper import ComparingMessagesTestCase
+# Mentioned in #1010
+TIMEOUT = 0.5 if IS_PYPY else 0.1 # 0.1 is the default set in SerialBus
+
class SerialDummy:
"""
@@ -40,7 +43,6 @@ def reset(self):
class SimpleSerialTestBase(ComparingMessagesTestCase):
-
MAX_TIMESTAMP = 0xFFFFFFFF / 1000
def __init__(self):
@@ -48,6 +50,9 @@ def __init__(self):
self, allowed_timestamp_delta=None, preserves_channel=True
)
+ def test_can_protocol(self):
+ self.assertEqual(self.bus.protocol, can.CanProtocol.CAN_20)
+
def test_rx_tx_min_max_data(self):
"""
Tests the transfer from 0x00 to 0xFF for a 1 byte payload
@@ -79,20 +84,38 @@ def test_rx_tx_data_none(self):
msg_receive = self.bus.recv()
self.assertMessageEqual(msg, msg_receive)
- def test_rx_tx_min_id(self):
+ def test_rx_tx_min_std_id(self):
+ """
+ Tests the transfer with the lowest standard arbitration id
+ """
+ msg = can.Message(arbitration_id=0, is_extended_id=False)
+ self.bus.send(msg)
+ msg_receive = self.bus.recv()
+ self.assertMessageEqual(msg, msg_receive)
+
+ def test_rx_tx_max_std_id(self):
+ """
+ Tests the transfer with the highest standard arbitration id
+ """
+ msg = can.Message(arbitration_id=0x7FF, is_extended_id=False)
+ self.bus.send(msg)
+ msg_receive = self.bus.recv()
+ self.assertMessageEqual(msg, msg_receive)
+
+ def test_rx_tx_min_ext_id(self):
"""
- Tests the transfer with the lowest arbitration id
+ Tests the transfer with the lowest extended arbitration id
"""
- msg = can.Message(arbitration_id=0)
+ msg = can.Message(arbitration_id=0x000, is_extended_id=True)
self.bus.send(msg)
msg_receive = self.bus.recv()
self.assertMessageEqual(msg, msg_receive)
- def test_rx_tx_max_id(self):
+ def test_rx_tx_max_ext_id(self):
"""
- Tests the transfer with the highest arbitration id
+ Tests the transfer with the highest extended arbitration id
"""
- msg = can.Message(arbitration_id=536870911)
+ msg = can.Message(arbitration_id=0x1FFFFFFF, is_extended_id=True)
self.bus.send(msg)
msg_receive = self.bus.recv()
self.assertMessageEqual(msg, msg_receive)
@@ -132,6 +155,46 @@ def test_rx_tx_min_timestamp_error(self):
msg = can.Message(timestamp=-1)
self.assertRaises(ValueError, self.bus.send, msg)
+ def test_rx_tx_err_frame(self):
+ """
+ Test the transfer of error frames.
+ """
+ msg = can.Message(
+ is_extended_id=False, is_error_frame=True, is_remote_frame=False
+ )
+ self.bus.send(msg)
+ msg_receive = self.bus.recv()
+ self.assertMessageEqual(msg, msg_receive)
+
+ def test_rx_tx_rtr_frame(self):
+ """
+ Test the transfer of remote frames.
+ """
+ msg = can.Message(
+ is_extended_id=False, is_error_frame=False, is_remote_frame=True
+ )
+ self.bus.send(msg)
+ msg_receive = self.bus.recv()
+ self.assertMessageEqual(msg, msg_receive)
+
+ def test_when_no_fileno(self):
+ """
+ Tests for the fileno method catching the missing pyserial implementeation on the Windows platform
+ """
+ try:
+ fileno = self.bus.fileno()
+ except NotImplementedError:
+ pass # allow it to be left non-implemented for Windows platform
+ else:
+ fileno.__gt__ = (
+ lambda self, compare: True
+ ) # Current platform implements fileno, so get the mock to respond to a greater than comparison
+ self.assertIsNotNone(fileno)
+ self.assertFalse(
+ fileno == -1
+ ) # forcing the value to -1 is the old way of managing fileno on Windows but it is not compatible with notifiers
+ self.assertTrue(fileno > 0)
+
class SimpleSerialTest(unittest.TestCase, SimpleSerialTestBase):
def __init__(self, *args, **kwargs):
@@ -145,7 +208,7 @@ def setUp(self):
self.mock_serial.return_value.write = self.serial_dummy.write
self.mock_serial.return_value.read = self.serial_dummy.read
self.addCleanup(self.patcher.stop)
- self.bus = SerialBus("bus")
+ self.bus = SerialBus("bus", timeout=TIMEOUT)
def tearDown(self):
self.serial_dummy.reset()
@@ -157,7 +220,7 @@ def __init__(self, *args, **kwargs):
SimpleSerialTestBase.__init__(self)
def setUp(self):
- self.bus = SerialBus("loop://")
+ self.bus = SerialBus("loop://", timeout=TIMEOUT)
def tearDown(self):
self.bus.shutdown()
diff --git a/test/simplecyclic_test.py b/test/simplecyclic_test.py
index 95bbd0a99..22a11e643 100644
--- a/test/simplecyclic_test.py
+++ b/test/simplecyclic_test.py
@@ -1,17 +1,22 @@
#!/usr/bin/env python
-# coding: utf-8
"""
This module tests cyclic send tasks.
"""
-from time import sleep
-import unittest
import gc
+import platform
+import sys
+import time
+import traceback
+import unittest
+from threading import Thread
+from time import sleep
+from unittest.mock import MagicMock
import can
-from .config import *
+from .config import IS_CI, IS_PYPY
from .message_helper import ComparingMessagesTestCase
@@ -31,125 +36,277 @@ def test_cycle_time(self):
is_extended_id=False, arbitration_id=0x123, data=[0, 1, 2, 3, 4, 5, 6, 7]
)
- with can.interface.Bus(bustype="virtual") as bus1:
- with can.interface.Bus(bustype="virtual") as bus2:
-
- # disabling the garbage collector makes the time readings more reliable
- gc.disable()
+ with (
+ can.interface.Bus(interface="virtual") as bus1,
+ can.interface.Bus(interface="virtual") as bus2,
+ ):
+ # disabling the garbage collector makes the time readings more reliable
+ gc.disable()
- task = bus1.send_periodic(msg, 0.01, 1)
- self.assertIsInstance(task, can.broadcastmanager.CyclicSendTaskABC)
+ task = bus1.send_periodic(msg, 0.01, 1)
+ self.assertIsInstance(task, can.broadcastmanager.CyclicSendTaskABC)
- sleep(2)
- size = bus2.queue.qsize()
- # About 100 messages should have been transmitted
- self.assertTrue(
- 80 <= size <= 120,
- "100 +/- 20 messages should have been transmitted. But queue contained {}".format(
- size
- ),
- )
- last_msg = bus2.recv()
- next_last_msg = bus2.recv()
+ sleep(2)
+ size = bus2.queue.qsize()
+ # About 100 messages should have been transmitted
+ self.assertTrue(
+ 80 <= size <= 120,
+ "100 +/- 20 messages should have been transmitted. But queue contained {}".format(
+ size
+ ),
+ )
+ last_msg = bus2.recv()
+ next_last_msg = bus2.recv()
- # we need to reenable the garbage collector again
- gc.enable()
+ # we need to reenable the garbage collector again
+ gc.enable()
- # Check consecutive messages are spaced properly in time and have
- # the same id/data
- self.assertMessageEqual(last_msg, next_last_msg)
+ # Check consecutive messages are spaced properly in time and have
+ # the same id/data
+ self.assertMessageEqual(last_msg, next_last_msg)
- # Check the message id/data sent is the same as message received
- # Set timestamp and channel to match recv'd because we don't care
- # and they are not initialized by the can.Message constructor.
- msg.timestamp = last_msg.timestamp
- msg.channel = last_msg.channel
- self.assertMessageEqual(msg, last_msg)
+ # Check the message id/data sent is the same as message received
+ # Set timestamp and channel to match recv'd because we don't care
+ # and they are not initialized by the can.Message constructor.
+ msg.timestamp = last_msg.timestamp
+ msg.channel = last_msg.channel
+ self.assertMessageEqual(msg, last_msg)
def test_removing_bus_tasks(self):
- bus = can.interface.Bus(bustype="virtual")
- tasks = []
- for task_i in range(10):
- msg = can.Message(
- is_extended_id=False,
- arbitration_id=0x123,
- data=[0, 1, 2, 3, 4, 5, 6, 7],
- )
- msg.arbitration_id = task_i
- task = bus.send_periodic(msg, 0.1, 1)
- tasks.append(task)
- self.assertIsInstance(task, can.broadcastmanager.CyclicSendTaskABC)
+ with can.interface.Bus(interface="virtual") as bus:
+ tasks = []
+ for task_i in range(10):
+ msg = can.Message(
+ is_extended_id=False,
+ arbitration_id=0x123,
+ data=[0, 1, 2, 3, 4, 5, 6, 7],
+ )
+ msg.arbitration_id = task_i
+ task = bus.send_periodic(msg, 0.1, 1)
+ tasks.append(task)
+ self.assertIsInstance(task, can.broadcastmanager.CyclicSendTaskABC)
- assert len(bus._periodic_tasks) == 10
+ assert len(bus._periodic_tasks) == 10
- for task in tasks:
- # Note calling task.stop will remove the task from the Bus's internal task management list
- task.stop()
+ for task in tasks:
+ # Note calling task.stop will remove the task from the Bus's internal task management list
+ task.stop()
- assert len(bus._periodic_tasks) == 0
- bus.shutdown()
+ self.join_threads([task.thread for task in tasks], 5.0)
- def test_managed_tasks(self):
- bus = can.interface.Bus(bustype="virtual", receive_own_messages=True)
- tasks = []
- for task_i in range(3):
- msg = can.Message(
- is_extended_id=False,
- arbitration_id=0x123,
- data=[0, 1, 2, 3, 4, 5, 6, 7],
- )
- msg.arbitration_id = task_i
- task = bus.send_periodic(msg, 0.1, 10, store_task=False)
- tasks.append(task)
- self.assertIsInstance(task, can.broadcastmanager.CyclicSendTaskABC)
+ assert len(bus._periodic_tasks) == 0
- assert len(bus._periodic_tasks) == 0
+ def test_managed_tasks(self):
+ with can.interface.Bus(interface="virtual", receive_own_messages=True) as bus:
+ tasks = []
+ for task_i in range(3):
+ msg = can.Message(
+ is_extended_id=False,
+ arbitration_id=0x123,
+ data=[0, 1, 2, 3, 4, 5, 6, 7],
+ )
+ msg.arbitration_id = task_i
+ task = bus.send_periodic(msg, 0.1, 10, store_task=False)
+ tasks.append(task)
+ self.assertIsInstance(task, can.broadcastmanager.CyclicSendTaskABC)
- # Self managed tasks should still be sending messages
- for _ in range(50):
- received_msg = bus.recv(timeout=5.0)
- assert received_msg is not None
- assert received_msg.arbitration_id in {0, 1, 2}
+ assert len(bus._periodic_tasks) == 0
- for task in tasks:
- task.stop()
+ # Self managed tasks should still be sending messages
+ for _ in range(50):
+ received_msg = bus.recv(timeout=5.0)
+ assert received_msg is not None
+ assert received_msg.arbitration_id in {0, 1, 2}
- for task in tasks:
- assert task.thread.join(5.0) is None, "Task didn't stop before timeout"
+ for task in tasks:
+ task.stop()
- bus.shutdown()
+ self.join_threads([task.thread for task in tasks], 5.0)
def test_stopping_perodic_tasks(self):
- bus = can.interface.Bus(bustype="virtual")
- tasks = []
- for task_i in range(10):
+ with can.interface.Bus(interface="virtual") as bus:
+ tasks = []
+ for task_i in range(10):
+ msg = can.Message(
+ is_extended_id=False,
+ arbitration_id=0x123,
+ data=[0, 1, 2, 3, 4, 5, 6, 7],
+ )
+ msg.arbitration_id = task_i
+ task = bus.send_periodic(msg, period=0.1)
+ tasks.append(task)
+
+ assert len(bus._periodic_tasks) == 10
+ # stop half the tasks using the task object
+ for task in tasks[::2]:
+ task.stop()
+
+ assert len(bus._periodic_tasks) == 5
+
+ # stop the other half using the bus api
+ bus.stop_all_periodic_tasks(remove_tasks=False)
+ self.join_threads([task.thread for task in tasks], 5.0)
+
+ # Tasks stopped via `stop_all_periodic_tasks` with remove_tasks=False should
+ # still be associated with the bus (e.g. for restarting)
+ assert len(bus._periodic_tasks) == 5
+
+ def test_restart_perodic_tasks(self):
+ period = 0.01
+ safe_timeout = period * 5 if not IS_PYPY else 1.0
+ duration = 0.3
+
+ msg = can.Message(
+ is_extended_id=False, arbitration_id=0x123, data=[0, 1, 2, 3, 4, 5, 6, 7]
+ )
+
+ def _read_all_messages(_bus: "can.interfaces.virtual.VirtualBus") -> None:
+ sleep(safe_timeout)
+ while not _bus.queue.empty():
+ _bus.recv(timeout=period)
+ sleep(safe_timeout)
+
+ with can.ThreadSafeBus(interface="virtual", receive_own_messages=True) as bus:
+ task = bus.send_periodic(msg, period)
+ self.assertIsInstance(task, can.broadcastmanager.ThreadBasedCyclicSendTask)
+
+ # Test that the task is sending messages
+ sleep(safe_timeout)
+ assert not bus.queue.empty(), "messages should have been transmitted"
+
+ # Stop the task and check that messages are no longer being sent
+ bus.stop_all_periodic_tasks(remove_tasks=False)
+ _read_all_messages(bus)
+ assert bus.queue.empty(), "messages should not have been transmitted"
+
+ # Restart the task and check that messages are being sent again
+ task.start()
+ sleep(safe_timeout)
+ assert not bus.queue.empty(), "messages should have been transmitted"
+
+ # Stop the task and check that messages are no longer being sent
+ bus.stop_all_periodic_tasks(remove_tasks=False)
+ _read_all_messages(bus)
+ assert bus.queue.empty(), "messages should not have been transmitted"
+
+ # Restart the task with limited duration and wait until it stops
+ task.duration = duration
+ task.start()
+ sleep(duration + safe_timeout)
+ assert task.stopped
+ assert time.time() > task.end_time
+ assert not bus.queue.empty(), "messages should have been transmitted"
+ _read_all_messages(bus)
+ assert bus.queue.empty(), "messages should not have been transmitted"
+
+ # Restart the task and check that messages are being sent again
+ task.start()
+ sleep(safe_timeout)
+ assert not bus.queue.empty(), "messages should have been transmitted"
+
+ # Stop all tasks and wait for the thread to exit
+ bus.stop_all_periodic_tasks()
+ # Avoids issues where the thread is still running when the bus is shutdown
+ self.join_threads([task.thread], 5.0)
+
+ @unittest.skipIf(IS_CI, "fails randomly when run on CI server")
+ def test_thread_based_cyclic_send_task(self):
+ with can.ThreadSafeBus(interface="virtual") as bus:
msg = can.Message(
is_extended_id=False,
arbitration_id=0x123,
data=[0, 1, 2, 3, 4, 5, 6, 7],
)
- msg.arbitration_id = task_i
- task = bus.send_periodic(msg, 0.1, 1)
- tasks.append(task)
- assert len(bus._periodic_tasks) == 10
- # stop half the tasks using the task object
- for task in tasks[::2]:
+ # good case, bus is up
+ on_error_mock = MagicMock(return_value=False)
+ task = can.broadcastmanager.ThreadBasedCyclicSendTask(
+ bus=bus,
+ lock=bus._lock_send_periodic,
+ messages=msg,
+ period=0.1,
+ duration=3,
+ on_error=on_error_mock,
+ )
+ sleep(1)
+ on_error_mock.assert_not_called()
task.stop()
- assert len(bus._periodic_tasks) == 5
+ # bus has been shut down
+ on_error_mock = MagicMock(return_value=False)
+ task = can.broadcastmanager.ThreadBasedCyclicSendTask(
+ bus=bus,
+ lock=bus._lock_send_periodic,
+ messages=msg,
+ period=0.1,
+ duration=3,
+ on_error=on_error_mock,
+ )
+ sleep(1)
+ self.assertEqual(1, on_error_mock.call_count)
+ task.stop()
+
+ # bus is still shut down, but on_error returns True
+ on_error_mock = MagicMock(return_value=True)
+ task = can.broadcastmanager.ThreadBasedCyclicSendTask(
+ bus=bus,
+ lock=bus._lock_send_periodic,
+ messages=msg,
+ period=0.1,
+ duration=3,
+ on_error=on_error_mock,
+ )
+ sleep(1)
+ self.assertTrue(on_error_mock.call_count > 1)
+ task.stop()
- # stop the other half using the bus api
- bus.stop_all_periodic_tasks(remove_tasks=False)
+ def test_modifier_callback(self) -> None:
+ msg_list: list[can.Message] = []
- for task in tasks:
- assert task.thread.join(5.0) is None, "Task didn't stop before timeout"
+ def increment_first_byte(msg: can.Message) -> None:
+ msg.data[0] = (msg.data[0] + 1) % 256
- # Tasks stopped via `stop_all_periodic_tasks` with remove_tasks=False should
- # still be associated with the bus (e.g. for restarting)
- assert len(bus._periodic_tasks) == 5
+ original_msg = can.Message(
+ is_extended_id=False, arbitration_id=0x123, data=[0] * 8
+ )
- bus.shutdown()
+ with can.ThreadSafeBus(interface="virtual", receive_own_messages=True) as bus:
+ notifier = can.Notifier(bus=bus, listeners=[msg_list.append])
+ task = bus.send_periodic(
+ msgs=original_msg, period=0.001, modifier_callback=increment_first_byte
+ )
+ time.sleep(0.2)
+ task.stop()
+ notifier.stop()
+
+ self.assertEqual(b"\x01\x00\x00\x00\x00\x00\x00\x00", bytes(msg_list[0].data))
+ self.assertEqual(b"\x02\x00\x00\x00\x00\x00\x00\x00", bytes(msg_list[1].data))
+ self.assertEqual(b"\x03\x00\x00\x00\x00\x00\x00\x00", bytes(msg_list[2].data))
+ self.assertEqual(b"\x04\x00\x00\x00\x00\x00\x00\x00", bytes(msg_list[3].data))
+ self.assertEqual(b"\x05\x00\x00\x00\x00\x00\x00\x00", bytes(msg_list[4].data))
+ self.assertEqual(b"\x06\x00\x00\x00\x00\x00\x00\x00", bytes(msg_list[5].data))
+ self.assertEqual(b"\x07\x00\x00\x00\x00\x00\x00\x00", bytes(msg_list[6].data))
+
+ @staticmethod
+ def join_threads(threads: list[Thread], timeout: float) -> None:
+ stuck_threads: list[Thread] = []
+ t0 = time.perf_counter()
+ for thread in threads:
+ time_left = timeout - (time.perf_counter() - t0)
+ if time_left > 0.0:
+ thread.join(time_left)
+ if thread.is_alive():
+ if platform.python_implementation() == "CPython":
+ # print thread frame to help with debugging
+ frame = sys._current_frames()[thread.ident]
+ traceback.print_stack(frame, file=sys.stderr)
+ stuck_threads.append(thread)
+ if stuck_threads:
+ err_message = (
+ f"Threads did not stop within {timeout:.1f} seconds: "
+ f"[{', '.join([str(t) for t in stuck_threads])}]"
+ )
+ raise RuntimeError(err_message)
if __name__ == "__main__":
diff --git a/test/test_bit_timing.py b/test/test_bit_timing.py
index 0b22e308f..514c31244 100644
--- a/test/test_bit_timing.py
+++ b/test/test_bit_timing.py
@@ -1,13 +1,20 @@
+#!/usr/bin/env python
+
+import struct
+
+import pytest
+
import can
+from can.interfaces.pcan.pcan import PCAN_BITRATES
def test_sja1000():
"""Test some values obtained using other bit timing calculators."""
timing = can.BitTiming(
- f_clock=8000000, bitrate=125000, tseg1=11, tseg2=4, sjw=2, nof_samples=3
+ f_clock=8_000_000, brp=4, tseg1=11, tseg2=4, sjw=2, nof_samples=3, strict=True
)
- assert timing.f_clock == 8000000
- assert timing.bitrate == 125000
+ assert timing.f_clock == 8_000_000
+ assert timing.bitrate == 125_000
assert timing.brp == 4
assert timing.nbt == 16
assert timing.tseg1 == 11
@@ -18,9 +25,11 @@ def test_sja1000():
assert timing.btr0 == 0x43
assert timing.btr1 == 0xBA
- timing = can.BitTiming(f_clock=8000000, bitrate=500000, tseg1=13, tseg2=2, sjw=1)
- assert timing.f_clock == 8000000
- assert timing.bitrate == 500000
+ timing = can.BitTiming(
+ f_clock=8_000_000, brp=1, tseg1=13, tseg2=2, sjw=1, strict=True
+ )
+ assert timing.f_clock == 8_000_000
+ assert timing.bitrate == 500_000
assert timing.brp == 1
assert timing.nbt == 16
assert timing.tseg1 == 13
@@ -31,9 +40,11 @@ def test_sja1000():
assert timing.btr0 == 0x00
assert timing.btr1 == 0x1C
- timing = can.BitTiming(f_clock=8000000, bitrate=1000000, tseg1=5, tseg2=2, sjw=1)
- assert timing.f_clock == 8000000
- assert timing.bitrate == 1000000
+ timing = can.BitTiming(
+ f_clock=8_000_000, brp=1, tseg1=5, tseg2=2, sjw=1, strict=True
+ )
+ assert timing.f_clock == 8_000_000
+ assert timing.bitrate == 1_000_000
assert timing.brp == 1
assert timing.nbt == 8
assert timing.tseg1 == 5
@@ -45,35 +56,175 @@ def test_sja1000():
assert timing.btr1 == 0x14
-def test_can_fd():
- timing = can.BitTiming(
- f_clock=80000000, bitrate=500000, tseg1=119, tseg2=40, sjw=40
+def test_from_bitrate_and_segments():
+ timing = can.BitTiming.from_bitrate_and_segments(
+ f_clock=8_000_000, bitrate=125_000, tseg1=11, tseg2=4, sjw=2, nof_samples=3
)
- assert timing.f_clock == 80000000
- assert timing.bitrate == 500000
- assert timing.brp == 1
- assert timing.nbt == 160
- assert timing.tseg1 == 119
- assert timing.tseg2 == 40
- assert timing.sjw == 40
+ assert timing.f_clock == 8_000_000
+ assert timing.bitrate == 125_000
+ assert timing.brp == 4
+ assert timing.nbt == 16
+ assert timing.tseg1 == 11
+ assert timing.tseg2 == 4
+ assert timing.sjw == 2
+ assert timing.nof_samples == 3
assert timing.sample_point == 75
+ assert timing.btr0 == 0x43
+ assert timing.btr1 == 0xBA
- timing = can.BitTiming(
- f_clock=80000000, bitrate=2000000, tseg1=29, tseg2=10, sjw=10
+ timing = can.BitTiming.from_bitrate_and_segments(
+ f_clock=8_000_000, bitrate=500_000, tseg1=13, tseg2=2, sjw=1
)
- assert timing.f_clock == 80000000
- assert timing.bitrate == 2000000
+ assert timing.f_clock == 8_000_000
+ assert timing.bitrate == 500_000
assert timing.brp == 1
- assert timing.nbt == 40
- assert timing.tseg1 == 29
- assert timing.tseg2 == 10
- assert timing.sjw == 10
+ assert timing.nbt == 16
+ assert timing.tseg1 == 13
+ assert timing.tseg2 == 2
+ assert timing.sjw == 1
+ assert timing.nof_samples == 1
+ assert timing.sample_point == 87.5
+ assert timing.btr0 == 0x00
+ assert timing.btr1 == 0x1C
+
+ timing = can.BitTiming.from_bitrate_and_segments(
+ f_clock=8_000_000, bitrate=1_000_000, tseg1=5, tseg2=2, sjw=1, strict=True
+ )
+ assert timing.f_clock == 8_000_000
+ assert timing.bitrate == 1_000_000
+ assert timing.brp == 1
+ assert timing.nbt == 8
+ assert timing.tseg1 == 5
+ assert timing.tseg2 == 2
+ assert timing.sjw == 1
+ assert timing.nof_samples == 1
assert timing.sample_point == 75
+ assert timing.btr0 == 0x00
+ assert timing.btr1 == 0x14
+
+ timing = can.BitTimingFd.from_bitrate_and_segments(
+ f_clock=80_000_000,
+ nom_bitrate=500_000,
+ nom_tseg1=119,
+ nom_tseg2=40,
+ nom_sjw=40,
+ data_bitrate=2_000_000,
+ data_tseg1=29,
+ data_tseg2=10,
+ data_sjw=10,
+ )
+
+ assert timing.f_clock == 80_000_000
+ assert timing.nom_bitrate == 500_000
+ assert timing.nom_brp == 1
+ assert timing.nbt == 160
+ assert timing.nom_tseg1 == 119
+ assert timing.nom_tseg2 == 40
+ assert timing.nom_sjw == 40
+ assert timing.nom_sample_point == 75
+ assert timing.f_clock == 80_000_000
+ assert timing.data_bitrate == 2_000_000
+ assert timing.data_brp == 1
+ assert timing.dbt == 40
+ assert timing.data_tseg1 == 29
+ assert timing.data_tseg2 == 10
+ assert timing.data_sjw == 10
+ assert timing.data_sample_point == 75
+
+ # test strict invalid
+ with pytest.raises(ValueError):
+ can.BitTimingFd.from_bitrate_and_segments(
+ f_clock=80_000_000,
+ nom_bitrate=500_000,
+ nom_tseg1=119,
+ nom_tseg2=40,
+ nom_sjw=40,
+ data_bitrate=2_000_000,
+ data_tseg1=29,
+ data_tseg2=10,
+ data_sjw=10,
+ strict=True,
+ )
+
+
+def test_can_fd():
+ # test non-strict
+ timing = can.BitTimingFd(
+ f_clock=80_000_000,
+ nom_brp=1,
+ nom_tseg1=119,
+ nom_tseg2=40,
+ nom_sjw=40,
+ data_brp=1,
+ data_tseg1=29,
+ data_tseg2=10,
+ data_sjw=10,
+ )
+
+ assert timing.f_clock == 80_000_000
+ assert timing.nom_bitrate == 500_000
+ assert timing.nom_brp == 1
+ assert timing.nbt == 160
+ assert timing.nom_tseg1 == 119
+ assert timing.nom_tseg2 == 40
+ assert timing.nom_sjw == 40
+ assert timing.nom_sample_point == 75
+ assert timing.data_bitrate == 2_000_000
+ assert timing.data_brp == 1
+ assert timing.dbt == 40
+ assert timing.data_tseg1 == 29
+ assert timing.data_tseg2 == 10
+ assert timing.data_sjw == 10
+ assert timing.data_sample_point == 75
+
+ # test strict invalid
+ with pytest.raises(ValueError):
+ can.BitTimingFd(
+ f_clock=80_000_000,
+ nom_brp=1,
+ nom_tseg1=119,
+ nom_tseg2=40,
+ nom_sjw=40,
+ data_brp=1,
+ data_tseg1=29,
+ data_tseg2=10,
+ data_sjw=10,
+ strict=True,
+ )
+
+ # test strict valid
+ timing = can.BitTimingFd(
+ f_clock=80_000_000,
+ nom_brp=2,
+ nom_tseg1=59,
+ nom_tseg2=20,
+ nom_sjw=20,
+ data_brp=2,
+ data_tseg1=14,
+ data_tseg2=5,
+ data_sjw=5,
+ strict=True,
+ )
+ assert timing.f_clock == 80_000_000
+ assert timing.nom_bitrate == 500_000
+ assert timing.nom_brp == 2
+ assert timing.nbt == 80
+ assert timing.nom_tseg1 == 59
+ assert timing.nom_tseg2 == 20
+ assert timing.nom_sjw == 20
+ assert timing.nom_sample_point == 75
+ assert timing.data_bitrate == 2_000_000
+ assert timing.data_brp == 2
+ assert timing.dbt == 20
+ assert timing.data_tseg1 == 14
+ assert timing.data_tseg2 == 5
+ assert timing.data_sjw == 5
+ assert timing.data_sample_point == 75
def test_from_btr():
- timing = can.BitTiming(f_clock=8000000, btr0=0x00, btr1=0x14)
- assert timing.bitrate == 1000000
+ timing = can.BitTiming.from_registers(f_clock=8_000_000, btr0=0x00, btr1=0x14)
+ assert timing.bitrate == 1_000_000
assert timing.brp == 1
assert timing.nbt == 8
assert timing.tseg1 == 5
@@ -84,9 +235,297 @@ def test_from_btr():
assert timing.btr1 == 0x14
+def test_btr_persistence():
+ f_clock = 8_000_000
+ for btr0btr1 in PCAN_BITRATES.values():
+ btr0, btr1 = struct.pack(">H", btr0btr1.value)
+
+ t = can.BitTiming.from_registers(f_clock, btr0, btr1)
+ assert t.btr0 == btr0
+ assert t.btr1 == btr1
+
+
+def test_from_sample_point():
+ timing = can.BitTiming.from_sample_point(
+ f_clock=16_000_000,
+ bitrate=500_000,
+ sample_point=69.0,
+ )
+ assert timing.f_clock == 16_000_000
+ assert timing.bitrate == 500_000
+ assert 68 < timing.sample_point < 70
+
+ fd_timing = can.BitTimingFd.from_sample_point(
+ f_clock=80_000_000,
+ nom_bitrate=1_000_000,
+ nom_sample_point=75.0,
+ data_bitrate=8_000_000,
+ data_sample_point=70.0,
+ )
+ assert fd_timing.f_clock == 80_000_000
+ assert fd_timing.nom_bitrate == 1_000_000
+ assert 74 < fd_timing.nom_sample_point < 76
+ assert fd_timing.data_bitrate == 8_000_000
+ assert 69 < fd_timing.data_sample_point < 71
+
+ # check that there is a solution for every sample point
+ for sp in range(50, 100):
+ can.BitTiming.from_sample_point(
+ f_clock=16_000_000, bitrate=500_000, sample_point=sp
+ )
+
+ # check that there is a solution for every sample point
+ for nsp in range(50, 100):
+ for dsp in range(50, 100):
+ can.BitTimingFd.from_sample_point(
+ f_clock=80_000_000,
+ nom_bitrate=500_000,
+ nom_sample_point=nsp,
+ data_bitrate=2_000_000,
+ data_sample_point=dsp,
+ )
+
+
+def test_iterate_from_sample_point():
+ for sp in range(50, 100):
+ solutions = list(
+ can.BitTiming.iterate_from_sample_point(
+ f_clock=16_000_000,
+ bitrate=500_000,
+ sample_point=sp,
+ )
+ )
+ assert len(solutions) >= 2
+
+ for nsp in range(50, 100):
+ for dsp in range(50, 100):
+ solutions = list(
+ can.BitTimingFd.iterate_from_sample_point(
+ f_clock=80_000_000,
+ nom_bitrate=500_000,
+ nom_sample_point=nsp,
+ data_bitrate=2_000_000,
+ data_sample_point=dsp,
+ )
+ )
+
+ assert len(solutions) >= 2
+
+
+def test_equality():
+ t1 = can.BitTiming.from_registers(f_clock=8_000_000, btr0=0x00, btr1=0x14)
+ t2 = can.BitTiming(f_clock=8_000_000, brp=1, tseg1=5, tseg2=2, sjw=1, nof_samples=1)
+ t3 = can.BitTiming(
+ f_clock=16_000_000, brp=2, tseg1=5, tseg2=2, sjw=1, nof_samples=1
+ )
+ assert t1 == t2
+ assert t1 != t3
+ assert t2 != t3
+ assert t1 != 10
+
+ t4 = can.BitTimingFd(
+ f_clock=80_000_000,
+ nom_brp=1,
+ nom_tseg1=119,
+ nom_tseg2=40,
+ nom_sjw=40,
+ data_brp=1,
+ data_tseg1=29,
+ data_tseg2=10,
+ data_sjw=10,
+ )
+ t5 = can.BitTimingFd(
+ f_clock=80_000_000,
+ nom_brp=1,
+ nom_tseg1=119,
+ nom_tseg2=40,
+ nom_sjw=40,
+ data_brp=1,
+ data_tseg1=29,
+ data_tseg2=10,
+ data_sjw=10,
+ )
+ t6 = can.BitTimingFd.from_sample_point(
+ f_clock=80_000_000,
+ nom_bitrate=1_000_000,
+ nom_sample_point=75.0,
+ data_bitrate=8_000_000,
+ data_sample_point=70.0,
+ )
+ assert t4 == t5
+ assert t4 != t6
+ assert t4 != t1
+
+
def test_string_representation():
- timing = can.BitTiming(f_clock=8000000, bitrate=1000000, tseg1=5, tseg2=2, sjw=1)
- assert (
- str(timing)
- == "1000000 bits/s, sample point: 75.00%, BRP: 1, TSEG1: 5, TSEG2: 2, SJW: 1, BTR: 0014h"
+ timing = can.BitTiming(f_clock=8_000_000, brp=1, tseg1=5, tseg2=2, sjw=1)
+ assert str(timing) == (
+ "BR: 1_000_000 bit/s, SP: 75.00%, BRP: 1, TSEG1: 5, TSEG2: 2, SJW: 1, "
+ "BTR: 0014h, CLK: 8MHz"
+ )
+
+ fd_timing = can.BitTimingFd(
+ f_clock=80_000_000,
+ nom_brp=1,
+ nom_tseg1=119,
+ nom_tseg2=40,
+ nom_sjw=40,
+ data_brp=1,
+ data_tseg1=29,
+ data_tseg2=10,
+ data_sjw=10,
+ )
+ assert str(fd_timing) == (
+ "NBR: 500_000 bit/s, NSP: 75.00%, NBRP: 1, NTSEG1: 119, NTSEG2: 40, NSJW: 40, "
+ "DBR: 2_000_000 bit/s, DSP: 75.00%, DBRP: 1, DTSEG1: 29, DTSEG2: 10, DSJW: 10, "
+ "CLK: 80MHz"
+ )
+
+
+def test_repr():
+ timing = can.BitTiming(f_clock=8_000_000, brp=1, tseg1=5, tseg2=2, sjw=1)
+ assert repr(timing) == (
+ "can.BitTiming(f_clock=8000000, brp=1, tseg1=5, tseg2=2, sjw=1, nof_samples=1)"
+ )
+
+ fd_timing = can.BitTimingFd(
+ f_clock=80_000_000,
+ nom_brp=1,
+ nom_tseg1=119,
+ nom_tseg2=40,
+ nom_sjw=40,
+ data_brp=1,
+ data_tseg1=29,
+ data_tseg2=10,
+ data_sjw=10,
+ )
+ assert repr(fd_timing) == (
+ "can.BitTimingFd(f_clock=80000000, nom_brp=1, nom_tseg1=119, nom_tseg2=40, "
+ "nom_sjw=40, data_brp=1, data_tseg1=29, data_tseg2=10, data_sjw=10)"
+ )
+
+
+def test_hash():
+ _timings = {
+ can.BitTiming(f_clock=8_000_000, brp=1, tseg1=5, tseg2=2, sjw=1, nof_samples=1),
+ can.BitTimingFd(
+ f_clock=80_000_000,
+ nom_brp=1,
+ nom_tseg1=119,
+ nom_tseg2=40,
+ nom_sjw=40,
+ data_brp=1,
+ data_tseg1=29,
+ data_tseg2=10,
+ data_sjw=10,
+ ),
+ }
+
+
+def test_mapping():
+ timing = can.BitTiming(f_clock=8_000_000, brp=1, tseg1=5, tseg2=2, sjw=1)
+ timing_dict = dict(timing)
+ assert timing_dict["f_clock"] == timing["f_clock"]
+ assert timing_dict["brp"] == timing["brp"]
+ assert timing_dict["tseg1"] == timing["tseg1"]
+ assert timing_dict["tseg2"] == timing["tseg2"]
+ assert timing_dict["sjw"] == timing["sjw"]
+ assert timing == can.BitTiming(**timing_dict)
+
+ fd_timing = can.BitTimingFd(
+ f_clock=80_000_000,
+ nom_brp=1,
+ nom_tseg1=119,
+ nom_tseg2=40,
+ nom_sjw=40,
+ data_brp=1,
+ data_tseg1=29,
+ data_tseg2=10,
+ data_sjw=10,
+ )
+ fd_timing_dict = dict(fd_timing)
+ assert fd_timing_dict["f_clock"] == fd_timing["f_clock"]
+ assert fd_timing_dict["nom_brp"] == fd_timing["nom_brp"]
+ assert fd_timing_dict["nom_tseg1"] == fd_timing["nom_tseg1"]
+ assert fd_timing_dict["nom_tseg2"] == fd_timing["nom_tseg2"]
+ assert fd_timing_dict["nom_sjw"] == fd_timing["nom_sjw"]
+ assert fd_timing_dict["data_brp"] == fd_timing["data_brp"]
+ assert fd_timing_dict["data_tseg1"] == fd_timing["data_tseg1"]
+ assert fd_timing_dict["data_tseg2"] == fd_timing["data_tseg2"]
+ assert fd_timing_dict["data_sjw"] == fd_timing["data_sjw"]
+ assert fd_timing == can.BitTimingFd(**fd_timing_dict)
+
+
+def test_oscillator_tolerance():
+ timing = can.BitTiming(f_clock=16_000_000, brp=2, tseg1=10, tseg2=5, sjw=4)
+ osc_tol = timing.oscillator_tolerance(
+ node_loop_delay_ns=250,
+ bus_length_m=10.0,
+ )
+ assert osc_tol == pytest.approx(1.23, abs=1e-2)
+
+ fd_timing = can.BitTimingFd(
+ f_clock=80_000_000,
+ nom_brp=5,
+ nom_tseg1=27,
+ nom_tseg2=4,
+ nom_sjw=4,
+ data_brp=5,
+ data_tseg1=6,
+ data_tseg2=1,
+ data_sjw=1,
+ )
+ osc_tol = fd_timing.oscillator_tolerance(
+ node_loop_delay_ns=250,
+ bus_length_m=10.0,
+ )
+ assert osc_tol == pytest.approx(0.48, abs=1e-2)
+
+
+def test_recreate_with_f_clock():
+ timing_8mhz = can.BitTiming(f_clock=8_000_000, brp=1, tseg1=5, tseg2=2, sjw=1)
+ timing_16mhz = timing_8mhz.recreate_with_f_clock(f_clock=16_000_000)
+ assert timing_8mhz.bitrate == timing_16mhz.bitrate
+ assert timing_8mhz.sample_point == timing_16mhz.sample_point
+ assert (timing_8mhz.sjw / timing_8mhz.nbt) == pytest.approx(
+ timing_16mhz.sjw / timing_16mhz.nbt, abs=1e-3
+ )
+ assert timing_8mhz.nof_samples == timing_16mhz.nof_samples
+
+ timing_16mhz = can.BitTiming(
+ f_clock=16000000, brp=2, tseg1=12, tseg2=3, sjw=3, nof_samples=1
+ )
+ timing_8mhz = timing_16mhz.recreate_with_f_clock(f_clock=8_000_000)
+ assert timing_8mhz.bitrate == timing_16mhz.bitrate
+ assert timing_8mhz.sample_point == timing_16mhz.sample_point
+ assert (timing_8mhz.sjw / timing_8mhz.nbt) == pytest.approx(
+ timing_16mhz.sjw / timing_16mhz.nbt, abs=1e-2
+ )
+ assert timing_8mhz.nof_samples == timing_16mhz.nof_samples
+
+ fd_timing_80mhz = can.BitTimingFd(
+ f_clock=80_000_000,
+ nom_brp=5,
+ nom_tseg1=27,
+ nom_tseg2=4,
+ nom_sjw=4,
+ data_brp=5,
+ data_tseg1=6,
+ data_tseg2=1,
+ data_sjw=1,
+ )
+ fd_timing_60mhz = fd_timing_80mhz.recreate_with_f_clock(f_clock=60_000_000)
+ assert fd_timing_80mhz.nom_bitrate == fd_timing_60mhz.nom_bitrate
+ assert fd_timing_80mhz.nom_sample_point == pytest.approx(
+ fd_timing_60mhz.nom_sample_point, abs=1.0
+ )
+ assert (fd_timing_80mhz.nom_sjw / fd_timing_80mhz.nbt) == pytest.approx(
+ fd_timing_60mhz.nom_sjw / fd_timing_60mhz.nbt, abs=1e-2
+ )
+ assert fd_timing_80mhz.data_bitrate == fd_timing_60mhz.data_bitrate
+ assert fd_timing_80mhz.data_sample_point == pytest.approx(
+ fd_timing_60mhz.data_sample_point, abs=1.0
+ )
+ assert (fd_timing_80mhz.data_sjw / fd_timing_80mhz.dbt) == pytest.approx(
+ fd_timing_60mhz.data_sjw / fd_timing_60mhz.dbt, abs=1e-2
)
diff --git a/test/test_bridge.py b/test/test_bridge.py
new file mode 100644
index 000000000..ee41bd949
--- /dev/null
+++ b/test/test_bridge.py
@@ -0,0 +1,126 @@
+#!/usr/bin/env python
+
+"""
+This module tests the functions inside of bridge.py
+"""
+
+import random
+import string
+import sys
+import threading
+import time
+from time import sleep as real_sleep
+import unittest.mock
+
+import can
+import can.bridge
+from can.interfaces import virtual
+
+from .message_helper import ComparingMessagesTestCase
+
+
+class TestBridgeScriptModule(unittest.TestCase, ComparingMessagesTestCase):
+
+ TIMEOUT = 3.0
+
+ def __init__(self, *args, **kwargs):
+ unittest.TestCase.__init__(self, *args, **kwargs)
+ ComparingMessagesTestCase.__init__(
+ self,
+ allowed_timestamp_delta=None,
+ preserves_channel=False,
+ )
+
+ def setUp(self) -> None:
+ self.stop_event = threading.Event()
+
+ self.channel1 = "".join(random.choices(string.ascii_letters, k=8))
+ self.channel2 = "".join(random.choices(string.ascii_letters, k=8))
+
+ self.cli_args = [
+ "--bus1-interface",
+ "virtual",
+ "--bus1-channel",
+ self.channel1,
+ "--bus2-interface",
+ "virtual",
+ "--bus2-channel",
+ self.channel2,
+ ]
+
+ self.testmsg = can.Message(
+ arbitration_id=0xC0FFEE, data=[0, 25, 0, 1, 3, 1, 4, 1], is_extended_id=True
+ )
+
+ def fake_sleep(self, duration):
+ """A fake replacement for time.sleep that checks periodically
+ whether self.stop_event is set, and raises KeyboardInterrupt
+ if so.
+
+ This allows tests to simulate an interrupt (like Ctrl+C)
+ during long sleeps, in a controlled and responsive way.
+ """
+ interval = 0.05 # Small interval for responsiveness
+ t_wakeup = time.perf_counter() + duration
+ while time.perf_counter() < t_wakeup:
+ if self.stop_event.is_set():
+ raise KeyboardInterrupt("Simulated interrupt from fake_sleep")
+ real_sleep(interval)
+
+ def test_bridge(self):
+ with (
+ unittest.mock.patch("can.bridge.time.sleep", new=self.fake_sleep),
+ unittest.mock.patch("can.bridge.sys.argv", [sys.argv[0], *self.cli_args]),
+ ):
+ # start script
+ thread = threading.Thread(target=can.bridge.main)
+ thread.start()
+
+ # wait until script instantiates virtual buses
+ t0 = time.perf_counter()
+ while True:
+ with virtual.channels_lock:
+ if (
+ self.channel1 in virtual.channels
+ and self.channel2 in virtual.channels
+ ):
+ break
+ if time.perf_counter() > t0 + 2.0:
+ raise TimeoutError("Bridge script did not create virtual buses")
+ real_sleep(0.2)
+
+ # create buses with the same channels as in scripts
+ with (
+ can.interfaces.virtual.VirtualBus(self.channel1) as bus1,
+ can.interfaces.virtual.VirtualBus(self.channel2) as bus2,
+ ):
+ # send test message to bus1, it should be received on bus2
+ bus1.send(self.testmsg)
+ recv_msg = bus2.recv(self.TIMEOUT)
+ self.assertMessageEqual(self.testmsg, recv_msg)
+
+ # assert that both buses are empty
+ self.assertIsNone(bus1.recv(0))
+ self.assertIsNone(bus2.recv(0))
+
+ # send test message to bus2, it should be received on bus1
+ bus2.send(self.testmsg)
+ recv_msg = bus1.recv(self.TIMEOUT)
+ self.assertMessageEqual(self.testmsg, recv_msg)
+
+ # assert that both buses are empty
+ self.assertIsNone(bus1.recv(0))
+ self.assertIsNone(bus2.recv(0))
+
+ # stop the bridge script
+ self.stop_event.set()
+ thread.join()
+
+ # assert that the virtual buses were closed
+ with virtual.channels_lock:
+ self.assertNotIn(self.channel1, virtual.channels)
+ self.assertNotIn(self.channel2, virtual.channels)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/test/test_bus.py b/test/test_bus.py
new file mode 100644
index 000000000..6a09a6deb
--- /dev/null
+++ b/test/test_bus.py
@@ -0,0 +1,23 @@
+import gc
+from unittest.mock import patch
+
+import can
+
+
+def test_bus_ignore_config():
+ with patch.object(
+ target=can.util, attribute="load_config", side_effect=can.util.load_config
+ ):
+ with can.Bus(interface="virtual", ignore_config=True):
+ assert not can.util.load_config.called
+
+ with can.Bus(interface="virtual"):
+ assert can.util.load_config.called
+
+
+@patch.object(can.bus.BusABC, "shutdown")
+def test_bus_attempts_self_cleanup(mock_shutdown):
+ bus = can.Bus(interface="virtual")
+ del bus
+ gc.collect()
+ mock_shutdown.assert_called()
diff --git a/test/test_cantact.py b/test/test_cantact.py
new file mode 100644
index 000000000..f90655ae5
--- /dev/null
+++ b/test/test_cantact.py
@@ -0,0 +1,63 @@
+#!/usr/bin/env python
+
+"""
+Tests for CANtact interfaces
+"""
+
+import unittest
+
+import can
+from can.interfaces import cantact
+
+
+class CantactTest(unittest.TestCase):
+ def test_bus_creation(self):
+ bus = can.Bus(channel=0, interface="cantact", _testing=True)
+ self.assertIsInstance(bus, cantact.CantactBus)
+ self.assertEqual(bus.protocol, can.CanProtocol.CAN_20)
+
+ cantact.MockInterface.set_bitrate.assert_called()
+ cantact.MockInterface.set_bit_timing.assert_not_called()
+ cantact.MockInterface.set_enabled.assert_called()
+ cantact.MockInterface.set_monitor.assert_called()
+ cantact.MockInterface.start.assert_called()
+
+ def test_bus_creation_bittiming(self):
+ cantact.MockInterface.set_bitrate.reset_mock()
+
+ bt = can.BitTiming(f_clock=24_000_000, brp=3, tseg1=13, tseg2=2, sjw=1)
+ bus = can.Bus(channel=0, interface="cantact", timing=bt, _testing=True)
+
+ self.assertIsInstance(bus, cantact.CantactBus)
+ self.assertEqual(bus.protocol, can.CanProtocol.CAN_20)
+
+ cantact.MockInterface.set_bitrate.assert_not_called()
+ cantact.MockInterface.set_bit_timing.assert_called()
+ cantact.MockInterface.set_enabled.assert_called()
+ cantact.MockInterface.set_monitor.assert_called()
+ cantact.MockInterface.start.assert_called()
+
+ def test_transmit(self):
+ bus = can.Bus(channel=0, interface="cantact", _testing=True)
+ msg = can.Message(
+ arbitration_id=0xC0FFEF, data=[1, 2, 3, 4, 5, 6, 7, 8], is_extended_id=True
+ )
+ bus.send(msg)
+ cantact.MockInterface.send.assert_called()
+
+ def test_recv(self):
+ bus = can.Bus(channel=0, interface="cantact", _testing=True)
+ frame = bus.recv(timeout=0.5)
+ cantact.MockInterface.recv.assert_called()
+ self.assertIsInstance(frame, can.Message)
+
+ def test_recv_timeout(self):
+ bus = can.Bus(channel=0, interface="cantact", _testing=True)
+ frame = bus.recv(timeout=0.0)
+ cantact.MockInterface.recv.assert_called()
+ self.assertIsNone(frame)
+
+ def test_shutdown(self):
+ bus = can.Bus(channel=0, interface="cantact", _testing=True)
+ bus.shutdown()
+ cantact.MockInterface.stop.assert_called()
diff --git a/test/test_cli.py b/test/test_cli.py
new file mode 100644
index 000000000..ecc662832
--- /dev/null
+++ b/test/test_cli.py
@@ -0,0 +1,154 @@
+import argparse
+import unittest
+from unittest.mock import patch
+
+from can.cli import add_bus_arguments, create_bus_from_namespace
+
+
+class TestCliUtils(unittest.TestCase):
+ def test_add_bus_arguments(self):
+ parser = argparse.ArgumentParser()
+ add_bus_arguments(parser, filter_arg=True, prefix="test")
+
+ parsed_args = parser.parse_args(
+ [
+ "--test-channel",
+ "0",
+ "--test-interface",
+ "vector",
+ "--test-timing",
+ "f_clock=8000000",
+ "brp=4",
+ "tseg1=11",
+ "tseg2=4",
+ "sjw=2",
+ "nof_samples=3",
+ "--test-filter",
+ "100:7FF",
+ "200~7F0",
+ "--test-bus-kwargs",
+ "app_name=MyApp",
+ "serial=1234",
+ ]
+ )
+
+ self.assertNotIn("channel", parsed_args)
+ self.assertNotIn("test_bitrate", parsed_args)
+ self.assertNotIn("test_data_bitrate", parsed_args)
+ self.assertNotIn("test_fd", parsed_args)
+
+ self.assertEqual(parsed_args.test_channel, "0")
+ self.assertEqual(parsed_args.test_interface, "vector")
+ self.assertEqual(parsed_args.test_timing.f_clock, 8000000)
+ self.assertEqual(parsed_args.test_timing.brp, 4)
+ self.assertEqual(parsed_args.test_timing.tseg1, 11)
+ self.assertEqual(parsed_args.test_timing.tseg2, 4)
+ self.assertEqual(parsed_args.test_timing.sjw, 2)
+ self.assertEqual(parsed_args.test_timing.nof_samples, 3)
+ self.assertEqual(len(parsed_args.test_can_filters), 2)
+ self.assertEqual(parsed_args.test_can_filters[0]["can_id"], 0x100)
+ self.assertEqual(parsed_args.test_can_filters[0]["can_mask"], 0x7FF)
+ self.assertEqual(parsed_args.test_can_filters[1]["can_id"], 0x200 | 0x20000000)
+ self.assertEqual(
+ parsed_args.test_can_filters[1]["can_mask"], 0x7F0 & 0x20000000
+ )
+ self.assertEqual(parsed_args.test_bus_kwargs["app_name"], "MyApp")
+ self.assertEqual(parsed_args.test_bus_kwargs["serial"], 1234)
+
+ def test_add_bus_arguments_no_prefix(self):
+ parser = argparse.ArgumentParser()
+ add_bus_arguments(parser, filter_arg=True)
+
+ parsed_args = parser.parse_args(
+ [
+ "--channel",
+ "0",
+ "--interface",
+ "vector",
+ "--timing",
+ "f_clock=8000000",
+ "brp=4",
+ "tseg1=11",
+ "tseg2=4",
+ "sjw=2",
+ "nof_samples=3",
+ "--filter",
+ "100:7FF",
+ "200~7F0",
+ "--bus-kwargs",
+ "app_name=MyApp",
+ "serial=1234",
+ ]
+ )
+
+ self.assertEqual(parsed_args.channel, "0")
+ self.assertEqual(parsed_args.interface, "vector")
+ self.assertEqual(parsed_args.timing.f_clock, 8000000)
+ self.assertEqual(parsed_args.timing.brp, 4)
+ self.assertEqual(parsed_args.timing.tseg1, 11)
+ self.assertEqual(parsed_args.timing.tseg2, 4)
+ self.assertEqual(parsed_args.timing.sjw, 2)
+ self.assertEqual(parsed_args.timing.nof_samples, 3)
+ self.assertEqual(len(parsed_args.can_filters), 2)
+ self.assertEqual(parsed_args.can_filters[0]["can_id"], 0x100)
+ self.assertEqual(parsed_args.can_filters[0]["can_mask"], 0x7FF)
+ self.assertEqual(parsed_args.can_filters[1]["can_id"], 0x200 | 0x20000000)
+ self.assertEqual(parsed_args.can_filters[1]["can_mask"], 0x7F0 & 0x20000000)
+ self.assertEqual(parsed_args.bus_kwargs["app_name"], "MyApp")
+ self.assertEqual(parsed_args.bus_kwargs["serial"], 1234)
+
+ @patch("can.Bus")
+ def test_create_bus_from_namespace(self, mock_bus):
+ namespace = argparse.Namespace(
+ test_channel="vcan0",
+ test_interface="virtual",
+ test_bitrate=500000,
+ test_data_bitrate=2000000,
+ test_fd=True,
+ test_can_filters=[{"can_id": 0x100, "can_mask": 0x7FF}],
+ test_bus_kwargs={"app_name": "MyApp", "serial": 1234},
+ )
+
+ create_bus_from_namespace(namespace, prefix="test")
+
+ mock_bus.assert_called_once_with(
+ channel="vcan0",
+ interface="virtual",
+ bitrate=500000,
+ data_bitrate=2000000,
+ fd=True,
+ can_filters=[{"can_id": 0x100, "can_mask": 0x7FF}],
+ app_name="MyApp",
+ serial=1234,
+ single_handle=True,
+ )
+
+ @patch("can.Bus")
+ def test_create_bus_from_namespace_no_prefix(self, mock_bus):
+ namespace = argparse.Namespace(
+ channel="vcan0",
+ interface="virtual",
+ bitrate=500000,
+ data_bitrate=2000000,
+ fd=True,
+ can_filters=[{"can_id": 0x100, "can_mask": 0x7FF}],
+ bus_kwargs={"app_name": "MyApp", "serial": 1234},
+ )
+
+ create_bus_from_namespace(namespace)
+
+ mock_bus.assert_called_once_with(
+ channel="vcan0",
+ interface="virtual",
+ bitrate=500000,
+ data_bitrate=2000000,
+ fd=True,
+ can_filters=[{"can_id": 0x100, "can_mask": 0x7FF}],
+ app_name="MyApp",
+ serial=1234,
+ single_handle=True,
+ )
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/test/test_cyclic_socketcan.py b/test/test_cyclic_socketcan.py
index bb5411be9..f19ce95b9 100644
--- a/test/test_cyclic_socketcan.py
+++ b/test/test_cyclic_socketcan.py
@@ -1,9 +1,11 @@
+#!/usr/bin/env python
+
"""
This module tests multiple message cyclic send tasks.
"""
+import time
import unittest
-import time
import can
from .config import TEST_INTERFACE_SOCKETCAN
@@ -244,7 +246,21 @@ def test_cyclic_initializer_different_arbitration_ids(self):
with self.assertRaises(ValueError):
task = self._send_bus.send_periodic(messages, self.PERIOD)
- def test_create_same_id_raises_exception(self):
+ def test_start_already_started_task(self):
+ messages_a = can.Message(
+ arbitration_id=0x401,
+ data=[0x11, 0x11, 0x11, 0x11, 0x11, 0x11],
+ is_extended_id=False,
+ )
+
+ task_a = self._send_bus.send_periodic(messages_a, self.PERIOD)
+ time.sleep(0.1)
+
+ # Task restarting is permitted as of #1440
+ task_a.start()
+ task_a.stop()
+
+ def test_create_same_id(self):
messages_a = can.Message(
arbitration_id=0x401,
data=[0x11, 0x11, 0x11, 0x11, 0x11, 0x11],
@@ -257,13 +273,41 @@ def test_create_same_id_raises_exception(self):
is_extended_id=False,
)
- task_a = self._send_bus.send_periodic(messages_a, 1)
+ task_a = self._send_bus.send_periodic(messages_a, self.PERIOD)
self.assertIsInstance(task_a, can.broadcastmanager.CyclicSendTaskABC)
+ task_b = self._send_bus.send_periodic(messages_b, self.PERIOD)
+ self.assertIsInstance(task_b, can.broadcastmanager.CyclicSendTaskABC)
- # The second one raises a ValueError when we attempt to create a new
- # Task, since it has the same arbitration ID.
- with self.assertRaises(ValueError):
- task_b = self._send_bus.send_periodic(messages_b, 1)
+ time.sleep(self.PERIOD * 4)
+
+ task_a.stop()
+ task_b.stop()
+
+ msgs = []
+ for _ in range(4):
+ msg = self._recv_bus.recv(self.PERIOD * 2)
+ self.assertIsNotNone(msg)
+
+ msgs.append(msg)
+
+ self.assertTrue(len(msgs) >= 4)
+
+ # Both messages should be recevied on the bus,
+ # even with the same arbitration id
+ msg_a_data_present = msg_b_data_present = False
+ for rx_message in msgs:
+ self.assertTrue(
+ rx_message.arbitration_id
+ == messages_a.arbitration_id
+ == messages_b.arbitration_id
+ )
+ if rx_message.data == messages_a.data:
+ msg_a_data_present = True
+ if rx_message.data == messages_b.data:
+ msg_b_data_present = True
+
+ self.assertTrue(msg_a_data_present)
+ self.assertTrue(msg_b_data_present)
def test_modify_data_list(self):
messages_odd = []
diff --git a/test/test_detect_available_configs.py b/test/test_detect_available_configs.py
index 0d94e31f1..f6590c276 100644
--- a/test/test_detect_available_configs.py
+++ b/test/test_detect_available_configs.py
@@ -1,17 +1,15 @@
#!/usr/bin/env python
-# coding: utf-8
"""
This module tests :meth:`can.BusABC._detect_available_configs` and
:meth:`can.BusABC.detect_available_configs`.
"""
-import sys
import unittest
from can import detect_available_configs
-from .config import IS_LINUX, IS_CI, TEST_INTERFACE_SOCKETCAN
+from .config import IS_CI, IS_UNIX, TEST_INTERFACE_SOCKETCAN
class TestDetectAvailableConfigs(unittest.TestCase):
@@ -30,19 +28,33 @@ def test_general_values(self):
for config in configs:
self.assertIn("interface", config)
self.assertIn("channel", config)
- self.assertIsInstance(config["interface"], str)
def test_content_virtual(self):
configs = detect_available_configs(interfaces="virtual")
+ self.assertGreaterEqual(len(configs), 1)
for config in configs:
self.assertEqual(config["interface"], "virtual")
+ def test_content_udp_multicast(self):
+ configs = detect_available_configs(interfaces="udp_multicast")
+ for config in configs:
+ self.assertEqual(config["interface"], "udp_multicast")
+
def test_content_socketcan(self):
configs = detect_available_configs(interfaces="socketcan")
for config in configs:
self.assertEqual(config["interface"], "socketcan")
- @unittest.skipUnless(TEST_INTERFACE_SOCKETCAN, "socketcan is not tested")
+ def test_count_udp_multicast(self):
+ configs = detect_available_configs(interfaces="udp_multicast")
+ if IS_UNIX:
+ self.assertGreaterEqual(len(configs), 2)
+ else:
+ self.assertEqual(len(configs), 0)
+
+ @unittest.skipUnless(
+ TEST_INTERFACE_SOCKETCAN and IS_CI, "this setup is very specific"
+ )
def test_socketcan_on_ci_server(self):
configs = detect_available_configs(interfaces="socketcan")
self.assertGreaterEqual(len(configs), 1)
diff --git a/test/test_interface.py b/test/test_interface.py
new file mode 100644
index 000000000..271e90b1b
--- /dev/null
+++ b/test/test_interface.py
@@ -0,0 +1,42 @@
+import importlib
+from unittest.mock import patch
+
+import pytest
+
+import can
+from can.interfaces import BACKENDS
+
+
+@pytest.fixture(params=(BACKENDS.keys()))
+def constructor(request):
+ mod, cls = BACKENDS[request.param]
+
+ try:
+ module = importlib.import_module(mod)
+ constructor = getattr(module, cls)
+ except:
+ pytest.skip("Unable to load interface")
+
+ return constructor
+
+
+@pytest.fixture
+def interface(constructor):
+ class MockInterface(constructor):
+ def __init__(self):
+ pass
+
+ def __del__(self):
+ pass
+
+ return MockInterface()
+
+
+@patch.object(can.bus.BusABC, "shutdown")
+def test_interface_calls_parent_shutdown(mock_shutdown, interface):
+ try:
+ interface.shutdown()
+ except:
+ pass
+ finally:
+ mock_shutdown.assert_called()
diff --git a/test/test_interface_canalystii.py b/test/test_interface_canalystii.py
new file mode 100755
index 000000000..3bdd281d2
--- /dev/null
+++ b/test/test_interface_canalystii.py
@@ -0,0 +1,105 @@
+#!/usr/bin/env python
+
+""" """
+
+import unittest
+from ctypes import c_ubyte
+from unittest.mock import call, patch
+
+import canalystii as driver # low-level driver module, mock out this layer
+
+import can
+from can.interfaces.canalystii import CANalystIIBus
+
+
+def create_mock_device():
+ return patch("canalystii.CanalystDevice")
+
+
+class CanalystIITest(unittest.TestCase):
+ def test_initialize_from_constructor(self):
+ with create_mock_device() as mock_device:
+ instance = mock_device.return_value
+ bus = CANalystIIBus(bitrate=1000000)
+
+ self.assertEqual(bus.protocol, can.CanProtocol.CAN_20)
+
+ instance.init.assert_has_calls(
+ [
+ call(0, bitrate=1000000),
+ call(1, bitrate=1000000),
+ ]
+ )
+
+ def test_initialize_single_channel_only(self):
+ for channel in 0, 1:
+ with create_mock_device() as mock_device:
+ instance = mock_device.return_value
+ bus = CANalystIIBus(channel, bitrate=1000000)
+
+ self.assertEqual(bus.protocol, can.CanProtocol.CAN_20)
+ instance.init.assert_called_once_with(channel, bitrate=1000000)
+
+ def test_initialize_with_timing_registers(self):
+ with create_mock_device() as mock_device:
+ instance = mock_device.return_value
+ timing = can.BitTiming.from_registers(
+ f_clock=8_000_000, btr0=0x03, btr1=0x6F
+ )
+ bus = CANalystIIBus(bitrate=None, timing=timing)
+ self.assertEqual(bus.protocol, can.CanProtocol.CAN_20)
+
+ instance.init.assert_has_calls(
+ [
+ call(0, timing0=0x03, timing1=0x6F),
+ call(1, timing0=0x03, timing1=0x6F),
+ ]
+ )
+
+ def test_missing_bitrate(self):
+ with self.assertRaises(ValueError) as cm:
+ bus = CANalystIIBus(0, bitrate=None, timing=None)
+ self.assertIn("bitrate", str(cm.exception))
+
+ def test_receive_message(self):
+ driver_message = driver.Message(
+ can_id=0x333,
+ timestamp=1000000,
+ time_flag=1,
+ send_type=0,
+ remote=False,
+ extended=False,
+ data_len=8,
+ data=(c_ubyte * 8)(*range(8)),
+ )
+
+ with create_mock_device() as mock_device:
+ instance = mock_device.return_value
+ instance.receive.return_value = [driver_message]
+ bus = CANalystIIBus(bitrate=1000000)
+ msg = bus.recv(0)
+ self.assertEqual(driver_message.can_id, msg.arbitration_id)
+ self.assertEqual(bytearray(driver_message.data), msg.data)
+
+ def test_send_message(self):
+ message = can.Message(arbitration_id=0x123, data=[3] * 8, is_extended_id=False)
+
+ with create_mock_device() as mock_device:
+ instance = mock_device.return_value
+ bus = CANalystIIBus(channel=0, bitrate=5000000)
+ bus.send(message)
+ instance.send.assert_called_once()
+
+ (channel, driver_messages, _timeout), _kwargs = instance.send.call_args
+ self.assertEqual(0, channel)
+
+ self.assertEqual(1, len(driver_messages))
+
+ driver_message = driver_messages[0]
+ self.assertEqual(message.arbitration_id, driver_message.can_id)
+ self.assertEqual(message.data, bytearray(driver_message.data))
+ self.assertEqual(8, driver_message.data_len)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/test/test_interface_ixxat.py b/test/test_interface_ixxat.py
new file mode 100644
index 000000000..90b5f7adc
--- /dev/null
+++ b/test/test_interface_ixxat.py
@@ -0,0 +1,77 @@
+#!/usr/bin/env python
+
+"""
+Unittest for ixxat interface.
+
+Run only this test:
+python setup.py test --addopts "--verbose -s test/test_interface_ixxat.py"
+"""
+
+import unittest
+
+import can
+
+
+class SoftwareTestCase(unittest.TestCase):
+ """
+ Test cases that test the software only and do not rely on an existing/connected hardware.
+ """
+
+ def setUp(self):
+ try:
+ bus = can.Bus(interface="ixxat", channel=0)
+ bus.shutdown()
+ except can.CanInterfaceNotImplementedError:
+ raise unittest.SkipTest("not available on this platform")
+
+ def test_bus_creation(self):
+ # channel must be >= 0
+ with self.assertRaises(ValueError):
+ can.Bus(interface="ixxat", channel=-1)
+
+ # rx_fifo_size must be > 0
+ with self.assertRaises(ValueError):
+ can.Bus(interface="ixxat", channel=0, rx_fifo_size=0)
+
+ # tx_fifo_size must be > 0
+ with self.assertRaises(ValueError):
+ can.Bus(interface="ixxat", channel=0, tx_fifo_size=0)
+
+
+class HardwareTestCase(unittest.TestCase):
+ """
+ Test cases that rely on an existing/connected hardware.
+ """
+
+ def setUp(self):
+ try:
+ bus = can.Bus(interface="ixxat", channel=0)
+ bus.shutdown()
+ except can.CanInterfaceNotImplementedError:
+ raise unittest.SkipTest("not available on this platform")
+
+ def test_bus_creation(self):
+ try:
+ configs = can.detect_available_configs("ixxat")
+ if configs:
+ for interface_kwargs in configs:
+ bus = can.Bus(**interface_kwargs)
+ bus.shutdown()
+ else:
+ raise unittest.SkipTest("No adapters were detected")
+ except can.CanInterfaceNotImplementedError:
+ raise unittest.SkipTest("not available on this platform")
+
+ def test_bus_creation_incorrect_channel(self):
+ # non-existent channel -> use arbitrary high value
+ with self.assertRaises(can.CanInitializationError):
+ can.Bus(interface="ixxat", channel=0xFFFF)
+
+ def test_send_after_shutdown(self):
+ with can.Bus(interface="ixxat", channel=0) as bus:
+ with self.assertRaises(can.CanOperationError):
+ bus.send(can.Message(arbitration_id=0x3FF, dlc=0))
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/test/test_interface_ixxat_fd.py b/test/test_interface_ixxat_fd.py
new file mode 100644
index 000000000..7274498aa
--- /dev/null
+++ b/test/test_interface_ixxat_fd.py
@@ -0,0 +1,65 @@
+#!/usr/bin/env python
+
+"""
+Unittest for ixxat interface using fd option.
+
+Run only this test:
+python setup.py test --addopts "--verbose -s test/test_interface_ixxat_fd.py"
+"""
+
+import unittest
+
+import can
+
+
+class SoftwareTestCase(unittest.TestCase):
+ """
+ Test cases that test the software only and do not rely on an existing/connected hardware.
+ """
+
+ def setUp(self):
+ try:
+ bus = can.Bus(interface="ixxat", fd=True, channel=0)
+ bus.shutdown()
+ except can.CanInterfaceNotImplementedError:
+ raise unittest.SkipTest("not available on this platform")
+
+ def test_bus_creation(self):
+ # channel must be >= 0
+ with self.assertRaises(ValueError):
+ can.Bus(interface="ixxat", fd=True, channel=-1)
+
+ # rx_fifo_size must be > 0
+ with self.assertRaises(ValueError):
+ can.Bus(interface="ixxat", fd=True, channel=0, rx_fifo_size=0)
+
+ # tx_fifo_size must be > 0
+ with self.assertRaises(ValueError):
+ can.Bus(interface="ixxat", fd=True, channel=0, tx_fifo_size=0)
+
+
+class HardwareTestCase(unittest.TestCase):
+ """
+ Test cases that rely on an existing/connected hardware.
+ """
+
+ def setUp(self):
+ try:
+ bus = can.Bus(interface="ixxat", fd=True, channel=0)
+ bus.shutdown()
+ except can.CanInterfaceNotImplementedError:
+ raise unittest.SkipTest("not available on this platform")
+
+ def test_bus_creation(self):
+ # non-existent channel -> use arbitrary high value
+ with self.assertRaises(can.CanInitializationError):
+ can.Bus(interface="ixxat", fd=True, channel=0xFFFF)
+
+ def test_send_after_shutdown(self):
+ with can.Bus(interface="ixxat", fd=True, channel=0) as bus:
+ with self.assertRaises(can.CanOperationError):
+ bus.send(can.Message(arbitration_id=0x3FF, dlc=0))
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/test/test_interface_virtual.py b/test/test_interface_virtual.py
new file mode 100644
index 000000000..c1d842180
--- /dev/null
+++ b/test/test_interface_virtual.py
@@ -0,0 +1,39 @@
+#!/usr/bin/env python
+
+"""
+This module tests :meth:`can.interface.virtual`.
+"""
+
+import unittest
+
+from can import Bus, Message
+
+EXAMPLE_MSG1 = Message(timestamp=1639739471.5565314, arbitration_id=0x481, data=b"\x01")
+
+
+class TestMessageFiltering(unittest.TestCase):
+ def setUp(self):
+ self.node1 = Bus("test", interface="virtual", preserve_timestamps=True)
+ self.node2 = Bus("test", interface="virtual")
+
+ def tearDown(self):
+ self.node1.shutdown()
+ self.node2.shutdown()
+
+ def test_sendmsg(self):
+ self.node2.send(EXAMPLE_MSG1)
+ r = self.node1.recv(0.1)
+ assert r.timestamp != EXAMPLE_MSG1.timestamp
+ assert r.arbitration_id == EXAMPLE_MSG1.arbitration_id
+ assert r.data == EXAMPLE_MSG1.data
+
+ def test_sendmsg_preserve_timestamp(self):
+ self.node1.send(EXAMPLE_MSG1)
+ r = self.node2.recv(0.1)
+ assert r.timestamp == EXAMPLE_MSG1.timestamp
+ assert r.arbitration_id == EXAMPLE_MSG1.arbitration_id
+ assert r.data == EXAMPLE_MSG1.data
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/test/test_kvaser.py b/test/test_kvaser.py
index 733bbc367..1ad035dec 100644
--- a/test/test_kvaser.py
+++ b/test/test_kvaser.py
@@ -1,20 +1,16 @@
#!/usr/bin/env python
-# coding: utf-8
-"""
-"""
+""" """
import ctypes
import time
-import logging
import unittest
-from unittest.mock import Mock, patch
+from unittest.mock import Mock
import pytest
import can
-from can.interfaces.kvaser import canlib
-from can.interfaces.kvaser import constants
+from can.interfaces.kvaser import canlib, constants
class KvaserTest(unittest.TestCase):
@@ -22,7 +18,9 @@ def setUp(self):
canlib.canGetNumberOfChannels = KvaserTest.canGetNumberOfChannels
canlib.canOpenChannel = Mock(return_value=0)
canlib.canIoCtl = Mock(return_value=0)
+ canlib.canIoCtlInit = Mock(return_value=0)
canlib.kvReadTimer = Mock()
+ canlib.canSetBusParamsC200 = Mock()
canlib.canSetBusParams = Mock()
canlib.canSetBusParamsFd = Mock()
canlib.canBusOn = Mock()
@@ -39,7 +37,7 @@ def setUp(self):
self.msg = {}
self.msg_in_cue = None
- self.bus = can.Bus(channel=0, bustype="kvaser")
+ self.bus = can.Bus(channel=0, interface="kvaser")
def tearDown(self):
if self.bus:
@@ -48,9 +46,30 @@ def tearDown(self):
def test_bus_creation(self):
self.assertIsInstance(self.bus, canlib.KvaserBus)
+ self.assertEqual(self.bus.protocol, can.CanProtocol.CAN_20)
self.assertTrue(canlib.canOpenChannel.called)
self.assertTrue(canlib.canBusOn.called)
+ def test_bus_creation_illegal_channel_name(self):
+ # Test if the bus constructor is able to deal with non-ASCII characters
+ def canGetChannelDataMock(
+ channel: ctypes.c_int,
+ param: ctypes.c_int,
+ buf: ctypes.c_void_p,
+ bufsize: ctypes.c_size_t,
+ ):
+ if param == constants.canCHANNELDATA_DEVDESCR_ASCII:
+ buf_char_ptr = ctypes.cast(buf, ctypes.POINTER(ctypes.c_char))
+ for i, char in enumerate(b"hello\x7a\xcb"):
+ buf_char_ptr[i] = char
+
+ canlib.canGetChannelData = canGetChannelDataMock
+ bus = can.Bus(channel=0, interface="kvaser")
+
+ self.assertTrue(bus.channel_info.startswith("hello"))
+
+ bus.shutdown()
+
def test_bus_shutdown(self):
self.bus.shutdown()
self.assertTrue(canlib.canBusOff.called)
@@ -143,15 +162,28 @@ def test_recv_standard(self):
def test_available_configs(self):
configs = canlib.KvaserBus._detect_available_configs()
expected = [
- {"interface": "kvaser", "channel": 0},
- {"interface": "kvaser", "channel": 1},
+ {
+ "interface": "kvaser",
+ "channel": 0,
+ "dongle_channel": 1,
+ "device_name": "",
+ "serial": 0,
+ },
+ {
+ "interface": "kvaser",
+ "channel": 1,
+ "dongle_channel": 1,
+ "device_name": "",
+ "serial": 0,
+ },
]
self.assertListEqual(configs, expected)
def test_canfd_default_data_bitrate(self):
canlib.canSetBusParams.reset_mock()
canlib.canSetBusParamsFd.reset_mock()
- can.Bus(channel=0, bustype="kvaser", fd=True)
+ bus = can.Bus(channel=0, interface="kvaser", fd=True)
+ self.assertEqual(bus.protocol, can.CanProtocol.CAN_FD)
canlib.canSetBusParams.assert_called_once_with(
0, constants.canFD_BITRATE_500K_80P, 0, 0, 0, 0, 0
)
@@ -159,11 +191,70 @@ def test_canfd_default_data_bitrate(self):
0, constants.canFD_BITRATE_500K_80P, 0, 0, 0
)
+ def test_can_timing(self):
+ canlib.canSetBusParams.reset_mock()
+ canlib.canSetBusParamsFd.reset_mock()
+ timing = can.BitTiming.from_bitrate_and_segments(
+ f_clock=16_000_000,
+ bitrate=125_000,
+ tseg1=13,
+ tseg2=2,
+ sjw=1,
+ )
+ can.Bus(channel=0, interface="kvaser", timing=timing)
+ canlib.canSetBusParamsC200.assert_called_once_with(0, timing.btr0, timing.btr1)
+
+ def test_canfd_timing(self):
+ canlib.canSetBusParams.reset_mock()
+ canlib.canSetBusParamsFd.reset_mock()
+ canlib.canOpenChannel.reset_mock()
+ timing = can.BitTimingFd.from_bitrate_and_segments(
+ f_clock=80_000_000,
+ nom_bitrate=500_000,
+ nom_tseg1=68,
+ nom_tseg2=11,
+ nom_sjw=10,
+ data_bitrate=2_000_000,
+ data_tseg1=10,
+ data_tseg2=9,
+ data_sjw=8,
+ )
+ can.Bus(channel=0, interface="kvaser", timing=timing)
+ canlib.canSetBusParams.assert_called_once_with(0, 500_000, 68, 11, 10, 1, 0)
+ canlib.canSetBusParamsFd.assert_called_once_with(0, 2_000_000, 10, 9, 8)
+ canlib.canOpenChannel.assert_called_with(
+ 0, constants.canOPEN_CAN_FD | constants.canOPEN_ACCEPT_VIRTUAL
+ )
+
+ def test_canfd_non_iso(self):
+ canlib.canSetBusParams.reset_mock()
+ canlib.canSetBusParamsFd.reset_mock()
+ canlib.canOpenChannel.reset_mock()
+ timing = can.BitTimingFd.from_bitrate_and_segments(
+ f_clock=80_000_000,
+ nom_bitrate=500_000,
+ nom_tseg1=68,
+ nom_tseg2=11,
+ nom_sjw=10,
+ data_bitrate=2_000_000,
+ data_tseg1=10,
+ data_tseg2=9,
+ data_sjw=8,
+ )
+ bus = can.Bus(channel=0, interface="kvaser", timing=timing, fd_non_iso=True)
+ self.assertEqual(bus.protocol, can.CanProtocol.CAN_FD_NON_ISO)
+ canlib.canSetBusParams.assert_called_once_with(0, 500_000, 68, 11, 10, 1, 0)
+ canlib.canSetBusParamsFd.assert_called_once_with(0, 2_000_000, 10, 9, 8)
+ canlib.canOpenChannel.assert_called_with(
+ 0, constants.canOPEN_CAN_FD_NONISO | constants.canOPEN_ACCEPT_VIRTUAL
+ )
+
def test_canfd_nondefault_data_bitrate(self):
canlib.canSetBusParams.reset_mock()
canlib.canSetBusParamsFd.reset_mock()
data_bitrate = 2000000
- can.Bus(channel=0, bustype="kvaser", fd=True, data_bitrate=data_bitrate)
+ bus = can.Bus(channel=0, interface="kvaser", fd=True, data_bitrate=data_bitrate)
+ self.assertEqual(bus.protocol, can.CanProtocol.CAN_FD)
bitrate_constant = canlib.BITRATE_FD[data_bitrate]
canlib.canSetBusParams.assert_called_once_with(
0, constants.canFD_BITRATE_500K_80P, 0, 0, 0, 0, 0
@@ -174,7 +265,7 @@ def test_canfd_custom_data_bitrate(self):
canlib.canSetBusParams.reset_mock()
canlib.canSetBusParamsFd.reset_mock()
data_bitrate = 123456
- can.Bus(channel=0, bustype="kvaser", fd=True, data_bitrate=data_bitrate)
+ can.Bus(channel=0, interface="kvaser", fd=True, data_bitrate=data_bitrate)
canlib.canSetBusParams.assert_called_once_with(
0, constants.canFD_BITRATE_500K_80P, 0, 0, 0, 0, 0
)
@@ -186,6 +277,19 @@ def test_bus_get_stats(self):
self.assertTrue(canlib.canGetBusStatistics.called)
self.assertIsInstance(stats, canlib.structures.BusStatistics)
+ def test_bus_no_init_access(self):
+ canlib.canOpenChannel.reset_mock()
+ bus = can.Bus(interface="kvaser", channel=0, no_init_access=True)
+
+ self.assertGreater(canlib.canOpenChannel.call_count, 0)
+ for call in canlib.canOpenChannel.call_args_list:
+ self.assertEqual(
+ call[0][1] & constants.canOPEN_NO_INIT_ACCESS,
+ constants.canOPEN_NO_INIT_ACCESS,
+ )
+
+ bus.shutdown()
+
@staticmethod
def canGetNumberOfChannels(count):
count._obj.value = 2
diff --git a/test/test_load_config.py b/test/test_load_config.py
new file mode 100644
index 000000000..3c850a730
--- /dev/null
+++ b/test/test_load_config.py
@@ -0,0 +1,91 @@
+#!/usr/bin/env python
+
+import shutil
+import tempfile
+import unittest
+import unittest.mock
+from tempfile import NamedTemporaryFile
+
+import can
+
+
+class LoadConfigTest(unittest.TestCase):
+ configuration_in = {
+ "default": {"interface": "serial", "channel": "0"},
+ "one": {"interface": "kvaser", "channel": "1", "bitrate": 100000},
+ "two": {"channel": "2"},
+ }
+ configuration_out = {
+ "default": {"interface": "serial", "channel": 0},
+ "one": {"interface": "kvaser", "channel": 1, "bitrate": 100000},
+ "two": {"channel": 2},
+ }
+
+ def setUp(self):
+ # Create a temporary directory
+ self.test_dir = tempfile.mkdtemp()
+
+ def tearDown(self):
+ # Remove the directory after the test
+ shutil.rmtree(self.test_dir)
+
+ def _gen_configration_file(self, sections):
+ with NamedTemporaryFile(
+ mode="w", dir=self.test_dir, delete=False
+ ) as tmp_config_file:
+ content = []
+ for section in sections:
+ content.append(f"[{section}]")
+ for k, v in self.configuration_in[section].items():
+ content.append(f"{k} = {v}")
+ tmp_config_file.write("\n".join(content))
+ return tmp_config_file.name
+
+ def _dict_to_env(self, d):
+ return {f"CAN_{k.upper()}": str(v) for k, v in d.items()}
+
+ def test_config_default(self):
+ tmp_config = self._gen_configration_file(["default"])
+ config = can.util.load_config(path=tmp_config)
+ self.assertEqual(config, self.configuration_out["default"])
+
+ def test_config_whole_default(self):
+ tmp_config = self._gen_configration_file(self.configuration_in)
+ config = can.util.load_config(path=tmp_config)
+ self.assertEqual(config, self.configuration_out["default"])
+
+ def test_config_whole_context(self):
+ tmp_config = self._gen_configration_file(self.configuration_in)
+ config = can.util.load_config(path=tmp_config, context="one")
+ self.assertEqual(config, self.configuration_out["one"])
+
+ def test_config_merge_context(self):
+ tmp_config = self._gen_configration_file(self.configuration_in)
+ config = can.util.load_config(path=tmp_config, context="two")
+ expected = self.configuration_out["default"].copy()
+ expected.update(self.configuration_out["two"])
+ self.assertEqual(config, expected)
+
+ def test_config_merge_environment_to_context(self):
+ tmp_config = self._gen_configration_file(self.configuration_in)
+ env_data = {"interface": "serial", "bitrate": 125000}
+ env_dict = self._dict_to_env(env_data)
+ with unittest.mock.patch.dict("os.environ", env_dict):
+ config = can.util.load_config(path=tmp_config, context="one")
+ expected = self.configuration_out["one"].copy()
+ expected.update(env_data)
+ self.assertEqual(config, expected)
+
+ def test_config_whole_environment(self):
+ tmp_config = self._gen_configration_file(self.configuration_in)
+ env_data = {"interface": "socketcan", "channel": "3", "bitrate": 250000}
+ env_dict = self._dict_to_env(env_data)
+ with unittest.mock.patch.dict("os.environ", env_dict):
+ config = can.util.load_config(path=tmp_config, context="one")
+ expected = self.configuration_out["one"].copy()
+ expected.update({"interface": "socketcan", "channel": 3, "bitrate": 250000})
+ self.assertEqual(config, expected)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/test/test_load_file_config.py b/test/test_load_file_config.py
index 79b2e6c4b..afedf58d4 100644
--- a/test/test_load_file_config.py
+++ b/test/test_load_file_config.py
@@ -1,5 +1,4 @@
#!/usr/bin/env python
-# coding: utf-8
import shutil
import tempfile
@@ -12,7 +11,7 @@
class LoadFileConfigTest(unittest.TestCase):
configuration = {
"default": {"interface": "virtual", "channel": "0"},
- "one": {"interface": "virtual", "channel": "1"},
+ "one": {"interface": "kvaser", "channel": "1"},
"two": {"channel": "2"},
"three": {"extra": "extra value"},
}
@@ -31,9 +30,9 @@ def _gen_configration_file(self, sections):
) as tmp_config_file:
content = []
for section in sections:
- content.append("[{}]".format(section))
+ content.append(f"[{section}]")
for k, v in self.configuration[section].items():
- content.append("{} = {}".format(k, v))
+ content.append(f"{k} = {v}")
tmp_config_file.write("\n".join(content))
return tmp_config_file.name
diff --git a/test/test_logger.py b/test/test_logger.py
new file mode 100644
index 000000000..41778ab6a
--- /dev/null
+++ b/test/test_logger.py
@@ -0,0 +1,283 @@
+#!/usr/bin/env python
+
+"""
+This module tests the functions inside of logger.py
+"""
+
+import gzip
+import os
+import sys
+import unittest
+from unittest import mock
+from unittest.mock import Mock
+
+import pytest
+
+import can
+import can.cli
+import can.logger
+
+
+class TestLoggerScriptModule(unittest.TestCase):
+ def setUp(self) -> None:
+ # Patch VirtualBus object
+ patcher_virtual_bus = mock.patch("can.interfaces.virtual.VirtualBus", spec=True)
+ self.MockVirtualBus = patcher_virtual_bus.start()
+ self.addCleanup(patcher_virtual_bus.stop)
+ self.mock_virtual_bus = self.MockVirtualBus.return_value
+ self.mock_virtual_bus.shutdown = Mock()
+
+ # Patch Logger object
+ patcher_logger = mock.patch("can.logger.Logger", spec=True)
+ self.MockLogger = patcher_logger.start()
+ self.addCleanup(patcher_logger.stop)
+ self.mock_logger = self.MockLogger.return_value
+ self.mock_logger.stop = Mock()
+
+ self.MockLoggerUse = self.MockLogger
+ self.loggerToUse = self.mock_logger
+
+ # Patch SizedRotatingLogger object
+ patcher_logger_sized = mock.patch("can.logger.SizedRotatingLogger", spec=True)
+ self.MockLoggerSized = patcher_logger_sized.start()
+ self.addCleanup(patcher_logger_sized.stop)
+ self.mock_logger_sized = self.MockLoggerSized.return_value
+ self.mock_logger_sized.stop = Mock()
+
+ self.testmsg = can.Message(
+ arbitration_id=0xC0FFEE, data=[0, 25, 0, 1, 3, 1, 4, 1], is_extended_id=True
+ )
+
+ self.baseargs = [sys.argv[0], "-i", "virtual"]
+
+ def assertSuccessfullCleanup(self):
+ self.MockVirtualBus.assert_called_once()
+ self.mock_virtual_bus.shutdown.assert_called_once()
+
+ self.MockLoggerUse.assert_called_once()
+ self.loggerToUse.stop.assert_called_once()
+
+ def test_log_virtual(self):
+ self.mock_virtual_bus.recv = Mock(side_effect=[self.testmsg, KeyboardInterrupt])
+
+ sys.argv = self.baseargs
+ can.logger.main()
+ self.assertSuccessfullCleanup()
+ self.mock_logger.assert_called_once()
+
+ def test_log_virtual_active(self):
+ self.mock_virtual_bus.recv = Mock(side_effect=[self.testmsg, KeyboardInterrupt])
+
+ sys.argv = self.baseargs + ["--active"]
+ can.logger.main()
+ self.assertSuccessfullCleanup()
+ self.mock_logger.assert_called_once()
+ self.assertEqual(self.mock_virtual_bus.state, can.BusState.ACTIVE)
+
+ def test_log_virtual_passive(self):
+ self.mock_virtual_bus.recv = Mock(side_effect=[self.testmsg, KeyboardInterrupt])
+
+ sys.argv = self.baseargs + ["--passive"]
+ can.logger.main()
+ self.assertSuccessfullCleanup()
+ self.mock_logger.assert_called_once()
+ self.assertEqual(self.mock_virtual_bus.state, can.BusState.PASSIVE)
+
+ def test_log_virtual_with_config(self):
+ self.mock_virtual_bus.recv = Mock(side_effect=[self.testmsg, KeyboardInterrupt])
+
+ sys.argv = self.baseargs + [
+ "--bitrate",
+ "250000",
+ "--fd",
+ "--data-bitrate",
+ "2000000",
+ ]
+ can.logger.main()
+ self.assertSuccessfullCleanup()
+ self.mock_logger.assert_called_once()
+
+ def test_log_virtual_sizedlogger(self):
+ self.mock_virtual_bus.recv = Mock(side_effect=[self.testmsg, KeyboardInterrupt])
+ self.MockLoggerUse = self.MockLoggerSized
+ self.loggerToUse = self.mock_logger_sized
+
+ sys.argv = self.baseargs + ["--file_size", "1000000"]
+ can.logger.main()
+ self.assertSuccessfullCleanup()
+ self.mock_logger_sized.assert_called_once()
+
+ def test_parse_logger_args(self):
+ args = self.baseargs + [
+ "--bitrate",
+ "250000",
+ "--fd",
+ "--data-bitrate",
+ "2000000",
+ "--receive-own-messages=True",
+ ]
+ results, additional_config = can.logger._parse_logger_args(args[1:])
+ assert results.interface == "virtual"
+ assert results.bitrate == 250_000
+ assert results.fd is True
+ assert results.data_bitrate == 2_000_000
+ assert additional_config["receive_own_messages"] is True
+
+ def test_parse_can_filters(self):
+ expected_can_filters = [{"can_id": 0x100, "can_mask": 0x7FC}]
+ results, additional_config = can.logger._parse_logger_args(
+ ["--filter", "100:7FC", "--bitrate", "250000"]
+ )
+ assert results.can_filters == expected_can_filters
+
+ def test_parse_can_filters_list(self):
+ expected_can_filters = [
+ {"can_id": 0x100, "can_mask": 0x7FC},
+ {"can_id": 0x200, "can_mask": 0x7F0},
+ ]
+ results, additional_config = can.logger._parse_logger_args(
+ ["--filter", "100:7FC", "200:7F0", "--bitrate", "250000"]
+ )
+ assert results.can_filters == expected_can_filters
+
+ def test_parse_timing(self) -> None:
+ can20_args = self.baseargs + [
+ "--timing",
+ "f_clock=8_000_000",
+ "tseg1=5",
+ "tseg2=2",
+ "sjw=2",
+ "brp=2",
+ "nof_samples=1",
+ "--app-name=CANalyzer",
+ ]
+ results, additional_config = can.logger._parse_logger_args(can20_args[1:])
+ assert results.timing == can.BitTiming(
+ f_clock=8_000_000, brp=2, tseg1=5, tseg2=2, sjw=2, nof_samples=1
+ )
+ assert additional_config["app_name"] == "CANalyzer"
+
+ canfd_args = self.baseargs + [
+ "--timing",
+ "f_clock=80_000_000",
+ "nom_tseg1=119",
+ "nom_tseg2=40",
+ "nom_sjw=40",
+ "nom_brp=1",
+ "data_tseg1=29",
+ "data_tseg2=10",
+ "data_sjw=10",
+ "data_brp=1",
+ "--app-name=CANalyzer",
+ ]
+ results, additional_config = can.logger._parse_logger_args(canfd_args[1:])
+ assert results.timing == can.BitTimingFd(
+ f_clock=80_000_000,
+ nom_brp=1,
+ nom_tseg1=119,
+ nom_tseg2=40,
+ nom_sjw=40,
+ data_brp=1,
+ data_tseg1=29,
+ data_tseg2=10,
+ data_sjw=10,
+ )
+ assert additional_config["app_name"] == "CANalyzer"
+
+ # remove f_clock parameter, parsing should fail
+ incomplete_args = self.baseargs + [
+ "--timing",
+ "tseg1=5",
+ "tseg2=2",
+ "sjw=2",
+ "brp=2",
+ "nof_samples=1",
+ "--app-name=CANalyzer",
+ ]
+ with self.assertRaises(SystemExit):
+ can.logger._parse_logger_args(incomplete_args[1:])
+
+ def test_parse_additional_config(self):
+ unknown_args = [
+ "--app-name=CANalyzer",
+ "--serial=5555",
+ "--receive-own-messages=True",
+ "--false-boolean=False",
+ "--offset=1.5",
+ "--tseg1-abr=127",
+ ]
+ parsed_args = can.cli._parse_additional_config(unknown_args)
+
+ assert "app_name" in parsed_args
+ assert parsed_args["app_name"] == "CANalyzer"
+
+ assert "serial" in parsed_args
+ assert parsed_args["serial"] == 5555
+
+ assert "receive_own_messages" in parsed_args
+ assert (
+ isinstance(parsed_args["receive_own_messages"], bool)
+ and parsed_args["receive_own_messages"] is True
+ )
+
+ assert "false_boolean" in parsed_args
+ assert (
+ isinstance(parsed_args["false_boolean"], bool)
+ and parsed_args["false_boolean"] is False
+ )
+
+ assert "offset" in parsed_args
+ assert parsed_args["offset"] == 1.5
+
+ assert "tseg1_abr" in parsed_args
+ assert parsed_args["tseg1_abr"] == 127
+
+ with pytest.raises(ValueError):
+ can.cli._parse_additional_config(["--wrong-format"])
+
+ with pytest.raises(ValueError):
+ can.cli._parse_additional_config(["-wrongformat=value"])
+
+ with pytest.raises(ValueError):
+ can.cli._parse_additional_config(["--wrongformat=value1 value2"])
+
+ with pytest.raises(ValueError):
+ can.cli._parse_additional_config(["wrongformat="])
+
+
+class TestLoggerCompressedFile(unittest.TestCase):
+ def setUp(self) -> None:
+ # Patch VirtualBus object
+ self.patcher_virtual_bus = mock.patch(
+ "can.interfaces.virtual.VirtualBus", spec=True
+ )
+ self.MockVirtualBus = self.patcher_virtual_bus.start()
+ self.mock_virtual_bus = self.MockVirtualBus.return_value
+
+ self.testmsg = can.Message(
+ arbitration_id=0xC0FFEE, data=[0, 25, 0, 1, 3, 1, 4, 1], is_extended_id=True
+ )
+ self.baseargs = [sys.argv[0], "-i", "virtual"]
+
+ self.testfile = open("coffee.log.gz", "w+")
+
+ def test_compressed_logfile(self):
+ """
+ Basic test to verify Logger is able to write gzip files.
+ """
+ self.mock_virtual_bus.recv = Mock(side_effect=[self.testmsg, KeyboardInterrupt])
+ sys.argv = self.baseargs + ["--file_name", self.testfile.name]
+ can.logger.main()
+ with gzip.open(self.testfile.name, "rt") as testlog:
+ last_line = testlog.readlines()[-1]
+
+ self.assertEqual(last_line, "(0.000000) vcan0 00C0FFEE#0019000103010401 R\n")
+
+ def tearDown(self) -> None:
+ self.testfile.close()
+ os.remove(self.testfile.name)
+ self.patcher_virtual_bus.stop()
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/test/test_message_class.py b/test/test_message_class.py
index 760a848bd..8e2367034 100644
--- a/test/test_message_class.py
+++ b/test/test_message_class.py
@@ -1,16 +1,22 @@
#!/usr/bin/env python
-# coding: utf-8
-import unittest
+import pickle
import sys
-from math import isinf, isnan
+import unittest
from copy import copy, deepcopy
+from datetime import timedelta
+from math import isinf, isnan
-from hypothesis import given, settings, reproduce_failure
+import hypothesis.errors
import hypothesis.strategies as st
+import pytest
+from hypothesis import HealthCheck, given, settings
from can import Message
+from .config import IS_GITHUB_ACTIONS, IS_PYPY, IS_WINDOWS
+from .message_helper import ComparingMessagesTestCase
+
class TestMessageClass(unittest.TestCase):
"""
@@ -32,7 +38,17 @@ class TestMessageClass(unittest.TestCase):
bitrate_switch=st.booleans(),
error_state_indicator=st.booleans(),
)
- @settings(max_examples=2000)
+ # The first run may take a second on CI runners and will hit the deadline
+ @settings(
+ max_examples=2000,
+ suppress_health_check=[HealthCheck.too_slow],
+ deadline=None if IS_GITHUB_ACTIONS else timedelta(milliseconds=500),
+ )
+ @pytest.mark.xfail(
+ IS_WINDOWS and IS_PYPY,
+ raises=hypothesis.errors.Flaky,
+ reason="Hypothesis generates inconsistent timestamp floats on Windows+PyPy-3.7",
+ )
def test_methods(self, **kwargs):
is_valid = not (
(
@@ -42,7 +58,10 @@ def test_methods(self, **kwargs):
or (kwargs["arbitration_id"] >= 0x800 and not kwargs["is_extended_id"])
or kwargs["arbitration_id"] >= 0x20000000
or kwargs["arbitration_id"] < 0
- or (kwargs["is_remote_frame"] and kwargs["is_error_frame"])
+ or (
+ kwargs["is_remote_frame"]
+ and (kwargs["is_fd"] or kwargs["is_error_frame"])
+ )
or (kwargs["is_remote_frame"] and len(kwargs["data"] or []) > 0)
or (
(kwargs["bitrate_switch"] or kwargs["error_state_indicator"])
@@ -67,10 +86,12 @@ def test_methods(self, **kwargs):
if is_valid:
self.assertEqual(len(message), kwargs["dlc"])
self.assertTrue(bool(message))
- self.assertGreater(len("{}".format(message)), 0)
- _ = "{}".format(message)
+ self.assertGreater(len(f"{message}"), 0)
+ _ = f"{message}"
with self.assertRaises(Exception):
- _ = "{somespec}".format(message)
+ _ = "{somespec}".format(
+ message
+ ) # pylint: disable=missing-format-argument-key
if sys.version_info.major > 2:
self.assertEqual(bytearray(bytes(message)), kwargs["data"])
@@ -85,5 +106,31 @@ def test_methods(self, **kwargs):
self.assertTrue(message.equals(other, timestamp_delta=0))
+class MessageSerialization(unittest.TestCase, ComparingMessagesTestCase):
+ def __init__(self, *args, **kwargs):
+ unittest.TestCase.__init__(self, *args, **kwargs)
+ ComparingMessagesTestCase.__init__(
+ self, allowed_timestamp_delta=0.016, preserves_channel=True
+ )
+
+ def test_serialization(self):
+ message = Message(
+ timestamp=1.0,
+ arbitration_id=0x401,
+ is_extended_id=False,
+ is_remote_frame=False,
+ is_error_frame=False,
+ channel=1,
+ dlc=6,
+ data=bytearray([0x01, 0x02, 0x03, 0x04, 0x05, 0x06]),
+ is_fd=False,
+ )
+
+ serialized = pickle.dumps(message, -1)
+ deserialized = pickle.loads(serialized)
+
+ self.assertMessageEqual(message, deserialized)
+
+
if __name__ == "__main__":
unittest.main()
diff --git a/test/test_message_filtering.py b/test/test_message_filtering.py
index 18ddf9e19..a73e07aa2 100644
--- a/test/test_message_filtering.py
+++ b/test/test_message_filtering.py
@@ -1,5 +1,4 @@
#!/usr/bin/env python
-# coding: utf-8
"""
This module tests :meth:`can.BusABC._matches_filters`.
@@ -11,7 +10,6 @@
from .data.example_data import TEST_ALL_MESSAGES
-
EXAMPLE_MSG = Message(arbitration_id=0x123, is_extended_id=True)
HIGHEST_MSG = Message(arbitration_id=0x1FFFFFFF, is_extended_id=True)
@@ -22,7 +20,7 @@
class TestMessageFiltering(unittest.TestCase):
def setUp(self):
- self.bus = Bus(bustype="virtual", channel="testy")
+ self.bus = Bus(interface="virtual", channel="testy")
def tearDown(self):
self.bus.shutdown()
diff --git a/test/test_message_sync.py b/test/test_message_sync.py
index b7b911bd0..90cbe372c 100644
--- a/test/test_message_sync.py
+++ b/test/test_message_sync.py
@@ -1,23 +1,21 @@
#!/usr/bin/env python
-# coding: utf-8
"""
This module tests :class:`can.MessageSync`.
"""
-from copy import copy
-from time import time
import gc
-
+import time
import unittest
+from copy import copy
+
import pytest
-from can import MessageSync, Message
+from can import Message, MessageSync
-from .config import IS_CI, IS_APPVEYOR, IS_TRAVIS, IS_OSX
-from .message_helper import ComparingMessagesTestCase
+from .config import IS_CI, IS_GITHUB_ACTIONS, IS_LINUX, IS_OSX, IS_TRAVIS
from .data.example_data import TEST_MESSAGES_BASE
-
+from .message_helper import ComparingMessagesTestCase
TEST_FEWER_MESSAGES = TEST_MESSAGES_BASE[::2]
@@ -30,10 +28,13 @@ def inc(value):
return value
-@unittest.skipIf(
- IS_APPVEYOR or (IS_TRAVIS and IS_OSX),
+skip_on_unreliable_platforms = unittest.skipIf(
+ (IS_TRAVIS and IS_OSX) or (IS_GITHUB_ACTIONS and not IS_LINUX),
"this environment's timings are too unpredictable",
)
+
+
+@skip_on_unreliable_platforms
class TestMessageSync(unittest.TestCase, ComparingMessagesTestCase):
def __init__(self, *args, **kwargs):
unittest.TestCase.__init__(self, *args, **kwargs)
@@ -47,75 +48,70 @@ def teardown_method(self, _):
# we need to reenable the garbage collector again
gc.enable()
- @pytest.mark.timeout(inc(0.2))
def test_general(self):
messages = [
Message(timestamp=50.0),
Message(timestamp=50.0),
Message(timestamp=50.0 + 0.05),
- Message(timestamp=50.0 + 0.05 + 0.08),
+ Message(timestamp=50.0 + 0.13),
Message(timestamp=50.0), # back in time
]
- sync = MessageSync(messages, gap=0.0)
+ sync = MessageSync(messages, gap=0.0, skip=0.0)
- start = time()
+ t_start = time.perf_counter()
collected = []
timings = []
for message in sync:
+ t_now = time.perf_counter()
collected.append(message)
- now = time()
- timings.append(now - start)
- start = now
+ timings.append(t_now - t_start)
self.assertMessagesEqual(messages, collected)
self.assertEqual(len(timings), len(messages), "programming error in test code")
- self.assertTrue(0.0 <= timings[0] < inc(0.005), str(timings[0]))
- self.assertTrue(0.0 <= timings[1] < inc(0.005), str(timings[1]))
- self.assertTrue(0.045 <= timings[2] < inc(0.055), str(timings[2]))
- self.assertTrue(0.075 <= timings[3] < inc(0.085), str(timings[3]))
- self.assertTrue(0.0 <= timings[4] < inc(0.005), str(timings[4]))
+ self.assertTrue(0.0 <= timings[0] < 0.0 + inc(0.02), str(timings[0]))
+ self.assertTrue(0.0 <= timings[1] < 0.0 + inc(0.02), str(timings[1]))
+ self.assertTrue(0.045 <= timings[2] < 0.05 + inc(0.02), str(timings[2]))
+ self.assertTrue(0.125 <= timings[3] < 0.13 + inc(0.02), str(timings[3]))
+ self.assertTrue(0.125 <= timings[4] < 0.13 + inc(0.02), str(timings[4]))
- @pytest.mark.timeout(inc(0.1) * len(TEST_FEWER_MESSAGES)) # very conservative
def test_skip(self):
messages = copy(TEST_FEWER_MESSAGES)
sync = MessageSync(messages, skip=0.005, gap=0.0)
- before = time()
+ before = time.perf_counter()
collected = list(sync)
- after = time()
+ after = time.perf_counter()
took = after - before
# the handling of the messages itself also takes some time:
# ~0.001 s/message on a ThinkPad T560 laptop (Ubuntu 18.04, i5-6200U)
- assert 0 < took < inc(len(messages) * (0.005 + 0.003)), "took: {}s".format(took)
+ assert 0 < took < inc(len(messages) * (0.005 + 0.003)), f"took: {took}s"
self.assertMessagesEqual(messages, collected)
-if not IS_APPVEYOR: # this environment's timings are too unpredictable
-
- @pytest.mark.timeout(inc(0.3))
- @pytest.mark.parametrize(
- "timestamp_1,timestamp_2", [(0.0, 0.0), (0.0, 0.01), (0.01, 0.0)]
- )
- def test_gap(timestamp_1, timestamp_2):
- """This method is alone so it can be parameterized."""
- messages = [
- Message(arbitration_id=0x1, timestamp=timestamp_1),
- Message(arbitration_id=0x2, timestamp=timestamp_2),
- ]
- sync = MessageSync(messages, gap=0.1)
-
- gc.disable()
- before = time()
- collected = list(sync)
- after = time()
- gc.enable()
- took = after - before
-
- assert 0.1 <= took < inc(0.3)
- assert messages == collected
+@skip_on_unreliable_platforms
+@pytest.mark.parametrize(
+ "timestamp_1,timestamp_2", [(0.0, 0.0), (0.0, 0.01), (0.01, 1.5)]
+)
+def test_gap(timestamp_1, timestamp_2):
+ """This method is alone so it can be parameterized."""
+ messages = [
+ Message(arbitration_id=0x1, timestamp=timestamp_1),
+ Message(arbitration_id=0x2, timestamp=timestamp_2),
+ ]
+ sync = MessageSync(messages, timestamps=False, gap=0.1)
+
+ gc.disable()
+ before = time.perf_counter()
+ collected = list(sync)
+ after = time.perf_counter()
+ gc.enable()
+ took = after - before
+
+ assert 0.195 <= took < 0.2 + inc(0.02)
+ assert messages == collected
if __name__ == "__main__":
diff --git a/test/test_neousys.py b/test/test_neousys.py
new file mode 100644
index 000000000..69c818869
--- /dev/null
+++ b/test/test_neousys.py
@@ -0,0 +1,109 @@
+#!/usr/bin/env python
+
+import unittest
+from ctypes import (
+ POINTER,
+ byref,
+ c_ubyte,
+ cast,
+ sizeof,
+)
+from unittest.mock import Mock
+
+import can
+from can.interfaces.neousys import neousys
+
+
+class TestNeousysBus(unittest.TestCase):
+ def setUp(self) -> None:
+ can.interfaces.neousys.neousys.NEOUSYS_CANLIB = Mock()
+ can.interfaces.neousys.neousys.NEOUSYS_CANLIB.CAN_RegisterReceived = Mock(
+ return_value=1
+ )
+ can.interfaces.neousys.neousys.NEOUSYS_CANLIB.CAN_RegisterStatus = Mock(
+ return_value=1
+ )
+ can.interfaces.neousys.neousys.NEOUSYS_CANLIB.CAN_Setup = Mock(return_value=1)
+ can.interfaces.neousys.neousys.NEOUSYS_CANLIB.CAN_Start = Mock(return_value=1)
+ can.interfaces.neousys.neousys.NEOUSYS_CANLIB.CAN_Send = Mock(return_value=1)
+ can.interfaces.neousys.neousys.NEOUSYS_CANLIB.CAN_Stop = Mock(return_value=1)
+ self.bus = can.Bus(channel=0, interface="neousys")
+
+ def tearDown(self) -> None:
+ if self.bus:
+ self.bus.shutdown()
+ self.bus = None
+
+ def test_bus_creation(self) -> None:
+ self.assertIsInstance(self.bus, neousys.NeousysBus)
+ self.assertEqual(self.bus.protocol, can.CanProtocol.CAN_20)
+ neousys.NEOUSYS_CANLIB.CAN_Setup.assert_called()
+ neousys.NEOUSYS_CANLIB.CAN_Start.assert_called()
+ neousys.NEOUSYS_CANLIB.CAN_RegisterReceived.assert_called()
+ neousys.NEOUSYS_CANLIB.CAN_RegisterStatus.assert_called()
+ neousys.NEOUSYS_CANLIB.CAN_Send.assert_not_called()
+ neousys.NEOUSYS_CANLIB.CAN_Stop.assert_not_called()
+
+ CAN_Start_args = (
+ can.interfaces.neousys.neousys.NEOUSYS_CANLIB.CAN_Setup.call_args[0]
+ )
+
+ # sizeof struct should be 16
+ self.assertEqual(CAN_Start_args[0], 0)
+ self.assertEqual(CAN_Start_args[2], 16)
+ NeousysCanSetup_struct = cast(
+ CAN_Start_args[1], POINTER(neousys.NeousysCanSetup)
+ )
+ self.assertEqual(NeousysCanSetup_struct.contents.bitRate, 500000)
+ self.assertEqual(
+ NeousysCanSetup_struct.contents.recvConfig,
+ neousys.NEOUSYS_CAN_MSG_USE_ID_FILTER,
+ )
+
+ def test_bus_creation_bitrate(self) -> None:
+ self.bus = can.Bus(channel=0, interface="neousys", bitrate=200000)
+ self.assertIsInstance(self.bus, neousys.NeousysBus)
+ self.assertEqual(self.bus.protocol, can.CanProtocol.CAN_20)
+
+ CAN_Start_args = (
+ can.interfaces.neousys.neousys.NEOUSYS_CANLIB.CAN_Setup.call_args[0]
+ )
+
+ # sizeof struct should be 16
+ self.assertEqual(CAN_Start_args[0], 0)
+ self.assertEqual(CAN_Start_args[2], 16)
+ NeousysCanSetup_struct = cast(
+ CAN_Start_args[1], POINTER(neousys.NeousysCanSetup)
+ )
+ self.assertEqual(NeousysCanSetup_struct.contents.bitRate, 200000)
+ self.assertEqual(
+ NeousysCanSetup_struct.contents.recvConfig,
+ neousys.NEOUSYS_CAN_MSG_USE_ID_FILTER,
+ )
+
+ def test_receive(self) -> None:
+ recv_msg = self.bus.recv(timeout=0.05)
+ self.assertEqual(recv_msg, None)
+ msg_data = [0x01, 0x02, 0x03, 0x04, 0x05]
+ NeousysCanMsg_msg = neousys.NeousysCanMsg(
+ 0x01, 0x00, 0x00, 0x05, (c_ubyte * 8)(*msg_data)
+ )
+ self.bus._neousys_recv_cb(byref(NeousysCanMsg_msg), sizeof(NeousysCanMsg_msg))
+ recv_msg = self.bus.recv(timeout=0.05)
+ self.assertEqual(recv_msg.dlc, 5)
+ self.assertSequenceEqual(recv_msg.data, msg_data)
+
+ def test_send(self) -> None:
+ msg = can.Message(
+ arbitration_id=0x01, data=[1, 2, 3, 4, 5, 6, 7, 8], is_extended_id=False
+ )
+ self.bus.send(msg)
+ neousys.NEOUSYS_CANLIB.CAN_Send.assert_called()
+
+ def test_shutdown(self) -> None:
+ self.bus.shutdown()
+ neousys.NEOUSYS_CANLIB.CAN_Stop.assert_called()
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/test/test_neovi.py b/test/test_neovi.py
new file mode 100644
index 000000000..8c816bef2
--- /dev/null
+++ b/test/test_neovi.py
@@ -0,0 +1,25 @@
+#!/usr/bin/env python
+
+""" """
+import pickle
+import unittest
+
+from can.interfaces.ics_neovi import ICSApiError
+
+
+class ICSApiErrorTest(unittest.TestCase):
+ def test_error_pickling(self):
+ iae = ICSApiError(
+ 0xF00,
+ "description_short",
+ "description_long",
+ severity=ICSApiError.ICS_SPY_ERR_CRITICAL,
+ restart_needed=1,
+ )
+ pickled_iae = pickle.dumps(iae)
+ un_pickled_iae = pickle.loads(pickled_iae)
+ assert iae.__dict__ == un_pickled_iae.__dict__
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/test/test_pcan.py b/test/test_pcan.py
new file mode 100644
index 000000000..a9c6ea922
--- /dev/null
+++ b/test/test_pcan.py
@@ -0,0 +1,512 @@
+"""
+Test for PCAN Interface
+"""
+
+import ctypes
+import struct
+import unittest
+from unittest import mock
+from unittest.mock import Mock, patch
+
+import pytest
+from parameterized import parameterized
+
+import can
+from can import BusState, CanProtocol
+from can.exceptions import CanInitializationError
+from can.interfaces.pcan import PcanBus, PcanError
+from can.interfaces.pcan.basic import *
+
+
+class TestPCANBus(unittest.TestCase):
+ def setUp(self) -> None:
+ patcher = mock.patch("can.interfaces.pcan.pcan.PCANBasic", spec=True)
+ self.MockPCANBasic = patcher.start()
+ self.addCleanup(patcher.stop)
+ self.mock_pcan = self.MockPCANBasic.return_value
+ self.mock_pcan.Initialize.return_value = PCAN_ERROR_OK
+ self.mock_pcan.InitializeFD = Mock(return_value=PCAN_ERROR_OK)
+ self.mock_pcan.SetValue = Mock(return_value=PCAN_ERROR_OK)
+ self.mock_pcan.GetValue = self._mockGetValue
+ self.PCAN_API_VERSION_SIM = "4.2"
+ self.bus = None
+
+ def tearDown(self) -> None:
+ if self.bus:
+ self.bus.shutdown()
+ self.bus = None
+
+ def _mockGetValue(self, channel, parameter):
+ """
+ This method is used as mock for GetValue method of PCANBasic object.
+ Only a subset of parameters are supported.
+ """
+ if parameter == PCAN_API_VERSION:
+ return PCAN_ERROR_OK, self.PCAN_API_VERSION_SIM.encode("ascii")
+ elif parameter == PCAN_RECEIVE_EVENT:
+ return PCAN_ERROR_OK, int.from_bytes(PCAN_RECEIVE_EVENT, "big")
+ raise NotImplementedError(
+ f"No mock return value specified for parameter {parameter}"
+ )
+
+ def test_bus_creation(self) -> None:
+ self.bus = can.Bus(interface="pcan")
+
+ self.assertIsInstance(self.bus, PcanBus)
+ self.assertEqual(self.bus.protocol, CanProtocol.CAN_20)
+
+ with pytest.deprecated_call():
+ self.assertFalse(self.bus.fd)
+
+ self.MockPCANBasic.assert_called_once()
+ self.mock_pcan.Initialize.assert_called_once()
+ self.mock_pcan.InitializeFD.assert_not_called()
+
+ def test_bus_creation_state_error(self) -> None:
+ with self.assertRaises(ValueError):
+ can.Bus(interface="pcan", state=BusState.ERROR)
+
+ @parameterized.expand([("f_clock", 80_000_000), ("f_clock_mhz", 80)])
+ def test_bus_creation_fd(self, clock_param: str, clock_val: int) -> None:
+ self.bus = can.Bus(
+ interface="pcan",
+ fd=True,
+ nom_brp=1,
+ nom_tseg1=129,
+ nom_tseg2=30,
+ nom_sjw=1,
+ data_brp=1,
+ data_tseg1=9,
+ data_tseg2=6,
+ data_sjw=1,
+ channel="PCAN_USBBUS1",
+ **{clock_param: clock_val},
+ )
+
+ self.assertIsInstance(self.bus, PcanBus)
+ self.assertEqual(self.bus.protocol, CanProtocol.CAN_FD)
+
+ with pytest.deprecated_call():
+ self.assertTrue(self.bus.fd)
+
+ self.MockPCANBasic.assert_called_once()
+ self.mock_pcan.Initialize.assert_not_called()
+ self.mock_pcan.InitializeFD.assert_called_once()
+
+ # Retrieve second argument of first call
+ bitrate_arg = self.mock_pcan.InitializeFD.call_args[0][-1]
+
+ self.assertTrue(f"{clock_param}={clock_val}".encode("ascii") in bitrate_arg)
+ self.assertTrue(b"nom_brp=1" in bitrate_arg)
+ self.assertTrue(b"nom_tseg1=129" in bitrate_arg)
+ self.assertTrue(b"nom_tseg2=30" in bitrate_arg)
+ self.assertTrue(b"nom_sjw=1" in bitrate_arg)
+ self.assertTrue(b"data_brp=1" in bitrate_arg)
+ self.assertTrue(b"data_tseg1=9" in bitrate_arg)
+ self.assertTrue(b"data_tseg2=6" in bitrate_arg)
+ self.assertTrue(b"data_sjw=1" in bitrate_arg)
+
+ def test_api_version_low(self) -> None:
+ self.PCAN_API_VERSION_SIM = "1.0"
+ with self.assertLogs("can.pcan", level="WARNING") as cm:
+ self.bus = can.Bus(interface="pcan")
+ found_version_warning = False
+ for i in cm.output:
+ if "version" in i and "pcan" in i:
+ found_version_warning = True
+ self.assertTrue(
+ found_version_warning,
+ f"No warning was logged for incompatible api version {cm.output}",
+ )
+
+ def test_api_version_read_fail(self) -> None:
+ self.mock_pcan.GetValue = Mock(return_value=(PCAN_ERROR_ILLOPERATION, None))
+ with self.assertRaises(CanInitializationError):
+ self.bus = can.Bus(interface="pcan")
+
+ def test_issue1642(self) -> None:
+ self.PCAN_API_VERSION_SIM = "1, 3, 0, 50"
+ with self.assertLogs("can.pcan", level="WARNING") as cm:
+ self.bus = can.Bus(interface="pcan")
+ found_version_warning = False
+ for i in cm.output:
+ if "version" in i and "pcan" in i:
+ found_version_warning = True
+ self.assertTrue(
+ found_version_warning,
+ f"No warning was logged for incompatible api version {cm.output}",
+ )
+
+ @parameterized.expand(
+ [
+ ("no_error", PCAN_ERROR_OK, PCAN_ERROR_OK, "some ok text 1"),
+ ("one_error", PCAN_ERROR_UNKNOWN, PCAN_ERROR_OK, "some ok text 2"),
+ (
+ "both_errors",
+ PCAN_ERROR_UNKNOWN,
+ PCAN_ERROR_UNKNOWN,
+ "An error occurred. Error-code's text (8h) couldn't be retrieved",
+ ),
+ ]
+ )
+ def test_get_formatted_error(self, name, status1, status2, expected_result: str):
+ with self.subTest(name):
+ self.bus = can.Bus(interface="pcan")
+ self.mock_pcan.GetErrorText = Mock(
+ side_effect=[
+ (status1, expected_result.encode("utf-8", errors="replace")),
+ (status2, expected_result.encode("utf-8", errors="replace")),
+ ]
+ )
+
+ complete_text = self.bus._get_formatted_error(PCAN_ERROR_BUSHEAVY)
+
+ self.assertEqual(complete_text, expected_result)
+
+ def test_status(self) -> None:
+ self.bus = can.Bus(interface="pcan")
+ self.bus.status()
+ self.mock_pcan.GetStatus.assert_called_once_with(PCAN_USBBUS1)
+
+ @parameterized.expand(
+ [("no_error", PCAN_ERROR_OK, True), ("error", PCAN_ERROR_UNKNOWN, False)]
+ )
+ def test_status_is_ok(self, name, status, expected_result) -> None:
+ with self.subTest(name):
+ self.mock_pcan.GetStatus = Mock(return_value=status)
+ self.bus = can.Bus(interface="pcan")
+ self.assertEqual(self.bus.status_is_ok(), expected_result)
+ self.mock_pcan.GetStatus.assert_called_once_with(PCAN_USBBUS1)
+
+ @parameterized.expand(
+ [("no_error", PCAN_ERROR_OK, True), ("error", PCAN_ERROR_UNKNOWN, False)]
+ )
+ def test_reset(self, name, status, expected_result) -> None:
+ with self.subTest(name):
+ self.mock_pcan.Reset = Mock(return_value=status)
+ self.bus = can.Bus(interface="pcan", fd=True)
+ self.assertEqual(self.bus.reset(), expected_result)
+ self.mock_pcan.Reset.assert_called_once_with(PCAN_USBBUS1)
+
+ @parameterized.expand(
+ [("no_error", PCAN_ERROR_OK, 1), ("error", PCAN_ERROR_UNKNOWN, None)]
+ )
+ def test_get_device_number(self, name, status, expected_result) -> None:
+ with self.subTest(name):
+ self.bus = can.Bus(interface="pcan", fd=True)
+ # Mock GetValue after creation of bus to use first mock of
+ # GetValue in constructor
+ self.mock_pcan.GetValue = Mock(return_value=(status, 1))
+
+ self.assertEqual(self.bus.get_device_number(), expected_result)
+ self.mock_pcan.GetValue.assert_called_once_with(
+ PCAN_USBBUS1, PCAN_DEVICE_NUMBER
+ )
+
+ @parameterized.expand(
+ [("no_error", PCAN_ERROR_OK, True), ("error", PCAN_ERROR_UNKNOWN, False)]
+ )
+ def test_set_device_number(self, name, status, expected_result) -> None:
+ with self.subTest(name):
+ self.bus = can.Bus(interface="pcan")
+ self.mock_pcan.SetValue = Mock(return_value=status)
+ self.assertEqual(self.bus.set_device_number(3), expected_result)
+ # check last SetValue call
+ self.assertEqual(
+ self.mock_pcan.SetValue.call_args_list[-1][0],
+ (PCAN_USBBUS1, PCAN_DEVICE_NUMBER, 3),
+ )
+
+ def test_recv(self):
+ data = (ctypes.c_ubyte * 8)(*[x for x in range(8)])
+ msg = TPCANMsg(ID=0xC0FFEF, LEN=8, MSGTYPE=PCAN_MESSAGE_EXTENDED, DATA=data)
+
+ timestamp = TPCANTimestamp()
+ self.mock_pcan.Read = Mock(return_value=(PCAN_ERROR_OK, msg, timestamp))
+ self.bus = can.Bus(interface="pcan")
+
+ recv_msg = self.bus.recv()
+ self.assertEqual(recv_msg.arbitration_id, msg.ID)
+ self.assertEqual(recv_msg.dlc, msg.LEN)
+ self.assertEqual(recv_msg.is_extended_id, True)
+ self.assertEqual(recv_msg.is_fd, False)
+ self.assertSequenceEqual(recv_msg.data, msg.DATA)
+ self.assertEqual(recv_msg.timestamp, 0)
+ self.assertEqual(recv_msg.channel, "PCAN_USBBUS1")
+
+ def test_recv_fd(self):
+ data = (ctypes.c_ubyte * 64)(*[x for x in range(64)])
+ msg = TPCANMsgFD(
+ ID=0xC0FFEF,
+ DLC=64,
+ MSGTYPE=(PCAN_MESSAGE_EXTENDED.value | PCAN_MESSAGE_FD.value),
+ DATA=data,
+ )
+
+ timestamp = TPCANTimestampFD()
+
+ self.mock_pcan.ReadFD = Mock(return_value=(PCAN_ERROR_OK, msg, timestamp))
+
+ self.bus = can.Bus(interface="pcan", fd=True)
+
+ recv_msg = self.bus.recv()
+ self.assertEqual(recv_msg.arbitration_id, msg.ID)
+ self.assertEqual(recv_msg.dlc, msg.DLC)
+ self.assertEqual(recv_msg.is_extended_id, True)
+ self.assertEqual(recv_msg.is_fd, True)
+ self.assertSequenceEqual(recv_msg.data, msg.DATA)
+ self.assertEqual(recv_msg.timestamp, 0)
+ self.assertEqual(recv_msg.channel, "PCAN_USBBUS1")
+
+ @pytest.mark.timeout(3.0)
+ @patch("select.select", return_value=([], [], []))
+ def test_recv_no_message(self, mock_select):
+ self.mock_pcan.Read = Mock(return_value=(PCAN_ERROR_QRCVEMPTY, None, None))
+ self.bus = can.Bus(interface="pcan")
+ self.assertEqual(self.bus.recv(timeout=0.5), None)
+
+ def test_send(self) -> None:
+ self.mock_pcan.Write = Mock(return_value=PCAN_ERROR_OK)
+ self.bus = can.Bus(interface="pcan")
+ msg = can.Message(
+ arbitration_id=0xC0FFEF, data=[1, 2, 3, 4, 5, 6, 7, 8], is_extended_id=True
+ )
+ self.bus.send(msg)
+ self.mock_pcan.Write.assert_called_once()
+ self.mock_pcan.WriteFD.assert_not_called()
+
+ def test_send_fd(self) -> None:
+ self.mock_pcan.WriteFD = Mock(return_value=PCAN_ERROR_OK)
+ self.bus = can.Bus(interface="pcan", fd=True)
+ msg = can.Message(
+ arbitration_id=0xC0FFEF, data=[1, 2, 3, 4, 5, 6, 7, 8], is_extended_id=True
+ )
+ self.bus.send(msg)
+ self.mock_pcan.Write.assert_not_called()
+ self.mock_pcan.WriteFD.assert_called_once()
+
+ @parameterized.expand(
+ [
+ (
+ "standart",
+ (False, False, False, False, False, False),
+ PCAN_MESSAGE_STANDARD,
+ ),
+ (
+ "extended",
+ (True, False, False, False, False, False),
+ PCAN_MESSAGE_EXTENDED,
+ ),
+ ("remote", (False, True, False, False, False, False), PCAN_MESSAGE_RTR),
+ ("error", (False, False, True, False, False, False), PCAN_MESSAGE_ERRFRAME),
+ ("fd", (False, False, False, True, False, False), PCAN_MESSAGE_FD),
+ (
+ "bitrate_switch",
+ (False, False, False, False, True, False),
+ PCAN_MESSAGE_BRS,
+ ),
+ (
+ "error_state_indicator",
+ (False, False, False, False, False, True),
+ PCAN_MESSAGE_ESI,
+ ),
+ ]
+ )
+ def test_send_type(self, name, msg_type, expected_value) -> None:
+ with self.subTest(name):
+ (
+ is_extended_id,
+ is_remote_frame,
+ is_error_frame,
+ is_fd,
+ bitrate_switch,
+ error_state_indicator,
+ ) = msg_type
+
+ self.mock_pcan.Write = Mock(return_value=PCAN_ERROR_OK)
+
+ self.bus = can.Bus(interface="pcan")
+ msg = can.Message(
+ arbitration_id=0xC0FFEF,
+ data=[1, 2, 3, 4, 5, 6, 7, 8],
+ is_extended_id=is_extended_id,
+ is_remote_frame=is_remote_frame,
+ is_error_frame=is_error_frame,
+ bitrate_switch=bitrate_switch,
+ error_state_indicator=error_state_indicator,
+ is_fd=is_fd,
+ )
+ self.bus.send(msg)
+ # self.mock_m_objPCANBasic.Write.assert_called_once()
+ CANMsg = self.mock_pcan.Write.call_args_list[0][0][1]
+ self.assertEqual(CANMsg.MSGTYPE, expected_value.value)
+
+ def test_send_error(self) -> None:
+ self.mock_pcan.Write = Mock(return_value=PCAN_ERROR_BUSHEAVY)
+ self.bus = can.Bus(interface="pcan")
+ msg = can.Message(
+ arbitration_id=0xC0FFEF, data=[1, 2, 3, 4, 5, 6, 7, 8], is_extended_id=True
+ )
+
+ with self.assertRaises(PcanError):
+ self.bus.send(msg)
+
+ @parameterized.expand([("on", True), ("off", False)])
+ def test_flash(self, name, flash) -> None:
+ with self.subTest(name):
+ self.bus = can.Bus(interface="pcan")
+ self.bus.flash(flash)
+ call_list = self.mock_pcan.SetValue.call_args_list
+ last_call_args_list = call_list[-1][0]
+ self.assertEqual(
+ last_call_args_list, (PCAN_USBBUS1, PCAN_CHANNEL_IDENTIFYING, flash)
+ )
+
+ def test_shutdown(self) -> None:
+ self.bus = can.Bus(interface="pcan")
+ self.bus.shutdown()
+ self.mock_pcan.Uninitialize.assert_called_once_with(PCAN_USBBUS1)
+
+ @parameterized.expand(
+ [
+ ("active", BusState.ACTIVE, PCAN_PARAMETER_OFF),
+ ("passive", BusState.PASSIVE, PCAN_PARAMETER_ON),
+ ]
+ )
+ def test_state(self, name, bus_state: BusState, expected_parameter) -> None:
+ with self.subTest(name):
+ self.bus = can.Bus(interface="pcan")
+
+ self.bus.state = bus_state
+ call_list = self.mock_pcan.SetValue.call_args_list
+ last_call_args_list = call_list[-1][0]
+ self.assertEqual(
+ last_call_args_list,
+ (PCAN_USBBUS1, PCAN_LISTEN_ONLY, expected_parameter),
+ )
+
+ def test_state_constructor(self):
+ for state in [BusState.ACTIVE, BusState.PASSIVE]:
+ bus = can.Bus(interface="pcan", state=state)
+ assert bus.state == state
+
+ def test_detect_available_configs(self) -> None:
+ if platform.system() == "Darwin":
+ self.mock_pcan.GetValue = Mock(
+ return_value=(PCAN_ERROR_OK, PCAN_CHANNEL_AVAILABLE)
+ )
+ configs = PcanBus._detect_available_configs()
+ self.assertEqual(len(configs), 50)
+ else:
+ value = (TPCANChannelInformation * 1).from_buffer_copy(
+ struct.pack("HBBI33sII", 81, 5, 0, 1, b"PCAN-USB FD", 1122867, 1)
+ )
+ self.mock_pcan.GetValue = Mock(return_value=(PCAN_ERROR_OK, value))
+ configs = PcanBus._detect_available_configs()
+ assert len(configs) == 1
+ assert configs[0]["interface"] == "pcan"
+ assert configs[0]["channel"] == "PCAN_USBBUS1"
+ assert configs[0]["supports_fd"]
+ assert configs[0]["controller_number"] == 0
+ assert configs[0]["device_features"] == 1
+ assert configs[0]["device_id"] == 1122867
+ assert configs[0]["device_name"] == "PCAN-USB FD"
+ assert configs[0]["device_type"] == 5
+ assert configs[0]["channel_condition"] == 1
+
+ @parameterized.expand([("valid", PCAN_ERROR_OK, "OK"), ("invalid", 0x00005, None)])
+ def test_status_string(self, name, status, expected_result) -> None:
+ with self.subTest(name):
+ self.bus = can.Bus(interface="pcan")
+ self.mock_pcan.GetStatus = Mock(return_value=status)
+ self.assertEqual(self.bus.status_string(), expected_result)
+ self.mock_pcan.GetStatus.assert_called()
+
+ @parameterized.expand([(0x0, "error"), (0x42, "PCAN_USBBUS8")])
+ def test_constructor_with_device_id(self, dev_id, expected_result):
+ def get_value_side_effect(handle, param):
+ if param == PCAN_API_VERSION:
+ return PCAN_ERROR_OK, self.PCAN_API_VERSION_SIM.encode("ascii")
+
+ if handle in (PCAN_USBBUS8, PCAN_USBBUS14):
+ return 0, 0x42
+ else:
+ return PCAN_ERROR_ILLHW, 0x0
+
+ self.mock_pcan.GetValue = Mock(side_effect=get_value_side_effect)
+
+ if expected_result == "error":
+ with self.assertRaises(ValueError):
+ can.Bus(interface="pcan", device_id=dev_id)
+ else:
+ self.bus = can.Bus(interface="pcan", device_id=dev_id)
+ self.assertEqual(expected_result, self.bus.channel_info)
+
+ def test_bus_creation_auto_reset(self):
+ self.bus = can.Bus(interface="pcan", auto_reset=True)
+ self.assertIsInstance(self.bus, PcanBus)
+ self.MockPCANBasic.assert_called_once()
+
+ def test_auto_reset_init_fault(self):
+ self.mock_pcan.SetValue = Mock(return_value=PCAN_ERROR_INITIALIZE)
+ with self.assertRaises(CanInitializationError):
+ self.bus = can.Bus(interface="pcan", auto_reset=True)
+
+ def test_peak_fd_bus_constructor_regression(self):
+ # Tests that the following issue has been fixed:
+ # https://github.com/hardbyte/python-can/issues/1458
+ params = {
+ "interface": "pcan",
+ "fd": True,
+ "f_clock": 80000000,
+ "nom_brp": 1,
+ "nom_tseg1": 129,
+ "nom_tseg2": 30,
+ "nom_sjw": 1,
+ "data_brp": 1,
+ "data_tseg1": 9,
+ "data_tseg2": 6,
+ "data_sjw": 1,
+ "channel": "PCAN_USBBUS1",
+ }
+
+ can.Bus(**params)
+
+ def test_constructor_bit_timing(self):
+ timing = can.BitTiming.from_registers(f_clock=8_000_000, btr0=0x47, btr1=0x2F)
+ bus = can.Bus(interface="pcan", channel="PCAN_USBBUS1", timing=timing)
+
+ bitrate_arg = self.mock_pcan.Initialize.call_args[0][1]
+ self.assertEqual(bitrate_arg.value, 0x472F)
+ self.assertEqual(bus.protocol, CanProtocol.CAN_20)
+
+ def test_constructor_bit_timing_fd(self):
+ timing = can.BitTimingFd(
+ f_clock=40_000_000,
+ nom_brp=1,
+ nom_tseg1=129,
+ nom_tseg2=30,
+ nom_sjw=1,
+ data_brp=1,
+ data_tseg1=9,
+ data_tseg2=6,
+ data_sjw=1,
+ )
+ bus = can.Bus(interface="pcan", channel="PCAN_USBBUS1", timing=timing)
+ self.assertEqual(bus.protocol, CanProtocol.CAN_FD)
+
+ bitrate_arg = self.mock_pcan.InitializeFD.call_args[0][-1]
+
+ self.assertTrue(b"f_clock=40000000" in bitrate_arg)
+ self.assertTrue(b"nom_brp=1" in bitrate_arg)
+ self.assertTrue(b"nom_tseg1=129" in bitrate_arg)
+ self.assertTrue(b"nom_tseg2=30" in bitrate_arg)
+ self.assertTrue(b"nom_sjw=1" in bitrate_arg)
+ self.assertTrue(b"data_brp=1" in bitrate_arg)
+ self.assertTrue(b"data_tseg1=9" in bitrate_arg)
+ self.assertTrue(b"data_tseg2=6" in bitrate_arg)
+ self.assertTrue(b"data_sjw=1" in bitrate_arg)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/test/test_player.py b/test/test_player.py
new file mode 100755
index 000000000..c4c3c90ef
--- /dev/null
+++ b/test/test_player.py
@@ -0,0 +1,155 @@
+#!/usr/bin/env python
+
+"""
+This module tests the functions inside of player.py
+"""
+
+import io
+import os
+import sys
+import unittest
+from unittest import mock
+from unittest.mock import Mock
+
+from parameterized import parameterized
+
+import can
+import can.player
+
+
+class TestPlayerScriptModule(unittest.TestCase):
+ logfile = os.path.join(os.path.dirname(__file__), "data", "test_CanMessage.asc")
+
+ def setUp(self) -> None:
+ # Patch VirtualBus object
+ patcher_virtual_bus = mock.patch("can.interfaces.virtual.VirtualBus", spec=True)
+ self.MockVirtualBus = patcher_virtual_bus.start()
+ self.addCleanup(patcher_virtual_bus.stop)
+ self.mock_virtual_bus = self.MockVirtualBus.return_value
+ self.mock_virtual_bus.__enter__ = Mock(return_value=self.mock_virtual_bus)
+
+ # Patch time sleep object
+ patcher_sleep = mock.patch("can.io.player.time.sleep", spec=True)
+ self.MockSleep = patcher_sleep.start()
+ self.addCleanup(patcher_sleep.stop)
+
+ self.baseargs = [sys.argv[0], "-i", "virtual"]
+
+ def assertSuccessfulCleanup(self):
+ self.MockVirtualBus.assert_called_once()
+ self.mock_virtual_bus.__exit__.assert_called_once()
+
+ def test_play_virtual(self):
+ sys.argv = [*self.baseargs, self.logfile]
+ can.player.main()
+ msg1 = can.Message(
+ timestamp=2.501,
+ arbitration_id=0xC8,
+ is_extended_id=False,
+ is_fd=False,
+ is_rx=False,
+ channel=1,
+ dlc=8,
+ data=[0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2],
+ )
+ msg2 = can.Message(
+ timestamp=17.876708,
+ arbitration_id=0x6F9,
+ is_extended_id=False,
+ is_fd=False,
+ is_rx=True,
+ channel=0,
+ dlc=8,
+ data=[0x5, 0xC, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0],
+ )
+ self.assertTrue(msg1.equals(self.mock_virtual_bus.send.mock_calls[0].args[0]))
+ self.assertTrue(msg2.equals(self.mock_virtual_bus.send.mock_calls[1].args[0]))
+ self.assertSuccessfulCleanup()
+
+ def test_play_virtual_verbose(self):
+ sys.argv = [*self.baseargs, "-v", self.logfile]
+ with mock.patch("sys.stdout", new_callable=io.StringIO) as mock_stdout:
+ can.player.main()
+ self.assertIn("09 08 07 06 05 04 03 02", mock_stdout.getvalue())
+ self.assertIn("05 0c 00 00 00 00 00 00", mock_stdout.getvalue())
+ self.assertEqual(self.mock_virtual_bus.send.call_count, 2)
+ self.assertSuccessfulCleanup()
+
+ def test_play_virtual_exit(self):
+ self.MockSleep.side_effect = [None, KeyboardInterrupt]
+
+ sys.argv = [*self.baseargs, self.logfile]
+ can.player.main()
+ assert self.mock_virtual_bus.send.call_count <= 2
+ self.assertSuccessfulCleanup()
+
+ def test_play_skip_error_frame(self):
+ logfile = os.path.join(
+ os.path.dirname(__file__), "data", "logfile_errorframes.asc"
+ )
+ sys.argv = [*self.baseargs, "-v", logfile]
+ can.player.main()
+ self.assertEqual(self.mock_virtual_bus.send.call_count, 9)
+ self.assertSuccessfulCleanup()
+
+ def test_play_error_frame(self):
+ logfile = os.path.join(
+ os.path.dirname(__file__), "data", "logfile_errorframes.asc"
+ )
+ sys.argv = [*self.baseargs, "-v", "--error-frames", logfile]
+ can.player.main()
+ self.assertEqual(self.mock_virtual_bus.send.call_count, 12)
+ self.assertSuccessfulCleanup()
+
+ @parameterized.expand([0, 1, 2, 3])
+ def test_play_loop(self, loop_val):
+ sys.argv = [*self.baseargs, "--loop", str(loop_val), self.logfile]
+ can.player.main()
+ msg1 = can.Message(
+ timestamp=2.501,
+ arbitration_id=0xC8,
+ is_extended_id=False,
+ is_fd=False,
+ is_rx=False,
+ channel=1,
+ dlc=8,
+ data=[0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2],
+ )
+ msg2 = can.Message(
+ timestamp=17.876708,
+ arbitration_id=0x6F9,
+ is_extended_id=False,
+ is_fd=False,
+ is_rx=True,
+ channel=0,
+ dlc=8,
+ data=[0x5, 0xC, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0],
+ )
+ for i in range(loop_val):
+ self.assertTrue(
+ msg1.equals(self.mock_virtual_bus.send.mock_calls[2 * i + 0].args[0])
+ )
+ self.assertTrue(
+ msg2.equals(self.mock_virtual_bus.send.mock_calls[2 * i + 1].args[0])
+ )
+ self.assertEqual(self.mock_virtual_bus.send.call_count, 2 * loop_val)
+ self.assertSuccessfulCleanup()
+
+ def test_play_loop_infinite(self):
+ self.mock_virtual_bus.send.side_effect = [None] * 99 + [KeyboardInterrupt]
+ sys.argv = [*self.baseargs, "-l", "i", self.logfile]
+ can.player.main()
+ self.assertEqual(self.mock_virtual_bus.send.call_count, 100)
+ self.assertSuccessfulCleanup()
+
+
+class TestPlayerCompressedFile(TestPlayerScriptModule):
+ """
+ Re-run tests using a compressed file.
+ """
+
+ logfile = os.path.join(os.path.dirname(__file__), "data", "test_CanMessage.asc.gz")
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/test/test_robotell.py b/test/test_robotell.py
index 58e2d9a7f..f95139917 100644
--- a/test/test_robotell.py
+++ b/test/test_robotell.py
@@ -1,20 +1,23 @@
#!/usr/bin/env python
-# coding: utf-8
import unittest
+
import can
class robotellTestCase(unittest.TestCase):
def setUp(self):
# will log timeout messages since we are not feeding ack messages to the serial port at this stage
- self.bus = can.Bus("loop://", bustype="robotell")
+ self.bus = can.Bus("loop://", interface="robotell")
self.serial = self.bus.serialPortOrig
self.serial.read(self.serial.in_waiting)
def tearDown(self):
self.bus.shutdown()
+ def test_protocol(self):
+ self.assertEqual(self.bus.protocol, can.CanProtocol.CAN_20)
+
def test_recv_extended(self):
self.serial.write(
bytearray(
@@ -941,6 +944,10 @@ def test_set_hw_filter(self):
),
)
+ def test_when_no_fileno(self):
+ with self.assertRaises(NotImplementedError):
+ self.bus.fileno()
+
if __name__ == "__main__":
unittest.main()
diff --git a/test/test_rotating_loggers.py b/test/test_rotating_loggers.py
new file mode 100644
index 000000000..77a2c7f5d
--- /dev/null
+++ b/test/test_rotating_loggers.py
@@ -0,0 +1,252 @@
+#!/usr/bin/env python
+
+"""
+Test rotating loggers
+"""
+
+import os
+from pathlib import Path
+from typing import cast
+from unittest.mock import Mock
+
+import can
+from can.io.generic import FileIOMessageWriter
+from can.typechecking import StringPathLike
+
+from .data.example_data import generate_message
+
+
+class TestBaseRotatingLogger:
+ @staticmethod
+ def _get_instance(file: StringPathLike) -> can.io.BaseRotatingLogger:
+ class SubClass(can.io.BaseRotatingLogger):
+ """Subclass that implements abstract methods for testing."""
+
+ _supported_formats = {".asc", ".blf", ".csv", ".log", ".txt"}
+
+ def __init__(self, file: StringPathLike, **kwargs) -> None:
+ super().__init__(**kwargs)
+ suffix = Path(file).suffix.lower()
+ if suffix not in self._supported_formats:
+ raise ValueError(f"Unsupported file format: {suffix}")
+ self._writer = can.Logger(filename=file)
+
+ @property
+ def writer(self) -> FileIOMessageWriter:
+ return cast(FileIOMessageWriter, self._writer)
+
+ def should_rollover(self, msg: can.Message) -> bool:
+ return False
+
+ def do_rollover(self): ...
+
+ return SubClass(file=file)
+
+ def test_import(self):
+ assert hasattr(can.io, "BaseRotatingLogger")
+
+ def test_attributes(self):
+ assert issubclass(can.io.BaseRotatingLogger, can.Listener)
+ assert hasattr(can.io.BaseRotatingLogger, "namer")
+ assert hasattr(can.io.BaseRotatingLogger, "rotator")
+ assert hasattr(can.io.BaseRotatingLogger, "rollover_count")
+ assert hasattr(can.io.BaseRotatingLogger, "writer")
+ assert hasattr(can.io.BaseRotatingLogger, "rotation_filename")
+ assert hasattr(can.io.BaseRotatingLogger, "rotate")
+ assert hasattr(can.io.BaseRotatingLogger, "on_message_received")
+ assert hasattr(can.io.BaseRotatingLogger, "stop")
+ assert hasattr(can.io.BaseRotatingLogger, "should_rollover")
+ assert hasattr(can.io.BaseRotatingLogger, "do_rollover")
+
+ def test_get_new_writer(self, tmp_path):
+ with self._get_instance(tmp_path / "file.ASC") as logger_instance:
+ assert isinstance(logger_instance.writer, can.ASCWriter)
+
+ with self._get_instance(tmp_path / "file.BLF") as logger_instance:
+ assert isinstance(logger_instance.writer, can.BLFWriter)
+
+ with self._get_instance(tmp_path / "file.CSV") as logger_instance:
+ assert isinstance(logger_instance.writer, can.CSVWriter)
+
+ with self._get_instance(tmp_path / "file.LOG") as logger_instance:
+ assert isinstance(logger_instance.writer, can.CanutilsLogWriter)
+
+ with self._get_instance(tmp_path / "file.TXT") as logger_instance:
+ assert isinstance(logger_instance.writer, can.Printer)
+
+ def test_rotation_filename(self, tmp_path):
+ with self._get_instance(tmp_path / "__unused.txt") as logger_instance:
+ default_name = "default"
+ assert logger_instance.rotation_filename(default_name) == "default"
+
+ logger_instance.namer = lambda x: x + "_by_namer"
+ assert logger_instance.rotation_filename(default_name) == "default_by_namer"
+
+ def test_rotate_without_rotator(self, tmp_path):
+ source = str(tmp_path / "source.txt")
+ dest = str(tmp_path / "dest.txt")
+
+ assert os.path.exists(source) is False
+ assert os.path.exists(dest) is False
+
+ with self._get_instance(source) as logger_instance:
+ # use context manager to create `source` file and close it
+ pass
+
+ assert os.path.exists(source) is True
+ assert os.path.exists(dest) is False
+
+ logger_instance.rotate(source, dest)
+
+ assert os.path.exists(source) is False
+ assert os.path.exists(dest) is True
+
+ def test_rotate_with_rotator(self, tmp_path):
+ source = str(tmp_path / "source.txt")
+ dest = str(tmp_path / "dest.txt")
+
+ assert os.path.exists(source) is False
+ assert os.path.exists(dest) is False
+
+ with self._get_instance(source) as logger_instance:
+ # use context manager to create `source` file and close it
+ pass
+
+ rotator_func = Mock()
+ logger_instance.rotator = rotator_func
+ logger_instance._writer = logger_instance._get_new_writer(source)
+ logger_instance.stop()
+
+ assert os.path.exists(source) is True
+ assert os.path.exists(dest) is False
+
+ logger_instance.rotate(source, dest)
+ rotator_func.assert_called_with(source, dest)
+
+ # assert that no rotation was performed since rotator_func
+ # does not do anything
+ assert os.path.exists(source) is True
+ assert os.path.exists(dest) is False
+
+ def test_stop(self, tmp_path):
+ """Test if stop() method of writer is called."""
+ with self._get_instance(tmp_path / "file.ASC") as logger_instance:
+ # replace stop method of writer with Mock
+ mock_stop = Mock(side_effect=logger_instance.writer.stop)
+ logger_instance.writer.stop = mock_stop
+
+ logger_instance.stop()
+ mock_stop.assert_called()
+
+ def test_on_message_received(self, tmp_path):
+ with self._get_instance(tmp_path / "file.ASC") as logger_instance:
+ # Test without rollover
+ should_rollover = Mock(return_value=False)
+ do_rollover = Mock()
+ writers_on_message_received = Mock()
+
+ logger_instance.should_rollover = should_rollover
+ logger_instance.do_rollover = do_rollover
+ logger_instance.writer.on_message_received = writers_on_message_received
+
+ msg = generate_message(0x123)
+ logger_instance.on_message_received(msg)
+
+ should_rollover.assert_called_with(msg)
+ do_rollover.assert_not_called()
+ writers_on_message_received.assert_called_with(msg)
+
+ # Test with rollover
+ should_rollover = Mock(return_value=True)
+ do_rollover = Mock()
+ writers_on_message_received = Mock()
+
+ logger_instance.should_rollover = should_rollover
+ logger_instance.do_rollover = do_rollover
+ logger_instance.writer.on_message_received = writers_on_message_received
+
+ msg = generate_message(0x123)
+ logger_instance.on_message_received(msg)
+
+ should_rollover.assert_called_with(msg)
+ do_rollover.assert_called()
+ writers_on_message_received.assert_called_with(msg)
+
+ def test_issue_1792(self, tmp_path):
+ filepath = tmp_path / "2017_Jeep_Grand_Cherokee_3.6L_V6.log"
+ with self._get_instance(filepath) as logger_instance:
+ assert isinstance(logger_instance.writer, can.CanutilsLogWriter)
+
+
+class TestSizedRotatingLogger:
+ def test_import(self):
+ assert hasattr(can.io, "SizedRotatingLogger")
+ assert hasattr(can, "SizedRotatingLogger")
+
+ def test_attributes(self):
+ assert issubclass(can.SizedRotatingLogger, can.io.BaseRotatingLogger)
+ assert hasattr(can.SizedRotatingLogger, "namer")
+ assert hasattr(can.SizedRotatingLogger, "rotator")
+ assert hasattr(can.SizedRotatingLogger, "should_rollover")
+ assert hasattr(can.SizedRotatingLogger, "do_rollover")
+
+ def test_create_instance(self, tmp_path):
+ base_filename = "mylogfile.ASC"
+ max_bytes = 512
+
+ with can.SizedRotatingLogger(
+ base_filename=tmp_path / base_filename, max_bytes=max_bytes
+ ) as logger_instance:
+ assert Path(logger_instance.base_filename).name == base_filename
+ assert logger_instance.max_bytes == max_bytes
+ assert logger_instance.rollover_count == 0
+ assert isinstance(logger_instance.writer, can.ASCWriter)
+
+ def test_should_rollover(self, tmp_path):
+ base_filename = "mylogfile.ASC"
+ max_bytes = 512
+
+ with can.SizedRotatingLogger(
+ base_filename=tmp_path / base_filename, max_bytes=max_bytes
+ ) as logger_instance:
+ msg = generate_message(0x123)
+ do_rollover = Mock()
+ logger_instance.do_rollover = do_rollover
+
+ logger_instance.writer.file.tell = Mock(return_value=511)
+ assert logger_instance.should_rollover(msg) is False
+ logger_instance.on_message_received(msg)
+ do_rollover.assert_not_called()
+
+ logger_instance.writer.file.tell = Mock(return_value=512)
+ assert logger_instance.should_rollover(msg) is True
+ logger_instance.on_message_received(msg)
+ do_rollover.assert_called()
+
+ def test_logfile_size(self, tmp_path):
+ base_filename = "mylogfile.ASC"
+ max_bytes = 1024
+ msg = generate_message(0x123)
+
+ with can.SizedRotatingLogger(
+ base_filename=tmp_path / base_filename, max_bytes=max_bytes
+ ) as logger_instance:
+ for _ in range(128):
+ logger_instance.on_message_received(msg)
+
+ for file_path in os.listdir(tmp_path):
+ assert os.path.getsize(tmp_path / file_path) <= 1100
+
+ def test_logfile_size_context_manager(self, tmp_path):
+ base_filename = "mylogfile.ASC"
+ max_bytes = 1024
+ msg = generate_message(0x123)
+
+ with can.SizedRotatingLogger(
+ base_filename=tmp_path / base_filename, max_bytes=max_bytes
+ ) as logger_instance:
+ for _ in range(128):
+ logger_instance.on_message_received(msg)
+
+ for file_path in os.listdir(tmp_path):
+ assert os.path.getsize(os.path.join(tmp_path, file_path)) <= 1100
diff --git a/test/test_scripts.py b/test/test_scripts.py
index 9504cf707..c1a6c082d 100644
--- a/test/test_scripts.py
+++ b/test/test_scripts.py
@@ -1,14 +1,13 @@
#!/usr/bin/env python
-# coding: utf-8
"""
This module tests that the scripts are all callable.
"""
+import errno
import subprocess
-import unittest
import sys
-import errno
+import unittest
from abc import ABCMeta, abstractmethod
from .config import *
@@ -28,7 +27,12 @@ def test_do_commands_exist(self):
"""
for command in self._commands():
try:
- subprocess.check_output(command.split(), stderr=subprocess.STDOUT)
+ subprocess.check_output(
+ command.split(),
+ stderr=subprocess.STDOUT,
+ encoding="utf-8",
+ shell=IS_WINDOWS,
+ )
except subprocess.CalledProcessError as e:
return_code = e.returncode
output = e.output
@@ -62,8 +66,7 @@ def _commands(self):
@abstractmethod
def _import(self):
- """Returns the modue of the script that has a main() function.
- """
+ """Returns the modue of the script that has a main() function."""
pass
@@ -71,10 +74,8 @@ class TestLoggerScript(CanScriptTest):
def _commands(self):
commands = [
"python -m can.logger --help",
- "python scripts/can_logger.py --help",
+ "can_logger --help",
]
- if IS_UNIX:
- commands += ["can_logger.py --help"]
return commands
def _import(self):
@@ -87,10 +88,8 @@ class TestPlayerScript(CanScriptTest):
def _commands(self):
commands = [
"python -m can.player --help",
- "python scripts/can_player.py --help",
+ "can_player --help",
]
- if IS_UNIX:
- commands += ["can_player.py --help"]
return commands
def _import(self):
@@ -99,6 +98,34 @@ def _import(self):
return module
+class TestBridgeScript(CanScriptTest):
+ def _commands(self):
+ commands = [
+ "python -m can.bridge --help",
+ "can_bridge --help",
+ ]
+ return commands
+
+ def _import(self):
+ import can.bridge as module
+
+ return module
+
+
+class TestLogconvertScript(CanScriptTest):
+ def _commands(self):
+ commands = [
+ "python -m can.logconvert --help",
+ "can_logconvert --help",
+ ]
+ return commands
+
+ def _import(self):
+ import can.logconvert as module
+
+ return module
+
+
# TODO add #390
diff --git a/test/test_slcan.py b/test/test_slcan.py
index 781fa75df..b757ad04d 100644
--- a/test/test_slcan.py
+++ b/test/test_slcan.py
@@ -1,22 +1,106 @@
#!/usr/bin/env python
-# coding: utf-8
-import unittest
-import can
+import unittest.mock
+from typing import cast, Optional
+
+from serial.serialutil import SerialBase
+
+import can.interfaces.slcan
+
+from .config import IS_PYPY
+
+"""
+Mentioned in #1010 & #1490
+
+> PyPy works best with pure Python applications. Whenever you use a C extension module,
+> it runs much slower than in CPython. The reason is that PyPy can't optimize C extension modules since they're not fully supported.
+> In addition, PyPy has to emulate reference counting for that part of the code, making it even slower.
+
+https://realpython.com/pypy-faster-python/#it-doesnt-work-well-with-c-extensions
+"""
+TIMEOUT = 0.5 if IS_PYPY else 0.01 # 0.001 is the default set in slcanBus
+
+
+class SerialMock(SerialBase):
+ def __init__(self, *args, **kwargs) -> None:
+ super().__init__(*args, **kwargs)
+
+ self._input_buffer = b""
+ self._output_buffer = b""
+
+ def open(self) -> None:
+ self.is_open = True
+
+ def close(self) -> None:
+ self.is_open = False
+ self._input_buffer = b""
+ self._output_buffer = b""
+
+ def read(self, size: int = -1, /) -> bytes:
+ if size > 0:
+ data = self._input_buffer[:size]
+ self._input_buffer = self._input_buffer[size:]
+ return data
+ return b""
+
+ def write(self, b: bytes, /) -> Optional[int]:
+ self._output_buffer = b
+ if b == b"N\r":
+ self.set_input_buffer(b"NA123\r")
+ elif b == b"V\r":
+ self.set_input_buffer(b"V1013\r")
+ return len(b)
+
+ def set_input_buffer(self, expected: bytes) -> None:
+ self._input_buffer = expected
+
+ def get_output_buffer(self) -> bytes:
+ return self._output_buffer
+
+ def reset_input_buffer(self) -> None:
+ self._input_buffer = b""
+
+ @property
+ def in_waiting(self) -> int:
+ return len(self._input_buffer)
+
+ @classmethod
+ def serial_for_url(cls, *args, **kwargs) -> SerialBase:
+ return cls(*args, **kwargs)
class slcanTestCase(unittest.TestCase):
+ @unittest.mock.patch("serial.serial_for_url", SerialMock.serial_for_url)
def setUp(self):
- self.bus = can.Bus("loop://", bustype="slcan", sleep_after_open=0)
- self.serial = self.bus.serialPortOrig
- self.serial.read(self.serial.in_waiting)
+ self.bus = cast(
+ can.interfaces.slcan.slcanBus,
+ can.Bus(
+ "loop://",
+ interface="slcan",
+ sleep_after_open=0,
+ timeout=TIMEOUT,
+ bitrate=500000,
+ ),
+ )
+ self.serial = cast(SerialMock, self.bus.serialPortOrig)
+ self.serial.reset_input_buffer()
def tearDown(self):
self.bus.shutdown()
def test_recv_extended(self):
- self.serial.write(b"T12ABCDEF2AA55\r")
- msg = self.bus.recv(0)
+ self.serial.set_input_buffer(b"T12ABCDEF2AA55\r")
+ msg = self.bus.recv(TIMEOUT)
+ self.assertIsNotNone(msg)
+ self.assertEqual(msg.arbitration_id, 0x12ABCDEF)
+ self.assertEqual(msg.is_extended_id, True)
+ self.assertEqual(msg.is_remote_frame, False)
+ self.assertEqual(msg.dlc, 2)
+ self.assertSequenceEqual(msg.data, [0xAA, 0x55])
+
+ # Ewert Energy Systems CANDapter specific
+ self.serial.set_input_buffer(b"x12ABCDEF2AA55\r")
+ msg = self.bus.recv(TIMEOUT)
self.assertIsNotNone(msg)
self.assertEqual(msg.arbitration_id, 0x12ABCDEF)
self.assertEqual(msg.is_extended_id, True)
@@ -25,16 +109,20 @@ def test_recv_extended(self):
self.assertSequenceEqual(msg.data, [0xAA, 0x55])
def test_send_extended(self):
+ payload = b"T12ABCDEF2AA55\r"
msg = can.Message(
arbitration_id=0x12ABCDEF, is_extended_id=True, data=[0xAA, 0x55]
)
self.bus.send(msg)
- data = self.serial.read(self.serial.in_waiting)
- self.assertEqual(data, b"T12ABCDEF2AA55\r")
+ self.assertEqual(payload, self.serial.get_output_buffer())
+
+ self.serial.set_input_buffer(payload)
+ rx_msg = self.bus.recv(TIMEOUT)
+ self.assertTrue(msg.equals(rx_msg, timestamp_delta=None))
def test_recv_standard(self):
- self.serial.write(b"t4563112233\r")
- msg = self.bus.recv(0)
+ self.serial.set_input_buffer(b"t4563112233\r")
+ msg = self.bus.recv(TIMEOUT)
self.assertIsNotNone(msg)
self.assertEqual(msg.arbitration_id, 0x456)
self.assertEqual(msg.is_extended_id, False)
@@ -43,16 +131,20 @@ def test_recv_standard(self):
self.assertSequenceEqual(msg.data, [0x11, 0x22, 0x33])
def test_send_standard(self):
+ payload = b"t4563112233\r"
msg = can.Message(
arbitration_id=0x456, is_extended_id=False, data=[0x11, 0x22, 0x33]
)
self.bus.send(msg)
- data = self.serial.read(self.serial.in_waiting)
- self.assertEqual(data, b"t4563112233\r")
+ self.assertEqual(payload, self.serial.get_output_buffer())
+
+ self.serial.set_input_buffer(payload)
+ rx_msg = self.bus.recv(TIMEOUT)
+ self.assertTrue(msg.equals(rx_msg, timestamp_delta=None))
def test_recv_standard_remote(self):
- self.serial.write(b"r1238\r")
- msg = self.bus.recv(0)
+ self.serial.set_input_buffer(b"r1238\r")
+ msg = self.bus.recv(TIMEOUT)
self.assertIsNotNone(msg)
self.assertEqual(msg.arbitration_id, 0x123)
self.assertEqual(msg.is_extended_id, False)
@@ -60,16 +152,20 @@ def test_recv_standard_remote(self):
self.assertEqual(msg.dlc, 8)
def test_send_standard_remote(self):
+ payload = b"r1238\r"
msg = can.Message(
arbitration_id=0x123, is_extended_id=False, is_remote_frame=True, dlc=8
)
self.bus.send(msg)
- data = self.serial.read(self.serial.in_waiting)
- self.assertEqual(data, b"r1238\r")
+ self.assertEqual(payload, self.serial.get_output_buffer())
+
+ self.serial.set_input_buffer(payload)
+ rx_msg = self.bus.recv(TIMEOUT)
+ self.assertTrue(msg.equals(rx_msg, timestamp_delta=None))
def test_recv_extended_remote(self):
- self.serial.write(b"R12ABCDEF6\r")
- msg = self.bus.recv(0)
+ self.serial.set_input_buffer(b"R12ABCDEF6\r")
+ msg = self.bus.recv(TIMEOUT)
self.assertIsNotNone(msg)
self.assertEqual(msg.arbitration_id, 0x12ABCDEF)
self.assertEqual(msg.is_extended_id, True)
@@ -77,20 +173,282 @@ def test_recv_extended_remote(self):
self.assertEqual(msg.dlc, 6)
def test_send_extended_remote(self):
+ payload = b"R12ABCDEF6\r"
msg = can.Message(
arbitration_id=0x12ABCDEF, is_extended_id=True, is_remote_frame=True, dlc=6
)
self.bus.send(msg)
- data = self.serial.read(self.serial.in_waiting)
- self.assertEqual(data, b"R12ABCDEF6\r")
+ self.assertEqual(payload, self.serial.get_output_buffer())
+
+ self.serial.set_input_buffer(payload)
+ rx_msg = self.bus.recv(TIMEOUT)
+ self.assertTrue(msg.equals(rx_msg, timestamp_delta=None))
+
+ def test_recv_fd(self):
+ self.serial.set_input_buffer(b"d123A303132333435363738393a3b3c3d3e3f\r")
+ msg = self.bus.recv(TIMEOUT)
+ self.assertIsNotNone(msg)
+ self.assertEqual(msg.arbitration_id, 0x123)
+ self.assertEqual(msg.is_extended_id, False)
+ self.assertEqual(msg.is_remote_frame, False)
+ self.assertEqual(msg.is_fd, True)
+ self.assertEqual(msg.bitrate_switch, False)
+ self.assertEqual(msg.dlc, 16)
+ self.assertSequenceEqual(
+ msg.data,
+ [
+ 0x30,
+ 0x31,
+ 0x32,
+ 0x33,
+ 0x34,
+ 0x35,
+ 0x36,
+ 0x37,
+ 0x38,
+ 0x39,
+ 0x3A,
+ 0x3B,
+ 0x3C,
+ 0x3D,
+ 0x3E,
+ 0x3F,
+ ],
+ )
+
+ def test_send_fd(self):
+ payload = b"d123A303132333435363738393A3B3C3D3E3F\r"
+ msg = can.Message(
+ arbitration_id=0x123,
+ is_extended_id=False,
+ is_fd=True,
+ data=[
+ 0x30,
+ 0x31,
+ 0x32,
+ 0x33,
+ 0x34,
+ 0x35,
+ 0x36,
+ 0x37,
+ 0x38,
+ 0x39,
+ 0x3A,
+ 0x3B,
+ 0x3C,
+ 0x3D,
+ 0x3E,
+ 0x3F,
+ ],
+ )
+ self.bus.send(msg)
+ self.assertEqual(payload, self.serial.get_output_buffer())
+
+ self.serial.set_input_buffer(payload)
+ rx_msg = self.bus.recv(TIMEOUT)
+ self.assertTrue(msg.equals(rx_msg, timestamp_delta=None))
+
+ def test_recv_fd_extended(self):
+ self.serial.set_input_buffer(b"D12ABCDEFA303132333435363738393A3B3C3D3E3F\r")
+ msg = self.bus.recv(TIMEOUT)
+ self.assertIsNotNone(msg)
+ self.assertEqual(msg.arbitration_id, 0x12ABCDEF)
+ self.assertEqual(msg.is_extended_id, True)
+ self.assertEqual(msg.is_remote_frame, False)
+ self.assertEqual(msg.dlc, 16)
+ self.assertEqual(msg.bitrate_switch, False)
+ self.assertTrue(msg.is_fd)
+ self.assertSequenceEqual(
+ msg.data,
+ [
+ 0x30,
+ 0x31,
+ 0x32,
+ 0x33,
+ 0x34,
+ 0x35,
+ 0x36,
+ 0x37,
+ 0x38,
+ 0x39,
+ 0x3A,
+ 0x3B,
+ 0x3C,
+ 0x3D,
+ 0x3E,
+ 0x3F,
+ ],
+ )
+
+ def test_send_fd_extended(self):
+ payload = b"D12ABCDEFA303132333435363738393A3B3C3D3E3F\r"
+ msg = can.Message(
+ arbitration_id=0x12ABCDEF,
+ is_extended_id=True,
+ is_fd=True,
+ data=[
+ 0x30,
+ 0x31,
+ 0x32,
+ 0x33,
+ 0x34,
+ 0x35,
+ 0x36,
+ 0x37,
+ 0x38,
+ 0x39,
+ 0x3A,
+ 0x3B,
+ 0x3C,
+ 0x3D,
+ 0x3E,
+ 0x3F,
+ ],
+ )
+ self.bus.send(msg)
+ self.assertEqual(payload, self.serial.get_output_buffer())
+
+ self.serial.set_input_buffer(payload)
+ rx_msg = self.bus.recv(TIMEOUT)
+ self.assertTrue(msg.equals(rx_msg, timestamp_delta=None))
+
+ def test_recv_fd_brs(self):
+ self.serial.set_input_buffer(b"b123A303132333435363738393a3b3c3d3e3f\r")
+ msg = self.bus.recv(TIMEOUT)
+ self.assertIsNotNone(msg)
+ self.assertEqual(msg.arbitration_id, 0x123)
+ self.assertEqual(msg.is_extended_id, False)
+ self.assertEqual(msg.is_remote_frame, False)
+ self.assertEqual(msg.is_fd, True)
+ self.assertEqual(msg.bitrate_switch, True)
+ self.assertEqual(msg.dlc, 16)
+ self.assertSequenceEqual(
+ msg.data,
+ [
+ 0x30,
+ 0x31,
+ 0x32,
+ 0x33,
+ 0x34,
+ 0x35,
+ 0x36,
+ 0x37,
+ 0x38,
+ 0x39,
+ 0x3A,
+ 0x3B,
+ 0x3C,
+ 0x3D,
+ 0x3E,
+ 0x3F,
+ ],
+ )
+
+ def test_send_fd_brs(self):
+ payload = b"b123A303132333435363738393A3B3C3D3E3F\r"
+ msg = can.Message(
+ arbitration_id=0x123,
+ is_extended_id=False,
+ is_fd=True,
+ bitrate_switch=True,
+ data=[
+ 0x30,
+ 0x31,
+ 0x32,
+ 0x33,
+ 0x34,
+ 0x35,
+ 0x36,
+ 0x37,
+ 0x38,
+ 0x39,
+ 0x3A,
+ 0x3B,
+ 0x3C,
+ 0x3D,
+ 0x3E,
+ 0x3F,
+ ],
+ )
+ self.bus.send(msg)
+ self.assertEqual(payload, self.serial.get_output_buffer())
+
+ self.serial.set_input_buffer(payload)
+ rx_msg = self.bus.recv(TIMEOUT)
+ self.assertTrue(msg.equals(rx_msg, timestamp_delta=None))
+
+ def test_recv_fd_brs_extended(self):
+ self.serial.set_input_buffer(b"B12ABCDEFA303132333435363738393A3B3C3D3E3F\r")
+ msg = self.bus.recv(TIMEOUT)
+ self.assertIsNotNone(msg)
+ self.assertEqual(msg.arbitration_id, 0x12ABCDEF)
+ self.assertEqual(msg.is_extended_id, True)
+ self.assertEqual(msg.is_remote_frame, False)
+ self.assertEqual(msg.dlc, 16)
+ self.assertEqual(msg.bitrate_switch, True)
+ self.assertTrue(msg.is_fd)
+ self.assertSequenceEqual(
+ msg.data,
+ [
+ 0x30,
+ 0x31,
+ 0x32,
+ 0x33,
+ 0x34,
+ 0x35,
+ 0x36,
+ 0x37,
+ 0x38,
+ 0x39,
+ 0x3A,
+ 0x3B,
+ 0x3C,
+ 0x3D,
+ 0x3E,
+ 0x3F,
+ ],
+ )
+
+ def test_send_fd_brs_extended(self):
+ payload = b"B12ABCDEFA303132333435363738393A3B3C3D3E3F\r"
+ msg = can.Message(
+ arbitration_id=0x12ABCDEF,
+ is_extended_id=True,
+ is_fd=True,
+ bitrate_switch=True,
+ data=[
+ 0x30,
+ 0x31,
+ 0x32,
+ 0x33,
+ 0x34,
+ 0x35,
+ 0x36,
+ 0x37,
+ 0x38,
+ 0x39,
+ 0x3A,
+ 0x3B,
+ 0x3C,
+ 0x3D,
+ 0x3E,
+ 0x3F,
+ ],
+ )
+ self.bus.send(msg)
+ self.assertEqual(payload, self.serial.get_output_buffer())
+
+ self.serial.set_input_buffer(payload)
+ rx_msg = self.bus.recv(TIMEOUT)
+ self.assertTrue(msg.equals(rx_msg, timestamp_delta=None))
def test_partial_recv(self):
- self.serial.write(b"T12ABCDEF")
- msg = self.bus.recv(0)
+ self.serial.set_input_buffer(b"T12ABCDEF")
+ msg = self.bus.recv(TIMEOUT)
self.assertIsNone(msg)
- self.serial.write(b"2AA55\rT12")
- msg = self.bus.recv(0)
+ self.serial.set_input_buffer(b"2AA55\rT12")
+ msg = self.bus.recv(TIMEOUT)
self.assertIsNotNone(msg)
self.assertEqual(msg.arbitration_id, 0x12ABCDEF)
self.assertEqual(msg.is_extended_id, True)
@@ -98,31 +456,24 @@ def test_partial_recv(self):
self.assertEqual(msg.dlc, 2)
self.assertSequenceEqual(msg.data, [0xAA, 0x55])
- msg = self.bus.recv(0)
+ msg = self.bus.recv(TIMEOUT)
self.assertIsNone(msg)
- self.serial.write(b"ABCDEF2AA55\r")
- msg = self.bus.recv(0)
+ self.serial.set_input_buffer(b"ABCDEF2AA55\r")
+ msg = self.bus.recv(TIMEOUT)
self.assertIsNotNone(msg)
def test_version(self):
- self.serial.write(b"V1013\r")
hw_ver, sw_ver = self.bus.get_version(0)
+ self.assertEqual(b"V\r", self.serial.get_output_buffer())
self.assertEqual(hw_ver, 10)
self.assertEqual(sw_ver, 13)
- hw_ver, sw_ver = self.bus.get_version(0)
- self.assertIsNone(hw_ver)
- self.assertIsNone(sw_ver)
-
def test_serial_number(self):
- self.serial.write(b"NA123\r")
sn = self.bus.get_serial_number(0)
+ self.assertEqual(b"N\r", self.serial.get_output_buffer())
self.assertEqual(sn, "A123")
- sn = self.bus.get_serial_number(0)
- self.assertIsNone(sn)
-
if __name__ == "__main__":
unittest.main()
diff --git a/test/test_socketcan.py b/test/test_socketcan.py
index 32389ff9f..534ee2a61 100644
--- a/test/test_socketcan.py
+++ b/test/test_socketcan.py
@@ -1,22 +1,16 @@
+#!/usr/bin/env python
+
"""
Test functions in `can.interfaces.socketcan.socketcan`.
"""
+import ctypes
+import struct
+import sys
import unittest
-
-from unittest.mock import Mock
+import warnings
from unittest.mock import patch
-from unittest.mock import call
-import ctypes
-
-from can.interfaces.socketcan.socketcan import (
- bcm_header_factory,
- build_bcm_header,
- build_bcm_tx_delete_header,
- build_bcm_transmit_header,
- build_bcm_update_header,
- BcmMsgHead,
-)
+import can
from can.interfaces.socketcan.constants import (
CAN_BCM_TX_DELETE,
CAN_BCM_TX_SETUP,
@@ -24,6 +18,16 @@
STARTTIMER,
TX_COUNTEVT,
)
+from can.interfaces.socketcan.socketcan import (
+ BcmMsgHead,
+ bcm_header_factory,
+ build_bcm_header,
+ build_bcm_transmit_header,
+ build_bcm_tx_delete_header,
+ build_bcm_update_header,
+)
+
+from .config import IS_LINUX, IS_PYPY, TEST_INTERFACE_SOCKETCAN
class SocketCANTest(unittest.TestCase):
@@ -31,6 +35,7 @@ def setUp(self):
self._ctypes_sizeof = ctypes.sizeof
self._ctypes_alignment = ctypes.alignment
+ @unittest.skipIf(sys.version_info >= (3, 14), "Fails on Python 3.14 or newer")
@patch("ctypes.sizeof")
@patch("ctypes.alignment")
def test_bcm_header_factory_32_bit_sizeof_long_4_alignof_long_4(
@@ -38,10 +43,10 @@ def test_bcm_header_factory_32_bit_sizeof_long_4_alignof_long_4(
):
"""This tests a 32-bit platform (ex. Debian Stretch on i386), where:
- * sizeof(long) == 4
- * sizeof(long long) == 8
- * alignof(long) == 4
- * alignof(long long) == 4
+ * sizeof(long) == 4
+ * sizeof(long long) == 8
+ * alignof(long) == 4
+ * alignof(long long) == 4
"""
def side_effect_ctypes_sizeof(value):
@@ -100,6 +105,7 @@ def side_effect_ctypes_alignment(value):
]
self.assertEqual(expected_fields, BcmMsgHead._fields_)
+ @unittest.skipIf(sys.version_info >= (3, 14), "Fails on Python 3.14 or newer")
@patch("ctypes.sizeof")
@patch("ctypes.alignment")
def test_bcm_header_factory_32_bit_sizeof_long_4_alignof_long_long_8(
@@ -107,10 +113,10 @@ def test_bcm_header_factory_32_bit_sizeof_long_4_alignof_long_long_8(
):
"""This tests a 32-bit platform (ex. Raspbian Stretch on armv7l), where:
- * sizeof(long) == 4
- * sizeof(long long) == 8
- * alignof(long) == 4
- * alignof(long long) == 8
+ * sizeof(long) == 4
+ * sizeof(long long) == 8
+ * alignof(long) == 4
+ * alignof(long long) == 8
"""
def side_effect_ctypes_sizeof(value):
@@ -169,6 +175,7 @@ def side_effect_ctypes_alignment(value):
]
self.assertEqual(expected_fields, BcmMsgHead._fields_)
+ @unittest.skipIf(sys.version_info >= (3, 14), "Fails on Python 3.14 or newer")
@patch("ctypes.sizeof")
@patch("ctypes.alignment")
def test_bcm_header_factory_64_bit_sizeof_long_8_alignof_long_8(
@@ -176,10 +183,10 @@ def test_bcm_header_factory_64_bit_sizeof_long_8_alignof_long_8(
):
"""This tests a 64-bit platform (ex. Ubuntu 18.04 on x86_64), where:
- * sizeof(long) == 8
- * sizeof(long long) == 8
- * alignof(long) == 8
- * alignof(long long) == 8
+ * sizeof(long) == 8
+ * sizeof(long long) == 8
+ * alignof(long) == 8
+ * alignof(long long) == 8
"""
def side_effect_ctypes_sizeof(value):
@@ -238,51 +245,27 @@ def side_effect_ctypes_alignment(value):
]
self.assertEqual(expected_fields, BcmMsgHead._fields_)
- @unittest.skipIf(
- not (
- ctypes.sizeof(ctypes.c_long) == 4 and ctypes.alignment(ctypes.c_long) == 4
- ),
- "Should only run on platforms where sizeof(long) == 4 and alignof(long) == 4",
- )
- def test_build_bcm_header_sizeof_long_4_alignof_long_4(self):
- expected_result = b""
- expected_result += b"\x02\x00\x00\x00\x00\x00\x00\x00"
- expected_result += b"\x00\x00\x00\x00\x00\x00\x00\x00"
- expected_result += b"\x00\x00\x00\x00\x00\x00\x00\x00"
- expected_result += b"\x00\x00\x00\x00\x01\x04\x00\x00"
- expected_result += b"\x01\x00\x00\x00\x00\x00\x00\x00"
-
- self.assertEqual(
- expected_result,
- build_bcm_header(
- opcode=CAN_BCM_TX_DELETE,
- flags=0,
- count=0,
- ival1_seconds=0,
- ival1_usec=0,
- ival2_seconds=0,
- ival2_usec=0,
- can_id=0x401,
- nframes=1,
- ),
+ def test_build_bcm_header(self):
+ def _find_u32_fmt_char() -> str:
+ for _fmt in ("H", "I", "L", "Q"):
+ if struct.calcsize(_fmt) == 4:
+ return _fmt
+
+ def _standard_size_little_endian_to_native(data: bytes) -> bytes:
+ std_le_fmt = "
+ ascii_msg = "< frame 123 1680000000.0 01020304 >"
+ msg = socketcand.convert_ascii_message_to_can_message(ascii_msg)
+ self.assertIsInstance(msg, can.Message)
+ self.assertEqual(msg.arbitration_id, 0x123)
+ self.assertEqual(msg.timestamp, 1680000000.0)
+ self.assertEqual(msg.data, bytearray([1, 2, 3, 4]))
+ self.assertEqual(msg.dlc, 4)
+ self.assertFalse(msg.is_extended_id)
+ self.assertTrue(msg.is_rx)
+
+ def test_valid_error_message(self):
+ # Example: < error 1ABCDEF0 1680000001.0 >
+ ascii_msg = "< error 1ABCDEF0 1680000001.0 >"
+ msg = socketcand.convert_ascii_message_to_can_message(ascii_msg)
+ self.assertIsInstance(msg, can.Message)
+ self.assertEqual(msg.arbitration_id, 0x1ABCDEF0)
+ self.assertEqual(msg.timestamp, 1680000001.0)
+ self.assertEqual(msg.data, bytearray([0]))
+ self.assertEqual(msg.dlc, 1)
+ self.assertTrue(msg.is_extended_id)
+ self.assertTrue(msg.is_error_frame)
+ self.assertTrue(msg.is_rx)
+
+ def test_invalid_message(self):
+ ascii_msg = "< unknown 123 0.0 >"
+ msg = socketcand.convert_ascii_message_to_can_message(ascii_msg)
+ self.assertIsNone(msg)
+
+ def test_missing_ending_character(self):
+ ascii_msg = "< frame 123 1680000000.0 01020304"
+ msg = socketcand.convert_ascii_message_to_can_message(ascii_msg)
+ self.assertIsNone(msg)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/test/test_systec.py b/test/test_systec.py
index 6910653fc..86ed31362 100644
--- a/test/test_systec.py
+++ b/test/test_systec.py
@@ -1,5 +1,4 @@
#!/usr/bin/env python
-# coding: utf-8
import unittest
from unittest.mock import Mock, patch
@@ -32,10 +31,13 @@ def setUp(self):
ucan.UcanDeinitHardware = Mock()
ucan.UcanWriteCanMsgEx = Mock()
ucan.UcanResetCanEx = Mock()
- self.bus = can.Bus(bustype="systec", channel=0, bitrate=125000)
+ ucan._UCAN_INITIALIZED = True # Fake this
+ self.bus = can.Bus(interface="systec", channel=0, bitrate=125000)
def test_bus_creation(self):
self.assertIsInstance(self.bus, ucanbus.UcanBus)
+ self.assertEqual(self.bus.protocol, can.CanProtocol.CAN_20)
+
self.assertTrue(ucan.UcanInitHwConnectControlEx.called)
self.assertTrue(
ucan.UcanInitHardwareEx.called or ucan.UcanInitHardwareEx2.called
@@ -136,7 +138,7 @@ def test_recv_standard(self, mock_read_can_msg, mock_get_msg_pending):
@staticmethod
def test_bus_defaults():
ucan.UcanInitCanEx2.reset_mock()
- bus = can.Bus(bustype="systec", channel=0)
+ bus = can.Bus(interface="systec", channel=0)
ucan.UcanInitCanEx2.assert_called_once_with(
bus._ucan._handle,
0,
@@ -155,7 +157,7 @@ def test_bus_defaults():
@staticmethod
def test_bus_channel():
ucan.UcanInitCanEx2.reset_mock()
- bus = can.Bus(bustype="systec", channel=1)
+ bus = can.Bus(interface="systec", channel=1)
ucan.UcanInitCanEx2.assert_called_once_with(
bus._ucan._handle,
1,
@@ -174,7 +176,7 @@ def test_bus_channel():
@staticmethod
def test_bus_bitrate():
ucan.UcanInitCanEx2.reset_mock()
- bus = can.Bus(bustype="systec", channel=0, bitrate=125000)
+ bus = can.Bus(interface="systec", channel=0, bitrate=125000)
ucan.UcanInitCanEx2.assert_called_once_with(
bus._ucan._handle,
0,
@@ -192,12 +194,12 @@ def test_bus_bitrate():
def test_bus_custom_bitrate(self):
with self.assertRaises(ValueError):
- can.Bus(bustype="systec", channel=0, bitrate=123456)
+ can.Bus(interface="systec", channel=0, bitrate=123456)
@staticmethod
def test_receive_own_messages():
ucan.UcanInitCanEx2.reset_mock()
- bus = can.Bus(bustype="systec", channel=0, receive_own_messages=True)
+ bus = can.Bus(interface="systec", channel=0, receive_own_messages=True)
ucan.UcanInitCanEx2.assert_called_once_with(
bus._ucan._handle,
0,
@@ -216,7 +218,7 @@ def test_receive_own_messages():
@staticmethod
def test_bus_passive_state():
ucan.UcanInitCanEx2.reset_mock()
- bus = can.Bus(bustype="systec", channel=0, state=can.BusState.PASSIVE)
+ bus = can.Bus(interface="systec", channel=0, state=can.BusState.PASSIVE)
ucan.UcanInitCanEx2.assert_called_once_with(
bus._ucan._handle,
0,
@@ -235,7 +237,7 @@ def test_bus_passive_state():
@staticmethod
def test_rx_buffer_entries():
ucan.UcanInitCanEx2.reset_mock()
- bus = can.Bus(bustype="systec", channel=0, rx_buffer_entries=1024)
+ bus = can.Bus(interface="systec", channel=0, rx_buffer_entries=1024)
ucan.UcanInitCanEx2.assert_called_once_with(
bus._ucan._handle,
0,
@@ -254,7 +256,7 @@ def test_rx_buffer_entries():
@staticmethod
def test_tx_buffer_entries():
ucan.UcanInitCanEx2.reset_mock()
- bus = can.Bus(bustype="systec", channel=0, tx_buffer_entries=1024)
+ bus = can.Bus(interface="systec", channel=0, tx_buffer_entries=1024)
ucan.UcanInitCanEx2.assert_called_once_with(
bus._ucan._handle,
0,
diff --git a/test/test_util.py b/test/test_util.py
new file mode 100644
index 000000000..53a9c973b
--- /dev/null
+++ b/test/test_util.py
@@ -0,0 +1,359 @@
+#!/usr/bin/env python
+
+import unittest
+import warnings
+
+import pytest
+
+import can
+from can import BitTiming, BitTimingFd
+from can.exceptions import CanInitializationError
+from can.util import (
+ _create_bus_config,
+ _rename_kwargs,
+ cast_from_string,
+ channel2int,
+ check_or_adjust_timing_clock,
+ deprecated_args_alias,
+)
+
+
+class RenameKwargsTest(unittest.TestCase):
+ expected_kwargs = dict(a=1, b=2, c=3, d=4)
+
+ def _test(self, start: str, end: str, kwargs, aliases):
+ # Test that we do get the DeprecationWarning when called with deprecated kwargs
+ with self.assertWarnsRegex(
+ DeprecationWarning, "is deprecated.*?" + start + ".*?" + end
+ ):
+ _rename_kwargs("unit_test", start, end, kwargs, aliases)
+
+ # Test that the aliases contains the deprecated values and
+ # the obsolete kwargs have been removed
+ assert kwargs == self.expected_kwargs
+
+ # Test that we do not get a DeprecationWarning when we call
+ # without deprecated kwargs
+
+ # Cause all warnings to always be triggered.
+ warnings.simplefilter("error", DeprecationWarning)
+ try:
+ _rename_kwargs("unit_test", start, end, kwargs, aliases)
+ finally:
+ warnings.resetwarnings()
+
+ def test_rename(self):
+ kwargs = dict(old_a=1, old_b=2, c=3, d=4)
+ aliases = {"old_a": "a", "old_b": "b"}
+ self._test("1.0", "2.0", kwargs, aliases)
+
+ def test_obsolete(self):
+ kwargs = dict(a=1, b=2, c=3, d=4, z=10)
+ aliases = {"z": None}
+ self._test("1.0", "2.0", kwargs, aliases)
+
+ def test_rename_and_obsolete(self):
+ kwargs = dict(old_a=1, old_b=2, c=3, d=4, z=10)
+ aliases = {"old_a": "a", "old_b": "b", "z": None}
+ self._test("1.0", "2.0", kwargs, aliases)
+
+ def test_with_new_and_alias_present(self):
+ kwargs = dict(old_a=1, a=1, b=2, c=3, d=4, z=10)
+ aliases = {"old_a": "a", "old_b": "b", "z": None}
+ with self.assertRaises(TypeError):
+ self._test("1.0", "2.0", kwargs, aliases)
+
+
+class DeprecatedArgsAliasTest(unittest.TestCase):
+ def test_decorator(self):
+ @deprecated_args_alias("1.0.0", old_a="a")
+ def _test_func1(a):
+ pass
+
+ with pytest.warns(DeprecationWarning) as record:
+ _test_func1(old_a=1)
+ assert len(record) == 1
+ assert (
+ record[0].message.args[0]
+ == "The 'old_a' argument is deprecated since python-can v1.0.0. Use 'a' instead."
+ )
+
+ @deprecated_args_alias("1.6.0", "3.4.0", old_a="a", old_b=None)
+ def _test_func2(a):
+ pass
+
+ with pytest.warns(DeprecationWarning) as record:
+ _test_func2(old_a=1, old_b=2)
+ assert len(record) == 2
+ assert record[0].message.args[0] == (
+ "The 'old_a' argument is deprecated since python-can v1.6.0, and scheduled for "
+ "removal in python-can v3.4.0. Use 'a' instead."
+ )
+ assert record[1].message.args[0] == (
+ "The 'old_b' argument is deprecated since python-can v1.6.0, and scheduled for "
+ "removal in python-can v3.4.0."
+ )
+
+ @deprecated_args_alias("1.6.0", "3.4.0", old_a="a")
+ @deprecated_args_alias("2.0.0", "4.0.0", old_b=None)
+ def _test_func3(a):
+ pass
+
+ with pytest.warns(DeprecationWarning) as record:
+ _test_func3(old_a=1, old_b=2)
+ assert len(record) == 2
+ assert record[0].message.args[0] == (
+ "The 'old_a' argument is deprecated since python-can v1.6.0, and scheduled "
+ "for removal in python-can v3.4.0. Use 'a' instead."
+ )
+ assert record[1].message.args[0] == (
+ "The 'old_b' argument is deprecated since python-can v2.0.0, and scheduled "
+ "for removal in python-can v4.0.0."
+ )
+
+ with pytest.warns(DeprecationWarning) as record:
+ _test_func3(old_a=1)
+ assert len(record) == 1
+ assert record[0].message.args[0] == (
+ "The 'old_a' argument is deprecated since python-can v1.6.0, and scheduled "
+ "for removal in python-can v3.4.0. Use 'a' instead."
+ )
+
+ with pytest.warns(DeprecationWarning) as record:
+ _test_func3(a=1, old_b=2)
+ assert len(record) == 1
+ assert record[0].message.args[0] == (
+ "The 'old_b' argument is deprecated since python-can v2.0.0, and scheduled "
+ "for removal in python-can v4.0.0."
+ )
+
+ with warnings.catch_warnings():
+ warnings.simplefilter("error")
+ _test_func3(a=1)
+
+
+class TestBusConfig(unittest.TestCase):
+ base_config = {"interface": "socketcan", "bitrate": 500_000}
+
+ def test_timing_can_use_int(self):
+ """
+ Test that an exception is not raised when using
+ integers for timing values in config.
+ """
+ timing_conf = dict(tseg1=5, tseg2=10, sjw=25)
+ try:
+ _create_bus_config({**self.base_config, **timing_conf})
+ except TypeError as e:
+ self.fail(e)
+
+ def test_port_datatype(self):
+ self.assertRaises(
+ ValueError, _create_bus_config, {**self.base_config, "port": "fail123"}
+ )
+ self.assertRaises(
+ ValueError, _create_bus_config, {**self.base_config, "port": "999999"}
+ )
+ self.assertRaises(
+ TypeError, _create_bus_config, {**self.base_config, "port": (1234,)}
+ )
+
+ try:
+ _create_bus_config({**self.base_config, "port": "1234"})
+ except TypeError as e:
+ self.fail(e)
+
+ def test_bit_timing_cfg(self):
+ can_cfg = _create_bus_config(
+ {
+ **self.base_config,
+ "f_clock": "8000000",
+ "brp": "1",
+ "tseg1": "5",
+ "tseg2": "2",
+ "sjw": "1",
+ "nof_samples": "1",
+ }
+ )
+ timing = can_cfg["timing"]
+ assert isinstance(timing, can.BitTiming)
+ assert timing.f_clock == 8_000_000
+ assert timing.brp == 1
+ assert timing.tseg1 == 5
+ assert timing.tseg2 == 2
+ assert timing.sjw == 1
+
+ def test_bit_timing_fd_cfg(self):
+ canfd_cfg = _create_bus_config(
+ {
+ **self.base_config,
+ "f_clock": "80000000",
+ "nom_brp": "1",
+ "nom_tseg1": "119",
+ "nom_tseg2": "40",
+ "nom_sjw": "40",
+ "data_brp": "1",
+ "data_tseg1": "29",
+ "data_tseg2": "10",
+ "data_sjw": "10",
+ }
+ )
+ timing = canfd_cfg["timing"]
+ assert isinstance(timing, can.BitTimingFd)
+ assert timing.f_clock == 80_000_000
+ assert timing.nom_brp == 1
+ assert timing.nom_tseg1 == 119
+ assert timing.nom_tseg2 == 40
+ assert timing.nom_sjw == 40
+ assert timing.data_brp == 1
+ assert timing.data_tseg1 == 29
+ assert timing.data_tseg2 == 10
+ assert timing.data_sjw == 10
+
+ def test_state_with_str(self):
+ can_cfg = _create_bus_config(
+ {
+ **self.base_config,
+ "state": "PASSIVE",
+ }
+ )
+ state = can_cfg["state"]
+ assert isinstance(state, can.BusState)
+ assert state is can.BusState.PASSIVE
+
+ def test_state_with_enum(self):
+ expected_state = can.BusState.PASSIVE
+ can_cfg = _create_bus_config(
+ {
+ **self.base_config,
+ "state": expected_state,
+ }
+ )
+ state = can_cfg["state"]
+ assert isinstance(state, can.BusState)
+ assert state is expected_state
+
+
+class TestChannel2Int(unittest.TestCase):
+ def test_channel2int(self) -> None:
+ self.assertEqual(0, channel2int("can0"))
+ self.assertEqual(0, channel2int("vcan0"))
+ self.assertEqual(1, channel2int("vcan1"))
+ self.assertEqual(12, channel2int("vcan12"))
+ self.assertEqual(3, channel2int(3))
+ self.assertEqual(42, channel2int("42"))
+ self.assertEqual(None, channel2int("can"))
+ self.assertEqual(None, channel2int("can0a"))
+
+
+class TestCheckAdjustTimingClock(unittest.TestCase):
+ def test_adjust_timing(self):
+ timing = BitTiming(f_clock=80_000_000, brp=10, tseg1=13, tseg2=2, sjw=1)
+
+ # Check identity case
+ new_timing = check_or_adjust_timing_clock(timing, valid_clocks=[80_000_000])
+ assert timing == new_timing
+
+ with pytest.warns(UserWarning) as record:
+ new_timing = check_or_adjust_timing_clock(
+ timing, valid_clocks=[8_000_000, 24_000_000]
+ )
+ assert len(record) == 1
+ assert (
+ record[0].message.args[0]
+ == "Adjusted f_clock in BitTiming from 80000000 to 8000000"
+ )
+ assert new_timing.__class__ == BitTiming
+ assert new_timing.f_clock == 8_000_000
+ assert new_timing.bitrate == timing.bitrate
+ assert new_timing.tseg1 == timing.tseg1
+ assert new_timing.tseg2 == timing.tseg2
+ assert new_timing.sjw == timing.sjw
+
+ # Check that order is preserved
+ with pytest.warns(UserWarning) as record:
+ new_timing = check_or_adjust_timing_clock(
+ timing, valid_clocks=[24_000_000, 8_000_000]
+ )
+ assert new_timing.f_clock == 24_000_000
+ assert len(record) == 1
+ assert (
+ record[0].message.args[0]
+ == "Adjusted f_clock in BitTiming from 80000000 to 24000000"
+ )
+
+ # Check that order is preserved for all valid clock rates
+ with pytest.warns(UserWarning) as record:
+ new_timing = check_or_adjust_timing_clock(
+ timing, valid_clocks=[8_000, 24_000_000, 8_000_000]
+ )
+ assert new_timing.f_clock == 24_000_000
+ assert len(record) == 1
+ assert (
+ record[0].message.args[0]
+ == "Adjusted f_clock in BitTiming from 80000000 to 24000000"
+ )
+
+ with pytest.raises(CanInitializationError):
+ check_or_adjust_timing_clock(timing, valid_clocks=[8_000, 16_000])
+
+ def test_adjust_timing_fd(self):
+ timing = BitTimingFd(
+ f_clock=160_000_000,
+ nom_brp=2,
+ nom_tseg1=119,
+ nom_tseg2=40,
+ nom_sjw=40,
+ data_brp=2,
+ data_tseg1=29,
+ data_tseg2=10,
+ data_sjw=10,
+ )
+
+ # Check identity case
+ new_timing = check_or_adjust_timing_clock(timing, valid_clocks=[160_000_000])
+ assert timing == new_timing
+
+ with pytest.warns(UserWarning) as record:
+ new_timing = check_or_adjust_timing_clock(
+ timing, valid_clocks=[8_000, 80_000_000]
+ )
+ assert len(record) == 1, "; ".join(
+ [record[i].message.args[0] for i in range(len(record))]
+ ) # print all warnings, if more than one warning is present
+ assert (
+ record[0].message.args[0]
+ == "Adjusted f_clock in BitTimingFd from 160000000 to 80000000"
+ )
+ assert new_timing.__class__ == BitTimingFd
+ assert new_timing.f_clock == 80_000_000
+ assert new_timing.nom_bitrate == timing.nom_bitrate
+ assert new_timing.nom_sample_point == timing.nom_sample_point
+ assert new_timing.data_bitrate == timing.data_bitrate
+ assert new_timing.data_sample_point == timing.data_sample_point
+
+ with pytest.raises(CanInitializationError):
+ check_or_adjust_timing_clock(timing, valid_clocks=[8_000, 16_000])
+
+
+class TestCastFromString(unittest.TestCase):
+ def test_cast_from_string(self) -> None:
+ self.assertEqual(1, cast_from_string("1"))
+ self.assertEqual(-1, cast_from_string("-1"))
+ self.assertEqual(0, cast_from_string("-0"))
+ self.assertEqual(1.1, cast_from_string("1.1"))
+ self.assertEqual(-1.1, cast_from_string("-1.1"))
+ self.assertEqual(0.1, cast_from_string(".1"))
+ self.assertEqual(10.0, cast_from_string(".1e2"))
+ self.assertEqual(0.001, cast_from_string(".1e-2"))
+ self.assertEqual(-0.001, cast_from_string("-.1e-2"))
+ self.assertEqual("text", cast_from_string("text"))
+ self.assertEqual("", cast_from_string(""))
+ self.assertEqual("can0", cast_from_string("can0"))
+ self.assertEqual("0can", cast_from_string("0can"))
+ self.assertEqual(False, cast_from_string("false"))
+ self.assertEqual(False, cast_from_string("False"))
+ self.assertEqual(True, cast_from_string("true"))
+ self.assertEqual(True, cast_from_string("True"))
+
+ with self.assertRaises(TypeError):
+ cast_from_string(None)
diff --git a/test/test_vector.py b/test/test_vector.py
index d99509df8..5d074f614 100644
--- a/test/test_vector.py
+++ b/test/test_vector.py
@@ -1,251 +1,1195 @@
#!/usr/bin/env python
-# coding: utf-8
"""
Test for Vector Interface
"""
import ctypes
+import functools
+import pickle
+import sys
import time
-import logging
-import os
-import unittest
+from test.config import IS_WINDOWS
from unittest.mock import Mock
import pytest
import can
-from can.interfaces.vector import canlib, xldefine, xlclass
+from can.interfaces.vector import (
+ VectorBusParams,
+ VectorCanFdParams,
+ VectorCanParams,
+ VectorChannelConfig,
+ VectorError,
+ VectorInitializationError,
+ VectorOperationError,
+ canlib,
+ xlclass,
+ xldefine,
+)
+XLDRIVER_FOUND = canlib.xldriver is not None
-class TestVectorBus(unittest.TestCase):
- def setUp(self) -> None:
- # basic mock for XLDriver
- can.interfaces.vector.canlib.xldriver = Mock()
- # bus creation functions
- can.interfaces.vector.canlib.xldriver.xlOpenDriver = Mock()
- can.interfaces.vector.canlib.xldriver.xlGetApplConfig = Mock(
- side_effect=xlGetApplConfig
- )
- can.interfaces.vector.canlib.xldriver.xlGetChannelIndex = Mock(
- side_effect=xlGetChannelIndex
- )
- can.interfaces.vector.canlib.xldriver.xlOpenPort = Mock(side_effect=xlOpenPort)
- can.interfaces.vector.canlib.xldriver.xlCanFdSetConfiguration = Mock(
- return_value=0
- )
- can.interfaces.vector.canlib.xldriver.xlCanSetChannelMode = Mock(return_value=0)
- can.interfaces.vector.canlib.xldriver.xlActivateChannel = Mock(return_value=0)
- can.interfaces.vector.canlib.xldriver.xlGetSyncTime = Mock(
- side_effect=xlGetSyncTime
- )
- can.interfaces.vector.canlib.xldriver.xlCanSetChannelAcceptance = Mock(
- return_value=0
- )
- can.interfaces.vector.canlib.xldriver.xlCanSetChannelBitrate = Mock(
- return_value=0
- )
- can.interfaces.vector.canlib.xldriver.xlSetNotification = Mock(
- side_effect=xlSetNotification
- )
+@pytest.fixture()
+def mock_xldriver() -> None:
+ # basic mock for XLDriver
+ xldriver_mock = Mock()
- # bus deactivation functions
- can.interfaces.vector.canlib.xldriver.xlDeactivateChannel = Mock(return_value=0)
- can.interfaces.vector.canlib.xldriver.xlClosePort = Mock(return_value=0)
- can.interfaces.vector.canlib.xldriver.xlCloseDriver = Mock()
+ # bus creation functions
+ xldriver_mock.xlOpenDriver = Mock()
+ xldriver_mock.xlGetApplConfig = Mock(side_effect=xlGetApplConfig)
+ xldriver_mock.xlGetChannelIndex = Mock(side_effect=xlGetChannelIndex)
+ xldriver_mock.xlOpenPort = Mock(side_effect=xlOpenPort)
+ xldriver_mock.xlCanFdSetConfiguration = Mock(return_value=0)
+ xldriver_mock.xlCanSetChannelMode = Mock(return_value=0)
+ xldriver_mock.xlActivateChannel = Mock(return_value=0)
+ xldriver_mock.xlGetSyncTime = Mock(side_effect=xlGetSyncTime)
+ xldriver_mock.xlCanSetChannelAcceptance = Mock(return_value=0)
+ xldriver_mock.xlCanSetChannelBitrate = Mock(return_value=0)
+ xldriver_mock.xlSetNotification = Mock(side_effect=xlSetNotification)
+ xldriver_mock.xlCanSetChannelOutput = Mock(return_value=0)
- # sender functions
- can.interfaces.vector.canlib.xldriver.xlCanTransmit = Mock(return_value=0)
- can.interfaces.vector.canlib.xldriver.xlCanTransmitEx = Mock(return_value=0)
+ # bus deactivation functions
+ xldriver_mock.xlDeactivateChannel = Mock(return_value=0)
+ xldriver_mock.xlClosePort = Mock(return_value=0)
+ xldriver_mock.xlCloseDriver = Mock()
- # various functions
- can.interfaces.vector.canlib.xldriver.xlCanFlushTransmitQueue = Mock()
- can.interfaces.vector.canlib.WaitForSingleObject = Mock()
+ # sender functions
+ xldriver_mock.xlCanTransmit = Mock(return_value=0)
+ xldriver_mock.xlCanTransmitEx = Mock(return_value=0)
- self.bus = None
+ # various functions
+ xldriver_mock.xlCanFlushTransmitQueue = Mock()
- def tearDown(self) -> None:
- if self.bus:
- self.bus.shutdown()
- self.bus = None
+ # backup unmodified values
+ real_xldriver = canlib.xldriver
+ real_waitforsingleobject = canlib.WaitForSingleObject
+ real_has_events = canlib.HAS_EVENTS
- def test_bus_creation(self) -> None:
- self.bus = can.Bus(channel=0, bustype="vector", _testing=True)
- self.assertIsInstance(self.bus, canlib.VectorBus)
- can.interfaces.vector.canlib.xldriver.xlOpenDriver.assert_called()
- can.interfaces.vector.canlib.xldriver.xlGetApplConfig.assert_called()
+ # set mock
+ canlib.xldriver = xldriver_mock
+ canlib.HAS_EVENTS = False
- can.interfaces.vector.canlib.xldriver.xlOpenPort.assert_called()
- xlOpenPort_args = can.interfaces.vector.canlib.xldriver.xlOpenPort.call_args[0]
- self.assertEqual(
- xlOpenPort_args[5], xldefine.XL_InterfaceVersion.XL_INTERFACE_VERSION.value
- )
- self.assertEqual(xlOpenPort_args[6], xldefine.XL_BusTypes.XL_BUS_TYPE_CAN.value)
+ yield
- can.interfaces.vector.canlib.xldriver.xlCanFdSetConfiguration.assert_not_called()
- can.interfaces.vector.canlib.xldriver.xlCanSetChannelBitrate.assert_not_called()
+ # cleanup
+ canlib.xldriver = real_xldriver
+ canlib.WaitForSingleObject = real_waitforsingleobject
+ canlib.HAS_EVENTS = real_has_events
- def test_bus_creation_bitrate(self) -> None:
- self.bus = can.Bus(channel=0, bustype="vector", bitrate=200000, _testing=True)
- self.assertIsInstance(self.bus, canlib.VectorBus)
- can.interfaces.vector.canlib.xldriver.xlOpenDriver.assert_called()
- can.interfaces.vector.canlib.xldriver.xlGetApplConfig.assert_called()
- can.interfaces.vector.canlib.xldriver.xlOpenPort.assert_called()
- xlOpenPort_args = can.interfaces.vector.canlib.xldriver.xlOpenPort.call_args[0]
- self.assertEqual(
- xlOpenPort_args[5], xldefine.XL_InterfaceVersion.XL_INTERFACE_VERSION.value
- )
- self.assertEqual(xlOpenPort_args[6], xldefine.XL_BusTypes.XL_BUS_TYPE_CAN.value)
-
- can.interfaces.vector.canlib.xldriver.xlCanFdSetConfiguration.assert_not_called()
- can.interfaces.vector.canlib.xldriver.xlCanSetChannelBitrate.assert_called()
- xlCanSetChannelBitrate_args = can.interfaces.vector.canlib.xldriver.xlCanSetChannelBitrate.call_args[
- 0
- ]
- self.assertEqual(xlCanSetChannelBitrate_args[2], 200000)
-
- def test_bus_creation_fd(self) -> None:
- self.bus = can.Bus(channel=0, bustype="vector", fd=True, _testing=True)
- self.assertIsInstance(self.bus, canlib.VectorBus)
- can.interfaces.vector.canlib.xldriver.xlOpenDriver.assert_called()
- can.interfaces.vector.canlib.xldriver.xlGetApplConfig.assert_called()
-
- can.interfaces.vector.canlib.xldriver.xlOpenPort.assert_called()
- xlOpenPort_args = can.interfaces.vector.canlib.xldriver.xlOpenPort.call_args[0]
- self.assertEqual(
- xlOpenPort_args[5],
- xldefine.XL_InterfaceVersion.XL_INTERFACE_VERSION_V4.value,
- )
- self.assertEqual(xlOpenPort_args[6], xldefine.XL_BusTypes.XL_BUS_TYPE_CAN.value)
+def test_listen_only_mocked(mock_xldriver) -> None:
+ bus = can.Bus(channel=0, interface="vector", listen_only=True, _testing=True)
+ assert isinstance(bus, canlib.VectorBus)
+ assert bus.protocol == can.CanProtocol.CAN_20
- can.interfaces.vector.canlib.xldriver.xlCanFdSetConfiguration.assert_called()
- can.interfaces.vector.canlib.xldriver.xlCanSetChannelBitrate.assert_not_called()
+ can.interfaces.vector.canlib.xldriver.xlCanSetChannelOutput.assert_called()
+ xlCanSetChannelOutput_args = (
+ can.interfaces.vector.canlib.xldriver.xlCanSetChannelOutput.call_args[0]
+ )
+ assert xlCanSetChannelOutput_args[2] == xldefine.XL_OutputMode.XL_OUTPUT_MODE_SILENT
- def test_bus_creation_fd_bitrate_timings(self) -> None:
- self.bus = can.Bus(
- channel=0,
- bustype="vector",
- fd=True,
- bitrate=500000,
- data_bitrate=2000000,
- sjwAbr=10,
- tseg1Abr=11,
- tseg2Abr=12,
- sjwDbr=13,
- tseg1Dbr=14,
- tseg2Dbr=15,
- _testing=True,
- )
- self.assertIsInstance(self.bus, canlib.VectorBus)
- can.interfaces.vector.canlib.xldriver.xlOpenDriver.assert_called()
- can.interfaces.vector.canlib.xldriver.xlGetApplConfig.assert_called()
-
- can.interfaces.vector.canlib.xldriver.xlOpenPort.assert_called()
- xlOpenPort_args = can.interfaces.vector.canlib.xldriver.xlOpenPort.call_args[0]
- self.assertEqual(
- xlOpenPort_args[5],
- xldefine.XL_InterfaceVersion.XL_INTERFACE_VERSION_V4.value,
- )
- self.assertEqual(xlOpenPort_args[6], xldefine.XL_BusTypes.XL_BUS_TYPE_CAN.value)
-
- can.interfaces.vector.canlib.xldriver.xlCanFdSetConfiguration.assert_called()
- can.interfaces.vector.canlib.xldriver.xlCanSetChannelBitrate.assert_not_called()
-
- xlCanFdSetConfiguration_args = can.interfaces.vector.canlib.xldriver.xlCanFdSetConfiguration.call_args[
- 0
- ]
- canFdConf = xlCanFdSetConfiguration_args[2]
- self.assertEqual(canFdConf.arbitrationBitRate, 500000)
- self.assertEqual(canFdConf.dataBitRate, 2000000)
- self.assertEqual(canFdConf.sjwAbr, 10)
- self.assertEqual(canFdConf.tseg1Abr, 11)
- self.assertEqual(canFdConf.tseg2Abr, 12)
- self.assertEqual(canFdConf.sjwDbr, 13)
- self.assertEqual(canFdConf.tseg1Dbr, 14)
- self.assertEqual(canFdConf.tseg2Dbr, 15)
-
- def test_receive(self) -> None:
- can.interfaces.vector.canlib.xldriver.xlReceive = Mock(side_effect=xlReceive)
- self.bus = can.Bus(channel=0, bustype="vector", _testing=True)
- self.bus.recv(timeout=0.05)
- can.interfaces.vector.canlib.xldriver.xlReceive.assert_called()
- can.interfaces.vector.canlib.xldriver.xlCanReceive.assert_not_called()
-
- def test_receive_fd(self) -> None:
- can.interfaces.vector.canlib.xldriver.xlCanReceive = Mock(
- side_effect=xlCanReceive
- )
- self.bus = can.Bus(channel=0, bustype="vector", fd=True, _testing=True)
- self.bus.recv(timeout=0.05)
- can.interfaces.vector.canlib.xldriver.xlReceive.assert_not_called()
- can.interfaces.vector.canlib.xldriver.xlCanReceive.assert_called()
-
- def test_receive_non_msg_event(self) -> None:
- can.interfaces.vector.canlib.xldriver.xlReceive = Mock(
- side_effect=xlReceive_chipstate
- )
- self.bus = can.Bus(channel=0, bustype="vector", _testing=True)
- self.bus.handle_can_event = Mock()
- self.bus.recv(timeout=0.05)
- can.interfaces.vector.canlib.xldriver.xlReceive.assert_called()
- can.interfaces.vector.canlib.xldriver.xlCanReceive.assert_not_called()
- self.bus.handle_can_event.assert_called()
-
- def test_receive_fd_non_msg_event(self) -> None:
- can.interfaces.vector.canlib.xldriver.xlCanReceive = Mock(
- side_effect=xlCanReceive_chipstate
+
+@pytest.mark.skipif(not XLDRIVER_FOUND, reason="Vector XL API is unavailable")
+def test_listen_only() -> None:
+ bus = can.Bus(
+ channel=0,
+ serial=_find_virtual_can_serial(),
+ interface="vector",
+ receive_own_messages=True,
+ listen_only=True,
+ )
+ assert isinstance(bus, canlib.VectorBus)
+ assert bus.protocol == can.CanProtocol.CAN_20
+
+ msg = can.Message(
+ arbitration_id=0xC0FFEF, data=[1, 2, 3, 4, 5, 6, 7, 8], is_extended_id=True
+ )
+
+ bus.send(msg)
+
+ received_msg = bus.recv()
+
+ assert received_msg.arbitration_id == msg.arbitration_id
+ assert received_msg.data == msg.data
+
+ bus.shutdown()
+
+
+def test_bus_creation_mocked(mock_xldriver) -> None:
+ bus = can.Bus(channel=0, interface="vector", _testing=True)
+ assert isinstance(bus, canlib.VectorBus)
+ assert bus.protocol == can.CanProtocol.CAN_20
+
+ can.interfaces.vector.canlib.xldriver.xlOpenDriver.assert_called()
+ can.interfaces.vector.canlib.xldriver.xlGetApplConfig.assert_called()
+
+ can.interfaces.vector.canlib.xldriver.xlOpenPort.assert_called()
+ xlOpenPort_args = can.interfaces.vector.canlib.xldriver.xlOpenPort.call_args[0]
+ assert xlOpenPort_args[5] == xldefine.XL_InterfaceVersion.XL_INTERFACE_VERSION.value
+ assert xlOpenPort_args[6] == xldefine.XL_BusTypes.XL_BUS_TYPE_CAN.value
+
+ can.interfaces.vector.canlib.xldriver.xlCanFdSetConfiguration.assert_not_called()
+ can.interfaces.vector.canlib.xldriver.xlCanSetChannelBitrate.assert_not_called()
+
+
+@pytest.mark.skipif(not XLDRIVER_FOUND, reason="Vector XL API is unavailable")
+def test_bus_creation() -> None:
+ bus = can.Bus(channel=0, serial=_find_virtual_can_serial(), interface="vector")
+ assert isinstance(bus, canlib.VectorBus)
+ assert bus.protocol == can.CanProtocol.CAN_20
+
+ bus.shutdown()
+
+ xl_channel_config = _find_xl_channel_config(
+ serial=_find_virtual_can_serial(), channel=0
+ )
+ assert bus.channel_masks[0] == xl_channel_config.channelMask
+ assert (
+ xl_channel_config.busParams.data.can.canOpMode
+ & xldefine.XL_CANFD_BusParams_CanOpMode.XL_BUS_PARAMS_CANOPMODE_CAN20
+ )
+
+ bus = canlib.VectorBus(channel=0, serial=_find_virtual_can_serial())
+ assert isinstance(bus, canlib.VectorBus)
+ assert bus.protocol == can.CanProtocol.CAN_20
+ bus.shutdown()
+
+
+@pytest.mark.skipif(not XLDRIVER_FOUND, reason="Vector XL API is unavailable")
+def test_bus_creation_channel_index() -> None:
+ channel_index = 1
+ bus = can.Bus(
+ channel=0,
+ serial=_find_virtual_can_serial(),
+ channel_index=channel_index,
+ interface="vector",
+ )
+ assert isinstance(bus, canlib.VectorBus)
+ assert bus.protocol == can.CanProtocol.CAN_20
+ assert bus.channel_masks[0] == 1 << channel_index
+
+ bus.shutdown()
+
+
+@pytest.mark.skipif(not XLDRIVER_FOUND, reason="Vector XL API is unavailable")
+def test_bus_creation_multiple_channels() -> None:
+ bus = can.Bus(
+ channel="0, 1",
+ bitrate=1_000_000,
+ serial=_find_virtual_can_serial(),
+ interface="vector",
+ )
+ assert isinstance(bus, canlib.VectorBus)
+ assert bus.protocol == can.CanProtocol.CAN_20
+ assert len(bus.channels) == 2
+ assert bus.mask == 3
+
+ xl_channel_config_0 = _find_xl_channel_config(
+ serial=_find_virtual_can_serial(), channel=0
+ )
+ assert xl_channel_config_0.busParams.data.can.bitRate == 1_000_000
+
+ xl_channel_config_1 = _find_xl_channel_config(
+ serial=_find_virtual_can_serial(), channel=1
+ )
+ assert xl_channel_config_1.busParams.data.can.bitRate == 1_000_000
+
+ bus.shutdown()
+
+
+def test_bus_creation_bitrate_mocked(mock_xldriver) -> None:
+ bus = can.Bus(channel=0, interface="vector", bitrate=200_000, _testing=True)
+ assert isinstance(bus, canlib.VectorBus)
+ assert bus.protocol == can.CanProtocol.CAN_20
+
+ can.interfaces.vector.canlib.xldriver.xlOpenDriver.assert_called()
+ can.interfaces.vector.canlib.xldriver.xlGetApplConfig.assert_called()
+
+ can.interfaces.vector.canlib.xldriver.xlOpenPort.assert_called()
+ xlOpenPort_args = can.interfaces.vector.canlib.xldriver.xlOpenPort.call_args[0]
+ assert xlOpenPort_args[5] == xldefine.XL_InterfaceVersion.XL_INTERFACE_VERSION.value
+ assert xlOpenPort_args[6] == xldefine.XL_BusTypes.XL_BUS_TYPE_CAN.value
+
+ can.interfaces.vector.canlib.xldriver.xlCanFdSetConfiguration.assert_not_called()
+ can.interfaces.vector.canlib.xldriver.xlCanSetChannelBitrate.assert_called()
+ xlCanSetChannelBitrate_args = (
+ can.interfaces.vector.canlib.xldriver.xlCanSetChannelBitrate.call_args[0]
+ )
+ assert xlCanSetChannelBitrate_args[2] == 200_000
+
+
+@pytest.mark.skipif(not XLDRIVER_FOUND, reason="Vector XL API is unavailable")
+def test_bus_creation_bitrate() -> None:
+ bus = can.Bus(
+ channel=0,
+ serial=_find_virtual_can_serial(),
+ interface="vector",
+ bitrate=200_000,
+ )
+ assert isinstance(bus, canlib.VectorBus)
+ assert bus.protocol == can.CanProtocol.CAN_20
+
+ xl_channel_config = _find_xl_channel_config(
+ serial=_find_virtual_can_serial(), channel=0
+ )
+ assert xl_channel_config.busParams.data.can.bitRate == 200_000
+
+ bus.shutdown()
+
+
+def test_bus_creation_fd_mocked(mock_xldriver) -> None:
+ bus = can.Bus(channel=0, interface="vector", fd=True, _testing=True)
+ assert isinstance(bus, canlib.VectorBus)
+ assert bus.protocol == can.CanProtocol.CAN_FD
+
+ can.interfaces.vector.canlib.xldriver.xlOpenDriver.assert_called()
+ can.interfaces.vector.canlib.xldriver.xlGetApplConfig.assert_called()
+
+ can.interfaces.vector.canlib.xldriver.xlOpenPort.assert_called()
+ xlOpenPort_args = can.interfaces.vector.canlib.xldriver.xlOpenPort.call_args[0]
+ assert (
+ xlOpenPort_args[5] == xldefine.XL_InterfaceVersion.XL_INTERFACE_VERSION_V4.value
+ )
+ assert xlOpenPort_args[6] == xldefine.XL_BusTypes.XL_BUS_TYPE_CAN.value
+
+ can.interfaces.vector.canlib.xldriver.xlCanFdSetConfiguration.assert_called()
+ can.interfaces.vector.canlib.xldriver.xlCanSetChannelBitrate.assert_not_called()
+
+
+@pytest.mark.skipif(not XLDRIVER_FOUND, reason="Vector XL API is unavailable")
+def test_bus_creation_fd() -> None:
+ bus = can.Bus(
+ channel=0, serial=_find_virtual_can_serial(), interface="vector", fd=True
+ )
+ assert isinstance(bus, canlib.VectorBus)
+ assert bus.protocol == can.CanProtocol.CAN_FD
+
+ xl_channel_config = _find_xl_channel_config(
+ serial=_find_virtual_can_serial(), channel=0
+ )
+ assert (
+ xl_channel_config.interfaceVersion
+ == xldefine.XL_InterfaceVersion.XL_INTERFACE_VERSION_V4
+ )
+ assert (
+ xl_channel_config.busParams.data.canFD.canOpMode
+ & xldefine.XL_CANFD_BusParams_CanOpMode.XL_BUS_PARAMS_CANOPMODE_CANFD
+ )
+ bus.shutdown()
+
+
+def test_bus_creation_fd_bitrate_timings_mocked(mock_xldriver) -> None:
+ bus = can.Bus(
+ channel=0,
+ interface="vector",
+ fd=True,
+ bitrate=500_000,
+ data_bitrate=2_000_000,
+ sjw_abr=16,
+ tseg1_abr=127,
+ tseg2_abr=32,
+ sjw_dbr=6,
+ tseg1_dbr=27,
+ tseg2_dbr=12,
+ _testing=True,
+ )
+ assert isinstance(bus, canlib.VectorBus)
+ assert bus.protocol == can.CanProtocol.CAN_FD
+
+ can.interfaces.vector.canlib.xldriver.xlOpenDriver.assert_called()
+ can.interfaces.vector.canlib.xldriver.xlGetApplConfig.assert_called()
+
+ can.interfaces.vector.canlib.xldriver.xlOpenPort.assert_called()
+ xlOpenPort_args = can.interfaces.vector.canlib.xldriver.xlOpenPort.call_args[0]
+ assert (
+ xlOpenPort_args[5] == xldefine.XL_InterfaceVersion.XL_INTERFACE_VERSION_V4.value
+ )
+
+ assert xlOpenPort_args[6] == xldefine.XL_BusTypes.XL_BUS_TYPE_CAN.value
+
+ can.interfaces.vector.canlib.xldriver.xlCanFdSetConfiguration.assert_called()
+ can.interfaces.vector.canlib.xldriver.xlCanSetChannelBitrate.assert_not_called()
+
+ xlCanFdSetConfiguration_args = (
+ can.interfaces.vector.canlib.xldriver.xlCanFdSetConfiguration.call_args[0]
+ )
+ canFdConf = xlCanFdSetConfiguration_args[2]
+ assert canFdConf.arbitrationBitRate == 500000
+ assert canFdConf.dataBitRate == 2000000
+ assert canFdConf.sjwAbr == 16
+ assert canFdConf.tseg1Abr == 127
+ assert canFdConf.tseg2Abr == 32
+ assert canFdConf.sjwDbr == 6
+ assert canFdConf.tseg1Dbr == 27
+ assert canFdConf.tseg2Dbr == 12
+
+
+@pytest.mark.skipif(not XLDRIVER_FOUND, reason="Vector XL API is unavailable")
+def test_bus_creation_fd_bitrate_timings() -> None:
+ bus = can.Bus(
+ channel=0,
+ serial=_find_virtual_can_serial(),
+ interface="vector",
+ fd=True,
+ bitrate=500_000,
+ data_bitrate=2_000_000,
+ sjw_abr=16,
+ tseg1_abr=127,
+ tseg2_abr=32,
+ sjw_dbr=6,
+ tseg1_dbr=27,
+ tseg2_dbr=12,
+ )
+
+ xl_channel_config = _find_xl_channel_config(
+ serial=_find_virtual_can_serial(), channel=0
+ )
+ assert (
+ xl_channel_config.interfaceVersion
+ == xldefine.XL_InterfaceVersion.XL_INTERFACE_VERSION_V4
+ )
+ assert (
+ xl_channel_config.busParams.data.canFD.canOpMode
+ & xldefine.XL_CANFD_BusParams_CanOpMode.XL_BUS_PARAMS_CANOPMODE_CANFD
+ )
+ assert xl_channel_config.busParams.data.canFD.arbitrationBitRate == 500_000
+ assert xl_channel_config.busParams.data.canFD.sjwAbr == 16
+ assert xl_channel_config.busParams.data.canFD.tseg1Abr == 127
+ assert xl_channel_config.busParams.data.canFD.tseg2Abr == 32
+ assert xl_channel_config.busParams.data.canFD.sjwDbr == 6
+ assert xl_channel_config.busParams.data.canFD.tseg1Dbr == 27
+ assert xl_channel_config.busParams.data.canFD.tseg2Dbr == 12
+ assert xl_channel_config.busParams.data.canFD.dataBitRate == 2_000_000
+
+ bus.shutdown()
+
+
+def test_bus_creation_timing_8mhz_mocked(mock_xldriver) -> None:
+ timing = can.BitTiming.from_bitrate_and_segments(
+ f_clock=8_000_000,
+ bitrate=125_000,
+ tseg1=13,
+ tseg2=2,
+ sjw=1,
+ )
+ bus = can.Bus(channel=0, interface="vector", timing=timing, _testing=True)
+ assert isinstance(bus, canlib.VectorBus)
+ can.interfaces.vector.canlib.xldriver.xlOpenDriver.assert_called()
+ can.interfaces.vector.canlib.xldriver.xlGetApplConfig.assert_called()
+
+ can.interfaces.vector.canlib.xldriver.xlOpenPort.assert_called()
+ xlOpenPort_args = can.interfaces.vector.canlib.xldriver.xlOpenPort.call_args[0]
+ assert xlOpenPort_args[5] == xldefine.XL_InterfaceVersion.XL_INTERFACE_VERSION.value
+ assert xlOpenPort_args[6] == xldefine.XL_BusTypes.XL_BUS_TYPE_CAN.value
+
+ can.interfaces.vector.canlib.xldriver.xlCanFdSetConfiguration.assert_not_called()
+ can.interfaces.vector.canlib.xldriver.xlCanSetChannelParamsC200.assert_called()
+ btr0, btr1 = (
+ can.interfaces.vector.canlib.xldriver.xlCanSetChannelParamsC200.call_args[0]
+ )[2:]
+ assert btr0 == timing.btr0
+ assert btr1 == timing.btr1
+
+
+def test_bus_creation_timing_16mhz_mocked(mock_xldriver) -> None:
+ timing = can.BitTiming.from_bitrate_and_segments(
+ f_clock=16_000_000,
+ bitrate=125_000,
+ tseg1=13,
+ tseg2=2,
+ sjw=1,
+ )
+ bus = can.Bus(channel=0, interface="vector", timing=timing, _testing=True)
+ assert isinstance(bus, canlib.VectorBus)
+ can.interfaces.vector.canlib.xldriver.xlOpenDriver.assert_called()
+ can.interfaces.vector.canlib.xldriver.xlGetApplConfig.assert_called()
+
+ can.interfaces.vector.canlib.xldriver.xlOpenPort.assert_called()
+ xlOpenPort_args = can.interfaces.vector.canlib.xldriver.xlOpenPort.call_args[0]
+ assert xlOpenPort_args[5] == xldefine.XL_InterfaceVersion.XL_INTERFACE_VERSION.value
+ assert xlOpenPort_args[6] == xldefine.XL_BusTypes.XL_BUS_TYPE_CAN.value
+
+ can.interfaces.vector.canlib.xldriver.xlCanFdSetConfiguration.assert_not_called()
+ can.interfaces.vector.canlib.xldriver.xlCanSetChannelParams.assert_called()
+ chip_params = (
+ can.interfaces.vector.canlib.xldriver.xlCanSetChannelParams.call_args[0]
+ )[2]
+ assert chip_params.bitRate == 125_000
+ assert chip_params.sjw == 1
+ assert chip_params.tseg1 == 13
+ assert chip_params.tseg2 == 2
+ assert chip_params.sam == 1
+
+
+@pytest.mark.skipif(not XLDRIVER_FOUND, reason="Vector XL API is unavailable")
+def test_bus_creation_timing() -> None:
+ for f_clock in [8_000_000, 16_000_000]:
+ timing = can.BitTiming.from_bitrate_and_segments(
+ f_clock=f_clock,
+ bitrate=125_000,
+ tseg1=13,
+ tseg2=2,
+ sjw=1,
)
- self.bus = can.Bus(channel=0, bustype="vector", fd=True, _testing=True)
- self.bus.handle_canfd_event = Mock()
- self.bus.recv(timeout=0.05)
- can.interfaces.vector.canlib.xldriver.xlReceive.assert_not_called()
- can.interfaces.vector.canlib.xldriver.xlCanReceive.assert_called()
- self.bus.handle_canfd_event.assert_called()
-
- def test_send(self) -> None:
- self.bus = can.Bus(channel=0, bustype="vector", _testing=True)
- msg = can.Message(
- arbitration_id=0xC0FFEF, data=[1, 2, 3, 4, 5, 6, 7, 8], is_extended_id=True
+ bus = can.Bus(
+ channel=0,
+ serial=_find_virtual_can_serial(),
+ interface="vector",
+ timing=timing,
)
- self.bus.send(msg)
- can.interfaces.vector.canlib.xldriver.xlCanTransmit.assert_called()
- can.interfaces.vector.canlib.xldriver.xlCanTransmitEx.assert_not_called()
-
- def test_send_fd(self) -> None:
- self.bus = can.Bus(channel=0, bustype="vector", fd=True, _testing=True)
- msg = can.Message(
- arbitration_id=0xC0FFEF, data=[1, 2, 3, 4, 5, 6, 7, 8], is_extended_id=True
+ assert isinstance(bus, canlib.VectorBus)
+ assert bus.protocol == can.CanProtocol.CAN_20
+
+ xl_channel_config = _find_xl_channel_config(
+ serial=_find_virtual_can_serial(), channel=0
)
- self.bus.send(msg)
- can.interfaces.vector.canlib.xldriver.xlCanTransmit.assert_not_called()
- can.interfaces.vector.canlib.xldriver.xlCanTransmitEx.assert_called()
-
- def test_flush_tx_buffer(self) -> None:
- self.bus = can.Bus(channel=0, bustype="vector", _testing=True)
- self.bus.flush_tx_buffer()
- can.interfaces.vector.canlib.xldriver.xlCanFlushTransmitQueue.assert_called()
-
- def test_shutdown(self) -> None:
- self.bus = can.Bus(channel=0, bustype="vector", _testing=True)
- self.bus.shutdown()
- can.interfaces.vector.canlib.xldriver.xlDeactivateChannel.assert_called()
- can.interfaces.vector.canlib.xldriver.xlClosePort.assert_called()
- can.interfaces.vector.canlib.xldriver.xlCloseDriver.assert_called()
-
- def test_reset(self) -> None:
- self.bus = can.Bus(channel=0, bustype="vector", _testing=True)
- self.bus.reset()
- can.interfaces.vector.canlib.xldriver.xlDeactivateChannel.assert_called()
- can.interfaces.vector.canlib.xldriver.xlActivateChannel.assert_called()
-
- def test_called_without_testing_argument(self) -> None:
- """This tests if an exception is thrown when we are not running on Windows."""
- if os.name != "nt":
- with self.assertRaises(OSError):
- # do not set the _testing argument, since it supresses the exception
- can.Bus(channel=0, bustype="vector")
+ assert xl_channel_config.busParams.data.can.bitRate == 125_000
+ assert xl_channel_config.busParams.data.can.sjw == 1
+ assert xl_channel_config.busParams.data.can.tseg1 == 13
+ assert xl_channel_config.busParams.data.can.tseg2 == 2
+
+ bus.shutdown()
+
+
+def test_bus_creation_timingfd_mocked(mock_xldriver) -> None:
+ timing = can.BitTimingFd.from_bitrate_and_segments(
+ f_clock=80_000_000,
+ nom_bitrate=500_000,
+ nom_tseg1=68,
+ nom_tseg2=11,
+ nom_sjw=10,
+ data_bitrate=2_000_000,
+ data_tseg1=10,
+ data_tseg2=9,
+ data_sjw=8,
+ )
+ bus = can.Bus(
+ channel=0,
+ interface="vector",
+ timing=timing,
+ _testing=True,
+ )
+ assert isinstance(bus, canlib.VectorBus)
+ assert bus.protocol == can.CanProtocol.CAN_FD
+
+ can.interfaces.vector.canlib.xldriver.xlOpenDriver.assert_called()
+ can.interfaces.vector.canlib.xldriver.xlGetApplConfig.assert_called()
+
+ can.interfaces.vector.canlib.xldriver.xlOpenPort.assert_called()
+ xlOpenPort_args = can.interfaces.vector.canlib.xldriver.xlOpenPort.call_args[0]
+ assert (
+ xlOpenPort_args[5] == xldefine.XL_InterfaceVersion.XL_INTERFACE_VERSION_V4.value
+ )
+
+ assert xlOpenPort_args[6] == xldefine.XL_BusTypes.XL_BUS_TYPE_CAN.value
+
+ can.interfaces.vector.canlib.xldriver.xlCanFdSetConfiguration.assert_called()
+ can.interfaces.vector.canlib.xldriver.xlCanSetChannelBitrate.assert_not_called()
+
+ xlCanFdSetConfiguration_args = (
+ can.interfaces.vector.canlib.xldriver.xlCanFdSetConfiguration.call_args[0]
+ )
+ canFdConf = xlCanFdSetConfiguration_args[2]
+ assert canFdConf.arbitrationBitRate == 500_000
+ assert canFdConf.dataBitRate == 2_000_000
+ assert canFdConf.sjwAbr == 10
+ assert canFdConf.tseg1Abr == 68
+ assert canFdConf.tseg2Abr == 11
+ assert canFdConf.sjwDbr == 8
+ assert canFdConf.tseg1Dbr == 10
+ assert canFdConf.tseg2Dbr == 9
+
+
+@pytest.mark.skipif(not XLDRIVER_FOUND, reason="Vector XL API is unavailable")
+def test_bus_creation_timingfd() -> None:
+ timing = can.BitTimingFd.from_bitrate_and_segments(
+ f_clock=80_000_000,
+ nom_bitrate=500_000,
+ nom_tseg1=68,
+ nom_tseg2=11,
+ nom_sjw=10,
+ data_bitrate=2_000_000,
+ data_tseg1=10,
+ data_tseg2=9,
+ data_sjw=8,
+ )
+ bus = can.Bus(
+ channel=0,
+ serial=_find_virtual_can_serial(),
+ interface="vector",
+ timing=timing,
+ )
+
+ assert bus.protocol == can.CanProtocol.CAN_FD
+
+ xl_channel_config = _find_xl_channel_config(
+ serial=_find_virtual_can_serial(), channel=0
+ )
+ assert (
+ xl_channel_config.interfaceVersion
+ == xldefine.XL_InterfaceVersion.XL_INTERFACE_VERSION_V4
+ )
+ assert (
+ xl_channel_config.busParams.data.canFD.canOpMode
+ & xldefine.XL_CANFD_BusParams_CanOpMode.XL_BUS_PARAMS_CANOPMODE_CANFD
+ )
+ assert xl_channel_config.busParams.data.canFD.arbitrationBitRate == 500_000
+ assert xl_channel_config.busParams.data.canFD.sjwAbr == 10
+ assert xl_channel_config.busParams.data.canFD.tseg1Abr == 68
+ assert xl_channel_config.busParams.data.canFD.tseg2Abr == 11
+ assert xl_channel_config.busParams.data.canFD.sjwDbr == 8
+ assert xl_channel_config.busParams.data.canFD.tseg1Dbr == 10
+ assert xl_channel_config.busParams.data.canFD.tseg2Dbr == 9
+ assert xl_channel_config.busParams.data.canFD.dataBitRate == 2_000_000
+
+ bus.shutdown()
+
+
+def test_send_mocked(mock_xldriver) -> None:
+ bus = can.Bus(channel=0, interface="vector", _testing=True)
+ msg = can.Message(
+ arbitration_id=0xC0FFEF, data=[1, 2, 3, 4, 5, 6, 7, 8], is_extended_id=True
+ )
+ bus.send(msg)
+ can.interfaces.vector.canlib.xldriver.xlCanTransmit.assert_called()
+ can.interfaces.vector.canlib.xldriver.xlCanTransmitEx.assert_not_called()
+
+
+def test_send_fd_mocked(mock_xldriver) -> None:
+ bus = can.Bus(channel=0, interface="vector", fd=True, _testing=True)
+ msg = can.Message(
+ arbitration_id=0xC0FFEF, data=[1, 2, 3, 4, 5, 6, 7, 8], is_extended_id=True
+ )
+ bus.send(msg)
+ can.interfaces.vector.canlib.xldriver.xlCanTransmit.assert_not_called()
+ can.interfaces.vector.canlib.xldriver.xlCanTransmitEx.assert_called()
+
+
+def test_receive_mocked(mock_xldriver) -> None:
+ can.interfaces.vector.canlib.xldriver.xlReceive = Mock(side_effect=xlReceive)
+ bus = can.Bus(channel=0, interface="vector", _testing=True)
+ bus.recv(timeout=0.05)
+ can.interfaces.vector.canlib.xldriver.xlReceive.assert_called()
+ can.interfaces.vector.canlib.xldriver.xlCanReceive.assert_not_called()
+
+
+def test_receive_fd_mocked(mock_xldriver) -> None:
+ can.interfaces.vector.canlib.xldriver.xlCanReceive = Mock(side_effect=xlCanReceive)
+ bus = can.Bus(channel=0, interface="vector", fd=True, _testing=True)
+ bus.recv(timeout=0.05)
+ can.interfaces.vector.canlib.xldriver.xlReceive.assert_not_called()
+ can.interfaces.vector.canlib.xldriver.xlCanReceive.assert_called()
+
+
+@pytest.mark.skipif(not XLDRIVER_FOUND, reason="Vector XL API is unavailable")
+def test_send_and_receive() -> None:
+ bus1 = can.Bus(channel=0, serial=_find_virtual_can_serial(), interface="vector")
+ bus2 = can.Bus(channel=0, serial=_find_virtual_can_serial(), interface="vector")
+
+ msg_std = can.Message(
+ channel=0, arbitration_id=0xFF, data=list(range(8)), is_extended_id=False
+ )
+ msg_ext = can.Message(
+ channel=0, arbitration_id=0xFFFFFF, data=list(range(8)), is_extended_id=True
+ )
+
+ bus1.send(msg_std)
+ msg_std_recv = bus2.recv(None)
+ assert msg_std.equals(msg_std_recv, timestamp_delta=None)
+
+ bus1.send(msg_ext)
+ msg_ext_recv = bus2.recv(None)
+ assert msg_ext.equals(msg_ext_recv, timestamp_delta=None)
+
+ bus1.shutdown()
+ bus2.shutdown()
+
+
+@pytest.mark.skipif(not XLDRIVER_FOUND, reason="Vector XL API is unavailable")
+def test_send_and_receive_fd() -> None:
+ bus1 = can.Bus(
+ channel=0, serial=_find_virtual_can_serial(), fd=True, interface="vector"
+ )
+ bus2 = can.Bus(
+ channel=0, serial=_find_virtual_can_serial(), fd=True, interface="vector"
+ )
+
+ msg_std = can.Message(
+ channel=0,
+ arbitration_id=0xFF,
+ data=list(range(64)),
+ is_extended_id=False,
+ is_fd=True,
+ )
+ msg_ext = can.Message(
+ channel=0,
+ arbitration_id=0xFFFFFF,
+ data=list(range(64)),
+ is_extended_id=True,
+ is_fd=True,
+ )
+
+ bus1.send(msg_std)
+ msg_std_recv = bus2.recv(None)
+ assert msg_std.equals(msg_std_recv, timestamp_delta=None)
+
+ bus1.send(msg_ext)
+ msg_ext_recv = bus2.recv(None)
+ assert msg_ext.equals(msg_ext_recv, timestamp_delta=None)
+
+ bus1.shutdown()
+ bus2.shutdown()
+
+
+def test_receive_non_msg_event_mocked(mock_xldriver) -> None:
+ can.interfaces.vector.canlib.xldriver.xlReceive = Mock(
+ side_effect=xlReceive_chipstate
+ )
+ bus = can.Bus(channel=0, interface="vector", _testing=True)
+ bus.handle_can_event = Mock()
+ bus.recv(timeout=0.05)
+ can.interfaces.vector.canlib.xldriver.xlReceive.assert_called()
+ can.interfaces.vector.canlib.xldriver.xlCanReceive.assert_not_called()
+ bus.handle_can_event.assert_called()
+
+
+@pytest.mark.skipif(not XLDRIVER_FOUND, reason="Vector XL API is unavailable")
+def test_receive_non_msg_event() -> None:
+ bus = canlib.VectorBus(
+ channel=0, serial=_find_virtual_can_serial(), interface="vector"
+ )
+ bus.handle_can_event = Mock()
+ bus.xldriver.xlCanRequestChipState(bus.port_handle, bus.channel_masks[0])
+ bus.recv(timeout=0.5)
+ bus.handle_can_event.assert_called()
+ bus.shutdown()
+
+
+def test_receive_fd_non_msg_event_mocked(mock_xldriver) -> None:
+ can.interfaces.vector.canlib.xldriver.xlCanReceive = Mock(
+ side_effect=xlCanReceive_chipstate
+ )
+ bus = can.Bus(channel=0, interface="vector", fd=True, _testing=True)
+ bus.handle_canfd_event = Mock()
+ bus.recv(timeout=0.05)
+ can.interfaces.vector.canlib.xldriver.xlReceive.assert_not_called()
+ can.interfaces.vector.canlib.xldriver.xlCanReceive.assert_called()
+ bus.handle_canfd_event.assert_called()
+
+
+@pytest.mark.skipif(not XLDRIVER_FOUND, reason="Vector XL API is unavailable")
+def test_receive_fd_non_msg_event() -> None:
+ bus = canlib.VectorBus(
+ channel=0, serial=_find_virtual_can_serial(), fd=True, interface="vector"
+ )
+ bus.handle_canfd_event = Mock()
+ bus.xldriver.xlCanRequestChipState(bus.port_handle, bus.channel_masks[0])
+ bus.recv(timeout=0.5)
+ bus.handle_canfd_event.assert_called()
+ bus.shutdown()
+
+
+def test_flush_tx_buffer_mocked(mock_xldriver) -> None:
+ bus = can.Bus(channel=0, interface="vector", _testing=True)
+ bus.flush_tx_buffer()
+ transmit_args = can.interfaces.vector.canlib.xldriver.xlCanTransmit.call_args[0]
+
+ num_msg = transmit_args[2]
+ assert num_msg.value == ctypes.c_uint(1).value
+
+ event = transmit_args[3]
+ assert isinstance(event, xlclass.XLevent)
+ assert event.tag & xldefine.XL_EventTags.XL_TRANSMIT_MSG
+ assert event.tagData.msg.flags & (
+ xldefine.XL_MessageFlags.XL_CAN_MSG_FLAG_OVERRUN
+ | xldefine.XL_MessageFlags.XL_CAN_MSG_FLAG_WAKEUP
+ )
+
+
+def test_flush_tx_buffer_fd_mocked(mock_xldriver) -> None:
+ bus = can.Bus(channel=0, interface="vector", fd=True, _testing=True)
+ bus.flush_tx_buffer()
+ transmit_args = can.interfaces.vector.canlib.xldriver.xlCanTransmitEx.call_args[0]
+
+ num_msg = transmit_args[2]
+ assert num_msg.value == ctypes.c_uint(1).value
+
+ num_msg_sent = transmit_args[3]
+ assert num_msg_sent.value == ctypes.c_uint(0).value
+
+ event = transmit_args[4]
+ assert isinstance(event, xlclass.XLcanTxEvent)
+ assert event.tag & xldefine.XL_CANFD_TX_EventTags.XL_CAN_EV_TAG_TX_MSG
+ assert (
+ event.tagData.canMsg.msgFlags
+ & xldefine.XL_CANFD_TX_MessageFlags.XL_CAN_TXMSG_FLAG_HIGHPRIO
+ )
+
+
+@pytest.mark.skipif(not XLDRIVER_FOUND, reason="Vector XL API is unavailable")
+def test_flush_tx_buffer() -> None:
+ bus = can.Bus(channel=0, serial=_find_virtual_can_serial(), interface="vector")
+ bus.flush_tx_buffer()
+ bus.shutdown()
+
+
+def test_shutdown_mocked(mock_xldriver) -> None:
+ bus = can.Bus(channel=0, interface="vector", _testing=True)
+ bus.shutdown()
+ can.interfaces.vector.canlib.xldriver.xlDeactivateChannel.assert_called()
+ can.interfaces.vector.canlib.xldriver.xlClosePort.assert_called()
+ can.interfaces.vector.canlib.xldriver.xlCloseDriver.assert_called()
+
+
+@pytest.mark.skipif(not XLDRIVER_FOUND, reason="Vector XL API is unavailable")
+def test_shutdown() -> None:
+ bus = can.Bus(channel=0, serial=_find_virtual_can_serial(), interface="vector")
+
+ xl_channel_config = _find_xl_channel_config(
+ serial=_find_virtual_can_serial(), channel=0
+ )
+ assert xl_channel_config.isOnBus != 0
+ bus.shutdown()
+
+ xl_channel_config = _find_xl_channel_config(
+ serial=_find_virtual_can_serial(), channel=0
+ )
+ assert xl_channel_config.isOnBus == 0
+
+
+def test_reset_mocked(mock_xldriver) -> None:
+ bus = canlib.VectorBus(channel=0, interface="vector", _testing=True)
+ bus.reset()
+ can.interfaces.vector.canlib.xldriver.xlDeactivateChannel.assert_called()
+ can.interfaces.vector.canlib.xldriver.xlActivateChannel.assert_called()
+
+
+@pytest.mark.skipif(not XLDRIVER_FOUND, reason="Vector XL API is unavailable")
+def test_reset() -> None:
+ bus = canlib.VectorBus(
+ channel=0, serial=_find_virtual_can_serial(), interface="vector"
+ )
+ bus.reset()
+ bus.shutdown()
+
+
+def test_popup_hw_cfg_mocked(mock_xldriver) -> None:
+ canlib.xldriver.xlPopupHwConfig = Mock()
+ canlib.VectorBus.popup_vector_hw_configuration(10)
+ assert canlib.xldriver.xlPopupHwConfig.called
+ args, kwargs = canlib.xldriver.xlPopupHwConfig.call_args
+ assert isinstance(args[0], ctypes.c_char_p)
+ assert isinstance(args[1], ctypes.c_uint)
+
+
+@pytest.mark.skipif(not XLDRIVER_FOUND, reason="Vector XL API is unavailable")
+def test_popup_hw_cfg() -> None:
+ with pytest.raises(VectorOperationError):
+ canlib.VectorBus.popup_vector_hw_configuration(1)
+
+
+def test_get_application_config_mocked(mock_xldriver) -> None:
+ canlib.xldriver.xlGetApplConfig = Mock()
+ canlib.VectorBus.get_application_config(app_name="CANalyzer", app_channel=0)
+ assert canlib.xldriver.xlGetApplConfig.called
+
+
+def test_set_application_config_mocked(mock_xldriver) -> None:
+ canlib.xldriver.xlSetApplConfig = Mock()
+ canlib.VectorBus.set_application_config(
+ app_name="CANalyzer",
+ app_channel=0,
+ hw_type=xldefine.XL_HardwareType.XL_HWTYPE_VN1610,
+ hw_index=0,
+ hw_channel=0,
+ )
+ assert canlib.xldriver.xlSetApplConfig.called
+
+
+@pytest.mark.skipif(not XLDRIVER_FOUND, reason="Vector XL API is unavailable")
+def test_set_and_get_application_config() -> None:
+ xl_channel_config = _find_xl_channel_config(
+ serial=_find_virtual_can_serial(), channel=1
+ )
+ canlib.VectorBus.set_application_config(
+ app_name="python-can::test_vector",
+ app_channel=5,
+ hw_channel=xl_channel_config.hwChannel,
+ hw_index=xl_channel_config.hwIndex,
+ hw_type=xldefine.XL_HardwareType(xl_channel_config.hwType),
+ )
+ hw_type, hw_index, hw_channel = canlib.VectorBus.get_application_config(
+ app_name="python-can::test_vector",
+ app_channel=5,
+ )
+ assert hw_type == xldefine.XL_HardwareType(xl_channel_config.hwType)
+ assert hw_index == xl_channel_config.hwIndex
+ assert hw_channel == xl_channel_config.hwChannel
+
+
+def test_set_timer_mocked(mock_xldriver) -> None:
+ canlib.xldriver.xlSetTimerRate = Mock()
+ bus = canlib.VectorBus(channel=0, interface="vector", fd=True, _testing=True)
+ bus.set_timer_rate(timer_rate_ms=1)
+ assert canlib.xldriver.xlSetTimerRate.called
+
+
+@pytest.mark.skipif(not XLDRIVER_FOUND, reason="Vector XL API is unavailable")
+def test_set_timer() -> None:
+ bus = canlib.VectorBus(
+ channel=0, serial=_find_virtual_can_serial(), interface="vector"
+ )
+ bus.handle_can_event = Mock()
+ bus.set_timer_rate(timer_rate_ms=1)
+ t0 = time.perf_counter()
+ while time.perf_counter() - t0 < 0.5:
+ bus.recv(timeout=-1)
+
+ # call_count is incorrect when using virtual bus
+ # assert bus.handle_can_event.call_count > 498
+ # assert bus.handle_can_event.call_count < 502
+
+
+@pytest.mark.skipif(IS_WINDOWS, reason="Not relevant for Windows.")
+def test_called_without_testing_argument() -> None:
+ """This tests if an exception is thrown when we are not running on Windows."""
+ with pytest.raises(can.CanInterfaceNotImplementedError):
+ # do not set the _testing argument, since it would suppress the exception
+ can.Bus(channel=0, interface="vector")
+
+
+def test_vector_error_pickle() -> None:
+ for error_type in [
+ VectorError,
+ VectorInitializationError,
+ VectorOperationError,
+ ]:
+ error_code = 118
+ error_string = "XL_ERROR"
+ function = "function_name"
+
+ exc = error_type(error_code, error_string, function)
+
+ # pickle and unpickle
+ p = pickle.dumps(exc)
+ exc_unpickled: VectorError = pickle.loads(p)
+
+ assert str(exc) == str(exc_unpickled)
+ assert error_code == exc_unpickled.error_code
+
+ with pytest.raises(error_type):
+ raise exc_unpickled
+
+
+def test_vector_subtype_error_from_generic() -> None:
+ for error_type in [VectorInitializationError, VectorOperationError]:
+ error_code = 118
+ error_string = "XL_ERROR"
+ function = "function_name"
+
+ generic = VectorError(error_code, error_string, function)
+
+ # pickle and unpickle
+ specific: VectorError = error_type.from_generic(generic)
+
+ assert str(generic) == str(specific)
+ assert error_code == specific.error_code
+
+ with pytest.raises(error_type):
+ raise specific
+
+
+def test_iterate_channel_index() -> None:
+ channel_mask = 0x23 # 100011
+ channels = list(canlib._iterate_channel_index(channel_mask))
+ assert channels == [0, 1, 5]
+
+
+@pytest.mark.skipif(
+ sys.byteorder != "little", reason="Test relies on little endian data."
+)
+def test_get_channel_configs() -> None:
+ _original_func = canlib._get_xl_driver_config
+ canlib._get_xl_driver_config = _get_predefined_xl_driver_config
+
+ channel_configs = canlib.get_channel_configs()
+ assert len(channel_configs) == 12
+
+ canlib._get_xl_driver_config = _original_func
+
+
+@pytest.mark.skipif(
+ sys.byteorder != "little", reason="Test relies on little endian data."
+)
+def test_detect_available_configs() -> None:
+ _original_func = canlib._get_xl_driver_config
+ canlib._get_xl_driver_config = _get_predefined_xl_driver_config
+
+ available_configs = canlib.VectorBus._detect_available_configs()
+
+ assert len(available_configs) == 5
+
+ assert available_configs[0]["interface"] == "vector"
+ assert available_configs[0]["channel"] == 2
+ assert available_configs[0]["serial"] == 1001
+ assert available_configs[0]["channel_index"] == 2
+ assert available_configs[0]["hw_type"] == xldefine.XL_HardwareType.XL_HWTYPE_VN8900
+ assert available_configs[0]["hw_index"] == 0
+ assert available_configs[0]["supports_fd"] is True
+ assert isinstance(
+ available_configs[0]["vector_channel_config"], VectorChannelConfig
+ )
+
+ canlib._get_xl_driver_config = _original_func
+
+
+@pytest.mark.skipif(not IS_WINDOWS, reason="Windows specific test")
+def test_winapi_availability() -> None:
+ assert canlib.WaitForSingleObject is not None
+ assert canlib.INFINITE is not None
+
+
+def test_vector_channel_config_attributes():
+ assert hasattr(VectorChannelConfig, "name")
+ assert hasattr(VectorChannelConfig, "hw_type")
+ assert hasattr(VectorChannelConfig, "hw_index")
+ assert hasattr(VectorChannelConfig, "hw_channel")
+ assert hasattr(VectorChannelConfig, "channel_index")
+ assert hasattr(VectorChannelConfig, "channel_mask")
+ assert hasattr(VectorChannelConfig, "channel_capabilities")
+ assert hasattr(VectorChannelConfig, "channel_bus_capabilities")
+ assert hasattr(VectorChannelConfig, "is_on_bus")
+ assert hasattr(VectorChannelConfig, "bus_params")
+ assert hasattr(VectorChannelConfig, "connected_bus_type")
+ assert hasattr(VectorChannelConfig, "serial_number")
+ assert hasattr(VectorChannelConfig, "article_number")
+ assert hasattr(VectorChannelConfig, "transceiver_name")
+
+
+def test_vector_bus_params_attributes():
+ assert hasattr(VectorBusParams, "bus_type")
+ assert hasattr(VectorBusParams, "can")
+ assert hasattr(VectorBusParams, "canfd")
+
+
+def test_vector_can_params_attributes():
+ assert hasattr(VectorCanParams, "bitrate")
+ assert hasattr(VectorCanParams, "sjw")
+ assert hasattr(VectorCanParams, "tseg1")
+ assert hasattr(VectorCanParams, "tseg2")
+ assert hasattr(VectorCanParams, "sam")
+ assert hasattr(VectorCanParams, "output_mode")
+ assert hasattr(VectorCanParams, "can_op_mode")
+
+
+def test_vector_canfd_params_attributes():
+ assert hasattr(VectorCanFdParams, "bitrate")
+ assert hasattr(VectorCanFdParams, "data_bitrate")
+ assert hasattr(VectorCanFdParams, "sjw_abr")
+ assert hasattr(VectorCanFdParams, "tseg1_abr")
+ assert hasattr(VectorCanFdParams, "tseg2_abr")
+ assert hasattr(VectorCanFdParams, "sam_abr")
+ assert hasattr(VectorCanFdParams, "sjw_dbr")
+ assert hasattr(VectorCanFdParams, "tseg1_dbr")
+ assert hasattr(VectorCanFdParams, "tseg2_dbr")
+ assert hasattr(VectorCanFdParams, "output_mode")
+ assert hasattr(VectorCanFdParams, "can_op_mode")
+
+
+# *****************************************************************************
+# Utility functions
+# *****************************************************************************
+
+
+def _find_xl_channel_config(serial: int, channel: int) -> xlclass.XLchannelConfig:
+ """Helper function"""
+ xl_driver_config = xlclass.XLdriverConfig()
+ canlib.xldriver.xlOpenDriver()
+ canlib.xldriver.xlGetDriverConfig(xl_driver_config)
+ canlib.xldriver.xlCloseDriver()
+
+ for i in range(xl_driver_config.channelCount):
+ xl_channel_config: xlclass.XLchannelConfig = xl_driver_config.channel[i]
+
+ if xl_channel_config.serialNumber != serial:
+ continue
+
+ if xl_channel_config.hwChannel != channel:
+ continue
+
+ return xl_channel_config
+
+ raise LookupError("XLchannelConfig not found.")
+
+
+@functools.lru_cache
+def _find_virtual_can_serial() -> int:
+ """Serial number might be 0 or 100 depending on driver version."""
+ xl_driver_config = xlclass.XLdriverConfig()
+ canlib.xldriver.xlOpenDriver()
+ canlib.xldriver.xlGetDriverConfig(xl_driver_config)
+ canlib.xldriver.xlCloseDriver()
+
+ for i in range(xl_driver_config.channelCount):
+ xl_channel_config: xlclass.XLchannelConfig = xl_driver_config.channel[i]
+
+ if "Virtual CAN" in xl_channel_config.transceiverName.decode():
+ return xl_channel_config.serialNumber
+
+ raise LookupError("Vector virtual CAN not found")
+
+
+XL_DRIVER_CONFIG_EXAMPLE = (
+ b"\x0e\x00\x1e\x14\x0c\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x56\x4e\x38\x39\x31\x34\x20\x43\x68\x61\x6e\x6e"
+ b"\x65\x6c\x20\x53\x74\x72\x65\x61\x6d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x04"
+ b"\x0a\x40\x00\x02\x00\x02\x00\x00\x02\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x02\x0a\x04\x00\x00\x00\x00\x00\x00\x00\x8e"
+ b"\x00\x02\x0a\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe9\x03\x00\x00\x08"
+ b"\x1c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x03\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x4e\x38\x39\x31"
+ b"\x34\x20\x43\x68\x61\x6e\x6e\x65\x6c\x20\x31\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x2d\x00\x01\x03\x02\x00\x00\x00\x00\x01\x02\x00\x00"
+ b"\x00\x00\x00\x00\x00\x02\x10\x00\x08\x07\x01\x04\x00\x00\x00\x00\x00\x00\x04\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x02\x0a\x04\x00"
+ b"\x00\x00\x00\x00\x00\x00\x8e\x00\x02\x0a\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\xe9\x03\x00\x00\x08\x1c\x00\x00\x46\x52\x70\x69\x67\x67\x79\x20\x31\x30"
+ b"\x38\x30\x41\x6d\x61\x67\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x05\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x56\x4e\x38\x39\x31\x34\x20\x43\x68\x61\x6e\x6e\x65\x6c\x20\x32\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2d\x00\x02\x3c\x01\x00"
+ b"\x00\x00\x00\x02\x04\x00\x00\x00\x00\x00\x00\x00\x12\x00\x00\xa2\x03\x05\x01\x00"
+ b"\x00\x00\x04\x00\x00\x01\x00\x00\x00\x20\xa1\x07\x00\x01\x04\x03\x01\x01\x00\x00"
+ b"\x00\x00\x00\x00\x00\x01\x80\x00\x00\x00\x68\x89\x09\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x0c\x00\x02\x0a\x04\x00\x00\x00\x00\x00\x00\x00\x8e\x00\x02\x0a\x00\x00\x00"
+ b"\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe9\x03\x00\x00\x08\x1c\x00\x00\x4f\x6e\x20"
+ b"\x62\x6f\x61\x72\x64\x20\x43\x41\x4e\x20\x31\x30\x35\x31\x63\x61\x70\x28\x48\x69"
+ b"\x67\x68\x73\x70\x65\x65\x64\x29\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03"
+ b"\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x4e\x38\x39\x31\x34\x20\x43\x68\x61\x6e"
+ b"\x6e\x65\x6c\x20\x33\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x2d\x00\x03\x3c\x01\x00\x00\x00\x00\x03\x08\x00\x00\x00\x00\x00\x00\x00\x12"
+ b"\x00\x00\xa2\x03\x09\x01\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x20\xa1\x07\x00"
+ b"\x01\x04\x03\x01\x01\x00\x00\x00\x00\x00\x00\x00\x01\x9b\x00\x00\x00\x68\x89\x09"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x02\x0a\x04\x00\x00\x00\x00\x00\x00\x00"
+ b"\x8e\x00\x02\x0a\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe9\x03\x00\x00"
+ b"\x08\x1c\x00\x00\x4f\x6e\x20\x62\x6f\x61\x72\x64\x20\x43\x41\x4e\x20\x31\x30\x35"
+ b"\x31\x63\x61\x70\x28\x48\x69\x67\x68\x73\x70\x65\x65\x64\x29\x00\x04\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x03\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x4e\x38\x39"
+ b"\x31\x34\x20\x43\x68\x61\x6e\x6e\x65\x6c\x20\x34\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x2d\x00\x04\x33\x01\x00\x00\x00\x00\x04\x10\x00"
+ b"\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x09\x02\x08\x00\x00\x00\x00\x00\x02"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x02\x0a\x03"
+ b"\x00\x00\x00\x00\x00\x00\x00\x8e\x00\x02\x0a\x00\x00\x00\x00\x00\x00\x00\x01\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\xe9\x03\x00\x00\x08\x1c\x00\x00\x4c\x49\x4e\x70\x69\x67\x67\x79\x20"
+ b"\x37\x32\x36\x39\x6d\x61\x67\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x07\x00\x00\x00\x70\x17\x00\x00\x0c\x09\x03\x04\x58\x02\x10\x0e\x30"
+ b"\x57\x05\x00\x00\x00\x00\x00\x88\x13\x88\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x56\x4e\x38\x39\x31\x34\x20\x43\x68\x61\x6e\x6e\x65\x6c\x20\x35\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2d\x00\x05\x00\x00"
+ b"\x00\x00\x02\x00\x05\x20\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x0c\x00\x02\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x8e\x00\x02\x0a\x00\x00"
+ b"\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe9\x03\x00\x00\x08\x1c\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x03\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x4e\x38\x39\x31\x34\x20\x43\x68\x61"
+ b"\x6e\x6e\x65\x6c\x20\x36\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x2d\x00\x06\x00\x00\x00\x00\x02\x00\x06\x40\x00\x00\x00\x00\x00\x00\x00"
+ b"\x02\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x02\x0a\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x8e\x00\x02\x0a\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe9\x03\x00"
+ b"\x00\x08\x1c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x03\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x4e\x38"
+ b"\x39\x31\x34\x20\x43\x68\x61\x6e\x6e\x65\x6c\x20\x37\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2d\x00\x07\x00\x00\x00\x00\x02\x00\x07\x80"
+ b"\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x02\x0a"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x8e\x00\x02\x0a\x00\x00\x00\x00\x00\x00\x00\x01"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\xe9\x03\x00\x00\x08\x1c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x04\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x56\x4e\x38\x39\x31\x34\x20\x43\x68\x61\x6e\x6e\x65\x6c\x20\x38"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2d\x00\x08\x3c"
+ b"\x01\x00\x00\x00\x00\x08\x00\x01\x00\x00\x00\x00\x00\x00\x12\x00\x00\xa2\x01\x00"
+ b"\x01\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x20\xa1\x07\x00\x01\x04\x03\x01\x01"
+ b"\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x68\x89\x09\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x0c\x00\x02\x0a\x04\x00\x00\x00\x00\x00\x00\x00\x8e\x00\x02\x0a\x00"
+ b"\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe9\x03\x00\x00\x08\x1c\x00\x00\x4f"
+ b"\x6e\x20\x62\x6f\x61\x72\x64\x20\x43\x41\x4e\x20\x31\x30\x35\x31\x63\x61\x70\x28"
+ b"\x48\x69\x67\x68\x73\x70\x65\x65\x64\x29\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x03\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x4e\x38\x39\x31\x34\x20\x43\x68"
+ b"\x61\x6e\x6e\x65\x6c\x20\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x2d\x00\x09\x80\x02\x00\x00\x00\x00\x09\x00\x02\x00\x00\x00\x00\x00"
+ b"\x00\x02\x00\x00\x00\x40\x00\x40\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x02\x0a\x03\x00\x00\x00\x00\x00"
+ b"\x00\x00\x8e\x00\x02\x0a\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe9\x03"
+ b"\x00\x00\x08\x1c\x00\x00\x44\x2f\x41\x20\x49\x4f\x70\x69\x67\x67\x79\x20\x38\x36"
+ b"\x34\x32\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x03\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x69"
+ b"\x72\x74\x75\x61\x6c\x20\x43\x68\x61\x6e\x6e\x65\x6c\x20\x31\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x16\x00\x00\x00\x00\x00\x0a"
+ b"\x00\x04\x00\x00\x00\x00\x00\x00\x07\x00\x00\xa0\x01\x00\x01\x00\x00\x00\x00\x00"
+ b"\x00\x01\x00\x00\x00\x20\xa1\x07\x00\x01\x04\x03\x01\x01\x00\x00\x00\x00\x00\x00"
+ b"\x00\x01\x00\x00\x00\x00\x68\x89\x09\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x1e"
+ b"\x14\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x69\x72\x74\x75\x61\x6c"
+ b"\x20\x43\x41\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x56\x69\x72\x74\x75\x61\x6c\x20\x43\x68\x61\x6e\x6e\x65\x6c"
+ b"\x20\x32\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x01"
+ b"\x16\x00\x00\x00\x00\x00\x0b\x00\x08\x00\x00\x00\x00\x00\x00\x07\x00\x00\xa0\x01"
+ b"\x00\x01\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x20\xa1\x07\x00\x01\x04\x03\x01"
+ b"\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x68\x89\x09\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x10\x00\x1e\x14\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x56\x69\x72\x74\x75\x61\x6c\x20\x43\x41\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00"
+ b"\x00\x00\x00\x02" + 11832 * b"\x00"
+)
+
+
+def _get_predefined_xl_driver_config() -> xlclass.XLdriverConfig:
+ return xlclass.XLdriverConfig.from_buffer_copy(XL_DRIVER_CONFIG_EXAMPLE)
+
+
+# *****************************************************************************
+# Mock functions/side effects
+# *****************************************************************************
def xlGetApplConfig(
@@ -257,7 +1201,7 @@ def xlGetApplConfig(
bus_type: ctypes.c_uint,
) -> int:
hw_type.value = 1
- hw_channel.value = app_channel
+ hw_channel.value = 0
return 0
@@ -270,13 +1214,14 @@ def xlGetChannelIndex(
def xlOpenPort(
port_handle_p: ctypes.POINTER(xlclass.XLportHandle),
app_name_p: ctypes.c_char_p,
- access_mask: xlclass.XLaccess,
- permission_mask_p: ctypes.POINTER(xlclass.XLaccess),
+ access_mask: int,
+ permission_mask: xlclass.XLaccess,
rx_queue_size: ctypes.c_uint,
xl_interface_version: ctypes.c_uint,
bus_type: ctypes.c_uint,
) -> int:
port_handle_p.value = 0
+ permission_mask.value = access_mask
return 0
@@ -350,7 +1295,3 @@ def xlCanReceive_chipstate(
event.timeStamp = 0
event.chanIndex = 2
return 0
-
-
-if __name__ == "__main__":
- unittest.main()
diff --git a/test/test_viewer.py b/test/test_viewer.py
index a0873d02b..e71d06dc8 100644
--- a/test/test_viewer.py
+++ b/test/test_viewer.py
@@ -1,5 +1,4 @@
-#!/usr/bin/python
-# coding: utf-8
+#!/usr/bin/env python
#
# Copyright (C) 2018 Kristian Sloth Lauszus.
#
@@ -24,26 +23,36 @@
# e-mail : lauszus@gmail.com
import argparse
-import curses
import math
import os
import random
import struct
import time
import unittest
-from typing import Dict, Tuple, Union
+from collections import defaultdict
+from test.config import IS_CI
from unittest.mock import patch
import pytest
import can
-from can.viewer import KEY_ESC, KEY_SPACE, CanViewer, parse_args
+from can.viewer import CanViewer, _parse_viewer_args
+
+# Allow the curses module to be missing (e.g. on PyPy on Windows)
+try:
+ import curses
+
+ CURSES_AVAILABLE = True
+except ImportError:
+ curses = None # type: ignore
+ CURSES_AVAILABLE = False
# noinspection SpellCheckingInspection,PyUnusedLocal
class StdscrDummy:
def __init__(self):
self.key_counter = 0
+ self.draw_buffer = defaultdict(dict)
@staticmethod
def clear():
@@ -56,13 +65,18 @@ def erase():
@staticmethod
def getmaxyx():
# Set y-value, so scrolling gets tested
- return 1, 1
+ # Set x-value, so the text will fit in the window
+ return 1, 100
- @staticmethod
- def addstr(row, col, txt, *args):
+ def addstr(self, row, col, txt, *args):
assert row >= 0
assert col >= 0
assert txt is not None
+
+ # Save the text written into the buffer
+ for i, t in enumerate(txt):
+ self.draw_buffer[row][col + i] = t
+
# Raise an exception 50 % of the time, so we can make sure the code handles it
if random.random() < 0.5:
raise curses.error
@@ -72,6 +86,8 @@ def nodelay(_bool):
pass
def getch(self):
+ assert curses is not None
+
self.key_counter += 1
if self.key_counter == 1:
# Send invalid key
@@ -79,12 +95,17 @@ def getch(self):
elif self.key_counter == 2:
return ord("c") # Clear
elif self.key_counter == 3:
- return KEY_SPACE # Pause
+ return curses.ascii.SP # Pause
elif self.key_counter == 4:
- return KEY_SPACE # Unpause
+ return curses.ascii.SP # Unpause
elif self.key_counter == 5:
return ord("s") # Sort
-
+ # Turn on byte highlighting (toggle)
+ elif self.key_counter == 6:
+ return ord("h")
+ # Turn off byte highlighting (toggle)
+ elif self.key_counter == 7:
+ return ord("h")
# Keep scrolling until it exceeds the number of messages
elif self.key_counter <= 100:
return curses.KEY_DOWN
@@ -92,9 +113,10 @@ def getch(self):
elif self.key_counter <= 200:
return curses.KEY_UP
- return KEY_ESC
+ return curses.ascii.ESC
+@unittest.skipUnless(CURSES_AVAILABLE, "curses might be missing on some platforms")
class CanViewerTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
@@ -102,7 +124,7 @@ def setUpClass(cls):
random.seed(0)
def setUp(self):
- stdscr = StdscrDummy()
+ self.stdscr_dummy = StdscrDummy()
config = {"interface": "virtual", "receive_own_messages": True}
bus = can.Bus(**config)
data_structs = None
@@ -133,7 +155,7 @@ def setUp(self):
patch_resizeterm.start()
self.addCleanup(patch_resizeterm.stop)
- self.can_viewer = CanViewer(stdscr, bus, data_structs, testing=True)
+ self.can_viewer = CanViewer(self.stdscr_dummy, bus, data_structs, testing=True)
def tearDown(self):
# Run the viewer after the test, this is done, so we can receive the CAN-Bus messages and make sure that they
@@ -165,6 +187,16 @@ def test_send(self):
msg = can.Message(arbitration_id=0x101, data=data, is_extended_id=False)
self.can_viewer.bus.send(msg)
+ # Send non-CANopen message with long parsed data length
+ data = [255, 255]
+ msg = can.Message(arbitration_id=0x102, data=data, is_extended_id=False)
+ self.can_viewer.bus.send(msg)
+
+ # Send the same command, but with shorter parsed data length
+ data = [0, 0]
+ msg = can.Message(arbitration_id=0x102, data=data, is_extended_id=False)
+ self.can_viewer.bus.send(msg)
+
# Message with extended id
data = [1, 2, 3, 4, 5, 6, 7, 8]
msg = can.Message(arbitration_id=0x123456, data=data, is_extended_id=True)
@@ -187,6 +219,8 @@ def test_receive(self):
# For converting the EMCY and HEARTBEAT messages
0x080 + 0x01: struct.Struct("ff"),
}
@@ -201,14 +235,25 @@ def test_receive(self):
if _id["msg"].arbitration_id == 0x101:
# Check if the counter is reset when the length has changed
self.assertEqual(_id["count"], 1)
+
+ # Make sure the line has been cleared after the shorted message was send
+ for col, v in self.stdscr_dummy.draw_buffer[_id["row"]].items():
+ if col >= 52 + _id["msg"].dlc * 3:
+ self.assertEqual(v, " ")
+ elif _id["msg"].arbitration_id == 0x102:
+ # Make sure the parsed values have been cleared after the shorted message was send
+ for col, v in self.stdscr_dummy.draw_buffer[_id["row"]].items():
+ if col >= 77 + _id["values_string_length"]:
+ self.assertEqual(v, " ")
elif _id["msg"].arbitration_id == 0x123456:
# Check if the counter is incremented
if _id["dt"] == 0:
self.assertEqual(_id["count"], 1)
else:
- self.assertTrue(
- pytest.approx(_id["dt"], 0.1)
- ) # dt should be ~0.1 s
+ if not IS_CI: # do not test timing in CI
+ assert _id["dt"] == pytest.approx(
+ 0.1, abs=5e-2
+ ) # dt should be ~0.1 s
self.assertEqual(_id["count"], 2)
else:
# Make sure dt is 0
@@ -256,7 +301,7 @@ def pack_data(
return struct_t.pack(*data)
else:
- raise ValueError("Unknown command: 0x{:02X}".format(cmd))
+ raise ValueError(f"Unknown command: 0x{cmd:02X}")
def test_pack_unpack(self):
CANOPEN_TPDO1 = 0x180
@@ -302,7 +347,7 @@ def test_pack_unpack(self):
raw_data = self.pack_data(CANOPEN_TPDO2 + 1, data_structs, 12.34, 4.5, 6)
parsed_data = CanViewer.unpack_data(CANOPEN_TPDO2 + 1, data_structs, raw_data)
- self.assertTrue(pytest.approx(parsed_data, [12.34, 4.5, 6]))
+ assert parsed_data == pytest.approx([12.34, 4.5, 6])
self.assertTrue(
isinstance(parsed_data[0], float)
and isinstance(parsed_data[1], float)
@@ -311,14 +356,14 @@ def test_pack_unpack(self):
raw_data = self.pack_data(CANOPEN_TPDO3 + 1, data_structs, 123.45, 67.89)
parsed_data = CanViewer.unpack_data(CANOPEN_TPDO3 + 1, data_structs, raw_data)
- self.assertTrue(pytest.approx(parsed_data, [123.45, 67.89]))
+ assert parsed_data == pytest.approx([123.45, 67.89])
self.assertTrue(all(isinstance(d, float) for d in parsed_data))
raw_data = self.pack_data(
CANOPEN_TPDO4 + 1, data_structs, math.pi / 2.0, math.pi
)
parsed_data = CanViewer.unpack_data(CANOPEN_TPDO4 + 1, data_structs, raw_data)
- self.assertTrue(pytest.approx(parsed_data, [math.pi / 2.0, math.pi]))
+ assert parsed_data == pytest.approx([math.pi / 2.0, math.pi])
self.assertTrue(all(isinstance(d, float) for d in parsed_data))
raw_data = self.pack_data(CANOPEN_TPDO1 + 2, data_structs)
@@ -352,19 +397,19 @@ def test_pack_unpack(self):
)
def test_parse_args(self):
- parsed_args, _, _ = parse_args(["-b", "250000"])
+ parsed_args, _ = _parse_viewer_args(["-b", "250000"])
self.assertEqual(parsed_args.bitrate, 250000)
- parsed_args, _, _ = parse_args(["--bitrate", "500000"])
+ parsed_args, _ = _parse_viewer_args(["--bitrate", "500000"])
self.assertEqual(parsed_args.bitrate, 500000)
- parsed_args, _, _ = parse_args(["-c", "can0"])
+ parsed_args, _ = _parse_viewer_args(["-c", "can0"])
self.assertEqual(parsed_args.channel, "can0")
- parsed_args, _, _ = parse_args(["--channel", "PCAN_USBBUS1"])
+ parsed_args, _ = _parse_viewer_args(["--channel", "PCAN_USBBUS1"])
self.assertEqual(parsed_args.channel, "PCAN_USBBUS1")
- parsed_args, _, data_structs = parse_args(["-d", "100: