diff --git a/.appveyor.yml b/.appveyor.yml
deleted file mode 100644
index ee7b98300..000000000
--- a/.appveyor.yml
+++ /dev/null
@@ -1,33 +0,0 @@
-environment:
- matrix:
-
- # For Python versions available on Appveyor, see
- # http://www.appveyor.com/docs/installed-software#python
- # Python 3.0-3.3 have reached EOL
-
- - PYTHON: "C:\\Python27"
- - PYTHON: "C:\\Python34"
- - PYTHON: "C:\\Python35"
- - PYTHON: "C:\\Python36"
- - PYTHON: "C:\\Python37"
- - PYTHON: "C:\\Python27-x64"
- - PYTHON: "C:\\Python34-x64"
- - PYTHON: "C:\\Python35-x64"
- - PYTHON: "C:\\Python36-x64"
- - PYTHON: "C:\\Python37-x64"
-
-install:
- # Prepend Python installation and scripts (e.g. pytest) to PATH
- - set PATH=%PYTHON_INSTALL%;%PYTHON_INSTALL%\\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"
diff --git a/.codecov.yml b/.codecov.yml
deleted file mode 100644
index d533fd085..000000000
--- a/.codecov.yml
+++ /dev/null
@@ -1,17 +0,0 @@
-codecov:
- archive:
- uploads: no
-
-coverage:
- precision: 2
- round: down
- range: 50...100
- status:
- # pull-requests only
- 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''',
- default=0.0001)
- parser.add_argument('-s', '--skip', type=float, default=60*60*24,
- help=''' skip gaps greater than 's' seconds''')
-
- parser.add_argument('infile', metavar='input-file', type=str,
- help='The file to replay. For supported types see can.LogReader.')
+def _parse_loop(value: str) -> int | float:
+ """Parse the loop argument, allowing integer or 'i' for infinite."""
+ if value == "i":
+ return float("inf")
+ try:
+ return int(value)
+ except ValueError as exc:
+ err_msg = "Loop count must be an integer or 'i' for infinite."
+ raise argparse.ArgumentTypeError(err_msg) from exc
+
+
+def _format_player_start_message(iteration: int, loop_count: int | float) -> str:
+ """
+ Generate a status message indicating the start of a CAN log replay iteration.
+
+ :param iteration:
+ The current loop iteration (zero-based).
+ :param loop_count:
+ Total number of replay loops, or infinity for endless replay.
+ :return:
+ A formatted string describing the replay start and loop information.
+ """
+ if loop_count < 2:
+ loop_info = ""
+ else:
+ loop_val = "∞" if math.isinf(loop_count) else str(loop_count)
+ loop_info = f" [loop {iteration + 1}/{loop_val}]"
+ return f"Can LogReader (Started on {datetime.now()}){loop_info}"
+
+
+def main() -> None:
+ parser = argparse.ArgumentParser(description="Replay CAN traffic.")
+
+ player_group = parser.add_argument_group("Player arguments")
+
+ player_group.add_argument(
+ "-v",
+ action="count",
+ dest="verbosity",
+ help="""Also print can frames to stdout.
+ You can add several of these to enable debugging""",
+ default=2,
+ )
+
+ player_group.add_argument(
+ "--ignore-timestamps",
+ dest="timestamps",
+ help="""Ignore timestamps (send all frames immediately with minimum gap between frames)""",
+ action="store_false",
+ )
+
+ player_group.add_argument(
+ "--error-frames",
+ help="Also send error frames to the interface.",
+ action="store_true",
+ )
+
+ player_group.add_argument(
+ "-g",
+ "--gap",
+ type=float,
+ help=" minimum time between replayed frames",
+ default=0.0001,
+ )
+ player_group.add_argument(
+ "-s",
+ "--skip",
+ type=float,
+ default=60 * 60 * 24,
+ 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.",
+ )
+ 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)
-
- config = {"single_handle": True}
- if results.interface:
- config["interface"] = results.interface
- if results.bitrate:
- config["bitrate"] = results.bitrate
- bus = Bus(results.channel, **config)
-
- reader = LogReader(results.infile)
-
- in_sync = MessageSync(reader, timestamps=results.timestamps,
- gap=results.gap, skip=results.skip)
-
- print('Can LogReader (Started on {})'.format(datetime.now()))
-
- try:
- for m in in_sync:
- if verbosity >= 3:
- print(m)
- bus.send(m)
- except KeyboardInterrupt:
- pass
- finally:
- bus.shutdown()
- reader.stop()
+ error_frames = results.error_frames
+
+ 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 1b0f75a2d..518604364 100644
--- a/can/thread_safe_bus.py
+++ b/can/thread_safe_bus.py
@@ -1,42 +1,29 @@
-#!/usr/bin/env python
-# coding: utf-8
+from contextlib import nullcontext
+from threading import RLock
+from typing import TYPE_CHECKING, Any, cast
-from __future__ import print_function, absolute_import
+from . import typechecking
+from .bus import BusState, CanProtocol
+from .interface import Bus
+from .message import Message
-from threading import RLock
+if TYPE_CHECKING:
+ from .bus import BusABC
try:
# Only raise an exception on instantiation but allow module
# to be imported
from wrapt import ObjectProxy
+
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
-
-except ImportError:
- class nullcontext(object):
- """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):
+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
@@ -53,59 +40,82 @@ class ThreadSafeBus(ObjectProxy):
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(ThreadSafeBus, self).__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
- self.__wrapped__._lock_send_periodic = nullcontext()
+ 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, can_filters=None, *args, **kwargs):
- with self._lock_recv:
- return self.__wrapped__.set_filters(can_filters=can_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
new file mode 100644
index 000000000..56ac5927f
--- /dev/null
+++ b/can/typechecking.py
@@ -0,0 +1,82 @@
+"""Types for mypy type-checking"""
+
+import io
+import os
+import sys
+from collections.abc import Iterable, Sequence
+from typing import IO, TYPE_CHECKING, Any, NewType, TypeAlias
+
+if sys.version_info >= (3, 12):
+ from typing import TypedDict
+else:
+ from typing_extensions import TypedDict
+
+
+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 = bytes | bytearray | int | Iterable[int]
+
+# Used for the Abstract Base Class
+ChannelStr = str
+ChannelInt = int
+Channel = ChannelInt | ChannelStr | Sequence[ChannelInt]
+
+# Used by the IO module
+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
+
+
+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 56b3d5d63..4cbeec60e 100644
--- a/can/util.py
+++ b/can/util.py
@@ -1,60 +1,54 @@
-#!/usr/bin/env python
-# coding: utf-8
-
"""
Utilities and configuration file parsing.
"""
-from __future__ import absolute_import, print_function
-
+import contextlib
+import copy
+import functools
+import json
+import logging
import os
import os.path
-import sys
import platform
import re
-import logging
-try:
- from configparser import ConfigParser
-except ImportError:
- from ConfigParser import SafeConfigParser as ConfigParser
+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
-log = logging.getLogger('can.util')
+from . import typechecking
+from .bit_timing import BitTiming, BitTimingFd
+from .exceptions import CanInitializationError, CanInterfaceNotImplementedError
+from .interfaces import VALID_INTERFACES
+
+log = logging.getLogger("can.util")
# List of valid data lengths for a CAN FD message
-CAN_FD_DLC = [
- 0, 1, 2, 3, 4, 5, 6, 7, 8,
- 12, 16, 20, 24, 32, 48, 64
-]
+CAN_FD_DLC = [0, 1, 2, 3, 4, 5, 6, 7, 8, 12, 16, 20, 24, 32, 48, 64]
-REQUIRED_KEYS = [
- 'interface',
- 'channel',
-]
+REQUIRED_KEYS = ["interface", "channel"]
-CONFIG_FILES = ['~/can.conf']
+CONFIG_FILES = ["~/can.conf"]
-if platform.system() == "Linux":
- CONFIG_FILES.extend(
- [
- '/etc/can.conf',
- '~/.can',
- '~/.canrc'
- ]
- )
+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')
- ]
- )
+ CONFIG_FILES.extend(["can.ini", os.path.join(os.getenv("APPDATA", ""), "can.ini")])
-def load_file_config(path=None, section=None):
+def load_file_config(
+ path: typechecking.StringPathLike | None = None, section: str = "default"
+) -> dict[str, str]:
"""
Loads configuration from file with following content::
@@ -69,45 +63,64 @@ def load_file_config(path=None, section=None):
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] = {}
- section = section if section is not None else 'default'
if config.has_section(section):
- if config.has_section('default'):
- _config.update(
- dict((key, val) for key, val in config.items('default')))
- _config.update(dict((key, val) for key, val in config.items(section)))
+ _config.update(config.items(section))
return _config
-def load_environment_config():
+def load_environment_config(context: str | None = None) -> dict[str, str]:
"""
Loads config dict from environmental variables (if set):
* CAN_INTERFACE
* CAN_CHANNEL
* CAN_BITRATE
+ * CAN_CONFIG
+
+ if context is supplied, "_{context}" is appended to the environment
+ variable name we will look at. For example if context="ABC":
+
+ * CAN_INTERFACE_ABC
+ * CAN_CHANNEL_ABC
+ * CAN_BITRATE_ABC
+ * CAN_CONFIG_ABC
"""
mapper = {
- 'interface': 'CAN_INTERFACE',
- 'channel': 'CAN_CHANNEL',
- 'bitrate': 'CAN_BITRATE',
+ "interface": "CAN_INTERFACE",
+ "channel": "CAN_CHANNEL",
+ "bitrate": "CAN_BITRATE",
}
- return dict(
- (key, os.environ.get(val))
- for key, val in mapper.items()
- if val in os.environ
- )
+
+ 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)
+ if config_option:
+ config[key] = config_option
+
+ return config
-def load_config(path=None, config=None, context=None):
+def load_config(
+ 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):
@@ -121,7 +134,7 @@ def load_config(path=None, config=None, context=None):
kvaser, socketcan, pcan, usb2can, ixxat, nican, virtual.
.. note::
-
+
The key ``bustype`` is copied to ``interface`` if that one is missing
and does never appear in the result.
@@ -133,7 +146,7 @@ def load_config(path=None, config=None, context=None):
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:
@@ -151,77 +164,145 @@ def load_config(path=None, config=None, context=None):
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(), # context is not supported
- lambda _context: load_file_config(path, _context)
- ]
+ # 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']
+ 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
- # deprecated socketcan types
- if config['interface'] in ('socketcan_native', 'socketcan_ctypes'):
- # Change this to a DeprecationWarning in future 2.x releases
- # Remove completely in 3.0
- log.warning('%s is deprecated, use socketcan instead', config['interface'])
- config['interface'] = 'socketcan'
+ if config["interface"] not in VALID_INTERFACES:
+ 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 "fd" in 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,
+ )
- if config['interface'] not in VALID_INTERFACES:
- raise NotImplementedError('Invalid CAN Bus Type - {}'.format(config['interface']))
+ return None
- if 'bitrate' in config:
- config['bitrate'] = int(config['bitrate'])
- can.log.debug("can config: {}".format(config))
- return config
+def set_logging_level(level_name: str) -> None:
+ """Set the logging level for the `"can"` logger.
-
-def set_logging_level(level_name=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')
+ can_logger = logging.getLogger("can")
try:
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):
+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)
- :rtype: int
"""
if length <= 8:
return length
@@ -231,41 +312,209 @@ def len2dlc(length):
return 15
-def dlc2len(dlc):
+def dlc2len(dlc: int) -> int:
"""Calculate the data length from DLC.
- :param int dlc: DLC (0-15)
+ :param dlc: DLC (0-15)
:returns: Data length in number of bytes (0-64)
- :rtype: int
"""
return CAN_FD_DLC[dlc] if dlc <= 15 else 64
-def channel2int(channel):
+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
-
- :returns: Channel integer or `None` if unsuccessful
- :rtype: int
+ Channel string (e.g. `"can0"`, `"CAN1"`) or an integer
+
+ :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 c120df994..8d9d228bb 100644
--- a/can/viewer.py
+++ b/can/viewer.py
@@ -1,7 +1,18 @@
-#!/usr/bin/python
-# coding: utf-8
+# Copyright (C) 2018 Kristian Sloth Lauszus.
#
-# Copyright (C) 2018 Kristian Sloth Lauszus. All rights reserved.
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 3 of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#
# Contact information
# -------------------
@@ -9,45 +20,64 @@
# Web : http://www.lauszus.com
# e-mail : lauszus@gmail.com
-from __future__ import absolute_import, print_function
-
import argparse
-import can
-import curses
+import errno
+import logging
import os
import struct
import sys
import time
-from curses.ascii import ESC as KEY_ESC, SP as KEY_SPACE
-from typing import Dict, List, Tuple, Union
-
from can import __version__
-
-
-class CanViewer:
-
+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.viewer")
+
+try:
+ import curses
+ 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 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!"
+ )
+ curses = None # type: ignore[assignment]
+
+
+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()
@@ -56,41 +86,49 @@ 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
- msg = self.bus.recv(timeout=1. / 1000.)
+ msg = self.bus.recv(timeout=1.0 / 1000.0)
if msg is not None:
self.draw_can_bus_message(msg)
else:
# Sleep 1 ms, so the application does not use 100 % of the CPU resources
- time.sleep(1. / 1000.)
+ time.sleep(1.0 / 1000.0)
# Read the terminal input
key = self.stdscr.getch()
# Stop program if the user presses ESC or 'q'
- if key == KEY_ESC or key == ord('q'):
+ if key == KEY_ESC or key == ord("q"):
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'):
+ elif key == ord("s"):
# Sort frames based on the CAN-Bus ID
self.draw_header()
for i, key in enumerate(sorted(self.ids.keys())):
# Set the new row index, but skip the header
- self.ids[key]['row'] = i + 1
+ self.ids[key]["row"] = i + 1
# Do a recursive call, so the frames are repositioned
- self.draw_can_bus_message(self.ids[key]['msg'], sorting=True)
+ self.draw_can_bus_message(self.ids[key]["msg"], sorting=True)
# Pause by pressing space
elif key == KEY_SPACE:
@@ -112,7 +150,7 @@ def run(self):
resized = curses.is_term_resized(self.y, self.x)
if resized is True:
self.y, self.x = self.stdscr.getmaxyx()
- if hasattr(curses, 'resizeterm'): # pragma: no cover
+ if hasattr(curses, "resizeterm"): # pragma: no cover
curses.resizeterm(self.y, self.x)
self.redraw_screen()
@@ -121,29 +159,32 @@ 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]]
- if not cmd_to_struct or len(data) == 0:
+ 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.keys():
+ 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 = value[0] # type: struct.Struct
+ struct_t: struct.Struct = value[0]
# 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:])]
+ values = [
+ d // val if isinstance(val, int) else float(d) / val
+ for d, val in zip(
+ struct_t.unpack(data), value[1:], strict=False
+ )
+ ]
else:
# No conversion from SI-units is needed
- struct_t = value # type: struct.Struct
- values = list(struct_t.unpack(data))
+ as_struct_t: struct.Struct = value
+ 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
@@ -151,7 +192,7 @@ def draw_can_bus_message(self, msg, sorting=False):
# Sort the extended IDs at the bottom by setting the 32-bit high
if msg.is_extended_id:
- key |= (1 << 32)
+ key |= 1 << 32
new_id_added, length_changed = False, False
if not sorting:
@@ -161,35 +202,45 @@ def draw_can_bus_message(self, msg, sorting=False):
# Set the start time when the first message has been received
if not self.start_time:
self.start_time = msg.timestamp
- elif msg.dlc != self.ids[key]['msg'].dlc:
+ 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']
+ row = len(self.ids) + 1 if new_id_added else self.ids[key]["row"]
# It's a new message ID or the length has changed, so add it to the dict
# The first index is the row index, the second is the frame counter,
# the third is a copy of the CAN-Bus frame
# and the forth index is the time since the previous message
- self.ids[key] = {'row': row, 'count': 0, 'msg': msg, 'dt': 0}
+ self.ids[key] = {"row": row, "count": 0, "msg": msg, "dt": 0}
else:
# Calculate the time since the last message and save the timestamp
- self.ids[key]['dt'] = msg.timestamp - self.ids[key]['msg'].timestamp
+ self.ids[key]["dt"] = msg.timestamp - self.ids[key]["msg"].timestamp
# Copy the CAN-Bus frame - this is used for sorting
- self.ids[key]['msg'] = msg
+ self.ids[key]["msg"] = msg
# Increment frame counter
- self.ids[key]['count'] += 1
+ 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)
-
- # Generate data string
- data_string = ''
- if msg.dlc > 0:
- data_string = ' '.join('{:02X}'.format(x) for x in msg.data)
+ 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
if msg.is_error_frame:
@@ -198,24 +249,62 @@ def draw_can_bus_message(self, msg, sorting=False):
color = curses.color_pair(0)
# Now draw the CAN-Bus message on the terminal window
- self.draw_line(self.ids[key]['row'], 0, str(self.ids[key]['count']), color)
- self.draw_line(self.ids[key]['row'], 8, '{0:.6f}'.format(self.ids[key]['msg'].timestamp - self.start_time),
- color)
- self.draw_line(self.ids[key]['row'], 23, '{0:.6f}'.format(self.ids[key]['dt']), 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)
- self.draw_line(self.ids[key]['row'], 52, data_string, color)
+ self.draw_line(self.ids[key]["row"], 0, str(self.ids[key]["count"]), color)
+ self.draw_line(
+ self.ids[key]["row"],
+ 8,
+ f"{self.ids[key]['msg'].timestamp - self.start_time:.6f}",
+ 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
+ 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:
values_list = []
- for x in self.unpack_data(msg.arbitration_id, self.data_structs, msg.data):
+ for x in self.unpack_data(
+ 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.draw_line(self.ids[key]['row'], 77, values_string, color)
+ 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
@@ -223,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)
@@ -234,43 +323,46 @@ def draw_line(self, row, col, txt, *args):
def draw_header(self):
self.stdscr.erase()
- self.draw_line(0, 0, 'Count', curses.A_BOLD)
- self.draw_line(0, 8, 'Time', curses.A_BOLD)
- self.draw_line(0, 23, 'dt', curses.A_BOLD)
- 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
- self.draw_line(0, 77, 'Parsed values', curses.A_BOLD)
+ self.draw_line(0, 0, "Count", curses.A_BOLD)
+ self.draw_line(0, 8, "Time", curses.A_BOLD)
+ self.draw_line(0, 23, "dt", curses.A_BOLD)
+ 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)
+
+ # 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.keys():
- 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()
def _format_usage(self, usage, actions, groups, prefix):
# Use uppercase for "Usage:" text
- return super(SmartFormatter, self)._format_usage(usage, actions, groups, 'Usage: ')
+ 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:
- return super(SmartFormatter, self)._format_args(action, default_metavar)
+ 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:
- return super(SmartFormatter, self)._format_action_invocation(action)
+ return super()._format_action_invocation(action)
# Modified so "-s ARGS, --long ARGS" is replaced with "-s, --long ARGS"
else:
@@ -279,133 +371,122 @@ 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)
- return ', '.join(parts)
+ parts.append(str(option_string))
+ return ", ".join(parts)
def _split_lines(self, text, width):
# Allow to manually split the lines
- if text.startswith('R|'):
+ if text.startswith("R|"):
return text[2:].splitlines()
- return super(SmartFormatter, self)._split_lines(text, width)
+ return super()._split_lines(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())
+ if text.startswith("R|"):
+ return "".join(indent + line + "\n" for line in text[2:].splitlines())
else:
- return super(SmartFormatter, self)._fill_text(text, width, indent)
-
+ 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 +---------+-------------------------+',
- formatter_class=SmartFormatter, add_help=False, **kwargs)
-
- optional = parser.add_argument_group('Optional arguments')
-
- optional.add_argument('-h', '--help', action='help', help='Show this help message and exit')
-
- optional.add_argument('--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('-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)''')
-
- optional.add_argument('-d', '--decode', dest='decode',
- help='R|Specify how to convert the raw bytes into real values.'
- '\nThe ID of the frame is given as the first argument and the format as the second.'
- '\nThe Python struct package is used to unpack the received data'
- '\nwhere the format characters have the following meaning:'
- '\n < = little-endian, > = big-endian'
- '\n x = pad byte'
- '\n c = char'
- '\n ? = bool'
- '\n b = int8_t, B = uint8_t'
- '\n h = int16, H = uint16'
- '\n l = int32_t, L = uint32_t'
- '\n q = int64_t, Q = uint64_t'
- '\n f = float (32-bits), d = double (64-bits)'
- '\nFx to convert six bytes with ID 0x100 into uint8_t, uint16 and uint32_t:'
- '\n $ python -m can.viewer -d "100:: (matches when & mask == can_id & mask)'
- '\n ~ (matches when & mask != can_id & mask)'
- '\nFx to show only frames with ID 0x100 to 0x103:'
- '\n python -m can.viewer -f 100:7FC'
- '\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))
+ 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 | h | Toggle highlight byte changes |"
+ "\n | SPACE | Pause the viewer |"
+ "\n | UP/DOWN | Scroll the viewer |"
+ "\n +---------+-------------------------------+",
+ formatter_class=SmartFormatter,
+ add_help=False,
+ 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(
+ "-h", "--help", action="help", help="Show this help message and exit"
+ )
+
+ optional.add_argument(
+ "--version",
+ action="version",
+ help="Show program's version number and exit",
+ version=f"%(prog)s (version {__version__})",
+ )
+
+ optional.add_argument(
+ "-d",
+ "--decode",
+ dest="decode",
+ help="R|Specify how to convert the raw bytes into real values."
+ "\nThe ID of the frame is given as the first argument and the format as the second."
+ "\nThe Python struct package is used to unpack the received data"
+ "\nwhere the format characters have the following meaning:"
+ "\n < = little-endian, > = big-endian"
+ "\n x = pad byte"
+ "\n c = char"
+ "\n ? = bool"
+ "\n b = int8_t, B = uint8_t"
+ "\n h = int16, H = uint16"
+ "\n l = int32_t, L = uint32_t"
+ "\n q = int64_t, Q = uint64_t"
+ "\n f = float (32-bits), d = double (64-bits)"
+ "\nFx to convert six bytes with ID 0x100 into uint8_t, uint16 and uint32_t:"
+ '\n $ python -m can.viewer -d "100: 0:
- # 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.
@@ -423,24 +504,26 @@ 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]]
- if len(parsed_args.decode) > 0:
+
+ 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
for s in structs:
- tmp = s.rstrip('\n').split(':')
+ tmp = s.rstrip("\n").split(":")
# The ID is given as a hex value, the format needs no conversion
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:
@@ -449,33 +532,21 @@ 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
+ 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__': # pragma: no cover
+if __name__ == "__main__":
# Catch ctrl+c
try:
main()
diff --git a/doc/api.rst b/doc/api.rst
index 8e657bd3c..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,37 +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
----------
-
-.. automodule:: can.util
- :members:
-
-.. automethod:: 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/asyncio.rst b/doc/asyncio.rst
index f5bd7771b..cd8d65de5 100644
--- a/doc/asyncio.rst
+++ b/doc/asyncio.rst
@@ -4,8 +4,9 @@ Asyncio support
===============
The :mod:`asyncio` module built into Python 3.4 and later can be used to write
-asynchronos code in a single thread. This library supports receiving messages
-asynchronosly in an event loop using the :class:`can.Notifier` class.
+asynchronous code in a single thread. This library supports receiving messages
+asynchronously in an event loop using the :class:`can.Notifier` class.
+
There will still be one thread per CAN bus but the user application will execute
entirely in the event loop, allowing simpler concurrency without worrying about
threading issues. Interfaces that have a valid file descriptor will however be
diff --git a/doc/bcm.rst b/doc/bcm.rst
index 0676a77eb..94cde0e60 100644
--- a/doc/bcm.rst
+++ b/doc/bcm.rst
@@ -1,13 +1,13 @@
+.. _bcm:
+
Broadcast Manager
=================
.. module:: can.broadcastmanager
-The broadcast manager isn't yet supported by all interfaces.
-Currently SocketCAN and IXXAT are supported at least partially.
-It allows the user to setup periodic message jobs.
-
-If periodic transmission is not supported natively, a software thread
+The broadcast manager allows the user to setup periodic message jobs.
+For example sending a particular message at a given period. The broadcast
+manager supported natively by several interfaces and a software thread
based scheduler is used as a fallback.
This example shows the socketcan backend using the broadcast manager:
@@ -23,6 +23,10 @@ Message Sending Tasks
The class based api for the broadcast manager uses a series of
`mixin classes `_.
All mixins inherit from :class:`~can.broadcastmanager.CyclicSendTaskABC`
+which inherits from :class:`~can.broadcastmanager.CyclicTask`.
+
+.. autoclass:: can.broadcastmanager.CyclicTask
+ :members:
.. autoclass:: can.broadcastmanager.CyclicSendTaskABC
:members:
@@ -39,13 +43,6 @@ All mixins inherit from :class:`~can.broadcastmanager.CyclicSendTaskABC`
.. autoclass:: can.RestartableCyclicTaskABC
:members:
+.. autoclass:: can.broadcastmanager.ThreadBasedCyclicSendTask
+ :members:
-Functional API
---------------
-
-.. warning::
- The functional API in :func:`can.broadcastmanager.send_periodic` is now deprecated
- and will be removed in version 2.3.
- Use the object oriented API via :meth:`can.BusABC.send_periodic` instead.
-
-.. autofunction:: can.broadcastmanager.send_periodic
diff --git a/doc/bit_timing.rst b/doc/bit_timing.rst
new file mode 100644
index 000000000..bf7aad486
--- /dev/null
+++ b/doc/bit_timing.rst
@@ -0,0 +1,136 @@
+Bit Timing Configuration
+========================
+
+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]
+ f_clock=8000000
+ brp=1
+ tseg1=5
+ tseg2=2
+ sjw=1
+ nof_samples=1
+
+The same is possible for CAN FD:
+
+.. code-block:: none
+
+ [default]
+ 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.
+
+Check :doc:`configuration` for more information about saving and loading configurations.
+
+
+.. 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 071d4094c..f63c244c2 100644
--- a/doc/bus.rst
+++ b/doc/bus.rst
@@ -3,41 +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. It itself is an instance of ``VectorBus``,
-but these specififc buses should not be instantiated directly.
+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:
+Transmitting
+''''''''''''
+Writing individual messages to the bus is done by calling the :meth:`~can.BusABC.send` method
+and passing a :class:`~can.Message` instance.
-API
-'''
+.. code-block:: python
+ :emphasize-lines: 8
-.. autoclass:: can.BusABC
- :members:
- :undoc-members:
+ 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")
-Transmitting
-''''''''''''
-
-Writing 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 `.
Receiving
'''''''''
@@ -45,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.
@@ -68,7 +102,9 @@ Conflicting calls are executed by blocking until the bus is accessible.
It can be used exactly like the normal :class:`~can.BusABC`:
- # 'socketcan' is only an exemple interface, it works with all the others too
+.. 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(...)
my_bus.recv(...)
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/changelog.d/2023.changed.md b/doc/changelog.d/2023.changed.md
new file mode 100644
index 000000000..f20e2997c
--- /dev/null
+++ b/doc/changelog.d/2023.changed.md
@@ -0,0 +1 @@
+Improve IXXAT VCI exception handling
diff --git a/doc/conf.py b/doc/conf.py
index e61801a6f..5e413361c 100755
--- a/doc/conf.py
+++ b/doc/conf.py
@@ -1,188 +1,226 @@
-# -*- coding: utf-8 -*-
-#
-# python-can documentation build configuration file
-#
-# This file is execfile()d with the current directory set to its containing dir.
+"""
+python-can documentation build configuration file
-from __future__ import unicode_literals, absolute_import
+This file is execfile()d with the current directory set to its containing dir.
+"""
-import sys
-import os
+# -- Imports -------------------------------------------------------------------
-# General information about the project.
-project = u'python-can'
+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('..'))
+sys.path.insert(0, os.path.abspath(".."))
+
+from can import ctypesutil # pylint: disable=wrong-import-position
+
+# -- General configuration -----------------------------------------------------
+
+# pylint: disable=invalid-name
-import can
# The version info for the project, acts as replacement for
# |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 configuration -----------------------------------------------------
+# General information about the project.
+project = "python-can"
-primary_domain = 'py'
+primary_domain = "py"
# Add any Sphinx extension module names here, as strings. They can be extensions
# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
-extensions = ['sphinx.ext.autodoc',
- 'sphinx.ext.doctest',
- 'sphinx.ext.extlinks',
- 'sphinx.ext.todo',
- 'sphinx.ext.intersphinx',
- 'sphinx.ext.coverage',
- 'sphinx.ext.viewcode',
- 'sphinx.ext.graphviz']
+extensions = [
+ "sphinx.ext.autodoc",
+ "sphinx.ext.doctest",
+ "sphinx.ext.extlinks",
+ "sphinx.ext.todo",
+ "sphinx.ext.intersphinx",
+ "sphinx.ext.coverage",
+ "sphinx.ext.viewcode",
+ "sphinx.ext.graphviz",
+ "sphinxcontrib.programoutput",
+ "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),
-}
+intersphinx_mapping = {"python": ("https://docs.python.org/3/", None)}
# If this is True, todo and todolist produce output, else they produce nothing.
# The default is False.
todo_include_todos = True
# Add any paths that contain templates here, relative to this directory.
-templates_path = ['_templates']
+templates_path = ["_templates"]
-graphviz_output_format = 'png' # 'svg'
+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'
+# source_encoding = 'utf-8-sig'
# The master toctree document.
-master_doc = 'index'
+master_doc = "index"
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
-language = 'en'
+language = "en"
# There are two options for replacing |today|: either, you set today to some
# non-false value, then it is used:
-#today = ''
+# today = ''
# Else, today_fmt is used as the format for a strftime call.
-#today_fmt = '%B %d, %Y'
+# today_fmt = '%B %d, %Y'
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
-exclude_patterns = ['_build']
+exclude_patterns = ["_build"]
# The reST default role (used for this markup: `text`) to use for all documents
-#default_role = None
+# default_role = None
# If true, '()' will be appended to :func: etc. cross-reference text.
-#add_function_parentheses = True
+# add_function_parentheses = True
# If true, the current module name will be prepended to all description
# unit titles (such as .. function::).
-#add_module_names = True
+# add_module_names = True
# If true, sectionauthor and moduleauthor directives will be shown in the
# output. They are ignored by default.
-#show_authors = False
+# show_authors = False
# The name of the Pygments (syntax highlighting) style to use.
-pygments_style = 'sphinx'
+pygments_style = "sphinx"
# Include documentation from both the class level and __init__
autoclass_content = "both"
# The default autodoc directive flags
-autodoc_default_flags = ['members', 'show-inheritance']
+autodoc_default_flags = ["members", "show-inheritance"]
# 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
# documentation.
-#html_theme_options = {}
+# html_theme_options = {}
# Add any paths that contain custom themes here, relative to this directory.
-#html_theme_path = []
+# html_theme_path = []
# The name for this set of Sphinx documents. If None, it defaults to
# " v documentation".
-#html_title = None
+# html_title = None
# A shorter title for the navigation bar. Default is the same as html_title.
-#html_short_title = None
+# html_short_title = None
# The name of an image file (relative to this directory) to place at the top
# of the sidebar.
-#html_logo = None
+# html_logo = None
# The name of an image file (within the static path) to use as favicon of the
# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32
# pixels large.
-#html_favicon = None
+# html_favicon = None
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
-#html_static_path = ['_static']
+# html_static_path = ['_static']
# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
# using the given strftime format.
-#html_last_updated_fmt = '%b %d, %Y'
+# html_last_updated_fmt = '%b %d, %Y'
# If true, SmartyPants will be used to convert quotes and dashes to
# typographically correct entities.
-#html_use_smartypants = True
+# html_use_smartypants = True
# Custom sidebar templates, maps document names to template names.
-#html_sidebars = {}
+# html_sidebars = {}
# Additional templates that should be rendered to pages, maps page names to
# template names.
-#html_additional_pages = {}
+# html_additional_pages = {}
# If false, no module index is generated.
-#html_domain_indices = True
+# html_domain_indices = True
# If false, no index is generated.
-#html_use_index = True
+# html_use_index = True
# If true, the index is split into individual pages for each letter.
-#html_split_index = False
+# html_split_index = False
# If true, links to the reST sources are added to the pages.
-#html_show_sourcelink = True
+# html_show_sourcelink = True
# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
-#html_show_sphinx = True
+# html_show_sphinx = True
# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
-#html_show_copyright = True
+# html_show_copyright = True
# If true, an OpenSearch description file will be output, and all pages will
# contain a tag referring to it. The value of this option must be the
# base URL from which the finished HTML is served.
-#html_use_opensearch = ''
+# html_use_opensearch = ''
# This is the file name suffix for HTML files (e.g. ".xhtml").
-#html_file_suffix = None
+# html_file_suffix = None
# Output file base name for HTML help builder.
-htmlhelp_basename = 'python-can'
+htmlhelp_basename = "python-can"
diff --git a/doc/configuration.rst b/doc/configuration.rst
index a7da791f6..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,24 +30,24 @@ 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:
-1. ``~/can.conf``
-2. ``/etc/can.conf``
-3. ``$HOME/.can``
-4. ``$HOME/.canrc``
+#. ``~/can.conf``
+#. ``/etc/can.conf``
+#. ``$HOME/.can``
+#. ``$HOME/.canrc``
On Windows systems the config file is searched in the following paths:
-1. ``~/can.conf``
-1. ``can.ini`` (current working directory)
-2. ``$APPDATA/can.ini``
+#. ``%USERPROFILE%/can.conf``
+#. ``can.ini`` (current working directory)
+#. ``%APPDATA%/can.ini``
The configuration file sets the default interface and channel:
@@ -57,7 +59,7 @@ The configuration file sets the default interface and channel:
bitrate =
-The configuration can also contain additional sections:
+The configuration can also contain additional sections (or context):
::
@@ -79,10 +81,10 @@ The configuration can also contain additional sections:
::
- from can.interfaces.interface import Bus
+ from can.interface import Bus
- hs_bus = Bus(config_section='HS')
- ms_bus = Bus(config_section='MS')
+ hs_bus = Bus(config_context='HS')
+ ms_bus = Bus(config_context='MS')
Environment Variables
---------------------
@@ -92,7 +94,15 @@ Configuration can be pulled from these environmental variables:
* CAN_INTERFACE
* CAN_CHANNEL
* CAN_BITRATE
+ * CAN_CONFIG
+
+The ``CAN_CONFIG`` environment variable allows to set any bus configuration using JSON.
+
+For example:
+
+``CAN_INTERFACE=socketcan CAN_CONFIG={"receive_own_messages": true, "fd": true}``
+.. _interface names:
Interface Names
---------------
@@ -102,27 +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` |
++---------------------+-------------------------------------+
+| ``"robotell"`` | :doc:`interfaces/robotell` |
++---------------------+-------------------------------------+
+| ``"seeedstudio"`` | :doc:`interfaces/seeedstudio` |
++---------------------+-------------------------------------+
+| ``"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 51924be16..40604c346 100644
--- a/doc/development.rst
+++ b/doc/development.rst
@@ -1,97 +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.
-
-
-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 subdirctory depending
- on the complexity) inside ``can.interfaces``
-- Implement the central part of the backend: the bus class that extends
- :class:`can.BusABC`. See below for more info on this one!
-- Register your backend bus class in ``can.interface.BACKENDS`` and
- ``can.interfaces.VALID_INTERFACES``.
-- Add docs where appropiate, like in ``doc/interfaces.rst`` and add
- an entry in ``doc/interface/*``.
- Update ``doc/scripts.rst`` accordingly.
-- Add tests in ``test/*`` where appropiate.
-
-
-About the ``BusABC`` class
---------------------------
-
-Concrete implementations *have to* implement the following:
- * :meth:`~can.BusABC.send` to send individual messages
- * :meth:`~can.BusABC._recv_internal` to receive individual messages
- (see note below!)
- * set the :attr:`~can.BusABC.channel_info` attribute to a string describing
- the underlying bus and/or channel
-
-They *might* implement the following:
- * :meth:`~can.BusABC.flush_tx_buffer` to allow discarding any
- messages yet to be sent
- * :meth:`~can.BusABC.shutdown` to override how the bus should
- shut down
- * :meth:`~can.BusABC.send_periodic` to override the software based
- periodic sending and push it down to the kernel or hardware
- * :meth:`~can.BusABC._apply_filters` to apply efficient filters
- to lower level systems like the OS kernel or hardware
- * :meth:`~can.BusABC._detect_available_configs` to allow the interface
- to report which configurations are currently available for new
- connections
- * :meth:`~can.BusABC.state` property to allow reading and/or changing
- the bus state
-
-.. note::
-
- *TL;DR*: Only override :meth:`~can.BusABC._recv_internal`,
- never :meth:`~can.BusABC.recv` directly.
-
- Previously, concrete bus classes had to override :meth:`~can.BusABC.recv`
- directly instead of :meth:`~can.BusABC._recv_internal`, but that has
- changed to allow the abstract base class to handle in-software message
- filtering as a fallback. All internal interfaces now implement that new
- behaviour. Older (custom) interfaces might still be implemented like that
- and thus might not provide message filtering:
-
-This is the entire ABC bus class with all internal methods:
-
-.. autoclass:: can.BusABC
- :private-members:
- :special-members:
-
-Concrete instances are created by :class:`can.Bus`.
+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:
@@ -104,28 +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. |
+---------------------------------+------------------------------------------------------+
-|:doc:`CAN ` | Legacy API. Deprecated. |
-+---------------------------------+------------------------------------------------------+
+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 `__.
-- 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 PyPi, Read the Docs and GitHub.
+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 Releases `__.
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 56%
rename from doc/listeners.rst
rename to doc/file_io.rst
index b807cc7a7..329ccac53 100644
--- a/doc/listeners.rst
+++ b/doc/file_io.rst
@@ -1,151 +1,204 @@
-Listeners
-=========
-
-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:
-
-
-BufferedReader
---------------
-
-.. autoclass:: can.BufferedReader
- :members:
-
-.. autoclass:: can.AsyncBufferedReader
- :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:
-
-
-Printer
--------
-
-.. autoclass:: can.Printer
- :members:
-
-
-CSVWriter
----------
-
-.. autoclass:: can.CSVWriter
- :members:
-
-.. autoclass:: can.CSVReader
- :members:
-
-
-SqliteWriter
-------------
-
-.. autoclass:: can.SqliteWriter
- :members:
-
-.. autoclass:: can.SqliteReader
- :members:
-
-
-Database table format
-~~~~~~~~~~~~~~~~~~~~~
-
-The messages are written to the table ``messages`` in the sqlite database
-by default. The table is created if it does not already exist.
-
-The entries are as follows:
-
-============== ============== ==============
-Name Data type Note
--------------- -------------- --------------
-ts REAL The timestamp of the message
-arbitration_id INTEGER The arbitration id, might use the extended format
-extended INTEGER ``1`` if the arbitration id uses the extended format, else ``0``
-remote INTEGER ``1`` if the message is a remote frame, else ``0``
-error INTEGER ``1`` if the message is an error frame, else ``0``
-dlc INTEGER The data length code (DLC)
-data BLOB The content of the message
-============== ============== ==============
-
-
-ASC (.asc Logging format)
--------------------------
-ASCWriter logs CAN data to an ASCII log file compatible with other CAN tools such as
-Vector CANalyzer/CANoe and other.
-Since no official specification exists for the format, it has been reverse-
-engineered from existing log files. One description of the format can be found `here
-`_.
-
-
-.. note::
-
- Channels will be converted to integers.
-
-
-.. autoclass:: can.ASCWriter
- :members:
-
-ASCReader reads CAN data from ASCII log files .asc,
-as further references can-utils can be used:
-`asc2log `_,
-`log2asc `_.
-
-.. autoclass:: can.ASCReader
- :members:
-
-
-Log (.log can-utils Logging format)
------------------------------------
-
-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
- :members:
-
-**CanutilsLogReader** reads CAN data from ASCII log files .log
-
-.. autoclass:: can.CanutilsLogReader
- :members:
-
-
-BLF (Binary Logging Format)
----------------------------
-
-Implements support for BLF (Binary Logging Format) which is a proprietary
-CAN log format from Vector Informatik GmbH.
-
-The data is stored in a compressed format which makes it very compact.
-
-.. note:: Channels will be converted to integers.
-
-.. autoclass:: can.BLFWriter
- :members:
-
-The following class can be used to read messages from BLF file:
-
-.. autoclass:: can.BLFReader
- :members:
+File IO
+=======
+
+
+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:
+
+
+CSVWriter
+---------
+
+.. autoclass:: can.CSVWriter
+ :show-inheritance:
+ :members:
+
+.. autoclass:: can.CSVReader
+ :show-inheritance:
+ :members:
+
+
+SqliteWriter
+------------
+
+.. autoclass:: can.SqliteWriter
+ :show-inheritance:
+ :members:
+
+.. autoclass:: can.SqliteReader
+ :show-inheritance:
+ :members:
+
+
+Database table format
+~~~~~~~~~~~~~~~~~~~~~
+
+The messages are written to the table ``messages`` in the sqlite database
+by default. The table is created if it does not already exist.
+
+The entries are as follows:
+
+============== ============== ==============
+Name Data type Note
+-------------- -------------- --------------
+ts REAL The timestamp of the message
+arbitration_id INTEGER The arbitration id, might use the extended format
+extended INTEGER ``1`` if the arbitration id uses the extended format, else ``0``
+remote INTEGER ``1`` if the message is a remote frame, else ``0``
+error INTEGER ``1`` if the message is an error frame, else ``0``
+dlc INTEGER The data length code (DLC)
+data BLOB The content of the message
+============== ============== ==============
+
+
+ASC (.asc Logging format)
+-------------------------
+ASCWriter logs CAN data to an ASCII log file compatible with other CAN tools such as
+Vector CANalyzer/CANoe and other.
+Since no official specification exists for the format, it has been reverse-
+engineered from existing log files. One description of the format can be found `here
+`_.
+
+
+.. note::
+
+ Channels will be converted to integers.
+
+
+.. autoclass:: can.ASCWriter
+ :show-inheritance:
+ :members:
+
+ASCReader reads CAN data from ASCII log files .asc,
+as further references can-utils can be used:
+`asc2log `_,
+`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 `_
+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:
+
+
+BLF (Binary Logging Format)
+---------------------------
+
+Implements support for BLF (Binary Logging Format) which is a proprietary
+CAN log format from Vector Informatik GmbH.
+
+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 3ffc9bb3b..73371af4c 100644
--- a/doc/history.rst
+++ b/doc/history.rst
@@ -1,5 +1,5 @@
-History and Roadmap
-===================
+History
+=======
Background
----------
@@ -44,16 +44,47 @@ and 2018.
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
============== ============================================================== ====
3.3 Initial SocketCAN support `Docs `__
-3.4 Broadcast Banagement (BCM) commands are natively supported `Docs `__
+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 0dc498583..822de2ce0 100644
--- a/doc/installation.rst
+++ b/doc/installation.rst
@@ -1,93 +1,144 @@
-Installation
-============
-
-
-Install ``can`` with ``pip``:
-::
-
- $ 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`.
-
-
-GNU/Linux dependencies
-----------------------
-
-Reasonably modern Linux Kernels (2.6.25 or newer) have an implementation
-of ``socketcan``. This version of python-can will directly use socketcan
-if called with Python 3.3 or greater, otherwise that interface is used
-via ctypes.
-
-Windows dependencies
---------------------
-
-Kvaser
-~~~~~~
-
-To install ``python-can`` using the Kvaser CANLib SDK as the backend:
-
-1. Install the `latest stable release of
- Python `__.
-
-2. Install `Kvaser's latest Windows CANLib
- drivers `__.
-
-3. 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 `__.
-
-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``.
-
-This library can take advantage of the `Python for Windows Extensions
-`__ library if installed.
-It will be used to get notified of new messages instead of
-the CPU intensive polling that will otherwise have be used.
-
-IXXAT
-~~~~~
-
-To install ``python-can`` using the IXXAT VCI V3 SDK as the backend:
-
-1. Install `IXXAT's latest Windows VCI V3 SDK
- 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.
-
-NI-CAN
-~~~~~~
-
-Download and install the NI-CAN drivers from
-`National Instruments `__.
-
-Currently the driver only supports 32-bit Python on Windows.
-
-neoVI
-~~~~~
-
-See :doc:`interfaces/neovi`.
-
-
-Installing python-can in development mode
------------------------------------------
-
-A "development" install of this package allows you to make changes locally
-or pull updates from the Mercurial repository and use them without having to
-reinstall. Download or clone the source repository then:
-
-::
-
- python setup.py develop
-
-
+Installation
+============
+
+
+Install the ``can`` package from PyPi with ``pip`` or similar::
+
+ $ pip install python-can
+
+
+
+
+.. 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
+----------------------
+
+Reasonably modern Linux Kernels (2.6.25 or newer) have an implementation
+of ``socketcan``. This version of python-can will directly use socketcan
+if called with Python 3.3 or greater, otherwise that interface is used
+via ctypes.
+
+Windows dependencies
+--------------------
+
+Kvaser
+~~~~~~
+
+To install ``python-can`` using the Kvaser CANLib SDK as the backend:
+
+1. Install `Kvaser's latest Windows CANLib drivers `__.
+
+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:
+
+- `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 python-can[pcan]``.
+
+This library can take advantage of the `Python for Windows Extensions
+`__ library if installed.
+It will be used to get notified of new messages instead of
+the CPU intensive polling that will otherwise have be used.
+
+IXXAT
+~~~~~
+
+To install ``python-can`` using the IXXAT VCI V3 or V4 SDK as the backend:
+
+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.
+
+NI-CAN
+~~~~~~
+
+Download and install the NI-CAN drivers from
+`National Instruments `__.
+
+Currently the driver only supports 32-bit Python on Windows.
+
+neoVI
+~~~~~
+
+See :doc:`interfaces/neovi`.
+
+Vector
+~~~~~~
+
+To install ``python-can`` using the XL Driver Library as the backend:
+
+1. Install the `latest drivers `__ for your Vector hardware interface.
+
+2. Install the `XL Driver Library `__ or copy the ``vxlapi.dll`` and/or
+ ``vxlapi64.dll`` into your working directory.
+
+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
+-----------------------------------------
+
+A "development" install of this package allows you to make changes locally
+or pull updates from the Git repository and use them without having to
+reinstall. Download or clone the source repository then:
+
+::
+
+ # install in editable mode
+ cd
+ python3 -m pip install -e .
+
diff --git a/doc/interfaces.rst b/doc/interfaces.rst
index 794959ee1..6645ec338 100644
--- a/doc/interfaces.rst
+++ b/doc/interfaces.rst
@@ -1,43 +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/ixxat
- interfaces/pcan
+ interfaces/socketcan
+ interfaces/socketcand
+ interfaces/systec
interfaces/usb2can
- interfaces/nican
- interfaces/iscan
- interfaces/neovi
interfaces/vector
- interfaces/virtual
-
-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
new file mode 100644
index 000000000..b48782259
--- /dev/null
+++ b/doc/interfaces/canalystii.rst
@@ -0,0 +1,34 @@
+CANalyst-II
+===========
+
+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
+
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 ff52776b8..1337bf738 100644
--- a/doc/interfaces/ixxat.rst
+++ b/doc/interfaces/ixxat.rst
@@ -1,67 +1,144 @@
.. _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
---------
-The IXXAT :class:`~can.BusABC` object is a farly straightforward interface
+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 289300093..f2c93f85b 100644
--- a/doc/interfaces/kvaser.rst
+++ b/doc/interfaces/kvaser.rst
@@ -10,6 +10,8 @@ Bus
---
.. autoclass:: can.interfaces.kvaser.canlib.KvaserBus
+ :members:
+ :exclude-members: get_stats
Internals
@@ -18,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
`_).
@@ -35,3 +37,14 @@ If one filter is requested, this is will be handled by the Kvaser driver.
If more than one filter is needed, these will be handled in Python code
in the ``recv`` method. If a message does not match any of the filters,
``recv()`` will return None.
+
+
+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 ec4e82cb6..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::
@@ -12,7 +12,7 @@ This interface adds support for CAN controllers by `National Instruments`_.
.. warning::
- CAN filtering has not been tested throughly and may not work as expected.
+ CAN filtering has not been tested thoroughly and may not work as expected.
Bus
@@ -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
new file mode 100644
index 000000000..65b9dfff6
--- /dev/null
+++ b/doc/interfaces/robotell.rst
@@ -0,0 +1,27 @@
+.. _robotell:
+
+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``
+the device should be compatible with this driver.
+These USB devices are based on a STM32 controller with a CH340 serial interface and use a binary protocol - NOT compatible with SLCAN
+
+See `https://www.amobbs.com/thread-4651667-1-1.html `_ for some background on these devices.
+
+This driver directly uses either the local or remote (not tested) serial port.
+Remote serial ports will be specified via special URL. Both raw TCP sockets as also RFC2217 ports are supported.
+
+Usage: use ``port or URL[@baurate]`` to open the device.
+For example use ``/dev/ttyUSB0@115200`` or ``COM4@9600`` for local serial ports and
+``socket://192.168.254.254:5000`` or ``rfc2217://192.168.254.254:5000`` for remote ports.
+
+
+
+Bus
+---
+
+.. autoclass:: can.interfaces.robotell.robotellBus
+ :members:
+
diff --git a/doc/interfaces/seeedstudio.rst b/doc/interfaces/seeedstudio.rst
new file mode 100644
index 000000000..173944e0d
--- /dev/null
+++ b/doc/interfaces/seeedstudio.rst
@@ -0,0 +1,92 @@
+.. _seeeddoc:
+
+
+Seeed Studio USB-CAN Analyzer
+=============================
+
+SKU: 114991193
+
+Links:
+
+- https://www.seeedstudio.com/USB-CAN-Analyzer-p-2888.html
+- 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 include the dependency ``pyserial``::
+
+ pip install python-can[seeedstudio]
+
+
+
+Interface
+---------
+
+::
+
+ can.interfaces.seeedstudio.SeeedBus
+
+A bus example::
+
+ bus = can.interface.Bus(interface='seeedstudio', channel='/dev/ttyUSB0', bitrate=500000)
+
+
+
+Configuration
+-------------
+::
+
+ SeeedBus(channel,
+ baudrate=2000000,
+ timeout=0.1,
+ frame_type='STD',
+ operation_mode='normal',
+ bitrate=500000,
+ can_filters=None)
+
+CHANNEL
+ The serial port created by the USB device when connected.
+
+TIMEOUT
+ Only used by the underling serial port, it probably should not be changed. The serial port baudrate=2000000 and rtscts=false are also matched to the device so are not added here.
+
+FRAMETYPE
+ - "STD"
+ - "EXT"
+
+OPERATIONMODE
+ - "normal"
+ - "loopback"
+ - "silent"
+ - "loopback_and_silent"
+
+BITRATE
+ - 1000000
+ - 800000
+ - 500000
+ - 400000
+ - 250000
+ - 200000
+ - 125000
+ - 100000
+ - 50000
+ - 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 f9c674174..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 3.0. Future 2.x release may 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,16 +177,16 @@ 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], extended_id=False)
+ msg = can.Message(arbitration_id=0xc0ffee, data=[id, i, 0, 1, 3, 1, 4, 1], is_extended_id=False)
bus.send(msg)
- # Issue #3: Need to keep running to ensure the writing threads stay alive. ?
+
time.sleep(1)
producer(10)
@@ -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
new file mode 100644
index 000000000..6b04fdfe0
--- /dev/null
+++ b/doc/interfaces/systec.rst
@@ -0,0 +1,78 @@
+.. _systec:
+
+SYSTEC interface
+================
+
+Windows interface for the USBCAN devices supporting up to 2 channels based on the
+particular product. There is support for the devices also on Linux through the :doc:`socketcan` interface and for Windows using this
+``systec`` interface.
+
+Installation
+------------
+
+The interface requires installation of the **USBCAN32.dll** library. Download and install the
+driver for specific `SYSTEC `__ device.
+
+Supported devices
+-----------------
+
+The interface supports following devices:
+
+- GW-001 (obsolete),
+- GW-002 (obsolete),
+- Multiport CAN-to-USB G3,
+- USB-CANmodul1 G3,
+- USB-CANmodul2 G3,
+- USB-CANmodul8 G3,
+- USB-CANmodul16 G3,
+- USB-CANmodul1 G4,
+- USB-CANmodul2 G4.
+
+Configuration
+-------------
+
+The simplest configuration would be::
+
+ interface = systec
+ channel = 0
+
+Python-can will search for the first device found if not specified explicitly by the
+``device_number`` parameter. The ``interface`` and ``channel`` are the only mandatory
+parameters. The interface supports two channels 0 and 1. The maximum number of entries in the receive and transmit buffer can be set by the
+parameters ``rx_buffer_entries`` and ``tx_buffer_entries``, with default value 4096
+set for both.
+
+Optional parameters:
+
+* ``bitrate`` (default 500000) Channel bitrate in bit/s
+* ``device_number`` (default first device) The device number of the USB-CAN
+* ``rx_buffer_entries`` (default 4096) The maximum number of entries in the receive buffer
+* ``tx_buffer_entries`` (default 4096) The maximum number of entries in the transmit buffer
+* ``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
+---------
+
+Message filtering
+~~~~~~~~~~~~~~~~~
+
+The interface and driver supports only setting of one filter per channel. If one filter
+is requested, this is will be handled by the driver itself. If more than one filter is
+needed, these will be handled in Python code in the ``recv`` method. If a message does
+not match any of the filters, ``recv()`` will return None.
+
+Periodic tasks
+~~~~~~~~~~~~~~
+
+The driver supports periodic message sending but without the possibility to set
+the interval between messages. Therefore the handling of the periodic messages is done
+by the interface using the :class:`~can.broadcastmanager.ThreadBasedCyclicSendTask`.
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 3a7e291cf..1ac9dd61f 100644
--- a/doc/interfaces/usb2can.rst
+++ b/doc/interfaces/usb2can.rst
@@ -1,35 +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.
- (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
@@ -49,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.
@@ -78,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 a936e693e..d3e2bed45 100644
--- a/doc/interfaces/vector.rst
+++ b/doc/interfaces/vector.rst
@@ -1,10 +1,13 @@
Vector
======
-This interface adds support for CAN controllers by `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
new file mode 100644
index 000000000..9e544f052
--- /dev/null
+++ b/doc/internal-api.rst
@@ -0,0 +1,141 @@
+.. _internalapi:
+
+Internal API
+============
+
+Here we document the odds and ends that are more helpful for creating your own interfaces
+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:
+
+
+Extending the ``BusABC`` class
+------------------------------
+
+Concrete implementations **must** implement the following:
+ * :meth:`~can.BusABC.send` to send individual messages
+ * :meth:`~can.BusABC._recv_internal` to receive individual messages
+ (see note below!)
+ * set the :attr:`~can.BusABC.channel_info` attribute to a string describing
+ the underlying bus and/or channel
+
+They **might** implement the following:
+ * :meth:`~can.BusABC.flush_tx_buffer` to allow discarding any
+ messages yet to be sent
+ * :meth:`~can.BusABC.shutdown` to override how the bus should
+ shut down
+ * :meth:`~can.BusABC._send_periodic_internal` to override the software based
+ periodic sending and push it down to the kernel or hardware.
+ * :meth:`~can.BusABC._apply_filters` to apply efficient filters
+ to lower level systems like the OS kernel or hardware.
+ * :meth:`~can.BusABC._detect_available_configs` to allow the interface
+ to report which configurations are currently available for new
+ connections.
+ * :meth:`~can.BusABC.state` property to allow reading and/or changing
+ the bus state.
+
+.. note::
+
+ *TL;DR*: Only override :meth:`~can.BusABC._recv_internal`,
+ never :meth:`~can.BusABC.recv` directly.
+
+ Previously, concrete bus classes had to override :meth:`~can.BusABC.recv`
+ directly instead of :meth:`~can.BusABC._recv_internal`, but that has
+ changed to allow the abstract base class to handle in-software message
+ filtering as a fallback. All internal interfaces now implement that new
+ behaviour. Older (custom) interfaces might still be implemented like that
+ and thus might not provide message filtering:
+
+
+Concrete instances are usually created by :func:`can.Bus` which takes the users
+configuration into account.
+
+
+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.
+
+.. 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 ``can.io``.
+Each file/IO type is within a separate module and ideally implements both a *Reader* and a *Writer*.
+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`.
+
+
+
+Adding support for new file formats
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+This assumes that you want to add a new file format, called *canstore*.
+Ideally add both reading and writing support for the new file format, although this is not strictly required.
+
+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 extends :class:`can.io.generic.MessageReader`.
+ Besides from a constructor, only ``__iter__(self)`` needs to be implemented.
+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.
+ Please mention features and limitations of the implementation.
+6. Add a short section to the bottom of *doc/listeners.rst*.
+7. Add tests where appropriate, for example by simply adding a test case called
+ `class TestCanstoreFileFormat(ReaderWriterTest)` to *test/logformats_test.py*.
+ That should already handle all of the general testing.
+ Just follow the way the other tests in there do it.
+8. Add imports to *can/__init__py* and *can/io/__init__py* so that the
+ new classes can be simply imported as *from can import CanstoreReader, CanstoreWriter*.
+
+
+
+IO Utilities
+~~~~~~~~~~~~
+
+
+.. automodule:: can.io.generic
+ :show-inheritance:
+ :members:
+ :private-members:
+ :member-order: bysource
+
+
+
+Other Utilities
+---------------
+
+
+.. automodule:: can.util
+ :members:
diff --git a/doc/message.rst b/doc/message.rst
index cd350d9f1..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
@@ -23,6 +23,15 @@ Message
2.0B) in length, and ``python-can`` exposes this difference with the
:attr:`~can.Message.is_extended_id` attribute.
+ .. attribute:: timestamp
+
+ :type: float
+
+ The timestamp field in a CAN message is a floating point number representing when
+ the message was received since the epoch in seconds. Where possible this will be
+ timestamped in hardware.
+
+
.. attribute:: arbitration_id
:type: int
@@ -30,12 +39,12 @@ Message
The frame identifier used for arbitration on the bus.
The arbitration ID can take an int between 0 and the
- maximum value allowed depending on the is_extended_id flag
+ maximum value allowed depending on the ``is_extended_id`` flag
(either 2\ :sup:`11` - 1 for 11-bit IDs, or
2\ :sup:`29` - 1 for 29-bit identifiers).
- >>> print(Message(extended_id=False, arbitration_id=100))
- Timestamp: 0.000000 ID: 0064 S DLC: 0
+ >>> print(Message(is_extended_id=False, arbitration_id=100))
+ Timestamp: 0.000000 ID: 064 S Rx DL: 0
.. attribute:: data
@@ -47,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:
@@ -63,7 +72,7 @@ Message
:type: int
- The :abbr:`DLC (Data Link Count)` parameter of a CAN message is an integer
+ The :abbr:`DLC (Data Length Code)` parameter of a CAN message is an integer
between 0 and 8 representing the frame payload length.
In the case of a CAN FD message, this indicates the data length in
@@ -82,20 +91,30 @@ Message
represents the amount of data contained in the message, in remote
frames it represents the amount of data being requested.
+ .. attribute:: channel
+
+ :type: str or int or None
+
+ This might store the channel from which the message came.
+
.. attribute:: is_extended_id
:type: bool
This flag controls the size of the :attr:`~can.Message.arbitration_id` field.
+ Previously this was exposed as `id_type`.
- >>> print(Message(extended_id=False))
- Timestamp: 0.000000 ID: 0000 S DLC: 0
- >>> print(Message(extended_id=True))
- Timestamp: 0.000000 ID: 00000000 X DLC: 0
+ >>> print(Message(is_extended_id=False))
+ Timestamp: 0.000000 ID: 000 S Rx DL: 0
+ >>> print(Message(is_extended_id=True))
+ Timestamp: 0.000000 ID: 00000000 X Rx DL: 0
- Previously this was exposed as `id_type`.
+ .. note::
+
+ The initializer argument and attribute ``extended_id`` has been deprecated in favor of
+ ``is_extended_id``, but will continue to work for the ``3.x`` release series.
.. attribute:: is_error_frame
@@ -105,18 +124,18 @@ 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
- :type: boolean
+ :type: bool
This boolean attribute indicates if the message is a remote frame or a data frame, and
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
@@ -126,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
@@ -141,15 +167,6 @@ Message
If this is a CAN FD message, this indicates an error active state.
- .. attribute:: timestamp
-
- :type: float
-
- The timestamp field in a CAN message is a floating point number representing when
- the message was received since the epoch in seconds. Where possible this will be
- timestamped in hardware.
-
-
.. method:: __str__
A string representation of a CAN message:
@@ -157,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.
@@ -183,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 b58125ea5..1d730a74b 100644
--- a/doc/scripts.rst
+++ b/doc/scripts.rst
@@ -1,176 +1,73 @@
-Scripts
-=======
-
-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).
-
-can.logger
-----------
-
-Command line help, called with ``--help``::
-
- usage: python -m can.logger [-h] [-f LOG_FILE] [-v] [-c CHANNEL]
- [-i {pcan,ixxat,socketcan_ctypes,kvaser,virtual,usb2can,vector,slcan,nican,socketcan,iscan,neovi,serial,socketcan_native}]
- [--filter ...] [-b BITRATE]
- [--active | --passive]
-
- Log CAN traffic, printing messages to stdout or to a given file.
-
- optional arguments:
- -h, --help show this help message and exit
- -f LOG_FILE, --file_name LOG_FILE
- Path and base log filename, for supported types see
- can.Logger.
- -v How much information do you want to see at the command
- line? You can add several of these e.g., -vv is DEBUG
- -c CHANNEL, --channel CHANNEL
- 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"
- -i {pcan,ixxat,socketcan_ctypes,kvaser,virtual,usb2can,vector,slcan,nican,socketcan,iscan,neovi,serial,socketcan_native}, --interface {pcan,ixxat,socketcan_ctypes,kvaser,virtual,usb2can,vector,slcan,nican,socketcan,iscan,neovi,serial,socketcan_native}
- Specify the backend CAN interface to use. If left
- blank, fall back to reading from configuration files.
- --filter ... Comma separated filters can be specified for the given
- CAN interface: : (matches when
- & mask == can_id & mask)
- ~ (matches when &
- mask != can_id & mask)
- -b BITRATE, --bitrate BITRATE
- Bitrate to use for the CAN bus.
- --active Start the bus as active, this is applied the default.
- --passive Start the bus as passive.
-
-
-can.player
-----------
-
-Command line help, called with ``--help``::
-
- usage: python -m can.player [-h] [-f LOG_FILE] [-v] [-c CHANNEL]
- [-i {pcan,ixxat,socketcan_ctypes,kvaser,virtual,usb2can,vector,slcan,nican,socketcan,iscan,neovi,serial,socketcan_native}]
- [-b BITRATE] [--ignore-timestamps]
- [-g GAP] [-s SKIP]
- input-file
-
- Replay CAN traffic.
-
- positional arguments:
- input-file The file to replay. For supported types see
- can.LogReader.
-
- optional arguments:
- -h, --help show this help message and exit
- -f LOG_FILE, --file_name LOG_FILE
- Path and base log filename, for supported types see
- can.LogReader.
- -v Also print can frames to stdout. You can add several
- of these to enable debugging
- -c CHANNEL, --channel CHANNEL
- 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"
- -i {pcan,ixxat,socketcan_ctypes,kvaser,virtual,usb2can,vector,slcan,nican,socketcan,iscan,neovi,serial,socketcan_native}, --interface {pcan,ixxat,socketcan_ctypes,kvaser,virtual,usb2can,vector,slcan,nican,socketcan,iscan,neovi,serial,socketcan_native}
- Specify the backend CAN interface to use. If left
- blank, fall back to reading from configuration files.
- -b BITRATE, --bitrate BITRATE
- Bitrate to use for the CAN bus.
- --ignore-timestamps Ignore timestamps (send all frames immediately with
- minimum gap between frames)
- -g GAP, --gap GAP minimum time between replayed frames
- -s SKIP, --skip SKIP skip gaps greater than 's' seconds
-
-can.viewer
-----------
-
-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.
-
-Command line arguments
-^^^^^^^^^^^^^^^^^^^^^^
-
-By default it will be using the :doc:`/interfaces/socketcan` interface. All interfaces supported are supported and can be specified using the ``-i`` argument.
-
-The full usage page can be seen below::
-
- Usage: python -m can.viewer [-h] [--version] [-b BITRATE] [-c CHANNEL]
- [-d {:,:::...:,file.txt}]
- [-f {:,~}]
- [-i {iscan,ixxat,kvaser,neovi,nican,pcan,serial,slcan,socketcan,socketcan_ctypes,socketcan_native,usb2can,vector,virtual}]
-
- A simple CAN viewer terminal application written in Python
-
- Optional arguments:
- -h, --help Show this help message and exit
- --version Show program's version number and exit
- -b, --bitrate BITRATE
- Bitrate to use for the given CAN interface
- -c, --channel CHANNEL
- 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)
- -d, --decode {:,:::...:,file.txt}
- Specify how to convert the raw bytes into real values.
- The ID of the frame is given as the first argument and the format as the second.
- The Python struct package is used to unpack the received data
- where the format characters have the following meaning:
- < = little-endian, > = big-endian
- x = pad byte
- c = char
- ? = bool
- b = int8_t, B = uint8_t
- h = int16, H = uint16
- l = int32_t, L = uint32_t
- q = int64_t, Q = uint64_t
- f = float (32-bits), d = double (64-bits)
- Fx to convert six bytes with ID 0x100 into uint8_t, uint16 and uint32_t:
- $ python -m can.viewer -d "100::,~}
- Comma separated CAN filters for the given CAN interface:
- : (matches when & mask == can_id & mask)
- ~ (matches when & mask != can_id & mask)
- Fx to show only frames with ID 0x100 to 0x103:
- python -m can.viewer -f 100:7FC
- Note that the ID and mask are alway interpreted as hex values
- -i, --interface {iscan,ixxat,kvaser,neovi,nican,pcan,serial,slcan,socketcan,socketcan_ctypes,socketcan_native,usb2can,vector,virtual}
- Specify the backend CAN interface to use.
-
- Shortcuts:
- +---------+-------------------------+
- | Key | Description |
- +---------+-------------------------+
- | ESQ/q | Exit the viewer |
- | c | Clear the stored frames |
- | s | Sort the stored frames |
- | SPACE | Pause the viewer |
- | UP/DOWN | Scroll the viewer |
- +---------+-------------------------+
+Command Line Tools
+==================
+
+The following modules are callable from ``python-can``.
+
+They can be called for example by ``python -m can.logger`` or ``can_logger`` (if installed using pip).
+
+can.logger
+----------
+
+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
+----------
+
+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.
+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
+^^^^^^^^^^^^^^^^^^^^^^
+
+By default the ``can.viewer`` uses the :doc:`/interfaces/socketcan` interface. All interfaces are supported and can be specified using the ``-i`` argument or configured following :doc:`/configuration`.
+
+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 3e71ae6db..6befbe7a9
--- a/examples/asyncio_demo.py
+++ b/examples/asyncio_demo.py
@@ -1,44 +1,55 @@
+#!/usr/bin/env python
+
+"""
+This example demonstrates how to use async IO with python-can.
+"""
+
import asyncio
+from typing import TYPE_CHECKING
+
import can
-def print_message(msg):
+if TYPE_CHECKING:
+ from can.notifier import MessageRecipient
+
+
+def print_message(msg: can.Message) -> None:
"""Regular callback function. Can also be a coroutine."""
print(msg)
-async def main():
- can0 = 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(can0, listeners, loop=loop)
- # Start sending first message
- can0.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
- can0.send(msg)
- # Wait for last message to arrive
- await reader.get_message()
- print('Done!')
-
- # Clean-up
- notifier.stop()
- can0.shutdown()
-
-# Get the default event loop
-loop = asyncio.get_event_loop()
-# Run until main coroutine finishes
-loop.run_until_complete(main())
-loop.close()
+
+async def main() -> None:
+ """The main function that runs in the loop."""
+
+ 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 f7972f55c..bdd69eef2 100755
--- a/examples/cyclic.py
+++ b/examples/cyclic.py
@@ -1,5 +1,4 @@
#!/usr/bin/env python
-# coding: utf-8
"""
This example exercises the periodic sending capabilities.
@@ -10,8 +9,6 @@
"""
-from __future__ import print_function
-
import logging
import time
@@ -26,7 +23,9 @@ def simple_periodic_send(bus):
Sleeps for 2 seconds then stops the task.
"""
print("Starting to send a message every 200ms for 2s")
- msg = can.Message(arbitration_id=0x123, data=[1, 2, 3, 4, 5, 6], extended_id=False)
+ msg = can.Message(
+ arbitration_id=0x123, data=[1, 2, 3, 4, 5, 6], is_extended_id=False
+ )
task = bus.send_periodic(msg, 0.20)
assert isinstance(task, can.CyclicSendTaskABC)
time.sleep(2)
@@ -35,21 +34,29 @@ def simple_periodic_send(bus):
def limited_periodic_send(bus):
+ """Send using LimitedDurationCyclicSendTaskABC."""
print("Starting to send a message every 200ms for 1s")
- msg = can.Message(arbitration_id=0x12345678, data=[0, 0, 0, 0, 0, 0], extended_id=True)
- task = bus.send_periodic(msg, 0.20, 1)
+ msg = can.Message(
+ arbitration_id=0x12345678, data=[0, 0, 0, 0, 0, 0], is_extended_id=True
+ )
+ task = bus.send_periodic(msg, 0.20, 1, store_task=False)
if not isinstance(task, can.LimitedDurationCyclicSendTaskABC):
- print("This interface doesn't seem to support a ")
+ print("This interface doesn't seem to support LimitedDurationCyclicSendTaskABC")
task.stop()
return
- time.sleep(1.5)
- print("stopped cyclic send")
+ time.sleep(2)
+ print("Cyclic send should have stopped as duration expired")
+ # Note the (finished) task will still be tracked by the Bus
+ # unless we pass `store_task=False` to bus.send_periodic
+ # alternatively calling stop removes the task from the bus
+ # task.stop()
def test_periodic_send_with_modifying_data(bus):
- print("Starting to send a message every 200ms. Initial data is ones")
- msg = can.Message(arbitration_id=0x0cf02200, data=[1, 1, 1, 1])
+ """Send using ModifiableCyclicTaskABC."""
+ print("Starting to send a message every 200ms. Initial data is four consecutive 1s")
+ msg = can.Message(arbitration_id=0x0CF02200, data=[1, 1, 1, 1])
task = bus.send_periodic(msg, 0.20)
if not isinstance(task, can.ModifiableCyclicTaskABC):
print("This interface doesn't seem to support modification")
@@ -64,7 +71,7 @@ def test_periodic_send_with_modifying_data(bus):
task.stop()
print("stopped cyclic send")
print("Changing data of stopped task to single ff byte")
- msg.data = bytearray([0xff])
+ msg.data = bytearray([0xFF])
msg.dlc = 1
task.modify_data(msg)
time.sleep(1)
@@ -101,17 +108,15 @@ def test_periodic_send_with_modifying_data(bus):
# print("done")
-if __name__ == "__main__":
-
- reset_msg = can.Message(arbitration_id=0x00, data=[0, 0, 0, 0, 0, 0], extended_id=False)
-
- for interface, channel in [
- ('socketcan', 'can0'),
- #('ixxat', 0)
- ]:
- print("Carrying out cyclic tests with {} interface".format(interface))
+def main():
+ """Test different cyclic sending tasks."""
+ reset_msg = can.Message(
+ arbitration_id=0x00, data=[0, 0, 0, 0, 0, 0], is_extended_id=False
+ )
- bus = can.Bus(interface=interface, channel=channel, bitrate=500000)
+ # 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)
@@ -122,10 +127,12 @@ def test_periodic_send_with_modifying_data(bus):
test_periodic_send_with_modifying_data(bus)
- #print("Carrying out multirate cyclic test for {} interface".format(interface))
- #can.rc['interface'] = interface
- #test_dual_rate_periodic_send()
-
- bus.shutdown()
+ # print("Carrying out multirate cyclic test for {} interface".format(interface))
+ # can.rc['interface'] = interface
+ # test_dual_rate_periodic_send()
time.sleep(2)
+
+
+if __name__ == "__main__":
+ main()
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
new file mode 100755
index 000000000..43dc0cd17
--- /dev/null
+++ b/examples/cyclic_multiple.py
@@ -0,0 +1,140 @@
+#!/usr/bin/env python
+
+"""
+This example exercises the periodic task's multiple message sending capabilities
+
+Expects a vcan0 interface:
+
+ python3 -m examples.cyclic_multiple
+
+"""
+
+import logging
+import time
+
+import can
+
+logging.basicConfig(level=logging.INFO)
+
+
+def cyclic_multiple_send(bus):
+ """
+ Sends periodic messages every 1 s with no explicit timeout
+ Sleeps for 10 seconds then stops the task.
+ """
+ print("Starting to send a message every 1 s for 10 s")
+ messages = []
+
+ messages.append(
+ can.Message(
+ arbitration_id=0x401,
+ data=[0x11, 0x11, 0x11, 0x11, 0x11, 0x11],
+ is_extended_id=False,
+ )
+ )
+ messages.append(
+ can.Message(
+ arbitration_id=0x401,
+ data=[0x22, 0x22, 0x22, 0x22, 0x22, 0x22],
+ is_extended_id=False,
+ )
+ )
+ messages.append(
+ can.Message(
+ arbitration_id=0x401,
+ data=[0x33, 0x33, 0x33, 0x33, 0x33, 0x33],
+ is_extended_id=False,
+ )
+ )
+ messages.append(
+ can.Message(
+ arbitration_id=0x401,
+ data=[0x44, 0x44, 0x44, 0x44, 0x44, 0x44],
+ is_extended_id=False,
+ )
+ )
+ messages.append(
+ can.Message(
+ arbitration_id=0x401,
+ data=[0x55, 0x55, 0x55, 0x55, 0x55, 0x55],
+ is_extended_id=False,
+ )
+ )
+ task = bus.send_periodic(messages, 1)
+ assert isinstance(task, can.CyclicSendTaskABC)
+ time.sleep(10)
+ task.stop()
+ print("stopped cyclic send")
+
+
+def cyclic_multiple_send_modify(bus):
+ """
+ Sends initial set of 3 Messages containing Odd data sent every 1 s with
+ no explicit timeout. Sleeps for 8 s.
+
+ Then the set is updated to 3 Messages containing Even data.
+ Sleeps for 10 s.
+ """
+ messages_odd = []
+ messages_odd.append(
+ can.Message(
+ arbitration_id=0x401,
+ data=[0x11, 0x11, 0x11, 0x11, 0x11, 0x11],
+ is_extended_id=False,
+ )
+ )
+ messages_odd.append(
+ can.Message(
+ arbitration_id=0x401,
+ data=[0x33, 0x33, 0x33, 0x33, 0x33, 0x33],
+ is_extended_id=False,
+ )
+ )
+ messages_odd.append(
+ can.Message(
+ arbitration_id=0x401,
+ data=[0x55, 0x55, 0x55, 0x55, 0x55, 0x55],
+ is_extended_id=False,
+ )
+ )
+ messages_even = []
+ messages_even.append(
+ can.Message(
+ arbitration_id=0x401,
+ data=[0x22, 0x22, 0x22, 0x22, 0x22, 0x22],
+ is_extended_id=False,
+ )
+ )
+ messages_even.append(
+ can.Message(
+ arbitration_id=0x401,
+ data=[0x44, 0x44, 0x44, 0x44, 0x44, 0x44],
+ is_extended_id=False,
+ )
+ )
+ messages_even.append(
+ can.Message(
+ arbitration_id=0x401,
+ data=[0x66, 0x66, 0x66, 0x66, 0x66, 0x66],
+ is_extended_id=False,
+ )
+ )
+ print("Starting to send a message with odd every 1 s for 8 s with odd data")
+ task = bus.send_periodic(messages_odd, 1)
+ assert isinstance(task, can.CyclicSendTaskABC)
+ time.sleep(8)
+ print("Starting to send a message with even data every 1 s for 10 s with even data")
+ task.modify_data(messages_even)
+ time.sleep(10)
+ print("stopped cyclic modify send")
+
+
+if __name__ == "__main__":
+ for interface, channel in [("socketcan", "vcan0")]:
+ print(f"Carrying out cyclic multiple tests with {interface} interface")
+
+ with can.Bus(interface=interface, channel=channel, bitrate=500000) as BUS:
+ cyclic_multiple_send(BUS)
+ cyclic_multiple_send_modify(BUS)
+
+ time.sleep(2)
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
old mode 100644
new mode 100755
index 6801f481d..e9410e49f
--- a/examples/receive_all.py
+++ b/examples/receive_all.py
@@ -1,25 +1,33 @@
-from __future__ import print_function
+#!/usr/bin/env python
+
+"""
+Shows how to receive messages via polling.
+"""
import can
from can.bus import BusState
def receive_all():
-
- 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.state = BusState.ACTIVE
- #bus.state = BusState.PASSIVE
-
- try:
- while True:
- msg = bus.recv(1)
- if msg is not None:
- print(msg)
- except KeyboardInterrupt:
- pass
+ """Receives all messages and prints them to the console until Ctrl+C is pressed."""
+
+ # 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
+ try:
+ bus.state = BusState.PASSIVE
+ except NotImplementedError:
+ pass
+
+ try:
+ while True:
+ msg = bus.recv(1)
+ if msg is not None:
+ print(msg)
+
+ except KeyboardInterrupt:
+ pass # exit normally
if __name__ == "__main__":
diff --git a/examples/send_multiple.py b/examples/send_multiple.py
new file mode 100755
index 000000000..9123e1bc8
--- /dev/null
+++ b/examples/send_multiple.py
@@ -0,0 +1,36 @@
+#!/usr/bin/env python
+
+"""
+This demo creates multiple processes of producers to spam a socketcan bus.
+"""
+
+from concurrent.futures import ProcessPoolExecutor
+from time import sleep
+
+import can
+
+
+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 sent
+ """
+
+ # 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,
+ data=[thread_id, i, 0, 1, 3, 1, 4, 1],
+ )
+ bus.send(msg)
+ sleep(1.0)
+
+ print(f"Producer #{thread_id} finished sending {message_count} messages")
+
+
+if __name__ == "__main__":
+ with ProcessPoolExecutor() as executor:
+ executor.map(producer, range(5))
diff --git a/examples/send_one.py b/examples/send_one.py
index ebf0d1790..41b3a3cd0 100755
--- a/examples/send_one.py
+++ b/examples/send_one.py
@@ -1,36 +1,35 @@
#!/usr/bin/env python
-# coding: utf-8
"""
This example shows how sending a single message works.
"""
-from __future__ import print_function
-
import can
+
def send_one():
+ """Sends a single message."""
# this uses the default configuration (for example from the config file)
- # see http://python-can.readthedocs.io/en/latest/configuration.html
- bus = can.interface.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)
- # ...
-
- msg = can.Message(arbitration_id=0xc0ffee,
- data=[0, 25, 0, 1, 3, 1, 4, 1],
- extended_id=True)
-
- try:
- bus.send(msg)
- print("Message sent on {}".format(bus.channel_info))
- except can.CanError:
- print("Message NOT sent")
-
-if __name__ == '__main__':
+ # see https://python-can.readthedocs.io/en/stable/configuration.html
+ with can.Bus() as bus:
+ # Using specific buses works similar:
+ # 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(
+ 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")
+
+
+if __name__ == "__main__":
send_one()
diff --git a/examples/serial_com.py b/examples/serial_com.py
old mode 100644
new mode 100755
index efa0bcdb5..9f203b2e0
--- a/examples/serial_com.py
+++ b/examples/serial_com.py
@@ -1,8 +1,7 @@
#!/usr/bin/env python
-# coding: utf-8
"""
-This example sends every second a messages over the serial interface and also
+This example sends every second a messages over the serial interface and also
receives incoming messages.
python3 -m examples.serial_com
@@ -19,55 +18,63 @@
com0com: http://com0com.sourceforge.net/
"""
-from __future__ import print_function
-
-import time
import threading
+import time
import can
def send_cyclic(bus, msg, stop_event):
+ """The loop for sending."""
print("Start to send a message every 1s")
start_time = time.time()
while not stop_event.is_set():
msg.timestamp = time.time() - start_time
bus.send(msg)
- print("tx: {}".format(tx_msg))
+ print(f"tx: {msg}")
time.sleep(1)
print("Stopped sending messages")
def receive(bus, stop_event):
+ """The loop for receiving."""
print("Start receiving messages")
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")
-if __name__ == "__main__":
- server = can.interface.Bus(bustype='serial', channel='/dev/ttyS10')
- client = can.interface.Bus(bustype='serial', channel='/dev/ttyS11')
-
- tx_msg = can.Message(arbitration_id=0x01, data=[0x11, 0x22, 0x33, 0x44,
- 0x55, 0x66, 0x77, 0x88])
-
- # Thread for sending and receiving messages
- stop_event = threading.Event()
- t_send_cyclic = threading.Thread(target=send_cyclic, args=(server, tx_msg,
- stop_event))
- t_receive = threading.Thread(target=receive, args=(client, stop_event))
- t_receive.start()
- t_send_cyclic.start()
-
- try:
- while True:
- pass
- except KeyboardInterrupt:
- pass
-
- stop_event.set()
- server.shutdown()
- client.shutdown()
+
+def main():
+ """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],
+ )
+
+ # Thread for sending and receiving messages
+ stop_event = threading.Event()
+ t_send_cyclic = threading.Thread(
+ target=send_cyclic, args=(server, tx_msg, stop_event)
+ )
+ t_receive = threading.Thread(target=receive, args=(client, stop_event))
+ t_receive.start()
+ t_send_cyclic.start()
+
+ try:
+ while True:
+ time.sleep(0) # yield
+ except KeyboardInterrupt:
+ pass # exit normally
+
+ stop_event.set()
+ time.sleep(0.5)
+
print("Stopped script")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/examples/simple_log_converter.py b/examples/simple_log_converter.py
index 782ac9b7c..20e8fba75 100755
--- a/examples/simple_log_converter.py
+++ b/examples/simple_log_converter.py
@@ -1,19 +1,25 @@
#!/usr/bin/env python
-# coding: utf-8
"""
Use this to convert .can/.asc files to .log files.
+Can be easily adapted for all sorts of files.
-Usage: simpleLogConvert.py sourceLog.asc targetLog.log
+Usage: python3 simple_log_convert.py sourceLog.asc targetLog.log
"""
import sys
-import can.io.logger
-import can.io.player
+import can
-reader = can.io.player.LogReader(sys.argv[1])
-writer = can.io.logger.Logger(sys.argv[2])
-for msg in reader:
- writer.on_message_received(msg)
+def main():
+ """The transcoder"""
+
+ 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)
+
+
+if __name__ == "__main__":
+ main()
diff --git a/examples/vcan_filtered.py b/examples/vcan_filtered.py
old mode 100644
new mode 100755
index 86ee7f5ed..22bca706c
--- a/examples/vcan_filtered.py
+++ b/examples/vcan_filtered.py
@@ -1,5 +1,4 @@
#!/usr/bin/env python
-# coding: utf-8
"""
This shows how message filtering works.
@@ -9,16 +8,22 @@
import can
-if __name__ == '__main__':
- bus = can.interface.Bus(bustype='socketcan',
- channel='vcan0',
- receive_own_messages=True)
- can_filters = [{"can_id": 1, "can_mask": 0xf, "extended": True}]
- bus.set_filters(can_filters)
- notifier = can.Notifier(bus, [can.Printer()])
- bus.send(can.Message(arbitration_id=1, extended_id=True))
- bus.send(can.Message(arbitration_id=2, extended_id=True))
- bus.send(can.Message(arbitration_id=1, extended_id=False))
+def main():
+ """Send some messages to itself and apply filtering."""
+ 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)
- time.sleep(10)
+ # 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
+ 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__":
+ main()
diff --git a/examples/virtual_can_demo.py b/examples/virtual_can_demo.py
deleted file mode 100644
index b69fb28da..000000000
--- a/examples/virtual_can_demo.py
+++ /dev/null
@@ -1,31 +0,0 @@
-#!/usr/bin/env python
-# coding: utf-8
-
-"""
-This demo creates multiple processes of producers to spam a socketcan bus.
-"""
-
-from time import sleep
-from concurrent.futures import ProcessPoolExecutor
-
-import can
-
-
-def producer(id, message_count=16):
- """Spam the bus with messages including the data id.
-
- :param int id: the id of the thread/process
- """
-
- with can.Bus(bustype='socketcan', channel='vcan0') as bus:
- for i in range(message_count):
- msg = can.Message(arbitration_id=0x0cf02200+id, data=[id, i, 0, 1, 3, 1, 4, 1])
- bus.send(msg)
- sleep(1.0)
-
- print("Producer #{} finished sending {} messages".format(id, message_count))
-
-
-if __name__ == "__main__":
- with ProcessPoolExecutor(max_workers=4) as executor:
- executor.map(producer, range(5))
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 000000000..ddaf61ef5
--- /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.12.*",
+ "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.13.*",
+ "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/scripts/can_logger.py b/scripts/can_logger.py
deleted file mode 100644
index 72a92b9d0..000000000
--- a/scripts/can_logger.py
+++ /dev/null
@@ -1,14 +0,0 @@
-#!/usr/bin/env python
-# coding: utf-8
-
-"""
-See :mod:`can.logger`.
-"""
-
-from __future__ import absolute_import
-
-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 afbd3df6e..000000000
--- a/scripts/can_player.py
+++ /dev/null
@@ -1,14 +0,0 @@
-#!/usr/bin/env python
-# coding: utf-8
-
-"""
-See :mod:`can.player`.
-"""
-
-from __future__ import absolute_import
-
-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 3c9ba738c..000000000
--- a/scripts/can_viewer.py
+++ /dev/null
@@ -1,14 +0,0 @@
-#!/usr/bin/env python
-# coding: utf-8
-
-"""
-See :mod:`can.viewer`.
-"""
-
-from __future__ import absolute_import
-
-from can.viewer import main
-
-
-if __name__ == "__main__":
- main()
diff --git a/setup.cfg b/setup.cfg
deleted file mode 100644
index 21ffc0053..000000000
--- a/setup.cfg
+++ /dev/null
@@ -1,28 +0,0 @@
-[bdist_wheel]
-universal = 1
-
-[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
-omit =
- # legacy code
- can/CAN.py
-
-[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 4aed26e23..000000000
--- a/setup.py
+++ /dev/null
@@ -1,110 +0,0 @@
-#!/usr/bin/env python
-# coding: utf-8
-
-"""
-python-can requires the setuptools package to be installed.
-"""
-
-from __future__ import absolute_import
-
-from os import listdir
-from os.path import isfile, join
-from sys import version_info
-import re
-import logging
-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 = {
- 'serial': ['pyserial ~= 3.0'],
- 'neovi': ['python-ics >= 2.12']
-}
-
-tests_require = [
- 'mock ~= 2.0',
- 'nose ~= 1.3',
- 'pytest ~= 3.6',
- 'pytest-timeout ~= 1.2',
- 'pytest-cov ~= 2.5',
- 'codecov ~= 2.0',
- 'future',
- 'six'
-] + extras_require['serial']
-
-extras_require['test'] = tests_require
-
-
-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 :: 2.7",
- "Programming Language :: Python :: 3.4",
- "Programming Language :: Python :: 3.5",
- "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", "test.*"]),
- 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={
- "": ["CONTRIBUTORS.txt", "LICENSE.txt", "CHANGELOG.txt"],
- "doc": ["*.*"]
- },
-
- # Installation
- # see https://www.python.org/dev/peps/pep-0345/#version-specifiers
- python_requires=">=2.7,!=3.0,!=3.1,!=3.2,!=3.3",
- install_requires=[
- 'wrapt ~= 1.10', 'typing', 'windows-curses;platform_system=="Windows"',
- ],
- extras_require=extras_require,
-
- # Testing
- test_suite="nose.collector",
- 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 5d0034330..ce7c39e2a 100644
--- a/test/back2back_test.py
+++ b/test/back2back_test.py
@@ -1,59 +1,73 @@
#!/usr/bin/env python
-# coding: utf-8
"""
-This module tests two virtual busses attached to each other.
+This module tests two buses attached to each other.
"""
-from __future__ import absolute_import, print_function
-
-import sys
+import random
import unittest
-from time import sleep
-from multiprocessing.dummy import Pool as ThreadPool
+from multiprocessing.dummy import Pool as ThreadPool
+from time import sleep, time
import pytest
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'
- INTERFACE_2 = 'virtual'
- CHANNEL_2 = 'virtual_channel_0'
+ INTERFACE_1 = "virtual"
+ CHANNEL_1 = "virtual_channel_0"
+ INTERFACE_2 = "virtual"
+ CHANNEL_2 = "virtual_channel_0"
def setUp(self):
- self.bus1 = can.Bus(channel=self.CHANNEL_1,
- bustype=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,
- bitrate=self.BITRATE,
- fd=TEST_CAN_FD,
- single_handle=True)
+ self.bus1 = can.Bus(
+ channel=self.CHANNEL_1,
+ interface=self.INTERFACE_1,
+ bitrate=self.BITRATE,
+ fd=TEST_CAN_FD,
+ single_handle=True,
+ )
+ self.bus2 = can.Bus(
+ channel=self.CHANNEL_2,
+ interface=self.INTERFACE_2,
+ bitrate=self.BITRATE,
+ fd=TEST_CAN_FD,
+ single_handle=True,
+ )
def tearDown(self):
self.bus1.shutdown()
self.bus2.shutdown()
- def _check_received_message(self, recv_msg, sent_msg):
- self.assertIsNotNone(recv_msg,
- "No message was received on %s" % self.INTERFACE_2)
+ 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
+ )
self.assertEqual(recv_msg.arbitration_id, sent_msg.arbitration_id)
- self.assertEqual(recv_msg.id_type, sent_msg.id_type)
+ self.assertEqual(recv_msg.is_extended_id, sent_msg.is_extended_id)
self.assertEqual(recv_msg.is_remote_frame, sent_msg.is_remote_frame)
self.assertEqual(recv_msg.is_error_frame, sent_msg.is_error_frame)
self.assertEqual(recv_msg.is_fd, sent_msg.is_fd)
@@ -62,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)
@@ -74,13 +88,23 @@ 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))
- @unittest.skipIf(IS_CI, "the timing sensitive behaviour cannot be reproduced reliably on a CI server")
+ 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",
+ )
def test_timestamp(self):
self.bus2.send(can.Message())
recv_msg1 = self.bus1.recv(self.TIMEOUT)
@@ -88,111 +112,303 @@ def test_timestamp(self):
self.bus2.send(can.Message())
recv_msg2 = self.bus1.recv(self.TIMEOUT)
delta_time = recv_msg2.timestamp - recv_msg1.timestamp
- self.assertTrue(1.75 <= delta_time <= 2.25,
- 'Time difference should have been 2s +/- 250ms.'
- 'But measured {}'.format(delta_time))
+ self.assertTrue(
+ 1.75 <= delta_time <= 2.25,
+ "Time difference should have been 2s +/- 250ms."
+ f"But measured {delta_time}",
+ )
def test_standard_message(self):
- msg = can.Message(extended_id=False,
- arbitration_id=0x100,
- data=[1, 2, 3, 4, 5, 6, 7, 8])
+ msg = can.Message(
+ is_extended_id=False, arbitration_id=0x100, data=[1, 2, 3, 4, 5, 6, 7, 8]
+ )
self._send_and_receive(msg)
def test_extended_message(self):
- msg = can.Message(extended_id=True,
- arbitration_id=0x123456,
- data=[10, 11, 12, 13, 14, 15, 16, 17])
+ msg = can.Message(
+ is_extended_id=True,
+ arbitration_id=0x123456,
+ data=[10, 11, 12, 13, 14, 15, 16, 17],
+ )
self._send_and_receive(msg)
def test_remote_message(self):
- msg = can.Message(extended_id=False,
- arbitration_id=0x200,
- is_remote_frame=True,
- dlc=4)
+ msg = can.Message(
+ is_extended_id=False, arbitration_id=0x200, is_remote_frame=True, dlc=4
+ )
self._send_and_receive(msg)
def test_dlc_less_than_eight(self):
- msg = can.Message(extended_id=False,
- arbitration_id=0x300,
- data=[4, 5, 6])
+ 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,
- extended_id=True,
- arbitration_id=0x56789,
- data=[0xff] * 64)
+ 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,
- bitrate_switch=True,
- extended_id=True,
- arbitration_id=0x98765,
- data=[0xff] * 48)
+ msg = can.Message(
+ is_fd=True,
+ bitrate_switch=True,
+ is_extended_id=True,
+ arbitration_id=0x98765,
+ data=[0xFF] * 48,
+ )
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'
+ 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()
self.regular_bus.shutdown()
def test_broadcast_channel(self):
- self.broadcast_bus.send(can.Message(channel='vcan0'))
+ self.broadcast_bus.send(can.Message(channel="vcan0"))
recv_msg = self.regular_bus.recv(1)
self.assertIsNotNone(recv_msg)
- self.assertEqual(recv_msg.channel, 'vcan0')
+ self.assertEqual(recv_msg.channel, "vcan0")
self.regular_bus.send(can.Message())
recv_msg = self.broadcast_bus.recv(1)
self.assertIsNotNone(recv_msg)
- self.assertEqual(recv_msg.channel, 'vcan0')
+ self.assertEqual(recv_msg.channel, "vcan0")
class TestThreadSafeBus(Back2BackTestCase):
- """Does some testing that is better than nothing.
- """
-
def setUp(self):
- self.bus1 = can.ThreadSafeBus(channel=self.CHANNEL_1,
- bustype=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,
- bitrate=self.BITRATE,
- fd=TEST_CAN_FD,
- single_handle=True)
-
- @pytest.mark.timeout(5.0)
+ self.bus1 = can.ThreadSafeBus(
+ channel=self.CHANNEL_1,
+ interface=self.INTERFACE_1,
+ bitrate=self.BITRATE,
+ fd=TEST_CAN_FD,
+ single_handle=True,
+ )
+ self.bus2 = can.ThreadSafeBus(
+ channel=self.CHANNEL_2,
+ interface=self.INTERFACE_2,
+ bitrate=self.BITRATE,
+ fd=TEST_CAN_FD,
+ single_handle=True,
+ )
+
+ @pytest.mark.timeout(180.0 if IS_PYPY else 5.0)
def test_concurrent_writes(self):
sender_pool = ThreadPool(100)
receiver_pool = ThreadPool(100)
message = can.Message(
arbitration_id=0x123,
- extended_id=True,
+ channel=self.CHANNEL_1,
+ is_extended_id=True,
timestamp=121334.365,
- data=[254, 255, 1, 2]
+ data=[254, 255, 1, 2],
)
workload = 1000 * [message]
@@ -200,12 +416,57 @@ def sender(msg):
self.bus1.send(msg)
def receiver(_):
- result = self.bus2.recv(timeout=2.0)
- self.assertIsNotNone(result)
- self.assertEqual(result, message)
+ return self.bus2.recv()
sender_pool.map_async(sender, workload)
- receiver_pool.map_async(receiver, len(workload) * [None])
+ for msg in receiver_pool.map(receiver, len(workload) * [None]):
+ self.assertIsNotNone(msg)
+ self.assertEqual(message.arbitration_id, msg.arbitration_id)
+ self.assertTrue(message.equals(msg, timestamp_delta=None))
+
+ sender_pool.close()
+ sender_pool.join()
+ receiver_pool.close()
+ receiver_pool.join()
+
+ @pytest.mark.timeout(180.0 if IS_PYPY else 5.0)
+ def test_filtered_bus(self):
+ sender_pool = ThreadPool(100)
+ receiver_pool = ThreadPool(100)
+
+ included_message = can.Message(
+ arbitration_id=0x123,
+ channel=self.CHANNEL_1,
+ is_extended_id=True,
+ timestamp=121334.365,
+ data=[254, 255, 1, 2],
+ )
+ excluded_message = can.Message(
+ arbitration_id=0x02,
+ channel=self.CHANNEL_1,
+ is_extended_id=True,
+ timestamp=121334.300,
+ data=[1, 2, 3],
+ )
+ workload = 500 * [included_message] + 500 * [excluded_message]
+ random.shuffle(workload)
+
+ self.bus2.set_filters([{"can_id": 0x123, "can_mask": 0xFF, "extended": True}])
+
+ def sender(msg):
+ self.bus1.send(msg)
+
+ def receiver(_):
+ return self.bus2.recv()
+
+ sender_pool.map_async(sender, workload)
+ received_msgs = receiver_pool.map(receiver, 500 * [None])
+
+ for msg in received_msgs:
+ self.assertIsNotNone(msg)
+ self.assertEqual(msg.arbitration_id, included_message.arbitration_id)
+ self.assertTrue(included_message.equals(msg, timestamp_delta=None))
+ self.assertEqual(len(received_msgs), 500)
sender_pool.close()
sender_pool.join()
@@ -213,5 +474,5 @@ def receiver(_):
receiver_pool.join()
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
diff --git a/test/config.py b/test/config.py
index 3c37bcbe6..d308a8cc8 100644
--- a/test/config.py
+++ b/test/config.py
@@ -1,32 +1,37 @@
#!/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
-# ############################## Continuos integration
+def env(name: str) -> bool:
+ return environment.get(name, "").lower() in ("yes", "true", "t", "1")
+
+
+# ############################## 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 = environment.get('TRAVIS', '').lower() == 'true'
-IS_APPVEYOR = environment.get('APPVEYOR', '').lower() == 'true'
+IS_TRAVIS = env("TRAVIS")
+IS_GITHUB_ACTIONS = env("GITHUB_ACTIONS")
-IS_CI = IS_TRAVIS or IS_APPVEYOR or \
- environment.get('CI', '').lower() == 'true' or \
- environment.get('CONTINUOUS_INTEGRATION', '').lower() == 'true'
+IS_CI = IS_TRAVIS or IS_GITHUB_ACTIONS or env("CI") or env("CONTINUOUS_INTEGRATION")
+
+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"
+ )
-if IS_APPVEYOR and IS_TRAVIS:
- raise EnvironmentError("IS_APPVEYOR and IS_TRAVIS cannot be both True at the same time")
# ############################## Platforms
@@ -35,18 +40,22 @@
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()}")'
)
-elif not IS_WINDOWS and not IS_LINUX and not IS_OSX:
- raise EnvironmentError("one of IS_WINDOWS, IS_LINUX, IS_OSX has to be True")
+
+
+# ############################## Implementations
+
+IS_PYPY = platform.python_implementation() == "PyPy"
+
# ############################## What tests to run
TEST_CAN_FD = True
-TEST_INTERFACE_SOCKETCAN = IS_CI and IS_LINUX
+TEST_INTERFACE_SOCKETCAN = IS_LINUX and env("TEST_SOCKETCAN")
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 ea9321502..fe87f33b0 100644
--- a/test/contextmanager_test.py
+++ b/test/contextmanager_test.py
@@ -1,22 +1,26 @@
#!/usr/bin/env python
-# coding: utf-8
"""
This module tests the context manager of Bus and Notifier classes
"""
import unittest
+
import can
class ContextManagerTest(unittest.TestCase):
-
def setUp(self):
data = [0, 1, 2, 3, 4, 5, 6, 7]
- self.msg_send = can.Message(extended_id=False, arbitration_id=0x100, data=data)
+ self.msg_send = can.Message(
+ is_extended_id=False, arbitration_id=0x100, data=data
+ )
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()
@@ -24,7 +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
@@ -32,5 +39,5 @@ def test_use_closed_bus(self):
self.assertRaises(can.CanError, bus_send.send, self.msg_send)
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
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 e1a446384..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
@@ -22,7 +21,7 @@ def sort_messages(messages):
:param Iterable[can.Message] messages: a sequence of messages to sort
:rtype: list
"""
- return list(sorted(messages, key=attrgetter('timestamp')))
+ return list(sorted(messages, key=attrgetter("timestamp")))
# some random number
@@ -30,114 +29,158 @@ def sort_messages(messages):
# List of messages of different types that can be used in tests
-TEST_MESSAGES_BASE = [
- Message(
- # empty
- ),
- Message(
- # only data
- data=[0x00, 0x42]
- ),
- Message(
- # no data
- arbitration_id=0xAB, extended_id=False
- ),
- Message(
- # no data
- arbitration_id=0x42, extended_id=True
- ),
- Message(
- # no data
- arbitration_id=0xABCDEF,
- ),
- Message(
- # empty data
- data=[]
- ),
- Message(
- # empty data
- data=[0xFF, 0xFE, 0xFD],
- ),
- Message(
- arbitration_id=0xABCDEF, extended_id=True,
- timestamp=TEST_TIME,
- data=[1, 2, 3, 4, 5, 6, 7, 8]
- ),
- Message(
- arbitration_id=0x123, extended_id=False,
- timestamp=TEST_TIME + 42.42,
- data=[0xff, 0xff]
- ),
- Message(
- arbitration_id=0xDADADA, extended_id=True,
- timestamp=TEST_TIME + .165,
- data=[1, 2, 3, 4, 5, 6, 7, 8]
- ),
- Message(
- arbitration_id=0x123, extended_id=False,
- timestamp=TEST_TIME + .365,
- data=[254, 255]
- ),
- Message(
- arbitration_id=0x768, extended_id=False,
- timestamp=TEST_TIME + 3.165
- ),
-]
-TEST_MESSAGES_BASE = sort_messages(TEST_MESSAGES_BASE)
-
-
-TEST_MESSAGES_REMOTE_FRAMES = [
- Message(
- arbitration_id=0xDADADA, extended_id=True, is_remote_frame=True,
- timestamp=TEST_TIME + .165,
- data=[1, 2, 3, 4, 5, 6, 7, 8]
- ),
- Message(
- arbitration_id=0x123, extended_id=False, is_remote_frame=True,
- timestamp=TEST_TIME + .365,
- data=[254, 255]
- ),
- Message(
- arbitration_id=0x768, extended_id=False, is_remote_frame=True,
- timestamp=TEST_TIME + 3.165
- ),
- Message(
- arbitration_id=0xABCDEF, extended_id=True, is_remote_frame=True,
- timestamp=TEST_TIME + 7858.67
- ),
-]
-TEST_MESSAGES_REMOTE_FRAMES = sort_messages(TEST_MESSAGES_REMOTE_FRAMES)
-
-
-TEST_MESSAGES_ERROR_FRAMES = [
- Message(
- is_error_frame=True
- ),
- Message(
- is_error_frame=True,
- timestamp=TEST_TIME + 0.170
- ),
- Message(
- is_error_frame=True,
- timestamp=TEST_TIME + 17.157
- )
-]
-TEST_MESSAGES_ERROR_FRAMES = sort_messages(TEST_MESSAGES_ERROR_FRAMES)
-
-
-TEST_ALL_MESSAGES = sort_messages(TEST_MESSAGES_BASE + TEST_MESSAGES_REMOTE_FRAMES + \
- TEST_MESSAGES_ERROR_FRAMES)
+TEST_MESSAGES_BASE = sort_messages(
+ [
+ Message(
+ # empty
+ timestamp=1e-4,
+ ),
+ Message(
+ # only data
+ 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
+ timestamp=5e-4,
+ arbitration_id=0xABCDEF,
+ ),
+ Message(
+ # empty data
+ timestamp=6e-4,
+ data=[],
+ ),
+ Message(
+ # empty data
+ timestamp=7e-4,
+ data=[0xFF, 0xFE, 0xFD],
+ ),
+ Message(
+ # with channel as integer
+ timestamp=8e-4,
+ channel=0,
+ ),
+ Message(
+ # with channel as integer
+ timestamp=9e-4,
+ channel=42,
+ ),
+ Message(
+ # with channel as string
+ timestamp=10e-4,
+ channel="vcan0",
+ ),
+ Message(
+ # with channel as string
+ timestamp=11e-4,
+ channel="awesome_channel",
+ ),
+ Message(
+ arbitration_id=0xABCDEF,
+ is_extended_id=True,
+ timestamp=TEST_TIME,
+ data=[1, 2, 3, 4, 5, 6, 7, 8],
+ ),
+ Message(
+ arbitration_id=0x123,
+ is_extended_id=False,
+ timestamp=TEST_TIME + 42.42,
+ data=[0xFF, 0xFF],
+ ),
+ Message(
+ arbitration_id=0xDADADA,
+ is_extended_id=True,
+ timestamp=TEST_TIME + 0.165,
+ data=[1, 2, 3, 4, 5, 6, 7, 8],
+ ),
+ Message(
+ arbitration_id=0x123,
+ is_extended_id=False,
+ timestamp=TEST_TIME + 0.365,
+ data=[254, 255],
+ ),
+ Message(
+ arbitration_id=0x768, is_extended_id=False, timestamp=TEST_TIME + 3.165
+ ),
+ ]
+)
+
+
+TEST_MESSAGES_CAN_FD = sort_messages(
+ [
+ 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),
+ ]
+)
+
+
+TEST_MESSAGES_REMOTE_FRAMES = sort_messages(
+ [
+ Message(
+ arbitration_id=0xDADADA,
+ is_extended_id=True,
+ is_remote_frame=True,
+ timestamp=TEST_TIME + 0.165,
+ ),
+ Message(
+ arbitration_id=0x123,
+ is_extended_id=False,
+ is_remote_frame=True,
+ timestamp=TEST_TIME + 0.365,
+ ),
+ Message(
+ arbitration_id=0x768,
+ is_extended_id=False,
+ is_remote_frame=True,
+ timestamp=TEST_TIME + 3.165,
+ ),
+ Message(
+ arbitration_id=0xABCDEF,
+ is_extended_id=True,
+ is_remote_frame=True,
+ timestamp=TEST_TIME + 7858.67,
+ ),
+ ]
+)
+
+
+TEST_MESSAGES_ERROR_FRAMES = sort_messages(
+ [
+ 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),
+ ]
+)
+
+
+TEST_ALL_MESSAGES = sort_messages(
+ TEST_MESSAGES_BASE + TEST_MESSAGES_REMOTE_FRAMES + TEST_MESSAGES_ERROR_FRAMES
+)
TEST_COMMENTS = [
"This is the first comment",
- "", # empty comment
+ "", # empty comment
"This third comment contains some strange characters: 'ä\"§$%&/()=?__::_Öüßêè and ends here.",
(
- "This fourth comment is quite long! " \
- "Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. " \
- "Duis autem vel eum iriure dolor in hendrerit in vulputate velit esse molestie consequat, vel illum dolore eu feugiat nulla facilisis at vero eros et accumsan et iusto odio dignissim qui blandit praesent luptatum zzril delenit augue duis dolore te feugait nulla facilisi. Lorem ipsum dolor sit amet, consectetuer adipiscing elit, sed diam nonummy nibh euismod tincidunt ut laoreet dolore magna aliquam erat volutpat. " \
- "Ut wisi enim ad minim veniam, quis nostrud exerci tation ullamcorper suscipit lobortis nisl ut aliquip ex ea commodo consequat. Duis autem vel eum iriure dolor in hendrerit in vulputate velit esse molestie consequat, vel illum dolore eu feugiat nulla facilisis at vero eros et accumsan et iusto odio dignissim qui blandit praesent luptatum zzril delenit augue duis dolore te feugait nulla facilisi." \
+ "This fourth comment is quite long! "
+ "Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. "
+ "Duis autem vel eum iriure dolor in hendrerit in vulputate velit esse molestie consequat, vel illum dolore eu feugiat nulla facilisis at vero eros et accumsan et iusto odio dignissim qui blandit praesent luptatum zzril delenit augue duis dolore te feugait nulla facilisi. Lorem ipsum dolor sit amet, consectetuer adipiscing elit, sed diam nonummy nibh euismod tincidunt ut laoreet dolore magna aliquam erat volutpat. "
+ "Ut wisi enim ad minim veniam, quis nostrud exerci tation ullamcorper suscipit lobortis nisl ut aliquip ex ea commodo consequat. Duis autem vel eum iriure dolor in hendrerit in vulputate velit esse molestie consequat, vel illum dolore eu feugiat nulla facilisis at vero eros et accumsan et iusto odio dignissim qui blandit praesent luptatum zzril delenit augue duis dolore te feugait nulla facilisi."
),
]
@@ -147,5 +190,10 @@ 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)])
- return Message(arbitration_id=arbitration_id, data=data, extended_id=False, timestamp=TEST_TIME)
+ data = bytearray([random.randrange(0, 2**8 - 1) for _ in range(8)])
+ return Message(
+ arbitration_id=arbitration_id,
+ data=data,
+ is_extended_id=False,
+ timestamp=TEST_TIME,
+ )
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 4b7c64363..13274a4c4 100644
--- a/test/data/logfile.asc
+++ b/test/data/logfile.asc
@@ -1,18 +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%
- 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%
- 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.blf b/test/data/logfile.blf
deleted file mode 100644
index 98cafe214..000000000
Binary files a/test/data/logfile.blf and /dev/null differ
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_CanErrorFrameExt.blf b/test/data/test_CanErrorFrameExt.blf
new file mode 100644
index 000000000..f7ea6eb35
Binary files /dev/null and b/test/data/test_CanErrorFrameExt.blf differ
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_CanFdMessage.blf b/test/data/test_CanFdMessage.blf
new file mode 100644
index 000000000..55b48bfe4
Binary files /dev/null and b/test/data/test_CanFdMessage.blf differ
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_CanFdMessage64.blf b/test/data/test_CanFdMessage64.blf
new file mode 100644
index 000000000..f26eccfde
Binary files /dev/null and b/test/data/test_CanFdMessage64.blf differ
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.blf b/test/data/test_CanMessage.blf
new file mode 100644
index 000000000..f0ad20365
Binary files /dev/null and b/test/data/test_CanMessage.blf 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_CanMessage2.blf b/test/data/test_CanMessage2.blf
new file mode 100644
index 000000000..6beb4fa43
Binary files /dev/null and b/test/data/test_CanMessage2.blf differ
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 c25a6fb56..bbcbed56e 100644
--- a/test/listener_test.py
+++ b/test/listener_test.py
@@ -1,27 +1,19 @@
#!/usr/bin/env python
-# coding: utf-8
-"""
-"""
-
-from __future__ import absolute_import, print_function
-
-from time import sleep
-import unittest
-import random
+""" """
+import asyncio
import logging
-import tempfile
-import sqlite3
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
@@ -29,46 +21,48 @@
class ListenerImportTest(unittest.TestCase):
-
def testClassesImportable(self):
- self.assertTrue(hasattr(can, 'Listener'))
- self.assertTrue(hasattr(can, 'BufferedReader'))
- self.assertTrue(hasattr(can, 'Notifier'))
- self.assertTrue(hasattr(can, 'Logger'))
+ self.assertTrue(hasattr(can, "Listener"))
+ self.assertTrue(hasattr(can, "BufferedReader"))
+ self.assertTrue(hasattr(can, "Notifier"))
+ self.assertTrue(hasattr(can, "Logger"))
- self.assertTrue(hasattr(can, 'ASCWriter'))
- self.assertTrue(hasattr(can, 'ASCReader'))
+ self.assertTrue(hasattr(can, "ASCWriter"))
+ self.assertTrue(hasattr(can, "ASCReader"))
- self.assertTrue(hasattr(can, 'BLFReader'))
- self.assertTrue(hasattr(can, 'BLFWriter'))
+ self.assertTrue(hasattr(can, "BLFReader"))
+ self.assertTrue(hasattr(can, "BLFWriter"))
- self.assertTrue(hasattr(can, 'CSVReader'))
- self.assertTrue(hasattr(can, 'CSVWriter'))
+ self.assertTrue(hasattr(can, "CSVReader"))
+ self.assertTrue(hasattr(can, "CSVWriter"))
- self.assertTrue(hasattr(can, 'CanutilsLogWriter'))
- self.assertTrue(hasattr(can, 'CanutilsLogReader'))
+ self.assertTrue(hasattr(can, "CanutilsLogWriter"))
+ self.assertTrue(hasattr(can, "CanutilsLogReader"))
- self.assertTrue(hasattr(can, 'SqliteReader'))
- self.assertTrue(hasattr(can, 'SqliteWriter'))
+ self.assertTrue(hasattr(can, "SqliteReader"))
+ self.assertTrue(hasattr(can, "SqliteWriter"))
- self.assertTrue(hasattr(can, 'Printer'))
+ self.assertTrue(hasattr(can, "Printer"))
- self.assertTrue(hasattr(can, 'LogReader'))
+ self.assertTrue(hasattr(can, "LogReader"))
- self.assertTrue(hasattr(can, 'MessageSync'))
+ self.assertTrue(hasattr(can, "MessageSync"))
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):
-
def testBasicListenerCanBeAddedToNotifier(self):
a_listener = can.Printer()
notifier = can.Notifier(self.bus, [a_listener], 0.1)
@@ -93,14 +87,18 @@ 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
- file_handler = open(join(dirname(__file__), "data/logfile.blf"))
+ file_handler = open(
+ join(dirname(__file__), "data", "test_CanMessage.blf")
+ )
else:
delete = True
- file_handler = tempfile.NamedTemporaryFile(suffix=extension, delete=False)
+ file_handler = tempfile.NamedTemporaryFile(
+ suffix=extension, delete=False
+ )
with file_handler as my_file:
filename = my_file.name
@@ -113,18 +111,22 @@ def test_filetype_to_instance(extension, klass):
test_filetype_to_instance(".asc", can.ASCReader)
test_filetype_to_instance(".blf", can.BLFReader)
test_filetype_to_instance(".csv", can.CSVReader)
- test_filetype_to_instance(".db" , can.SqliteReader)
+ test_filetype_to_instance(".db", can.SqliteReader)
test_filetype_to_instance(".log", can.CanutilsLogReader)
- # test file extensions that are not supported
- with self.assertRaisesRegexp(NotImplementedError, ".xyz_42"):
- test_filetype_to_instance(".xyz_42", can.Printer)
+ def testPlayerTypeResolutionUnsupportedFileTypes(self):
+ for should_fail_with in ["", ".", ".some_unknown_extention_42"]:
+ with self.assertRaises(ValueError):
+ with can.LogReader(should_fail_with): # make sure we close it anyways
+ pass
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) as my_file:
+ with tempfile.NamedTemporaryFile(
+ suffix=extension, delete=False
+ ) as my_file:
filename = my_file.name
with can.Logger(filename) as writer:
self.assertIsInstance(writer, klass)
@@ -134,17 +136,19 @@ def test_filetype_to_instance(extension, klass):
test_filetype_to_instance(".asc", can.ASCWriter)
test_filetype_to_instance(".blf", can.BLFWriter)
test_filetype_to_instance(".csv", can.CSVWriter)
- test_filetype_to_instance(".db" , can.SqliteWriter)
+ test_filetype_to_instance(".db", can.SqliteWriter)
test_filetype_to_instance(".log", can.CanutilsLogWriter)
test_filetype_to_instance(".txt", can.Printer)
- # test file extensions that should use a fallback
- test_filetype_to_instance("", can.Printer)
- test_filetype_to_instance(".", can.Printer)
- test_filetype_to_instance(".some_unknown_extention_42", can.Printer)
with can.Logger(None) as logger:
self.assertIsInstance(logger, can.Printer)
+ def testLoggerTypeResolutionUnsupportedFileTypes(self):
+ for should_fail_with in ["", ".", ".some_unknown_extention_42"]:
+ with self.assertRaises(ValueError):
+ with can.Logger(should_fail_with): # make sure we close it anyways
+ pass
+
def testBufferedListenerReceives(self):
a_listener = can.BufferedReader()
a_listener(generate_message(0xDADADA))
@@ -154,5 +158,22 @@ def testBufferedListenerReceives(self):
self.assertIsNotNone(a_listener.get_message(0.1))
-if __name__ == '__main__':
+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 2a315352d..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.*
@@ -10,46 +9,114 @@
different writer/reader pairs - e.g., some don't handle error frames and
comments.
-TODO: implement CAN FD support testing
+TODO: correctly set preserves_channel and adds_default_channel
"""
-
-from __future__ import print_function, absolute_import, division
-
+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
-try:
- # Python 3
- from itertools import zip_longest
-except ImportError:
- # Python 2
- from itertools import izip_longest as zip_longest
+from parameterized import parameterized
import can
-
-from .data.example_data import TEST_MESSAGES_BASE, TEST_MESSAGES_REMOTE_FRAMES, \
- TEST_MESSAGES_ERROR_FRAMES, TEST_COMMENTS, \
- sort_messages
+from can.io import blf
+from .data.example_data import (
+ TEST_COMMENTS,
+ TEST_MESSAGES_BASE,
+ TEST_MESSAGES_CAN_FD,
+ 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):
+class ReaderWriterTest(unittest.TestCase, ComparingMessagesTestCase, metaclass=ABCMeta):
"""Tests a pair of writer and reader by writing all data first and
then reading all data and checking if they could be reconstructed
correctly. Optionally writes some comments as well.
+ .. note::
+ This class is prevented from being executed as a test
+ case itself by a *del* statement in at the end of the file.
+ (Source: `*Wojciech B.* on StackOverlfow `_)
"""
- __test__ = False
-
- __metaclass__ = ABCMeta
-
def __init__(self, *args, **kwargs):
- super(ReaderWriterTest, self).__init__(*args, **kwargs)
+ unittest.TestCase.__init__(self, *args, **kwargs)
self._setup_instance()
@abstractmethod
@@ -57,31 +124,48 @@ def _setup_instance(self):
"""Hook for subclasses."""
raise NotImplementedError()
- def _setup_instance_helper(self,
- writer_constructor, reader_constructor, binary_file=False,
- check_remote_frames=True, check_error_frames=True, check_comments=False,
- test_append=False, round_timestamps=False):
+ def _setup_instance_helper(
+ self,
+ writer_constructor,
+ reader_constructor,
+ binary_file=False,
+ check_remote_frames=True,
+ check_error_frames=True,
+ check_fd=True,
+ check_comments=False,
+ test_append=False,
+ 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
:param Callable reader_constructor: the constructor of the reader class
+ :param bool binary_file: if True, opens files in binary and not in text mode
:param bool check_remote_frames: if True, also tests remote frames
:param bool check_error_frames: if True, also tests error frames
+ :param bool check_fd: if True, also tests CAN FD frames
:param bool check_comments: if True, also inserts comments at some
locations and checks if they are contained anywhere literally
in the resulting file. The locations as selected randomly
but deterministically, which makes the test reproducible.
:param bool test_append: tests the writer in append mode as well
- :param bool round_timestamps: if True, rounds timestamps using :meth:`~builtin.round`
- before comparing the read messages/events
+ :param float or int or None allowed_timestamp_delta: directly passed to :meth:`can.Message.equals`
+ :param bool preserves_channel: if True, checks that the channel attribute is preserved
+ :param any adds_default_channel: sets this as the channel when not other channel was given
+ ignored, if *preserves_channel* is True
"""
# get all test messages
- self.original_messages = TEST_MESSAGES_BASE
+ self.original_messages = list(TEST_MESSAGES_BASE)
if check_remote_frames:
self.original_messages += TEST_MESSAGES_REMOTE_FRAMES
if check_error_frames:
self.original_messages += TEST_MESSAGES_ERROR_FRAMES
+ if check_fd:
+ self.original_messages += TEST_MESSAGES_CAN_FD
# sort them so that for example ASCWriter does not "fix" any messages with timestamp 0.0
self.original_messages = sort_messages(self.original_messages)
@@ -90,9 +174,12 @@ def _setup_instance_helper(self,
# we check this because of the lack of a common base class
# we filter for not starts with '__' so we do not get all the builtin
# methods when logging to the console
- attrs = [attr for attr in dir(writer_constructor) if not attr.startswith('__')]
- assert 'log_event' in attrs, \
- "cannot check comments with this writer: {}".format(writer_constructor)
+ attrs = [
+ attr for attr in dir(writer_constructor) if not attr.startswith("__")
+ ]
+ assert (
+ "log_event" in attrs
+ ), f"cannot check comments with this writer: {writer_constructor}"
# get all test comments
self.original_comments = TEST_COMMENTS if check_comments else ()
@@ -101,10 +188,17 @@ def _setup_instance_helper(self,
self.reader_constructor = reader_constructor
self.binary_file = binary_file
self.test_append_enabled = test_append
- self.round_timestamps = round_timestamps
+ self.assert_file_closed = assert_file_closed
+
+ ComparingMessagesTestCase.__init__(
+ self,
+ allowed_timestamp_delta=allowed_timestamp_delta,
+ preserves_channel=preserves_channel,
+ )
+ # adds_default_channel=adds_default_channel # TODO inlcude in tests
def setUp(self):
- with tempfile.NamedTemporaryFile('w+', delete=False) as test_file:
+ with tempfile.NamedTemporaryFile("w+", delete=False) as test_file:
self.test_file_name = test_file.name
def tearDown(self):
@@ -120,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")
@@ -128,15 +222,18 @@ 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
# could use assertCountEqual in later versions of Python and in the other methods
- self.assertEqual(len(read_messages), len(self.original_messages),
- "the number of written messages does not match the number of read messages")
+ self.assertEqual(
+ len(read_messages),
+ len(self.original_messages),
+ "the number of written messages does not match the number of read messages",
+ )
- self.assertMessagesEqual(read_messages)
+ self.assertMessagesEqual(self.original_messages, read_messages)
self.assertIncludesComments(self.test_file_name)
def test_path_like_context_manager(self):
@@ -148,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
@@ -156,14 +253,17 @@ 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;
- self.assertEqual(len(read_messages), len(self.original_messages),
- "the number of written messages does not match the number of read messages")
+ # check if at least the number of messages matches;
+ self.assertEqual(
+ len(read_messages),
+ len(self.original_messages),
+ "the number of written messages does not match the number of read messages",
+ )
- self.assertMessagesEqual(read_messages)
+ self.assertMessagesEqual(self.original_messages, read_messages)
self.assertIncludesComments(self.test_file_name)
def test_file_like_explicit_stop(self):
@@ -171,29 +271,32 @@ def test_file_like_explicit_stop(self):
# create writer
print("writing all messages/comments")
- my_file = open(self.test_file_name, 'wb' if self.binary_file else 'w')
+ my_file = open(self.test_file_name, "wb" if self.binary_file else "w")
writer = self.writer_constructor(my_file)
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")
- my_file = open(self.test_file_name, 'rb' if self.binary_file else 'r')
+ my_file = open(self.test_file_name, "rb" if self.binary_file else "r")
reader = self.reader_constructor(my_file)
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
# could use assertCountEqual in later versions of Python and in the other methods
- self.assertEqual(len(read_messages), len(self.original_messages),
- "the number of written messages does not match the number of read messages")
+ self.assertEqual(
+ len(read_messages),
+ len(self.original_messages),
+ "the number of written messages does not match the number of read messages",
+ )
- self.assertMessagesEqual(read_messages)
+ self.assertMessagesEqual(self.original_messages, read_messages)
self.assertIncludesComments(self.test_file_name)
def test_file_like_context_manager(self):
@@ -201,28 +304,31 @@ def test_file_like_context_manager(self):
# create writer
print("writing all messages/comments")
- my_file = open(self.test_file_name, 'wb' if self.binary_file else 'w')
+ my_file = open(self.test_file_name, "wb" if self.binary_file else "w")
with self.writer_constructor(my_file) as writer:
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
print("reading all messages")
- my_file = open(self.test_file_name, 'rb' if self.binary_file else 'r')
+ my_file = open(self.test_file_name, "rb" if self.binary_file else "r")
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;
- self.assertEqual(len(read_messages), len(self.original_messages),
- "the number of written messages does not match the number of read messages")
+ # check if at least the number of messages matches;
+ self.assertEqual(
+ len(read_messages),
+ len(self.original_messages),
+ "the number of written messages does not match the number of read messages",
+ )
- self.assertMessagesEqual(read_messages)
+ self.assertMessagesEqual(self.original_messages, read_messages)
self.assertIncludesComments(self.test_file_name)
def test_append_mode(self):
@@ -233,8 +339,8 @@ def test_append_mode(self):
raise unittest.SkipTest("do not test append mode")
count = len(self.original_messages)
- first_part = self.original_messages[:count // 2]
- second_part = self.original_messages[count // 2:]
+ first_part = self.original_messages[: count // 2]
+ second_part = self.original_messages[count // 2 :]
# write first half
with self.writer_constructor(self.test_file_name) as writer:
@@ -245,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:
@@ -259,45 +365,27 @@ def test_append_mode(self):
with self.reader_constructor(self.test_file_name) as reader:
read_messages = list(reader)
- self.assertMessagesEqual(read_messages)
+ self.assertMessagesEqual(self.original_messages, read_messages)
def _write_all(self, writer):
"""Writes messages and insert comments here and there."""
# Note: we make no assumptions about the length of original_messages and original_comments
- for msg, comment in zip_longest(self.original_messages, self.original_comments, fillvalue=None):
+ for msg, comment in zip_longest(
+ self.original_messages, self.original_comments, fillvalue=None
+ ):
# msg and comment might be None
if comment is not None:
print("writing comment: ", comment)
- writer.log_event(comment) # we already know that this method exists
+ writer.log_event(comment) # we already know that this method exists
if msg is not None:
print("writing message: ", msg)
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())
- def assertMessagesEqual(self, read_messages):
- """
- Checks the order and content of the individual messages.
- """
- for index, (original, read) in enumerate(zip(self.original_messages, read_messages)):
- try:
- # check everything except the timestamp
- self.assertEqual(original, read, "messages are not equal at index #{}".format(index))
- # check the timestamp
- if self.round_timestamps:
- original.timestamp = round(original.timestamp)
- read.timestamp = round(read.timestamp)
- self.assertAlmostEqual(read.timestamp, original.timestamp, places=6,
- msg="message timestamps are not almost_equal at index #{} ({!r} !~= {!r})"
- .format(index, original.timestamp, read.timestamp))
- except:
- print("Comparing: original message: {!r}".format(original))
- print(" read message: {!r}".format(read))
- raise
-
def assertIncludesComments(self, filename):
"""
Ensures that all comments are literally contained in the given file.
@@ -306,7 +394,7 @@ def assertIncludesComments(self, filename):
"""
if self.original_comments:
# read the entire outout file
- with open(filename, 'rb' if self.binary_file else 'r') as file:
+ with open(filename, "rb" if self.binary_file else "r") as file:
output_contents = file.read()
# check each, if they can be found in there literally
for comment in self.original_comments:
@@ -316,79 +404,510 @@ def assertIncludesComments(self, filename):
class TestAscFileFormat(ReaderWriterTest):
"""Tests can.ASCWriter and can.ASCReader"""
- __test__ = True
+ FORMAT_START_OF_FILE_DATE = "%a %b %d %I:%M:%S.%f %p %Y"
def _setup_instance(self):
- super(TestAscFileFormat, self)._setup_instance_helper(
- can.ASCWriter, can.ASCReader,
- check_comments=True, round_timestamps=True
+ super()._setup_instance_helper(
+ can.ASCWriter,
+ can.ASCReader,
+ 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"""
+ """Tests can.BLFWriter and can.BLFReader.
- __test__ = True
+ Uses log files created by Toby Lorenz:
+ https://bitbucket.org/tobylorenz/vector_blf/src/master/src/Vector/BLF/tests/unittests/events_from_binlog/
+ """
def _setup_instance(self):
- super(TestBlfFileFormat, self)._setup_instance_helper(
- can.BLFWriter, can.BLFReader,
+ super()._setup_instance_helper(
+ can.BLFWriter,
+ can.BLFReader,
binary_file=True,
- check_comments=False
+ check_fd=True,
+ check_comments=False,
+ test_append=True,
+ preserves_channel=False,
+ adds_default_channel=0,
)
- def test_read_known_file(self):
- logfile = os.path.join(os.path.dirname(__file__), "data", "logfile.blf")
+ def _read_log_file(self, filename):
+ logfile = os.path.join(os.path.dirname(__file__), "data", filename)
with can.BLFReader(logfile) as reader:
- messages = list(reader)
- self.assertEqual(len(messages), 2)
- self.assertEqual(messages[0],
- can.Message(
- extended_id=False,
- arbitration_id=0x64,
- data=[0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]))
- self.assertEqual(messages[0].channel, 0)
- self.assertEqual(messages[1],
- can.Message(
- is_error_frame=True,
- extended_id=True,
- arbitration_id=0x1FFFFFFF))
- self.assertEqual(messages[1].channel, 0)
+ return list(reader)
+
+ def test_can_message(self):
+ expected = can.Message(
+ timestamp=2459565876.494607,
+ arbitration_id=0x4444444,
+ is_extended_id=False,
+ channel=0x1110,
+ dlc=0x33,
+ data=[0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC],
+ )
+ actual = self._read_log_file("test_CanMessage.blf")
+ self.assertMessagesEqual(actual, [expected] * 2)
+ self.assertEqual(actual[0].channel, expected.channel)
+
+ def test_can_message_2(self):
+ expected = can.Message(
+ timestamp=2459565876.494607,
+ arbitration_id=0x4444444,
+ is_extended_id=False,
+ channel=0x1110,
+ dlc=0x33,
+ data=[0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC],
+ )
+ actual = self._read_log_file("test_CanMessage2.blf")
+ self.assertMessagesEqual(actual, [expected] * 2)
+ self.assertEqual(actual[0].channel, expected.channel)
+
+ def test_can_fd_message(self):
+ expected = can.Message(
+ timestamp=2459565876.494607,
+ arbitration_id=0x4444444,
+ is_extended_id=False,
+ channel=0x1110,
+ dlc=64,
+ is_fd=True,
+ bitrate_switch=True,
+ error_state_indicator=True,
+ data=range(64),
+ )
+ actual = self._read_log_file("test_CanFdMessage.blf")
+ self.assertMessagesEqual(actual, [expected] * 2)
+ self.assertEqual(actual[0].channel, expected.channel)
+
+ def test_can_fd_message_64(self):
+ expected = can.Message(
+ timestamp=2459565876.494607,
+ arbitration_id=0x15555555,
+ is_extended_id=False,
+ is_remote_frame=True,
+ channel=0x10,
+ dlc=64,
+ is_fd=True,
+ is_rx=False,
+ bitrate_switch=True,
+ error_state_indicator=True,
+ )
+ actual = self._read_log_file("test_CanFdMessage64.blf")
+ self.assertMessagesEqual(actual, [expected] * 2)
+ self.assertEqual(actual[0].channel, expected.channel)
+
+ def test_can_error_frame_ext(self):
+ expected = can.Message(
+ timestamp=2459565876.494607,
+ is_error_frame=True,
+ arbitration_id=0x19999999,
+ is_extended_id=True,
+ channel=0x1110,
+ dlc=0x66,
+ data=[0xCC, 0xDD, 0xEE, 0xFF, 0x11, 0x22, 0x33, 0x44],
+ )
+ actual = self._read_log_file("test_CanErrorFrameExt.blf")
+ 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"""
- __test__ = True
-
def _setup_instance(self):
- super(TestCanutilsFileFormat, self)._setup_instance_helper(
- can.CanutilsLogWriter, can.CanutilsLogReader,
- test_append=True, check_comments=False
+ super()._setup_instance_helper(
+ can.CanutilsLogWriter,
+ can.CanutilsLogReader,
+ check_fd=True,
+ test_append=True,
+ check_comments=False,
+ preserves_channel=False,
+ adds_default_channel="vcan0",
)
class TestCsvFileFormat(ReaderWriterTest):
- """Tests can.ASCWriter and can.ASCReader"""
+ """Tests can.CSVWriter and can.CSVReader"""
+
+ def _setup_instance(self):
+ super()._setup_instance_helper(
+ can.CSVWriter,
+ can.CSVReader,
+ check_fd=False,
+ test_append=True,
+ check_comments=False,
+ preserves_channel=False,
+ adds_default_channel=None,
+ )
- __test__ = True
+
+@unittest.skipIf(asammdf is None, "MF4 is unavailable")
+class TestMF4FileFormat(ReaderWriterTest):
+ """Tests can.MF4Writer and can.MF4Reader"""
def _setup_instance(self):
- super(TestCsvFileFormat, self)._setup_instance_helper(
- can.CSVWriter, can.CSVReader,
- test_append=True, check_comments=False
+ 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"""
- __test__ = True
-
def _setup_instance(self):
- super(TestSqliteDatabaseFormat, self)._setup_instance_helper(
- can.SqliteWriter, can.SqliteReader,
- test_append=True, check_comments=False
+ super()._setup_instance_helper(
+ can.SqliteWriter,
+ can.SqliteReader,
+ check_fd=False,
+ test_append=True,
+ check_comments=False,
+ preserves_channel=False,
+ adds_default_channel=None,
+ assert_file_closed=False,
)
@unittest.skip("not implemented")
@@ -413,17 +932,28 @@ def test_read_all(self):
with self.reader_constructor(self.test_file_name) as reader:
read_messages = list(reader.read_all())
- # check if at least the number of messages matches;
- self.assertEqual(len(read_messages), len(self.original_messages),
- "the number of written messages does not match the number of read messages")
+ # check if at least the number of messages matches;
+ self.assertEqual(
+ len(read_messages),
+ len(self.original_messages),
+ "the number of written messages does not match the number of read messages",
+ )
- self.assertMessagesEqual(read_messages)
+ self.assertMessagesEqual(self.original_messages, read_messages)
class TestPrinter(unittest.TestCase):
- """Tests that can.Printer does not crash"""
+ """Tests that can.Printer does not crash.
+
+ TODO test append mode
+ """
- messages = TEST_MESSAGES_BASE + TEST_MESSAGES_REMOTE_FRAMES + TEST_MESSAGES_ERROR_FRAMES
+ messages = (
+ TEST_MESSAGES_BASE
+ + TEST_MESSAGES_REMOTE_FRAMES
+ + TEST_MESSAGES_ERROR_FRAMES
+ + TEST_MESSAGES_CAN_FD
+ )
def test_not_crashes_with_stdout(self):
with can.Printer() as printer:
@@ -431,11 +961,168 @@ 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)
-if __name__ == '__main__':
+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__":
unittest.main()
diff --git a/test/message_helper.py b/test/message_helper.py
new file mode 100644
index 000000000..d10e9195f
--- /dev/null
+++ b/test/message_helper.py
@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+
+"""
+This module contains a helper for writing test cases that need to compare messages.
+"""
+
+
+class ComparingMessagesTestCase:
+ """
+ Must be extended by a class also extending a unittest.TestCase.
+
+ .. note:: This class does not extend unittest.TestCase so it does not get
+ run as a test itself.
+ """
+
+ def __init__(self, allowed_timestamp_delta=0.0, preserves_channel=True):
+ """
+ :param float or int or None allowed_timestamp_delta: directly passed to :meth:`can.Message.equals`
+ :param bool preserves_channel: if True, checks that the channel attribute is preserved
+ """
+ self.allowed_timestamp_delta = allowed_timestamp_delta
+ self.preserves_channel = preserves_channel
+
+ def assertMessageEqual(self, message_1, message_2):
+ """
+ Checks that two messages are equal, according to the given rules.
+ """
+
+ 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):
+ """
+ Checks the order and content of the individual messages pairwise.
+ Raises an error if the lengths of the sequences are not equal.
+ """
+ self.assertEqual(
+ len(messages_1), len(messages_2), "the number of messages differs"
+ )
+
+ for message_1, message_2 in zip(messages_1, messages_2):
+ self.assertMessageEqual(message_1, message_2)
diff --git a/test/network_test.py b/test/network_test.py
index 830adceca..3a231dff7 100644
--- a/test/network_test.py
+++ b/test/network_test.py
@@ -1,29 +1,21 @@
#!/usr/bin/env python
-# coding: utf-8
-
-from __future__ import print_function
-
-import unittest
-import threading
-try:
- import queue
-except ImportError:
- import Queue as queue
+import contextlib
+import logging
import random
+import threading
+import unittest
+
+import can
+from test.config import IS_PYPY
-import logging
logging.getLogger(__file__).setLevel(logging.WARNING)
-# make a random bool:
-rbool = lambda: bool(round(random.random()))
-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.
@@ -43,77 +35,66 @@ class ControllerAreaNetworkTestCase(unittest.TestCase):
extended_flags = [rbool() for _ in range(num_messages)]
ids = list(range(num_messages))
- data = list(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],
- 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)
+ data = list(
+ bytearray([random.randrange(0, 2**8 - 1) for a in range(random.randrange(9))])
+ for b in range(num_messages)
+ )
+
+ 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.id_type, 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()
-
-if __name__ == '__main__':
+ 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__":
unittest.main()
diff --git a/test/notifier_test.py b/test/notifier_test.py
index ca462a2ad..d8512a00b 100644
--- a/test/notifier_test.py
+++ b/test/notifier_test.py
@@ -1,64 +1,93 @@
#!/usr/bin/env python
-# coding: utf-8
-import unittest
+
+import asyncio
import time
-try:
- import asyncio
-except ImportError:
- asyncio = None
+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)
-class AsyncNotifierTest(unittest.TestCase):
+ 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,))
- @unittest.skipIf(asyncio is None, 'Test requires asyncio')
+ # 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__':
+if __name__ == "__main__":
unittest.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 da67cfaa2..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.
@@ -8,16 +7,23 @@
"""
import unittest
-from mock import patch
+from unittest.mock import patch
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:
"""
Dummy to mock the serial communication
"""
+
msg = None
def __init__(self):
@@ -36,9 +42,17 @@ def reset(self):
self.msg = None
-class SimpleSerialTestBase(object):
+class SimpleSerialTestBase(ComparingMessagesTestCase):
MAX_TIMESTAMP = 0xFFFFFFFF / 1000
+ def __init__(self):
+ ComparingMessagesTestCase.__init__(
+ 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
@@ -47,7 +61,7 @@ def test_rx_tx_min_max_data(self):
msg = can.Message(data=[b])
self.bus.send(msg)
msg_receive = self.bus.recv()
- self.assertEqual(msg, msg_receive)
+ self.assertMessageEqual(msg, msg_receive)
def test_rx_tx_min_max_dlc(self):
"""
@@ -59,7 +73,7 @@ def test_rx_tx_min_max_dlc(self):
msg = can.Message(data=payload)
self.bus.send(msg)
msg_receive = self.bus.recv()
- self.assertEqual(msg, msg_receive)
+ self.assertMessageEqual(msg, msg_receive)
def test_rx_tx_data_none(self):
"""
@@ -68,25 +82,43 @@ def test_rx_tx_data_none(self):
msg = can.Message(data=None)
self.bus.send(msg)
msg_receive = self.bus.recv()
- self.assertEqual(msg, msg_receive)
+ 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 arbitration id
+ Tests the transfer with the lowest standard arbitration id
"""
- msg = can.Message(arbitration_id=0)
+ msg = can.Message(arbitration_id=0, is_extended_id=False)
self.bus.send(msg)
msg_receive = self.bus.recv()
- self.assertEqual(msg, msg_receive)
+ self.assertMessageEqual(msg, msg_receive)
- def test_rx_tx_max_id(self):
+ def test_rx_tx_max_std_id(self):
"""
- Tests the transfer with the highest arbitration id
+ Tests the transfer with the highest standard arbitration id
"""
- msg = can.Message(arbitration_id=536870911)
+ msg = can.Message(arbitration_id=0x7FF, is_extended_id=False)
self.bus.send(msg)
msg_receive = self.bus.recv()
- self.assertEqual(msg, msg_receive)
+ self.assertMessageEqual(msg, msg_receive)
+
+ def test_rx_tx_min_ext_id(self):
+ """
+ Tests the transfer with the lowest extended arbitration id
+ """
+ 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_ext_id(self):
+ """
+ Tests the transfer with the highest extended arbitration id
+ """
+ msg = can.Message(arbitration_id=0x1FFFFFFF, is_extended_id=True)
+ self.bus.send(msg)
+ msg_receive = self.bus.recv()
+ self.assertMessageEqual(msg, msg_receive)
def test_rx_tx_max_timestamp(self):
"""
@@ -96,14 +128,14 @@ def test_rx_tx_max_timestamp(self):
msg = can.Message(timestamp=self.MAX_TIMESTAMP)
self.bus.send(msg)
msg_receive = self.bus.recv()
- self.assertEqual(msg, msg_receive)
+ self.assertMessageEqual(msg, msg_receive)
self.assertEqual(msg.timestamp, msg_receive.timestamp)
def test_rx_tx_max_timestamp_error(self):
"""
Tests for an exception with an out of range timestamp (max + 1)
"""
- msg = can.Message(timestamp=self.MAX_TIMESTAMP+1)
+ msg = can.Message(timestamp=self.MAX_TIMESTAMP + 1)
self.assertRaises(ValueError, self.bus.send, msg)
def test_rx_tx_min_timestamp(self):
@@ -113,7 +145,7 @@ def test_rx_tx_min_timestamp(self):
msg = can.Message(timestamp=0)
self.bus.send(msg)
msg_receive = self.bus.recv()
- self.assertEqual(msg, msg_receive)
+ self.assertMessageEqual(msg, msg_receive)
self.assertEqual(msg.timestamp, msg_receive.timestamp)
def test_rx_tx_min_timestamp_error(self):
@@ -123,30 +155,76 @@ 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):
+ unittest.TestCase.__init__(self, *args, **kwargs)
+ SimpleSerialTestBase.__init__(self)
def setUp(self):
- self.patcher = patch('serial.Serial')
+ self.patcher = patch("serial.Serial")
self.mock_serial = self.patcher.start()
self.serial_dummy = SerialDummy()
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()
class SimpleSerialLoopTest(unittest.TestCase, SimpleSerialTestBase):
+ def __init__(self, *args, **kwargs):
+ unittest.TestCase.__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()
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
diff --git a/test/simplecyclic_test.py b/test/simplecyclic_test.py
index 8763174a8..22a11e643 100644
--- a/test/simplecyclic_test.py
+++ b/test/simplecyclic_test.py
@@ -1,39 +1,313 @@
#!/usr/bin/env python
-# coding: utf-8
"""
This module tests cyclic send tasks.
"""
-from __future__ import absolute_import
-
-from time import sleep
+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
-class SimpleCyclicSendTaskTest(unittest.TestCase):
- @unittest.skipIf(IS_CI, "the timing sensitive behaviour cannot be reproduced reliably on a CI server")
+class SimpleCyclicSendTaskTest(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
+ )
+
+ @unittest.skipIf(
+ IS_CI,
+ "the timing sensitive behaviour cannot be reproduced reliably on a CI server",
+ )
def test_cycle_time(self):
- msg = can.Message(extended_id=False, arbitration_id=0x123, data=[0,1,2,3,4,5,6,7])
- bus1 = can.interface.Bus(bustype='virtual')
- bus2 = can.interface.Bus(bustype='virtual')
- 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()
- self.assertEqual(last_msg, msg)
-
- bus1.shutdown()
- bus2.shutdown()
-
-if __name__ == '__main__':
+ msg = can.Message(
+ is_extended_id=False, arbitration_id=0x123, data=[0, 1, 2, 3, 4, 5, 6, 7]
+ )
+
+ 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)
+
+ 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()
+
+ # 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)
+
+ def test_removing_bus_tasks(self):
+ 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
+
+ for task in tasks:
+ # Note calling task.stop will remove the task from the Bus's internal task management list
+ task.stop()
+
+ self.join_threads([task.thread for task in tasks], 5.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)
+
+ assert len(bus._periodic_tasks) == 0
+
+ # 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:
+ task.stop()
+
+ self.join_threads([task.thread for task in tasks], 5.0)
+
+ def test_stopping_perodic_tasks(self):
+ 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],
+ )
+
+ # 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()
+
+ # 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()
+
+ def test_modifier_callback(self) -> None:
+ msg_list: list[can.Message] = []
+
+ def increment_first_byte(msg: can.Message) -> None:
+ msg.data[0] = (msg.data[0] + 1) % 256
+
+ original_msg = can.Message(
+ is_extended_id=False, arbitration_id=0x123, data=[0] * 8
+ )
+
+ 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__":
unittest.main()
diff --git a/test/test_bit_timing.py b/test/test_bit_timing.py
new file mode 100644
index 000000000..514c31244
--- /dev/null
+++ b/test/test_bit_timing.py
@@ -0,0 +1,531 @@
+#!/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=8_000_000, brp=4, tseg1=11, tseg2=4, sjw=2, nof_samples=3, strict=True
+ )
+ 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=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
+ 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(
+ 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
+ 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
+
+
+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 == 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.from_bitrate_and_segments(
+ f_clock=8_000_000, bitrate=500_000, tseg1=13, tseg2=2, sjw=1
+ )
+ assert timing.f_clock == 8_000_000
+ assert timing.bitrate == 500_000
+ assert timing.brp == 1
+ 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.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
+ assert timing.tseg2 == 2
+ assert timing.sjw == 1
+ assert timing.sample_point == 75
+ assert timing.btr0 == 0x00
+ 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=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
new file mode 100644
index 000000000..f19ce95b9
--- /dev/null
+++ b/test/test_cyclic_socketcan.py
@@ -0,0 +1,622 @@
+#!/usr/bin/env python
+
+"""
+This module tests multiple message cyclic send tasks.
+"""
+import time
+import unittest
+
+import can
+
+from .config import TEST_INTERFACE_SOCKETCAN
+
+
+@unittest.skipUnless(TEST_INTERFACE_SOCKETCAN, "skip testing of socketcan")
+class CyclicSocketCan(unittest.TestCase):
+ BITRATE = 500000
+ TIMEOUT = 0.1
+
+ INTERFACE_1 = "socketcan"
+ CHANNEL_1 = "vcan0"
+ INTERFACE_2 = "socketcan"
+ CHANNEL_2 = "vcan0"
+
+ PERIOD = 1.0
+
+ DELTA = 0.01
+
+ def _find_start_index(self, tx_messages, message):
+ """
+ :param tx_messages:
+ The list of messages that were passed to the periodic backend
+ :param message:
+ The message whose data we wish to match and align to
+
+ :returns: start index in the tx_messages
+ """
+ start_index = -1
+ for index, tx_message in enumerate(tx_messages):
+ if tx_message.data == message.data:
+ start_index = index
+ break
+ return start_index
+
+ def setUp(self):
+ self._send_bus = can.Bus(
+ interface=self.INTERFACE_1, channel=self.CHANNEL_1, bitrate=self.BITRATE
+ )
+ self._recv_bus = can.Bus(
+ interface=self.INTERFACE_2, channel=self.CHANNEL_2, bitrate=self.BITRATE
+ )
+
+ def tearDown(self):
+ self._send_bus.shutdown()
+ self._recv_bus.shutdown()
+
+ def test_cyclic_initializer_list(self):
+ messages = []
+ messages.append(
+ can.Message(
+ arbitration_id=0x401,
+ data=[0x11, 0x11, 0x11, 0x11, 0x11, 0x11],
+ is_extended_id=False,
+ )
+ )
+ messages.append(
+ can.Message(
+ arbitration_id=0x401,
+ data=[0x22, 0x22, 0x22, 0x22, 0x22, 0x22],
+ is_extended_id=False,
+ )
+ )
+ messages.append(
+ can.Message(
+ arbitration_id=0x401,
+ data=[0x33, 0x33, 0x33, 0x33, 0x33, 0x33],
+ is_extended_id=False,
+ )
+ )
+ messages.append(
+ can.Message(
+ arbitration_id=0x401,
+ data=[0x44, 0x44, 0x44, 0x44, 0x44, 0x44],
+ is_extended_id=False,
+ )
+ )
+ messages.append(
+ can.Message(
+ arbitration_id=0x401,
+ data=[0x55, 0x55, 0x55, 0x55, 0x55, 0x55],
+ is_extended_id=False,
+ )
+ )
+
+ task = self._send_bus.send_periodic(messages, self.PERIOD)
+ self.assertIsInstance(task, can.broadcastmanager.CyclicSendTaskABC)
+
+ results = []
+ for _ in range(len(messages) * 2):
+ result = self._recv_bus.recv(self.PERIOD * 2)
+ if result:
+ results.append(result)
+
+ task.stop()
+
+ # Find starting index for each
+ start_index = self._find_start_index(messages, results[0])
+ self.assertTrue(start_index != -1)
+
+ # Now go through the partitioned results and assert that they're equal
+ for rx_index, rx_message in enumerate(results):
+ tx_message = messages[start_index]
+
+ self.assertIsNotNone(rx_message)
+ self.assertEqual(tx_message.arbitration_id, rx_message.arbitration_id)
+ self.assertEqual(tx_message.dlc, rx_message.dlc)
+ self.assertEqual(tx_message.data, rx_message.data)
+ self.assertEqual(tx_message.is_extended_id, rx_message.is_extended_id)
+ self.assertEqual(tx_message.is_remote_frame, rx_message.is_remote_frame)
+ self.assertEqual(tx_message.is_error_frame, rx_message.is_error_frame)
+ self.assertEqual(tx_message.is_fd, rx_message.is_fd)
+
+ start_index = (start_index + 1) % len(messages)
+
+ def test_cyclic_initializer_tuple(self):
+ messages = []
+ messages.append(
+ can.Message(
+ arbitration_id=0x401,
+ data=[0x11, 0x11, 0x11, 0x11, 0x11, 0x11],
+ is_extended_id=False,
+ )
+ )
+ messages.append(
+ can.Message(
+ arbitration_id=0x401,
+ data=[0x22, 0x22, 0x22, 0x22, 0x22, 0x22],
+ is_extended_id=False,
+ )
+ )
+ messages.append(
+ can.Message(
+ arbitration_id=0x401,
+ data=[0x33, 0x33, 0x33, 0x33, 0x33, 0x33],
+ is_extended_id=False,
+ )
+ )
+ messages.append(
+ can.Message(
+ arbitration_id=0x401,
+ data=[0x44, 0x44, 0x44, 0x44, 0x44, 0x44],
+ is_extended_id=False,
+ )
+ )
+ messages.append(
+ can.Message(
+ arbitration_id=0x401,
+ data=[0x55, 0x55, 0x55, 0x55, 0x55, 0x55],
+ is_extended_id=False,
+ )
+ )
+ messages = tuple(messages)
+
+ self.assertIsInstance(messages, tuple)
+
+ task = self._send_bus.send_periodic(messages, self.PERIOD)
+ self.assertIsInstance(task, can.broadcastmanager.CyclicSendTaskABC)
+
+ results = []
+ for _ in range(len(messages) * 2):
+ result = self._recv_bus.recv(self.PERIOD * 2)
+ if result:
+ results.append(result)
+
+ task.stop()
+
+ # Find starting index for each
+ start_index = self._find_start_index(messages, results[0])
+ self.assertTrue(start_index != -1)
+
+ # Now go through the partitioned results and assert that they're equal
+ for rx_index, rx_message in enumerate(results):
+ tx_message = messages[start_index]
+
+ self.assertIsNotNone(rx_message)
+ self.assertEqual(tx_message.arbitration_id, rx_message.arbitration_id)
+ self.assertEqual(tx_message.dlc, rx_message.dlc)
+ self.assertEqual(tx_message.data, rx_message.data)
+ self.assertEqual(tx_message.is_extended_id, rx_message.is_extended_id)
+ self.assertEqual(tx_message.is_remote_frame, rx_message.is_remote_frame)
+ self.assertEqual(tx_message.is_error_frame, rx_message.is_error_frame)
+ self.assertEqual(tx_message.is_fd, rx_message.is_fd)
+
+ start_index = (start_index + 1) % len(messages)
+
+ def test_cyclic_initializer_message(self):
+ message = can.Message(
+ arbitration_id=0x401,
+ data=[0x11, 0x11, 0x11, 0x11, 0x11, 0x11],
+ is_extended_id=False,
+ )
+
+ task = self._send_bus.send_periodic(message, self.PERIOD)
+ self.assertIsInstance(task, can.broadcastmanager.CyclicSendTaskABC)
+
+ # Take advantage of kernel's queueing mechanisms
+ time.sleep(4 * self.PERIOD)
+ task.stop()
+
+ for _ in range(4):
+ tx_message = message
+ rx_message = self._recv_bus.recv(self.TIMEOUT)
+
+ self.assertIsNotNone(rx_message)
+ self.assertEqual(tx_message.arbitration_id, rx_message.arbitration_id)
+ self.assertEqual(tx_message.dlc, rx_message.dlc)
+ self.assertEqual(tx_message.data, rx_message.data)
+ self.assertEqual(tx_message.is_extended_id, rx_message.is_extended_id)
+ self.assertEqual(tx_message.is_remote_frame, rx_message.is_remote_frame)
+ self.assertEqual(tx_message.is_error_frame, rx_message.is_error_frame)
+ self.assertEqual(tx_message.is_fd, rx_message.is_fd)
+
+ def test_cyclic_initializer_invalid_none(self):
+ with self.assertRaises(ValueError):
+ task = self._send_bus.send_periodic(None, self.PERIOD)
+
+ def test_cyclic_initializer_invalid_empty_list(self):
+ with self.assertRaises(ValueError):
+ task = self._send_bus.send_periodic([], self.PERIOD)
+
+ def test_cyclic_initializer_different_arbitration_ids(self):
+ messages = []
+ messages.append(
+ can.Message(
+ arbitration_id=0x401,
+ data=[0x11, 0x11, 0x11, 0x11, 0x11, 0x11],
+ is_extended_id=False,
+ )
+ )
+ messages.append(
+ can.Message(
+ arbitration_id=0x3E1,
+ data=[0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE],
+ is_extended_id=False,
+ )
+ )
+ with self.assertRaises(ValueError):
+ task = self._send_bus.send_periodic(messages, self.PERIOD)
+
+ 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],
+ is_extended_id=False,
+ )
+
+ messages_b = can.Message(
+ arbitration_id=0x401,
+ data=[0x22, 0x22, 0x22, 0x22, 0x22, 0x22],
+ is_extended_id=False,
+ )
+
+ 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)
+
+ 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 = []
+ messages_odd.append(
+ can.Message(
+ arbitration_id=0x401,
+ data=[0x11, 0x11, 0x11, 0x11, 0x11, 0x11],
+ is_extended_id=False,
+ )
+ )
+ messages_odd.append(
+ can.Message(
+ arbitration_id=0x401,
+ data=[0x33, 0x33, 0x33, 0x33, 0x33, 0x33],
+ is_extended_id=False,
+ )
+ )
+ messages_odd.append(
+ can.Message(
+ arbitration_id=0x401,
+ data=[0x55, 0x55, 0x55, 0x55, 0x55, 0x55],
+ is_extended_id=False,
+ )
+ )
+ messages_even = []
+ messages_even.append(
+ can.Message(
+ arbitration_id=0x401,
+ data=[0x22, 0x22, 0x22, 0x22, 0x22, 0x22],
+ is_extended_id=False,
+ )
+ )
+ messages_even.append(
+ can.Message(
+ arbitration_id=0x401,
+ data=[0x44, 0x44, 0x44, 0x44, 0x44, 0x44],
+ is_extended_id=False,
+ )
+ )
+ messages_even.append(
+ can.Message(
+ arbitration_id=0x401,
+ data=[0x66, 0x66, 0x66, 0x66, 0x66, 0x66],
+ is_extended_id=False,
+ )
+ )
+
+ task = self._send_bus.send_periodic(messages_odd, self.PERIOD)
+ self.assertIsInstance(task, can.broadcastmanager.ModifiableCyclicTaskABC)
+
+ results_odd = []
+ results_even = []
+ for _ in range(len(messages_odd) * 2):
+ result = self._recv_bus.recv(self.PERIOD * 2)
+ if result:
+ results_odd.append(result)
+
+ task.modify_data(messages_even)
+ for _ in range(len(messages_even) * 2):
+ result = self._recv_bus.recv(self.PERIOD * 2)
+ if result:
+ results_even.append(result)
+
+ task.stop()
+
+ # Make sure we received some messages
+ self.assertTrue(len(results_even) != 0)
+ self.assertTrue(len(results_odd) != 0)
+
+ # Find starting index for each
+ start_index_even = self._find_start_index(messages_even, results_even[0])
+ self.assertTrue(start_index_even != -1)
+
+ start_index_odd = self._find_start_index(messages_odd, results_odd[0])
+ self.assertTrue(start_index_odd != -1)
+
+ # Now go through the partitioned results and assert that they're equal
+ for rx_index, rx_message in enumerate(results_even):
+ tx_message = messages_even[start_index_even]
+
+ self.assertEqual(tx_message.arbitration_id, rx_message.arbitration_id)
+ self.assertEqual(tx_message.dlc, rx_message.dlc)
+ self.assertEqual(tx_message.data, rx_message.data)
+ self.assertEqual(tx_message.is_extended_id, rx_message.is_extended_id)
+ self.assertEqual(tx_message.is_remote_frame, rx_message.is_remote_frame)
+ self.assertEqual(tx_message.is_error_frame, rx_message.is_error_frame)
+ self.assertEqual(tx_message.is_fd, rx_message.is_fd)
+
+ start_index_even = (start_index_even + 1) % len(messages_even)
+
+ if rx_index != 0:
+ prev_rx_message = results_even[rx_index - 1]
+ # Assert timestamps are within the expected period
+ self.assertTrue(
+ abs(
+ (rx_message.timestamp - prev_rx_message.timestamp) - self.PERIOD
+ )
+ <= self.DELTA
+ )
+
+ for rx_index, rx_message in enumerate(results_odd):
+ tx_message = messages_odd[start_index_odd]
+
+ self.assertEqual(tx_message.arbitration_id, rx_message.arbitration_id)
+ self.assertEqual(tx_message.dlc, rx_message.dlc)
+ self.assertEqual(tx_message.data, rx_message.data)
+ self.assertEqual(tx_message.is_extended_id, rx_message.is_extended_id)
+ self.assertEqual(tx_message.is_remote_frame, rx_message.is_remote_frame)
+ self.assertEqual(tx_message.is_error_frame, rx_message.is_error_frame)
+ self.assertEqual(tx_message.is_fd, rx_message.is_fd)
+
+ start_index_odd = (start_index_odd + 1) % len(messages_odd)
+
+ if rx_index != 0:
+ prev_rx_message = results_odd[rx_index - 1]
+ # Assert timestamps are within the expected period
+ self.assertTrue(
+ abs(
+ (rx_message.timestamp - prev_rx_message.timestamp) - self.PERIOD
+ )
+ <= self.DELTA
+ )
+
+ def test_modify_data_message(self):
+ message_odd = can.Message(
+ arbitration_id=0x401,
+ data=[0x11, 0x11, 0x11, 0x11, 0x11, 0x11],
+ is_extended_id=False,
+ )
+ message_even = can.Message(
+ arbitration_id=0x401,
+ data=[0x22, 0x22, 0x22, 0x22, 0x22, 0x22],
+ is_extended_id=False,
+ )
+ task = self._send_bus.send_periodic(message_odd, self.PERIOD)
+ self.assertIsInstance(task, can.broadcastmanager.ModifiableCyclicTaskABC)
+
+ results_odd = []
+ results_even = []
+ for _ in range(1 * 4):
+ result = self._recv_bus.recv(self.PERIOD * 2)
+ if result:
+ results_odd.append(result)
+
+ task.modify_data(message_even)
+ for _ in range(1 * 4):
+ result = self._recv_bus.recv(self.PERIOD * 2)
+ if result:
+ results_even.append(result)
+
+ task.stop()
+
+ # Now go through the partitioned results and assert that they're equal
+ for rx_index, rx_message in enumerate(results_even):
+ tx_message = message_even
+
+ self.assertEqual(tx_message.arbitration_id, rx_message.arbitration_id)
+ self.assertEqual(tx_message.dlc, rx_message.dlc)
+ self.assertEqual(tx_message.data, rx_message.data)
+ self.assertEqual(tx_message.is_extended_id, rx_message.is_extended_id)
+ self.assertEqual(tx_message.is_remote_frame, rx_message.is_remote_frame)
+ self.assertEqual(tx_message.is_error_frame, rx_message.is_error_frame)
+ self.assertEqual(tx_message.is_fd, rx_message.is_fd)
+
+ if rx_index != 0:
+ prev_rx_message = results_even[rx_index - 1]
+ # Assert timestamps are within the expected period
+ self.assertTrue(
+ abs(
+ (rx_message.timestamp - prev_rx_message.timestamp) - self.PERIOD
+ )
+ <= self.DELTA
+ )
+
+ for rx_index, rx_message in enumerate(results_odd):
+ tx_message = message_odd
+
+ self.assertEqual(tx_message.arbitration_id, rx_message.arbitration_id)
+ self.assertEqual(tx_message.dlc, rx_message.dlc)
+ self.assertEqual(tx_message.data, rx_message.data)
+ self.assertEqual(tx_message.is_extended_id, rx_message.is_extended_id)
+ self.assertEqual(tx_message.is_remote_frame, rx_message.is_remote_frame)
+ self.assertEqual(tx_message.is_error_frame, rx_message.is_error_frame)
+ self.assertEqual(tx_message.is_fd, rx_message.is_fd)
+
+ if rx_index != 0:
+ prev_rx_message = results_odd[rx_index - 1]
+ # Assert timestamps are within the expected period
+ self.assertTrue(
+ abs(
+ (rx_message.timestamp - prev_rx_message.timestamp) - self.PERIOD
+ )
+ <= self.DELTA
+ )
+
+ def test_modify_data_invalid(self):
+ message = can.Message(
+ arbitration_id=0x401,
+ data=[0x11, 0x11, 0x11, 0x11, 0x11, 0x11],
+ is_extended_id=False,
+ )
+ task = self._send_bus.send_periodic(message, self.PERIOD)
+ self.assertIsInstance(task, can.broadcastmanager.ModifiableCyclicTaskABC)
+
+ time.sleep(2 * self.PERIOD)
+
+ with self.assertRaises(ValueError):
+ task.modify_data(None)
+
+ def test_modify_data_unequal_lengths(self):
+ message = can.Message(
+ arbitration_id=0x401,
+ data=[0x11, 0x11, 0x11, 0x11, 0x11, 0x11],
+ is_extended_id=False,
+ )
+ new_messages = []
+ new_messages.append(
+ can.Message(
+ arbitration_id=0x401,
+ data=[0x11, 0x11, 0x11, 0x11, 0x11, 0x11],
+ is_extended_id=False,
+ )
+ )
+ new_messages.append(
+ can.Message(
+ arbitration_id=0x401,
+ data=[0x22, 0x22, 0x22, 0x22, 0x22, 0x22],
+ is_extended_id=False,
+ )
+ )
+
+ task = self._send_bus.send_periodic(message, self.PERIOD)
+ self.assertIsInstance(task, can.broadcastmanager.ModifiableCyclicTaskABC)
+
+ time.sleep(2 * self.PERIOD)
+
+ with self.assertRaises(ValueError):
+ task.modify_data(new_messages)
+
+ def test_modify_data_different_arbitration_id_than_original(self):
+ old_message = can.Message(
+ arbitration_id=0x401,
+ data=[0x11, 0x11, 0x11, 0x11, 0x11, 0x11],
+ is_extended_id=False,
+ )
+ new_message = can.Message(
+ arbitration_id=0x3E1,
+ data=[0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE],
+ is_extended_id=False,
+ )
+
+ task = self._send_bus.send_periodic(old_message, self.PERIOD)
+ self.assertIsInstance(task, can.broadcastmanager.ModifiableCyclicTaskABC)
+
+ time.sleep(2 * self.PERIOD)
+
+ with self.assertRaises(ValueError):
+ task.modify_data(new_message)
+
+ def test_stop_all_periodic_tasks_and_remove_task(self):
+ message_a = can.Message(
+ arbitration_id=0x401,
+ data=[0x11, 0x11, 0x11, 0x11, 0x11, 0x11],
+ is_extended_id=False,
+ )
+ message_b = can.Message(
+ arbitration_id=0x402,
+ data=[0x22, 0x22, 0x22, 0x22, 0x22, 0x22],
+ is_extended_id=False,
+ )
+ message_c = can.Message(
+ arbitration_id=0x403,
+ data=[0x33, 0x33, 0x33, 0x33, 0x33, 0x33],
+ is_extended_id=False,
+ )
+
+ # Start Tasks
+ task_a = self._send_bus.send_periodic(message_a, self.PERIOD)
+ task_b = self._send_bus.send_periodic(message_b, self.PERIOD)
+ task_c = self._send_bus.send_periodic(message_c, self.PERIOD)
+
+ self.assertIsInstance(task_a, can.broadcastmanager.ModifiableCyclicTaskABC)
+ self.assertIsInstance(task_b, can.broadcastmanager.ModifiableCyclicTaskABC)
+ self.assertIsInstance(task_c, can.broadcastmanager.ModifiableCyclicTaskABC)
+
+ for _ in range(6):
+ _ = self._recv_bus.recv(self.PERIOD)
+
+ # Stop all tasks and delete
+ self._send_bus.stop_all_periodic_tasks(remove_tasks=True)
+
+ # Now wait for a few periods, after which we should definitely not
+ # receive any CAN messages
+ time.sleep(4 * self.PERIOD)
+
+ # If we successfully deleted everything, then we will eventually read
+ # 0 messages.
+ successfully_stopped = False
+ for _ in range(6):
+ rx_message = self._recv_bus.recv(self.PERIOD)
+
+ if rx_message is None:
+ successfully_stopped = True
+ break
+ self.assertTrue(successfully_stopped, "Still received messages after stopping")
+
+ # None of the tasks should still be associated with the bus
+ self.assertEqual(0, len(self._send_bus._periodic_tasks))
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/test/test_detect_available_configs.py b/test/test_detect_available_configs.py
index 417a3eb3e..f6590c276 100644
--- a/test/test_detect_available_configs.py
+++ b/test/test_detect_available_configs.py
@@ -1,58 +1,67 @@
#!/usr/bin/env python
-# coding: utf-8
"""
This module tests :meth:`can.BusABC._detect_available_configs` and
:meth:`can.BusABC.detect_available_configs`.
"""
-from __future__ import absolute_import
-
-import sys
import unittest
-if sys.version_info.major > 2:
- basestring = str
from can import detect_available_configs
-from .config import IS_LINUX
+from .config import IS_CI, IS_UNIX, TEST_INTERFACE_SOCKETCAN
class TestDetectAvailableConfigs(unittest.TestCase):
-
def test_count_returned(self):
# At least virtual has to always return at least one interface
- self.assertGreaterEqual (len(detect_available_configs() ), 1)
- self.assertEqual (len(detect_available_configs(interfaces=[]) ), 0)
- self.assertGreaterEqual (len(detect_available_configs(interfaces='virtual') ), 1)
- self.assertGreaterEqual (len(detect_available_configs(interfaces=['virtual']) ), 1)
- self.assertGreaterEqual (len(detect_available_configs(interfaces=None) ), 1)
+ self.assertGreaterEqual(len(detect_available_configs()), 1)
+ self.assertEqual(len(detect_available_configs(interfaces=[])), 0)
+ self.assertGreaterEqual(len(detect_available_configs(interfaces="virtual")), 1)
+ self.assertGreaterEqual(
+ len(detect_available_configs(interfaces=["virtual"])), 1
+ )
+ self.assertGreaterEqual(len(detect_available_configs(interfaces=None)), 1)
def test_general_values(self):
configs = detect_available_configs()
for config in configs:
- self.assertIn('interface', config)
- self.assertIn('channel', config)
- self.assertIsInstance(config['interface'], basestring)
+ self.assertIn("interface", config)
+ self.assertIn("channel", config)
def test_content_virtual(self):
- configs = detect_available_configs(interfaces='virtual')
+ configs = detect_available_configs(interfaces="virtual")
+ self.assertGreaterEqual(len(configs), 1)
for config in configs:
- self.assertEqual(config['interface'], 'virtual')
+ 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')
+ configs = detect_available_configs(interfaces="socketcan")
for config in configs:
- self.assertEqual(config['interface'], 'socketcan')
+ self.assertEqual(config["interface"], "socketcan")
+
+ 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(IS_LINUX, "socketcan is only available on Linux")
+ @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')
+ configs = detect_available_configs(interfaces="socketcan")
self.assertGreaterEqual(len(configs), 1)
- self.assertIn('vcan0', [config['channel'] for config in configs])
+ self.assertIn("vcan0", [config["channel"] for config in configs])
- # see TestSocketCanHelpers.test_find_available_interfaces()
+ # see TestSocketCanHelpers.test_find_available_interfaces() too
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
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 229381934..1ad035dec 100644
--- a/test/test_kvaser.py
+++ b/test/test_kvaser.py
@@ -1,33 +1,28 @@
#!/usr/bin/env python
-# coding: utf-8
-"""
-"""
+""" """
import ctypes
import time
-import logging
import unittest
-try:
- from unittest.mock import Mock, patch
-except ImportError:
- from mock import patch, Mock
+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):
-
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()
canlib.canBusOff = Mock()
canlib.canClose = Mock()
@@ -37,10 +32,12 @@ def setUp(self):
canlib.canWriteSync = Mock()
canlib.canWrite = self.canWrite
canlib.canReadWait = self.canReadWait
+ canlib.canGetBusStatistics = Mock()
+ canlib.canRequestBusStatistics = Mock()
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:
@@ -49,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)
@@ -60,67 +78,58 @@ def test_bus_shutdown(self):
def test_filter_setup(self):
# No filter in constructor
expected_args = [
- ((0, 0, 0, 0),), # Disable filtering STD on read handle
- ((0, 0, 0, 1),), # Disable filtering EXT on read handle
- ((0, 0, 0, 0),), # Disable filtering STD on write handle
- ((0, 0, 0, 1),), # Disable filtering EXT on write handle
+ ((0, 0, 0, 0),), # Disable filtering STD on read handle
+ ((0, 0, 0, 1),), # Disable filtering EXT on read handle
+ ((0, 0, 0, 0),), # Disable filtering STD on write handle
+ ((0, 0, 0, 1),), # Disable filtering EXT on write handle
]
- self.assertEqual(canlib.canSetAcceptanceFilter.call_args_list,
- expected_args)
+ self.assertEqual(canlib.canSetAcceptanceFilter.call_args_list, expected_args)
# One filter, will be handled by canlib
canlib.canSetAcceptanceFilter.reset_mock()
- self.bus.set_filters([
- {'can_id': 0x8, 'can_mask': 0xff, 'extended': True}
- ])
+ self.bus.set_filters([{"can_id": 0x8, "can_mask": 0xFF, "extended": True}])
expected_args = [
- ((0, 0x8, 0xff, 1),), # Enable filtering EXT on read handle
- ((0, 0x8, 0xff, 1),), # Enable filtering EXT on write handle
+ ((0, 0x8, 0xFF, 1),), # Enable filtering EXT on read handle
+ ((0, 0x8, 0xFF, 1),), # Enable filtering EXT on write handle
]
- self.assertEqual(canlib.canSetAcceptanceFilter.call_args_list,
- expected_args)
+ self.assertEqual(canlib.canSetAcceptanceFilter.call_args_list, expected_args)
# Multiple filters, will be handled in Python
canlib.canSetAcceptanceFilter.reset_mock()
multiple_filters = [
- {'can_id': 0x8, 'can_mask': 0xff},
- {'can_id': 0x9, 'can_mask': 0xff}
+ {"can_id": 0x8, "can_mask": 0xFF},
+ {"can_id": 0x9, "can_mask": 0xFF},
]
self.bus.set_filters(multiple_filters)
expected_args = [
- ((0, 0, 0, 0),), # Disable filtering STD on read handle
- ((0, 0, 0, 1),), # Disable filtering EXT on read handle
- ((0, 0, 0, 0),), # Disable filtering STD on write handle
- ((0, 0, 0, 1),), # Disable filtering EXT on write handle
+ ((0, 0, 0, 0),), # Disable filtering STD on read handle
+ ((0, 0, 0, 1),), # Disable filtering EXT on read handle
+ ((0, 0, 0, 0),), # Disable filtering STD on write handle
+ ((0, 0, 0, 1),), # Disable filtering EXT on write handle
]
- self.assertEqual(canlib.canSetAcceptanceFilter.call_args_list,
- expected_args)
+ self.assertEqual(canlib.canSetAcceptanceFilter.call_args_list, expected_args)
def test_send_extended(self):
msg = can.Message(
- arbitration_id=0xc0ffee,
- data=[0, 25, 0, 1, 3, 1, 4],
- extended_id=True)
+ arbitration_id=0xC0FFEE, data=[0, 25, 0, 1, 3, 1, 4], is_extended_id=True
+ )
self.bus.send(msg)
- self.assertEqual(self.msg['arb_id'], 0xc0ffee)
- self.assertEqual(self.msg['dlc'], 7)
- self.assertEqual(self.msg['flags'], constants.canMSG_EXT)
- self.assertSequenceEqual(self.msg['data'], [0, 25, 0, 1, 3, 1, 4])
+ self.assertEqual(self.msg["arb_id"], 0xC0FFEE)
+ self.assertEqual(self.msg["dlc"], 7)
+ self.assertEqual(self.msg["flags"], constants.canMSG_EXT)
+ self.assertSequenceEqual(self.msg["data"], [0, 25, 0, 1, 3, 1, 4])
def test_send_standard(self):
- msg = can.Message(
- arbitration_id=0x321,
- data=[50, 51],
- extended_id=False)
+ msg = can.Message(arbitration_id=0x321, data=[50, 51], is_extended_id=False)
self.bus.send(msg)
- self.assertEqual(self.msg['arb_id'], 0x321)
- self.assertEqual(self.msg['dlc'], 2)
- self.assertEqual(self.msg['flags'], constants.canMSG_STD)
- self.assertSequenceEqual(self.msg['data'], [50, 51])
+ self.assertEqual(self.msg["arb_id"], 0x321)
+ self.assertEqual(self.msg["dlc"], 2)
+ self.assertEqual(self.msg["flags"], constants.canMSG_STD)
+ self.assertSequenceEqual(self.msg["data"], [50, 51])
@pytest.mark.timeout(3.0)
def test_recv_no_message(self):
@@ -128,47 +137,168 @@ def test_recv_no_message(self):
def test_recv_extended(self):
self.msg_in_cue = can.Message(
- arbitration_id=0xc0ffef,
- data=[1, 2, 3, 4, 5, 6, 7, 8],
- extended_id=True)
+ arbitration_id=0xC0FFEF, data=[1, 2, 3, 4, 5, 6, 7, 8], is_extended_id=True
+ )
now = time.time()
msg = self.bus.recv()
- self.assertEqual(msg.arbitration_id, 0xc0ffef)
+ self.assertEqual(msg.arbitration_id, 0xC0FFEF)
self.assertEqual(msg.dlc, 8)
- self.assertEqual(msg.id_type, True)
+ self.assertEqual(msg.is_extended_id, True)
self.assertSequenceEqual(msg.data, self.msg_in_cue.data)
self.assertTrue(now - 1 < msg.timestamp < now + 1)
def test_recv_standard(self):
self.msg_in_cue = can.Message(
- arbitration_id=0x123,
- data=[100, 101],
- extended_id=False)
+ arbitration_id=0x123, data=[100, 101], is_extended_id=False
+ )
msg = self.bus.recv()
self.assertEqual(msg.arbitration_id, 0x123)
self.assertEqual(msg.dlc, 2)
- self.assertEqual(msg.id_type, False)
+ self.assertEqual(msg.is_extended_id, False)
self.assertSequenceEqual(msg.data, [100, 101])
-
+
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()
+ 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
+ )
+ canlib.canSetBusParamsFd.assert_called_once_with(
+ 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
+ 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
+ )
+ canlib.canSetBusParamsFd.assert_called_once_with(0, bitrate_constant, 0, 0, 0)
+
+ def test_canfd_custom_data_bitrate(self):
+ canlib.canSetBusParams.reset_mock()
+ canlib.canSetBusParamsFd.reset_mock()
+ data_bitrate = 123456
+ 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
+ )
+ canlib.canSetBusParamsFd.assert_called_once_with(0, data_bitrate, 0, 0, 0)
+
+ def test_bus_get_stats(self):
+ stats = self.bus.get_stats()
+ self.assertTrue(canlib.canRequestBusStatistics.called)
+ 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
def canWrite(self, handle, arb_id, buf, dlc, flags):
- self.msg['arb_id'] = arb_id
- self.msg['dlc'] = dlc
- self.msg['flags'] = flags
- self.msg['data'] = bytearray(buf._obj)
+ self.msg["arb_id"] = arb_id
+ self.msg["dlc"] = dlc
+ self.msg["flags"] = flags
+ self.msg["data"] = bytearray(buf._obj)
def canReadWait(self, handle, arb_id, data, dlc, flags, timestamp, timeout):
if not self.msg_in_cue:
@@ -178,7 +308,7 @@ def canReadWait(self, handle, arb_id, data, dlc, flags, timestamp, timeout):
dlc._obj.value = self.msg_in_cue.dlc
data._obj.raw = self.msg_in_cue.data
flags_temp = 0
- if self.msg_in_cue.id_type:
+ if self.msg_in_cue.is_extended_id:
flags_temp |= constants.canMSG_EXT
else:
flags_temp |= constants.canMSG_STD
@@ -191,5 +321,6 @@ def canReadWait(self, handle, arb_id, data, dlc, flags, timestamp, timeout):
return constants.canOK
-if __name__ == '__main__':
+
+if __name__ == "__main__":
unittest.main()
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 52a45d734..afedf58d4 100644
--- a/test/test_load_file_config.py
+++ b/test/test_load_file_config.py
@@ -1,5 +1,5 @@
#!/usr/bin/env python
-# coding: utf-8
+
import shutil
import tempfile
import unittest
@@ -10,10 +10,10 @@
class LoadFileConfigTest(unittest.TestCase):
configuration = {
- 'default': {'interface': 'virtual', 'channel': '0'},
- 'one': {'interface': 'virtual', 'channel': '1'},
- 'two': {'channel': '2'},
- 'three': {'extra': 'extra value'},
+ "default": {"interface": "virtual", "channel": "0"},
+ "one": {"interface": "kvaser", "channel": "1"},
+ "two": {"channel": "2"},
+ "three": {"extra": "extra value"},
}
def setUp(self):
@@ -25,65 +25,70 @@ def tearDown(self):
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:
+ with NamedTemporaryFile(
+ mode="w", dir=self.test_dir, delete=False
+ ) 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))
- tmp_config_file.write('\n'.join(content))
+ content.append(f"{k} = {v}")
+ tmp_config_file.write("\n".join(content))
return tmp_config_file.name
def test_config_file_with_default(self):
- tmp_config = self._gen_configration_file(['default'])
+ tmp_config = self._gen_configration_file(["default"])
config = can.util.load_file_config(path=tmp_config)
- self.assertEqual(config, self.configuration['default'])
+ self.assertEqual(config, self.configuration["default"])
def test_config_file_with_default_and_section(self):
- tmp_config = self._gen_configration_file(['default', 'one'])
+ tmp_config = self._gen_configration_file(["default", "one"])
- default = can.util.load_file_config(path=tmp_config)
- self.assertEqual(default, self.configuration['default'])
+ config = can.util.load_file_config(path=tmp_config)
+ self.assertEqual(config, self.configuration["default"])
- one = can.util.load_file_config(path=tmp_config, section='one')
- self.assertEqual(one, self.configuration['one'])
+ config.update(can.util.load_file_config(path=tmp_config, section="one"))
+ self.assertEqual(config, self.configuration["one"])
def test_config_file_with_section_only(self):
- tmp_config = self._gen_configration_file(['one'])
- config = can.util.load_file_config(path=tmp_config, section='one')
- self.assertEqual(config, self.configuration['one'])
+ tmp_config = self._gen_configration_file(["one"])
+ config = can.util.load_file_config(path=tmp_config)
+ config.update(can.util.load_file_config(path=tmp_config, section="one"))
+ self.assertEqual(config, self.configuration["one"])
def test_config_file_with_section_and_key_in_default(self):
- expected = self.configuration['default'].copy()
- expected.update(self.configuration['two'])
+ expected = self.configuration["default"].copy()
+ expected.update(self.configuration["two"])
- tmp_config = self._gen_configration_file(['default', 'two'])
- config = can.util.load_file_config(path=tmp_config, section='two')
+ tmp_config = self._gen_configration_file(["default", "two"])
+ config = can.util.load_file_config(path=tmp_config)
+ config.update(can.util.load_file_config(path=tmp_config, section="two"))
self.assertEqual(config, expected)
def test_config_file_with_section_missing_interface(self):
- expected = self.configuration['two'].copy()
- tmp_config = self._gen_configration_file(['two'])
- config = can.util.load_file_config(path=tmp_config, section='two')
+ expected = self.configuration["two"].copy()
+ tmp_config = self._gen_configration_file(["two"])
+ config = can.util.load_file_config(path=tmp_config)
+ config.update(can.util.load_file_config(path=tmp_config, section="two"))
self.assertEqual(config, expected)
def test_config_file_extra(self):
- expected = self.configuration['default'].copy()
- expected.update(self.configuration['three'])
+ expected = self.configuration["default"].copy()
+ expected.update(self.configuration["three"])
- tmp_config = self._gen_configration_file(['default', 'three'])
- config = can.util.load_file_config(path=tmp_config, section='three')
+ tmp_config = self._gen_configration_file(["default", "three"])
+ config = can.util.load_file_config(path=tmp_config)
+ config.update(can.util.load_file_config(path=tmp_config, section="three"))
self.assertEqual(config, expected)
def test_config_file_with_non_existing_section(self):
- expected = {}
+ expected = self.configuration["default"].copy()
- tmp_config = self._gen_configration_file([
- 'default', 'one', 'two', 'three'])
- config = can.util.load_file_config(path=tmp_config, section='zero')
+ tmp_config = self._gen_configration_file(["default", "one", "two", "three"])
+ config = can.util.load_file_config(path=tmp_config)
+ config.update(can.util.load_file_config(path=tmp_config, section="zero"))
self.assertEqual(config, expected)
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
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
new file mode 100644
index 000000000..8e2367034
--- /dev/null
+++ b/test/test_message_class.py
@@ -0,0 +1,136 @@
+#!/usr/bin/env python
+
+import pickle
+import sys
+import unittest
+from copy import copy, deepcopy
+from datetime import timedelta
+from math import isinf, isnan
+
+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):
+ """
+ This test tries many inputs to the message class constructor and then sanity checks
+ all methods and ensures that nothing crashes. It also checks whether Message._check()
+ allows all valid can frames.
+ """
+
+ @given(
+ timestamp=st.floats(min_value=0.0),
+ arbitration_id=st.integers(),
+ is_extended_id=st.booleans(),
+ is_remote_frame=st.booleans(),
+ is_error_frame=st.booleans(),
+ channel=st.one_of(st.text(), st.integers()),
+ dlc=st.integers(min_value=0, max_value=8),
+ data=st.one_of(st.binary(min_size=0, max_size=8), st.none()),
+ is_fd=st.booleans(),
+ bitrate_switch=st.booleans(),
+ error_state_indicator=st.booleans(),
+ )
+ # 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 (
+ (
+ not kwargs["is_remote_frame"]
+ and (len(kwargs["data"] or []) != kwargs["dlc"])
+ )
+ 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_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"])
+ and not kwargs["is_fd"]
+ )
+ or isnan(kwargs["timestamp"])
+ or isinf(kwargs["timestamp"])
+ )
+
+ # this should return normally and not throw an exception
+ message = Message(check=is_valid, **kwargs)
+
+ if kwargs["data"] is None or kwargs["is_remote_frame"]:
+ kwargs["data"] = bytearray()
+
+ if not is_valid and not kwargs["is_remote_frame"]:
+ with self.assertRaises(ValueError):
+ Message(check=True, **kwargs)
+
+ self.assertGreater(len(str(message)), 0)
+ self.assertGreater(len(message.__repr__()), 0)
+ if is_valid:
+ self.assertEqual(len(message), kwargs["dlc"])
+ self.assertTrue(bool(message))
+ self.assertGreater(len(f"{message}"), 0)
+ _ = f"{message}"
+ with self.assertRaises(Exception):
+ _ = "{somespec}".format(
+ message
+ ) # pylint: disable=missing-format-argument-key
+ if sys.version_info.major > 2:
+ self.assertEqual(bytearray(bytes(message)), kwargs["data"])
+
+ # check copies and equalities
+ if is_valid:
+ self.assertEqual(message, message)
+ normal_copy = copy(message)
+ deep_copy = deepcopy(message)
+ for other in (normal_copy, deep_copy, message):
+ self.assertTrue(message.equals(other, timestamp_delta=None))
+ self.assertTrue(message.equals(other))
+ 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 e08e6acfd..a73e07aa2 100644
--- a/test/test_message_filtering.py
+++ b/test/test_message_filtering.py
@@ -1,39 +1,26 @@
#!/usr/bin/env python
-# coding: utf-8
"""
This module tests :meth:`can.BusABC._matches_filters`.
"""
-from __future__ import absolute_import
-
import unittest
from can import Bus, Message
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)
-EXAMPLE_MSG = Message(arbitration_id=0x123, extended_id=True)
-HIGHEST_MSG = Message(arbitration_id=0x1FFFFFFF, extended_id=True)
-
-MATCH_EXAMPLE = [{
- "can_id": 0x123,
- "can_mask": 0x1FFFFFFF,
- "extended": True
-}]
+MATCH_EXAMPLE = [{"can_id": 0x123, "can_mask": 0x1FFFFFFF, "extended": True}]
-MATCH_ONLY_HIGHEST = [{
- "can_id": 0xFFFFFFFF,
- "can_mask": 0x1FFFFFFF,
- "extended": True
-}]
+MATCH_ONLY_HIGHEST = [{"can_id": 0xFFFFFFFF, "can_mask": 0x1FFFFFFF, "extended": True}]
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()
@@ -60,5 +47,5 @@ def test_match_example_message(self):
self.assertTrue(self.bus._matches_filters(HIGHEST_MSG))
-if __name__ == '__main__':
+if __name__ == "__main__":
unittest.main()
diff --git a/test/test_message_sync.py b/test/test_message_sync.py
new file mode 100644
index 000000000..90cbe372c
--- /dev/null
+++ b/test/test_message_sync.py
@@ -0,0 +1,118 @@
+#!/usr/bin/env python
+
+"""
+This module tests :class:`can.MessageSync`.
+"""
+
+import gc
+import time
+import unittest
+from copy import copy
+
+import pytest
+
+from can import Message, MessageSync
+
+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]
+
+
+def inc(value):
+ """Makes the test boundaries give some more space when run on the CI server."""
+ if IS_CI:
+ return value * 1.5
+ else:
+ return value
+
+
+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)
+ ComparingMessagesTestCase.__init__(self)
+
+ def setup_method(self, _):
+ # disabling the garbage collector makes the time readings more reliable
+ gc.disable()
+
+ def teardown_method(self, _):
+ # we need to reenable the garbage collector again
+ gc.enable()
+
+ def test_general(self):
+ messages = [
+ Message(timestamp=50.0),
+ Message(timestamp=50.0),
+ Message(timestamp=50.0 + 0.05),
+ Message(timestamp=50.0 + 0.13),
+ Message(timestamp=50.0), # back in time
+ ]
+ sync = MessageSync(messages, gap=0.0, skip=0.0)
+
+ t_start = time.perf_counter()
+ collected = []
+ timings = []
+ for message in sync:
+ t_now = time.perf_counter()
+ collected.append(message)
+ 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] < 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]))
+
+ def test_skip(self):
+ messages = copy(TEST_FEWER_MESSAGES)
+ sync = MessageSync(messages, skip=0.005, gap=0.0)
+
+ before = time.perf_counter()
+ collected = list(sync)
+ 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)), f"took: {took}s"
+
+ self.assertMessagesEqual(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__":
+ unittest.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
new file mode 100644
index 000000000..f95139917
--- /dev/null
+++ b/test/test_robotell.py
@@ -0,0 +1,953 @@
+#!/usr/bin/env python
+
+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://", 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(
+ [
+ 0xAA,
+ 0xAA,
+ 0x56,
+ 0x34,
+ 0x12,
+ 0x00,
+ 0xA5,
+ 0xAA,
+ 0xA5,
+ 0xA5,
+ 0xA5,
+ 0x55,
+ 0xA5,
+ 0x55,
+ 0xA5,
+ 0xA5,
+ 0xA5,
+ 0xAA,
+ 0x00,
+ 0x00,
+ 0x06,
+ 0x00,
+ 0x01,
+ 0x00,
+ 0xEB,
+ 0x55,
+ 0x55,
+ ]
+ )
+ )
+ msg = self.bus.recv(1)
+ self.assertIsNotNone(msg)
+ self.assertEqual(msg.arbitration_id, 0x123456)
+ self.assertEqual(msg.is_extended_id, True)
+ self.assertEqual(msg.is_remote_frame, False)
+ self.assertEqual(msg.dlc, 6)
+ self.assertSequenceEqual(msg.data, [0xAA, 0xA5, 0x55, 0x55, 0xA5, 0xAA])
+ data = self.serial.read(self.serial.in_waiting)
+
+ def test_send_extended(self):
+ msg = can.Message(
+ arbitration_id=0x123456,
+ is_extended_id=True,
+ data=[0xAA, 0xA5, 0x55, 0x55, 0xA5, 0xAA],
+ )
+ self.bus.send(msg)
+ data = self.serial.read(self.serial.in_waiting)
+ self.assertEqual(
+ data,
+ bytearray(
+ [
+ 0xAA,
+ 0xAA,
+ 0x56,
+ 0x34,
+ 0x12,
+ 0x00,
+ 0xA5,
+ 0xAA,
+ 0xA5,
+ 0xA5,
+ 0xA5,
+ 0x55,
+ 0xA5,
+ 0x55,
+ 0xA5,
+ 0xA5,
+ 0xA5,
+ 0xAA,
+ 0x00,
+ 0x00,
+ 0x06,
+ 0x00,
+ 0x01,
+ 0x00,
+ 0xEB,
+ 0x55,
+ 0x55,
+ ]
+ ),
+ )
+
+ def test_recv_standard(self):
+ self.serial.write(
+ bytearray(
+ [
+ 0xAA,
+ 0xAA,
+ 0x7B,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x48,
+ 0x65,
+ 0x6C,
+ 0x6C,
+ 0x6F,
+ 0x31,
+ 0x32,
+ 0x33,
+ 0x08,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x0D,
+ 0x55,
+ 0x55,
+ ]
+ )
+ )
+ msg = self.bus.recv(1)
+ self.assertIsNotNone(msg)
+ self.assertEqual(msg.arbitration_id, 123)
+ self.assertEqual(msg.is_extended_id, False)
+ self.assertEqual(msg.is_remote_frame, False)
+ self.assertEqual(msg.dlc, 8)
+ self.assertSequenceEqual(
+ msg.data, [0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x31, 0x32, 0x33]
+ )
+ data = self.serial.read(self.serial.in_waiting)
+
+ def test_send_standard(self):
+ msg = can.Message(
+ arbitration_id=123,
+ is_extended_id=False,
+ data=[0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x31, 0x32, 0x33],
+ )
+ self.bus.send(msg)
+ data = self.serial.read(self.serial.in_waiting)
+ self.assertEqual(
+ data,
+ bytearray(
+ [
+ 0xAA,
+ 0xAA,
+ 0x7B,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x48,
+ 0x65,
+ 0x6C,
+ 0x6C,
+ 0x6F,
+ 0x31,
+ 0x32,
+ 0x33,
+ 0x08,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x0D,
+ 0x55,
+ 0x55,
+ ]
+ ),
+ )
+
+ def test_recv_extended_remote(self):
+ self.serial.write(
+ bytearray(
+ [
+ 0xAA,
+ 0xAA,
+ 0x56,
+ 0x34,
+ 0x12,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x07,
+ 0x00,
+ 0x01,
+ 0x01,
+ 0xA5,
+ 0xA5,
+ 0x55,
+ 0x55,
+ ]
+ )
+ )
+ msg = self.bus.recv(1)
+ self.assertIsNotNone(msg)
+ self.assertEqual(msg.arbitration_id, 0x123456)
+ self.assertEqual(msg.is_extended_id, True)
+ self.assertEqual(msg.is_remote_frame, True)
+ self.assertEqual(msg.dlc, 7)
+ data = self.serial.read(self.serial.in_waiting)
+
+ def test_send_extended_remote(self):
+ msg = can.Message(
+ arbitration_id=0x123456, is_extended_id=True, is_remote_frame=True, dlc=7
+ )
+ self.bus.send(msg)
+ data = self.serial.read(self.serial.in_waiting)
+ self.assertEqual(
+ data,
+ bytearray(
+ [
+ 0xAA,
+ 0xAA,
+ 0x56,
+ 0x34,
+ 0x12,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x07,
+ 0x00,
+ 0x01,
+ 0x01,
+ 0xA5,
+ 0xA5,
+ 0x55,
+ 0x55,
+ ]
+ ),
+ )
+
+ def test_partial_recv(self):
+ # write some junk data and then start of message
+ self.serial.write(
+ bytearray([0x11, 0x22, 0x33, 0xAA, 0xAA, 0x7B, 0x00, 0x00, 0x00, 0x48])
+ )
+ msg = self.bus.recv(1)
+ self.assertIsNone(msg)
+
+ # write rest of first message, and then a second message
+ self.serial.write(
+ bytearray(
+ [
+ 0x65,
+ 0x6C,
+ 0x6C,
+ 0x6F,
+ 0x31,
+ 0x32,
+ 0x33,
+ 0x08,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x0D,
+ 0x55,
+ 0x55,
+ ]
+ )
+ )
+ self.serial.write(
+ bytearray(
+ [
+ 0xAA,
+ 0xAA,
+ 0x56,
+ 0x34,
+ 0x12,
+ 0x00,
+ 0xA5,
+ 0xAA,
+ 0xA5,
+ 0xA5,
+ 0xA5,
+ 0x55,
+ 0xA5,
+ 0x55,
+ 0xA5,
+ 0xA5,
+ 0xA5,
+ 0xAA,
+ 0x00,
+ 0x00,
+ 0x06,
+ 0x00,
+ 0x01,
+ 0x00,
+ 0xEB,
+ 0x55,
+ 0x55,
+ ]
+ )
+ )
+ msg = self.bus.recv(1)
+ self.assertIsNotNone(msg)
+ self.assertEqual(msg.arbitration_id, 123)
+ self.assertEqual(msg.is_extended_id, False)
+ self.assertEqual(msg.is_remote_frame, False)
+ self.assertEqual(msg.dlc, 8)
+ self.assertSequenceEqual(
+ msg.data, [0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x31, 0x32, 0x33]
+ )
+
+ # now try to also receive 2nd message
+ msg = self.bus.recv(1)
+ self.assertIsNotNone(msg)
+ self.assertEqual(msg.arbitration_id, 0x123456)
+ self.assertEqual(msg.is_extended_id, True)
+ self.assertEqual(msg.is_remote_frame, False)
+ self.assertEqual(msg.dlc, 6)
+ self.assertSequenceEqual(msg.data, [0xAA, 0xA5, 0x55, 0x55, 0xA5, 0xAA])
+
+ # test nothing more left
+ msg = self.bus.recv(1)
+ self.assertIsNone(msg)
+ data = self.serial.read(self.serial.in_waiting)
+
+ def test_serial_number(self):
+ self.serial.write(
+ bytearray(
+ [
+ 0xAA,
+ 0xAA,
+ 0xF0,
+ 0xFF,
+ 0xFF,
+ 0x01,
+ 0x53,
+ 0xFF,
+ 0x6A,
+ 0x06,
+ 0x49,
+ 0x72,
+ 0x48,
+ 0xA5,
+ 0x55,
+ 0x08,
+ 0xFF,
+ 0x01,
+ 0x00,
+ 0x11,
+ 0x55,
+ 0x55,
+ ]
+ )
+ )
+ self.serial.write(
+ bytearray(
+ [
+ 0xAA,
+ 0xAA,
+ 0xF1,
+ 0xFF,
+ 0xFF,
+ 0x01,
+ 0x40,
+ 0x60,
+ 0x17,
+ 0x87,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x08,
+ 0xFF,
+ 0x01,
+ 0x00,
+ 0x36,
+ 0x55,
+ 0x55,
+ ]
+ )
+ )
+ sn = self.bus.get_serial_number(1)
+ self.assertEqual(sn, "53FF-6A06-4972-4855-4060-1787")
+ data = self.serial.read(self.serial.in_waiting)
+ self.assertEqual(
+ data,
+ bytearray(
+ [
+ 0xAA,
+ 0xAA,
+ 0xF0,
+ 0xFF,
+ 0xFF,
+ 0x01,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x08,
+ 0xFF,
+ 0x01,
+ 0x01,
+ 0xF8,
+ 0x55,
+ 0x55,
+ 0xAA,
+ 0xAA,
+ 0xF1,
+ 0xFF,
+ 0xFF,
+ 0x01,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x08,
+ 0xFF,
+ 0x01,
+ 0x01,
+ 0xF9,
+ 0x55,
+ 0x55,
+ ]
+ ),
+ )
+
+ sn = self.bus.get_serial_number(0)
+ self.assertIsNone(sn)
+ data = self.serial.read(self.serial.in_waiting)
+
+ def test_set_bitrate(self):
+ self.serial.write(
+ bytearray(
+ [
+ 0xAA,
+ 0xAA,
+ 0xD0,
+ 0xFE,
+ 0xFF,
+ 0x01,
+ 0x40,
+ 0x42,
+ 0x0F,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x04,
+ 0xFF,
+ 0x01,
+ 0x01,
+ 0x64,
+ 0x55,
+ 0x55,
+ ]
+ )
+ )
+ self.bus.set_bitrate(1000000)
+ data = self.serial.read(self.serial.in_waiting)
+ self.assertEqual(
+ data,
+ bytearray(
+ [
+ 0xAA,
+ 0xAA,
+ 0xD0,
+ 0xFE,
+ 0xFF,
+ 0x01,
+ 0x40,
+ 0x42,
+ 0x0F,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x04,
+ 0xFF,
+ 0x01,
+ 0x00,
+ 0x63,
+ 0x55,
+ 0x55,
+ ]
+ ),
+ )
+
+ def test_set_auto_retransmit(self):
+ self.serial.write(
+ bytearray(
+ [
+ 0xAA,
+ 0xAA,
+ 0xA0,
+ 0xFE,
+ 0xFF,
+ 0x01,
+ 0x01,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x01,
+ 0xFF,
+ 0x01,
+ 0x01,
+ 0xA1,
+ 0x55,
+ 0x55,
+ ]
+ )
+ )
+ self.serial.write(
+ bytearray(
+ [
+ 0xAA,
+ 0xAA,
+ 0xA0,
+ 0xFE,
+ 0xFF,
+ 0x01,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x01,
+ 0xFF,
+ 0x01,
+ 0x01,
+ 0xA0,
+ 0x55,
+ 0x55,
+ ]
+ )
+ )
+ self.bus.set_auto_retransmit(True)
+ self.bus.set_auto_retransmit(False)
+ data = self.serial.read(self.serial.in_waiting)
+ self.assertEqual(
+ data,
+ bytearray(
+ [
+ 0xAA,
+ 0xAA,
+ 0xA0,
+ 0xFE,
+ 0xFF,
+ 0x01,
+ 0x01,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x01,
+ 0xFF,
+ 0x01,
+ 0x00,
+ 0xA0,
+ 0x55,
+ 0x55,
+ 0xAA,
+ 0xAA,
+ 0xA0,
+ 0xFE,
+ 0xFF,
+ 0x01,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x01,
+ 0xFF,
+ 0x01,
+ 0x00,
+ 0x9F,
+ 0x55,
+ 0x55,
+ ]
+ ),
+ )
+
+ def test_set_auto_bus_management(self):
+ self.serial.write(
+ bytearray(
+ [
+ 0xAA,
+ 0xAA,
+ 0xB0,
+ 0xFE,
+ 0xFF,
+ 0x01,
+ 0x01,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x01,
+ 0xFF,
+ 0x01,
+ 0x01,
+ 0xB1,
+ 0x55,
+ 0x55,
+ ]
+ )
+ )
+ self.serial.write(
+ bytearray(
+ [
+ 0xAA,
+ 0xAA,
+ 0xB0,
+ 0xFE,
+ 0xFF,
+ 0x01,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x01,
+ 0xFF,
+ 0x01,
+ 0x01,
+ 0xB0,
+ 0x55,
+ 0x55,
+ ]
+ )
+ )
+ self.bus.set_auto_bus_management(True)
+ self.bus.set_auto_bus_management(False)
+ data = self.serial.read(self.serial.in_waiting)
+ self.assertEqual(
+ data,
+ bytearray(
+ [
+ 0xAA,
+ 0xAA,
+ 0xB0,
+ 0xFE,
+ 0xFF,
+ 0x01,
+ 0x01,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x01,
+ 0xFF,
+ 0x01,
+ 0x00,
+ 0xB0,
+ 0x55,
+ 0x55,
+ 0xAA,
+ 0xAA,
+ 0xB0,
+ 0xFE,
+ 0xFF,
+ 0x01,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x01,
+ 0xFF,
+ 0x01,
+ 0x00,
+ 0xAF,
+ 0x55,
+ 0x55,
+ ]
+ ),
+ )
+
+ def test_set_serial_rate(self):
+ self.serial.write(
+ bytearray(
+ [
+ 0xAA,
+ 0xAA,
+ 0x90,
+ 0xFE,
+ 0xFF,
+ 0x01,
+ 0x00,
+ 0xC2,
+ 0x01,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x04,
+ 0xFF,
+ 0x01,
+ 0x01,
+ 0x56,
+ 0x55,
+ 0x55,
+ ]
+ )
+ )
+ self.bus.set_serial_rate(115200)
+ data = self.serial.read(self.serial.in_waiting)
+ self.assertEqual(
+ data,
+ bytearray(
+ [
+ 0xAA,
+ 0xAA,
+ 0x90,
+ 0xFE,
+ 0xFF,
+ 0x01,
+ 0x00,
+ 0xC2,
+ 0x01,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x04,
+ 0xFF,
+ 0x01,
+ 0x00,
+ 0xA5,
+ 0x55,
+ 0x55,
+ 0x55,
+ ]
+ ),
+ )
+
+ def test_set_hw_filter(self):
+ self.serial.write(
+ bytearray(
+ [
+ 0xAA,
+ 0xAA,
+ 0xE0,
+ 0xFE,
+ 0xFF,
+ 0x01,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x80,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x08,
+ 0xFF,
+ 0x01,
+ 0x01,
+ 0x67,
+ 0x55,
+ 0x55,
+ ]
+ )
+ )
+ self.serial.write(
+ bytearray(
+ [
+ 0xAA,
+ 0xAA,
+ 0xE1,
+ 0xFE,
+ 0xFF,
+ 0x01,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0xC0,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x08,
+ 0xFF,
+ 0x01,
+ 0x01,
+ 0xA8,
+ 0x55,
+ 0x55,
+ ]
+ )
+ )
+ self.serial.write(
+ bytearray(
+ [
+ 0xAA,
+ 0xAA,
+ 0xE2,
+ 0xFE,
+ 0xFF,
+ 0x01,
+ 0xF0,
+ 0x01,
+ 0x00,
+ 0x00,
+ 0xF0,
+ 0x01,
+ 0x00,
+ 0x00,
+ 0x08,
+ 0xFF,
+ 0x01,
+ 0x01,
+ 0xCB,
+ 0x55,
+ 0x55,
+ ]
+ )
+ )
+ self.bus.set_hw_filter(1, True, 0, 0, False)
+ self.bus.set_hw_filter(2, True, 0, 0, True)
+ self.bus.set_hw_filter(3, False, 0x1F0, 0x1F0, False)
+ data = self.serial.read(self.serial.in_waiting)
+ self.assertEqual(
+ data,
+ bytearray(
+ [
+ 0xAA,
+ 0xAA,
+ 0xE0,
+ 0xFE,
+ 0xFF,
+ 0x01,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x80,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x08,
+ 0xFF,
+ 0x01,
+ 0x00,
+ 0x66,
+ 0x55,
+ 0x55,
+ 0xAA,
+ 0xAA,
+ 0xE1,
+ 0xFE,
+ 0xFF,
+ 0x01,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0xC0,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x08,
+ 0xFF,
+ 0x01,
+ 0x00,
+ 0xA7,
+ 0x55,
+ 0x55,
+ 0xAA,
+ 0xAA,
+ 0xE2,
+ 0xFE,
+ 0xFF,
+ 0x01,
+ 0xF0,
+ 0x01,
+ 0x00,
+ 0x00,
+ 0xF0,
+ 0x01,
+ 0x00,
+ 0x00,
+ 0x08,
+ 0xFF,
+ 0x01,
+ 0x00,
+ 0xCA,
+ 0x55,
+ 0x55,
+ ]
+ ),
+ )
+
+ 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 90687ccd7..c1a6c082d 100644
--- a/test/test_scripts.py
+++ b/test/test_scripts.py
@@ -1,41 +1,38 @@
#!/usr/bin/env python
-# coding: utf-8
"""
This module tests that the scripts are all callable.
"""
-from __future__ import absolute_import
-
+import errno
import subprocess
-import unittest
import sys
-import errno
+import unittest
from abc import ABCMeta, abstractmethod
from .config import *
-class CanScriptTest(unittest.TestCase):
+class CanScriptTest(unittest.TestCase, metaclass=ABCMeta):
@classmethod
def setUpClass(cls):
# clean up the argument list so the call to the main() functions
# in test_does_not_crash() succeeds
sys.argv = sys.argv[:1]
- #: this is overridden by the subclasses
- __test__ = False
-
- __metaclass__ = ABCMeta
-
def test_do_commands_exist(self):
- """This test calls each scripts once and veifies that the help
+ """This test calls each scripts once and verifies that the help
can be read without any other errors, like the script not being
found.
"""
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
@@ -44,9 +41,13 @@ def test_do_commands_exist(self):
output = "-- NO OUTPUT --"
allowed = [0, errno.EINVAL]
- self.assertIn(return_code, allowed,
- 'Calling "{}" failed (exit code was {} and not SUCCESS/0 or EINVAL/22):\n{}'
- .format(command, return_code, output))
+ self.assertIn(
+ return_code,
+ allowed,
+ 'Calling "{}" failed (exit code was {} and not SUCCESS/0 or EINVAL/22):\n{}'.format(
+ command, return_code, output
+ ),
+ )
def test_does_not_crash(self):
# test import
@@ -54,8 +55,7 @@ def test_does_not_crash(self):
# test main method
with self.assertRaises(SystemExit) as cm:
module.main()
- self.assertEqual(cm.exception.code, errno.EINVAL,
- 'Calling main failed:\n{}'.format(command, e.output))
+ self.assertEqual(cm.exception.code, errno.EINVAL)
@abstractmethod
def _commands(self):
@@ -66,49 +66,72 @@ 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
class TestLoggerScript(CanScriptTest):
-
- __test__ = True
-
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):
import can.logger as module
+
return module
class TestPlayerScript(CanScriptTest):
-
- __test__ = True
-
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):
import can.player as module
+
+ 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
-if __name__ == '__main__':
+# this excludes the base class from being executed as a test case itself
+del CanScriptTest
+
+
+if __name__ == "__main__":
unittest.main()
diff --git a/test/test_slcan.py b/test/test_slcan.py
new file mode 100644
index 000000000..b757ad04d
--- /dev/null
+++ b/test/test_slcan.py
@@ -0,0 +1,479 @@
+#!/usr/bin/env python
+
+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 = 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.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)
+ self.assertEqual(msg.is_remote_frame, False)
+ self.assertEqual(msg.dlc, 2)
+ 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)
+ 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.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)
+ self.assertEqual(msg.is_remote_frame, False)
+ self.assertEqual(msg.dlc, 3)
+ 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)
+ 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.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)
+ self.assertEqual(msg.is_remote_frame, True)
+ 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)
+ 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.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)
+ self.assertEqual(msg.is_remote_frame, True)
+ 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)
+ 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.set_input_buffer(b"T12ABCDEF")
+ msg = self.bus.recv(TIMEOUT)
+ self.assertIsNone(msg)
+
+ 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)
+ self.assertEqual(msg.is_remote_frame, False)
+ self.assertEqual(msg.dlc, 2)
+ self.assertSequenceEqual(msg.data, [0xAA, 0x55])
+
+ msg = self.bus.recv(TIMEOUT)
+ self.assertIsNone(msg)
+
+ self.serial.set_input_buffer(b"ABCDEF2AA55\r")
+ msg = self.bus.recv(TIMEOUT)
+ self.assertIsNotNone(msg)
+
+ def test_version(self):
+ 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)
+
+ def test_serial_number(self):
+ sn = self.bus.get_serial_number(0)
+ self.assertEqual(b"N\r", self.serial.get_output_buffer())
+ self.assertEqual(sn, "A123")
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/test/test_socketcan.py b/test/test_socketcan.py
new file mode 100644
index 000000000..534ee2a61
--- /dev/null
+++ b/test/test_socketcan.py
@@ -0,0 +1,394 @@
+#!/usr/bin/env python
+
+"""
+Test functions in `can.interfaces.socketcan.socketcan`.
+"""
+import ctypes
+import struct
+import sys
+import unittest
+import warnings
+from unittest.mock import patch
+
+import can
+from can.interfaces.socketcan.constants import (
+ CAN_BCM_TX_DELETE,
+ CAN_BCM_TX_SETUP,
+ SETTIMER,
+ 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):
+ 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(
+ self, ctypes_sizeof, ctypes_alignment
+ ):
+ """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
+ """
+
+ def side_effect_ctypes_sizeof(value):
+ type_to_size = {
+ ctypes.c_longlong: 8,
+ ctypes.c_long: 4,
+ ctypes.c_uint8: 1,
+ ctypes.c_uint16: 2,
+ ctypes.c_uint32: 4,
+ ctypes.c_uint64: 8,
+ }
+ return type_to_size[value]
+
+ def side_effect_ctypes_alignment(value):
+ type_to_alignment = {
+ ctypes.c_longlong: 4,
+ ctypes.c_long: 4,
+ ctypes.c_uint8: 1,
+ ctypes.c_uint16: 2,
+ ctypes.c_uint32: 4,
+ ctypes.c_uint64: 4,
+ }
+ return type_to_alignment[value]
+
+ ctypes_sizeof.side_effect = side_effect_ctypes_sizeof
+ ctypes_alignment.side_effect = side_effect_ctypes_alignment
+
+ fields = [
+ ("opcode", ctypes.c_uint32),
+ ("flags", ctypes.c_uint32),
+ ("count", ctypes.c_uint32),
+ ("ival1_tv_sec", ctypes.c_long),
+ ("ival1_tv_usec", ctypes.c_long),
+ ("ival2_tv_sec", ctypes.c_long),
+ ("ival2_tv_usec", ctypes.c_long),
+ ("can_id", ctypes.c_uint32),
+ ("nframes", ctypes.c_uint32),
+ ]
+ BcmMsgHead = bcm_header_factory(fields)
+
+ expected_fields = [
+ ("opcode", ctypes.c_uint32),
+ ("flags", ctypes.c_uint32),
+ ("count", ctypes.c_uint32),
+ ("ival1_tv_sec", ctypes.c_long),
+ ("ival1_tv_usec", ctypes.c_long),
+ ("ival2_tv_sec", ctypes.c_long),
+ ("ival2_tv_usec", ctypes.c_long),
+ ("can_id", ctypes.c_uint32),
+ ("nframes", ctypes.c_uint32),
+ # We expect 4 bytes of padding
+ ("pad_0", ctypes.c_uint8),
+ ("pad_1", ctypes.c_uint8),
+ ("pad_2", ctypes.c_uint8),
+ ("pad_3", ctypes.c_uint8),
+ ]
+ 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(
+ self, ctypes_sizeof, ctypes_alignment
+ ):
+ """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
+ """
+
+ def side_effect_ctypes_sizeof(value):
+ type_to_size = {
+ ctypes.c_longlong: 8,
+ ctypes.c_long: 4,
+ ctypes.c_uint8: 1,
+ ctypes.c_uint16: 2,
+ ctypes.c_uint32: 4,
+ ctypes.c_uint64: 8,
+ }
+ return type_to_size[value]
+
+ def side_effect_ctypes_alignment(value):
+ type_to_alignment = {
+ ctypes.c_longlong: 8,
+ ctypes.c_long: 4,
+ ctypes.c_uint8: 1,
+ ctypes.c_uint16: 2,
+ ctypes.c_uint32: 4,
+ ctypes.c_uint64: 8,
+ }
+ return type_to_alignment[value]
+
+ ctypes_sizeof.side_effect = side_effect_ctypes_sizeof
+ ctypes_alignment.side_effect = side_effect_ctypes_alignment
+
+ fields = [
+ ("opcode", ctypes.c_uint32),
+ ("flags", ctypes.c_uint32),
+ ("count", ctypes.c_uint32),
+ ("ival1_tv_sec", ctypes.c_long),
+ ("ival1_tv_usec", ctypes.c_long),
+ ("ival2_tv_sec", ctypes.c_long),
+ ("ival2_tv_usec", ctypes.c_long),
+ ("can_id", ctypes.c_uint32),
+ ("nframes", ctypes.c_uint32),
+ ]
+ BcmMsgHead = bcm_header_factory(fields)
+
+ expected_fields = [
+ ("opcode", ctypes.c_uint32),
+ ("flags", ctypes.c_uint32),
+ ("count", ctypes.c_uint32),
+ ("ival1_tv_sec", ctypes.c_long),
+ ("ival1_tv_usec", ctypes.c_long),
+ ("ival2_tv_sec", ctypes.c_long),
+ ("ival2_tv_usec", ctypes.c_long),
+ ("can_id", ctypes.c_uint32),
+ ("nframes", ctypes.c_uint32),
+ # We expect 4 bytes of padding
+ ("pad_0", ctypes.c_uint8),
+ ("pad_1", ctypes.c_uint8),
+ ("pad_2", ctypes.c_uint8),
+ ("pad_3", ctypes.c_uint8),
+ ]
+ 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(
+ self, ctypes_sizeof, ctypes_alignment
+ ):
+ """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
+ """
+
+ def side_effect_ctypes_sizeof(value):
+ type_to_size = {
+ ctypes.c_longlong: 8,
+ ctypes.c_long: 8,
+ ctypes.c_uint8: 1,
+ ctypes.c_uint16: 2,
+ ctypes.c_uint32: 4,
+ ctypes.c_uint64: 8,
+ }
+ return type_to_size[value]
+
+ def side_effect_ctypes_alignment(value):
+ type_to_alignment = {
+ ctypes.c_longlong: 8,
+ ctypes.c_long: 8,
+ ctypes.c_uint8: 1,
+ ctypes.c_uint16: 2,
+ ctypes.c_uint32: 4,
+ ctypes.c_uint64: 8,
+ }
+ return type_to_alignment[value]
+
+ ctypes_sizeof.side_effect = side_effect_ctypes_sizeof
+ ctypes_alignment.side_effect = side_effect_ctypes_alignment
+
+ fields = [
+ ("opcode", ctypes.c_uint32),
+ ("flags", ctypes.c_uint32),
+ ("count", ctypes.c_uint32),
+ ("ival1_tv_sec", ctypes.c_long),
+ ("ival1_tv_usec", ctypes.c_long),
+ ("ival2_tv_sec", ctypes.c_long),
+ ("ival2_tv_usec", ctypes.c_long),
+ ("can_id", ctypes.c_uint32),
+ ("nframes", ctypes.c_uint32),
+ ]
+ BcmMsgHead = bcm_header_factory(fields)
+
+ expected_fields = [
+ ("opcode", ctypes.c_uint32),
+ ("flags", ctypes.c_uint32),
+ ("count", ctypes.c_uint32),
+ # We expect 4 bytes of padding
+ ("pad_0", ctypes.c_uint8),
+ ("pad_1", ctypes.c_uint8),
+ ("pad_2", ctypes.c_uint8),
+ ("pad_3", ctypes.c_uint8),
+ ("ival1_tv_sec", ctypes.c_long),
+ ("ival1_tv_usec", ctypes.c_long),
+ ("ival2_tv_sec", ctypes.c_long),
+ ("ival2_tv_usec", ctypes.c_long),
+ ("can_id", ctypes.c_uint32),
+ ("nframes", ctypes.c_uint32),
+ ]
+ self.assertEqual(expected_fields, BcmMsgHead._fields_)
+
+ 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
new file mode 100644
index 000000000..86ed31362
--- /dev/null
+++ b/test/test_systec.py
@@ -0,0 +1,283 @@
+#!/usr/bin/env python
+
+import unittest
+from unittest.mock import Mock, patch
+
+import can
+from can.interfaces.systec import ucan, ucanbus
+from can.interfaces.systec.ucan import *
+
+
+class SystecTest(unittest.TestCase):
+ def compare_message(self, first, second, msg):
+ if (
+ first.arbitration_id != second.arbitration_id
+ or first.data != second.data
+ or first.is_extended_id != second.is_extended_id
+ ):
+ raise self.failureException(msg)
+
+ def setUp(self):
+ # add equality function for can.Message
+ self.addTypeEqualityFunc(can.Message, self.compare_message)
+
+ ucan.UcanInitHwConnectControlEx = Mock()
+ ucan.UcanInitHardwareEx = Mock()
+ ucan.UcanInitHardwareEx2 = Mock()
+ ucan.UcanInitCanEx2 = Mock()
+ ucan.UcanGetHardwareInfoEx2 = Mock()
+ ucan.UcanSetAcceptanceEx = Mock()
+ ucan.UcanDeinitCanEx = Mock()
+ ucan.UcanDeinitHardware = Mock()
+ ucan.UcanWriteCanMsgEx = Mock()
+ ucan.UcanResetCanEx = Mock()
+ 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
+ )
+ self.assertTrue(ucan.UcanInitCanEx2.called)
+ self.assertTrue(ucan.UcanGetHardwareInfoEx2.called)
+ self.assertTrue(ucan.UcanSetAcceptanceEx.called)
+
+ def test_bus_shutdown(self):
+ self.bus.shutdown()
+ self.assertTrue(ucan.UcanDeinitCanEx.called)
+ self.assertTrue(ucan.UcanDeinitHardware.called)
+
+ def test_filter_setup(self):
+ # no filter in the constructor
+ expected_args = ((self.bus._ucan._handle, 0, AMR_ALL, ACR_ALL),)
+ self.assertEqual(ucan.UcanSetAcceptanceEx.call_args, expected_args)
+
+ # one filter is handled by the driver
+ ucan.UcanSetAcceptanceEx.reset_mock()
+ can_filter = (True, 0x123, 0x123, False, False)
+ self.bus.set_filters(ucanbus.UcanBus.create_filter(*can_filter))
+ expected_args = (
+ (
+ self.bus._ucan._handle,
+ 0,
+ ucan.UcanServer.calculate_amr(*can_filter),
+ ucan.UcanServer.calculate_acr(*can_filter),
+ ),
+ )
+ self.assertEqual(ucan.UcanSetAcceptanceEx.call_args, expected_args)
+
+ # multiple filters are handled by the bus
+ ucan.UcanSetAcceptanceEx.reset_mock()
+ can_filter = ((False, 0x8, 0x8, False, False), (False, 0x9, 0x9, False, False))
+ self.bus.set_filters(
+ ucanbus.UcanBus.create_filter(*can_filter[0])
+ + ucanbus.UcanBus.create_filter(*can_filter[1])
+ )
+ expected_args = ((self.bus._ucan._handle, 0, AMR_ALL, ACR_ALL),)
+ self.assertEqual(ucan.UcanSetAcceptanceEx.call_args, expected_args)
+
+ @patch("can.interfaces.systec.ucan.UcanServer.write_can_msg")
+ def test_send_extended(self, mock_write_can_msg):
+ msg = can.Message(
+ arbitration_id=0xC0FFEE, data=[0, 25, 0, 1, 3, 1, 4], is_extended_id=True
+ )
+ self.bus.send(msg)
+
+ expected_args = (
+ (0, [CanMsg(msg.arbitration_id, MsgFrameFormat.MSG_FF_EXT, msg.data)]),
+ )
+ self.assertEqual(mock_write_can_msg.call_args, expected_args)
+
+ @patch("can.interfaces.systec.ucan.UcanServer.write_can_msg")
+ def test_send_standard(self, mock_write_can_msg):
+ msg = can.Message(arbitration_id=0x321, data=[50, 51], is_extended_id=False)
+ self.bus.send(msg)
+
+ expected_args = (
+ (0, [CanMsg(msg.arbitration_id, MsgFrameFormat.MSG_FF_STD, msg.data)]),
+ )
+ self.assertEqual(mock_write_can_msg.call_args, expected_args)
+
+ @patch("can.interfaces.systec.ucan.UcanServer.get_msg_pending")
+ def test_recv_no_message(self, mock_get_msg_pending):
+ mock_get_msg_pending.return_value = 0
+ self.assertEqual(self.bus.recv(timeout=0.5), None)
+
+ @patch("can.interfaces.systec.ucan.UcanServer.get_msg_pending")
+ @patch("can.interfaces.systec.ucan.UcanServer.read_can_msg")
+ def test_recv_extended(self, mock_read_can_msg, mock_get_msg_pending):
+ mock_read_can_msg.return_value = (
+ [CanMsg(0xC0FFEF, MsgFrameFormat.MSG_FF_EXT, [1, 2, 3, 4, 5, 6, 7, 8])],
+ 0,
+ )
+ mock_get_msg_pending.return_value = 1
+
+ msg = can.Message(
+ arbitration_id=0xC0FFEF, data=[1, 2, 3, 4, 5, 6, 7, 8], is_extended_id=True
+ )
+ can_msg = self.bus.recv()
+ self.assertEqual(can_msg, msg)
+
+ @patch("can.interfaces.systec.ucan.UcanServer.get_msg_pending")
+ @patch("can.interfaces.systec.ucan.UcanServer.read_can_msg")
+ def test_recv_standard(self, mock_read_can_msg, mock_get_msg_pending):
+ mock_read_can_msg.return_value = (
+ [CanMsg(0x321, MsgFrameFormat.MSG_FF_STD, [50, 51])],
+ 0,
+ )
+ mock_get_msg_pending.return_value = 1
+
+ msg = can.Message(arbitration_id=0x321, data=[50, 51], is_extended_id=False)
+ can_msg = self.bus.recv()
+ self.assertEqual(can_msg, msg)
+
+ @staticmethod
+ def test_bus_defaults():
+ ucan.UcanInitCanEx2.reset_mock()
+ bus = can.Bus(interface="systec", channel=0)
+ ucan.UcanInitCanEx2.assert_called_once_with(
+ bus._ucan._handle,
+ 0,
+ InitCanParam(
+ Mode.MODE_NORMAL,
+ Baudrate.BAUD_500kBit,
+ OutputControl.OCR_DEFAULT,
+ AMR_ALL,
+ ACR_ALL,
+ BaudrateEx.BAUDEX_USE_BTR01,
+ DEFAULT_BUFFER_ENTRIES,
+ DEFAULT_BUFFER_ENTRIES,
+ ),
+ )
+
+ @staticmethod
+ def test_bus_channel():
+ ucan.UcanInitCanEx2.reset_mock()
+ bus = can.Bus(interface="systec", channel=1)
+ ucan.UcanInitCanEx2.assert_called_once_with(
+ bus._ucan._handle,
+ 1,
+ InitCanParam(
+ Mode.MODE_NORMAL,
+ Baudrate.BAUD_500kBit,
+ OutputControl.OCR_DEFAULT,
+ AMR_ALL,
+ ACR_ALL,
+ BaudrateEx.BAUDEX_USE_BTR01,
+ DEFAULT_BUFFER_ENTRIES,
+ DEFAULT_BUFFER_ENTRIES,
+ ),
+ )
+
+ @staticmethod
+ def test_bus_bitrate():
+ ucan.UcanInitCanEx2.reset_mock()
+ bus = can.Bus(interface="systec", channel=0, bitrate=125000)
+ ucan.UcanInitCanEx2.assert_called_once_with(
+ bus._ucan._handle,
+ 0,
+ InitCanParam(
+ Mode.MODE_NORMAL,
+ Baudrate.BAUD_125kBit,
+ OutputControl.OCR_DEFAULT,
+ AMR_ALL,
+ ACR_ALL,
+ BaudrateEx.BAUDEX_USE_BTR01,
+ DEFAULT_BUFFER_ENTRIES,
+ DEFAULT_BUFFER_ENTRIES,
+ ),
+ )
+
+ def test_bus_custom_bitrate(self):
+ with self.assertRaises(ValueError):
+ can.Bus(interface="systec", channel=0, bitrate=123456)
+
+ @staticmethod
+ def test_receive_own_messages():
+ ucan.UcanInitCanEx2.reset_mock()
+ bus = can.Bus(interface="systec", channel=0, receive_own_messages=True)
+ ucan.UcanInitCanEx2.assert_called_once_with(
+ bus._ucan._handle,
+ 0,
+ InitCanParam(
+ Mode.MODE_TX_ECHO,
+ Baudrate.BAUD_500kBit,
+ OutputControl.OCR_DEFAULT,
+ AMR_ALL,
+ ACR_ALL,
+ BaudrateEx.BAUDEX_USE_BTR01,
+ DEFAULT_BUFFER_ENTRIES,
+ DEFAULT_BUFFER_ENTRIES,
+ ),
+ )
+
+ @staticmethod
+ def test_bus_passive_state():
+ ucan.UcanInitCanEx2.reset_mock()
+ bus = can.Bus(interface="systec", channel=0, state=can.BusState.PASSIVE)
+ ucan.UcanInitCanEx2.assert_called_once_with(
+ bus._ucan._handle,
+ 0,
+ InitCanParam(
+ Mode.MODE_LISTEN_ONLY,
+ Baudrate.BAUD_500kBit,
+ OutputControl.OCR_DEFAULT,
+ AMR_ALL,
+ ACR_ALL,
+ BaudrateEx.BAUDEX_USE_BTR01,
+ DEFAULT_BUFFER_ENTRIES,
+ DEFAULT_BUFFER_ENTRIES,
+ ),
+ )
+
+ @staticmethod
+ def test_rx_buffer_entries():
+ ucan.UcanInitCanEx2.reset_mock()
+ bus = can.Bus(interface="systec", channel=0, rx_buffer_entries=1024)
+ ucan.UcanInitCanEx2.assert_called_once_with(
+ bus._ucan._handle,
+ 0,
+ InitCanParam(
+ Mode.MODE_NORMAL,
+ Baudrate.BAUD_500kBit,
+ OutputControl.OCR_DEFAULT,
+ AMR_ALL,
+ ACR_ALL,
+ BaudrateEx.BAUDEX_USE_BTR01,
+ 1024,
+ DEFAULT_BUFFER_ENTRIES,
+ ),
+ )
+
+ @staticmethod
+ def test_tx_buffer_entries():
+ ucan.UcanInitCanEx2.reset_mock()
+ bus = can.Bus(interface="systec", channel=0, tx_buffer_entries=1024)
+ ucan.UcanInitCanEx2.assert_called_once_with(
+ bus._ucan._handle,
+ 0,
+ InitCanParam(
+ Mode.MODE_NORMAL,
+ Baudrate.BAUD_500kBit,
+ OutputControl.OCR_DEFAULT,
+ AMR_ALL,
+ ACR_ALL,
+ BaudrateEx.BAUDEX_USE_BTR01,
+ DEFAULT_BUFFER_ENTRIES,
+ 1024,
+ ),
+ )
+
+ def test_flush_tx_buffer(self):
+ self.bus.flush_tx_buffer()
+ ucan.UcanResetCanEx.assert_called_once_with(
+ self.bus._ucan._handle, 0, ResetFlags.RESET_ONLY_TX_BUFF
+ )
+
+
+if __name__ == "__main__":
+ unittest.main()
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
new file mode 100644
index 000000000..5d074f614
--- /dev/null
+++ b/test/test_vector.py
@@ -0,0 +1,1297 @@
+#!/usr/bin/env python
+
+"""
+Test for Vector Interface
+"""
+
+import ctypes
+import functools
+import pickle
+import sys
+import time
+from test.config import IS_WINDOWS
+from unittest.mock import Mock
+
+import pytest
+
+import can
+from can.interfaces.vector import (
+ VectorBusParams,
+ VectorCanFdParams,
+ VectorCanParams,
+ VectorChannelConfig,
+ VectorError,
+ VectorInitializationError,
+ VectorOperationError,
+ canlib,
+ xlclass,
+ xldefine,
+)
+
+XLDRIVER_FOUND = canlib.xldriver is not None
+
+
+@pytest.fixture()
+def mock_xldriver() -> None:
+ # basic mock for XLDriver
+ xldriver_mock = 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)
+
+ # bus deactivation functions
+ xldriver_mock.xlDeactivateChannel = Mock(return_value=0)
+ xldriver_mock.xlClosePort = Mock(return_value=0)
+ xldriver_mock.xlCloseDriver = Mock()
+
+ # sender functions
+ xldriver_mock.xlCanTransmit = Mock(return_value=0)
+ xldriver_mock.xlCanTransmitEx = Mock(return_value=0)
+
+ # various functions
+ xldriver_mock.xlCanFlushTransmitQueue = Mock()
+
+ # backup unmodified values
+ real_xldriver = canlib.xldriver
+ real_waitforsingleobject = canlib.WaitForSingleObject
+ real_has_events = canlib.HAS_EVENTS
+
+ # set mock
+ canlib.xldriver = xldriver_mock
+ canlib.HAS_EVENTS = False
+
+ yield
+
+ # cleanup
+ canlib.xldriver = real_xldriver
+ canlib.WaitForSingleObject = real_waitforsingleobject
+ canlib.HAS_EVENTS = real_has_events
+
+
+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.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
+
+
+@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,
+ )
+ bus = can.Bus(
+ channel=0,
+ serial=_find_virtual_can_serial(),
+ interface="vector",
+ timing=timing,
+ )
+ 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 == 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(
+ app_name_p: ctypes.c_char_p,
+ app_channel: ctypes.c_uint,
+ hw_type: ctypes.POINTER(ctypes.c_uint),
+ hw_index: ctypes.POINTER(ctypes.c_uint),
+ hw_channel: ctypes.POINTER(ctypes.c_uint),
+ bus_type: ctypes.c_uint,
+) -> int:
+ hw_type.value = 1
+ hw_channel.value = 0
+ return 0
+
+
+def xlGetChannelIndex(
+ hw_type: ctypes.c_int, hw_index: ctypes.c_int, hw_channel: ctypes.c_int
+) -> int:
+ return hw_channel
+
+
+def xlOpenPort(
+ port_handle_p: ctypes.POINTER(xlclass.XLportHandle),
+ app_name_p: ctypes.c_char_p,
+ 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
+
+
+def xlGetSyncTime(
+ port_handle: xlclass.XLportHandle, time_p: ctypes.POINTER(xlclass.XLuint64)
+) -> int:
+ time_p.value = 544219859027581
+ return 0
+
+
+def xlSetNotification(
+ port_handle: xlclass.XLportHandle,
+ event_handle: ctypes.POINTER(xlclass.XLhandle),
+ queue_level: ctypes.c_int,
+) -> int:
+ event_handle.value = 520
+ return 0
+
+
+def xlReceive(
+ port_handle: xlclass.XLportHandle,
+ event_count_p: ctypes.POINTER(ctypes.c_uint),
+ event: ctypes.POINTER(xlclass.XLevent),
+) -> int:
+ event.tag = xldefine.XL_EventTags.XL_RECEIVE_MSG.value
+ event.tagData.msg.id = 0x123
+ event.tagData.msg.dlc = 8
+ event.tagData.msg.flags = 0
+ event.timeStamp = 0
+ event.chanIndex = 0
+ for idx, value in enumerate([1, 2, 3, 4, 5, 6, 7, 8]):
+ event.tagData.msg.data[idx] = value
+ return 0
+
+
+def xlCanReceive(
+ port_handle: xlclass.XLportHandle, event: ctypes.POINTER(xlclass.XLcanRxEvent)
+) -> int:
+ event.tag = xldefine.XL_CANFD_RX_EventTags.XL_CAN_EV_TAG_RX_OK.value
+ event.tagData.canRxOkMsg.canId = 0x123
+ event.tagData.canRxOkMsg.dlc = 8
+ event.tagData.canRxOkMsg.msgFlags = 0
+ event.timeStamp = 0
+ event.chanIndex = 0
+ for idx, value in enumerate([1, 2, 3, 4, 5, 6, 7, 8]):
+ event.tagData.canRxOkMsg.data[idx] = value
+ return 0
+
+
+def xlReceive_chipstate(
+ port_handle: xlclass.XLportHandle,
+ event_count_p: ctypes.POINTER(ctypes.c_uint),
+ event: ctypes.POINTER(xlclass.XLevent),
+) -> int:
+ event.tag = xldefine.XL_EventTags.XL_CHIP_STATE.value
+ event.tagData.chipState.busStatus = 8
+ event.tagData.chipState.rxErrorCounter = 0
+ event.tagData.chipState.txErrorCounter = 0
+ event.timeStamp = 0
+ event.chanIndex = 2
+ return 0
+
+
+def xlCanReceive_chipstate(
+ port_handle: xlclass.XLportHandle, event: ctypes.POINTER(xlclass.XLcanRxEvent)
+) -> int:
+ event.tag = xldefine.XL_CANFD_RX_EventTags.XL_CAN_EV_TAG_CHIP_STATE.value
+ event.tagData.canChipState.busStatus = 8
+ event.tagData.canChipState.rxErrorCounter = 0
+ event.tagData.canChipState.txErrorCounter = 0
+ event.timeStamp = 0
+ event.chanIndex = 2
+ return 0
diff --git a/test/test_viewer.py b/test/test_viewer.py
index d978f12ed..e71d06dc8 100644
--- a/test/test_viewer.py
+++ b/test/test_viewer.py
@@ -1,7 +1,20 @@
-#!/usr/bin/python
-# coding: utf-8
+#!/usr/bin/env python
#
-# Copyright (C) 2018 Kristian Sloth Lauszus. All rights reserved.
+# Copyright (C) 2018 Kristian Sloth Lauszus.
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 3 of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#
# Contact information
# -------------------
@@ -9,37 +22,37 @@
# Web : http://www.lauszus.com
# e-mail : lauszus@gmail.com
-from __future__ import absolute_import
-
import argparse
-import can
-import curses
import math
-import pytest
+import os
import random
import struct
import time
import unittest
-import os
-import six
+from collections import defaultdict
+from test.config import IS_CI
+from unittest.mock import patch
-from typing import Dict, Tuple, Union
+import pytest
+import can
+from can.viewer import CanViewer, _parse_viewer_args
+
+# Allow the curses module to be missing (e.g. on PyPy on Windows)
try:
- # noinspection PyCompatibility
- from unittest.mock import Mock, patch
-except ImportError:
- # noinspection PyPackageRequirements
- from mock import Mock, patch
+ import curses
-from can.viewer import KEY_ESC, KEY_SPACE, CanViewer, parse_args
+ 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():
@@ -52,15 +65,20 @@ 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() < .5:
+ if random.random() < 0.5:
raise curses.error
@staticmethod
@@ -68,19 +86,26 @@ def nodelay(_bool):
pass
def getch(self):
+ assert curses is not None
+
self.key_counter += 1
if self.key_counter == 1:
# Send invalid key
return -1
elif self.key_counter == 2:
- return ord('c') # Clear
+ 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
-
+ 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
@@ -88,49 +113,49 @@ 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):
# Set seed, so the tests are not affected
random.seed(0)
def setUp(self):
- stdscr = StdscrDummy()
- config = {'interface': 'virtual', 'receive_own_messages': True}
+ self.stdscr_dummy = StdscrDummy()
+ config = {"interface": "virtual", "receive_own_messages": True}
bus = can.Bus(**config)
data_structs = None
- patch_curs_set = patch('curses.curs_set')
+ patch_curs_set = patch("curses.curs_set")
patch_curs_set.start()
self.addCleanup(patch_curs_set.stop)
- patch_use_default_colors = patch('curses.use_default_colors')
+ patch_use_default_colors = patch("curses.use_default_colors")
patch_use_default_colors.start()
self.addCleanup(patch_use_default_colors.stop)
- patch_init_pair = patch('curses.init_pair')
+ patch_init_pair = patch("curses.init_pair")
patch_init_pair.start()
self.addCleanup(patch_init_pair.stop)
- patch_color_pair = patch('curses.color_pair')
+ patch_color_pair = patch("curses.color_pair")
patch_color_pair.start()
self.addCleanup(patch_color_pair.stop)
- patch_is_term_resized = patch('curses.is_term_resized')
+ patch_is_term_resized = patch("curses.is_term_resized")
mock_is_term_resized = patch_is_term_resized.start()
- mock_is_term_resized.return_value = True if random.random() < .5 else False
+ mock_is_term_resized.return_value = True if random.random() < 0.5 else False
self.addCleanup(patch_is_term_resized.stop)
- if hasattr(curses, 'resizeterm'):
- patch_resizeterm = patch('curses.resizeterm')
+ if hasattr(curses, "resizeterm"):
+ patch_resizeterm = patch("curses.resizeterm")
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
@@ -140,36 +165,46 @@ def tearDown(self):
def test_send(self):
# CANopen EMCY
data = [1, 2, 3, 4, 5, 6, 7] # Wrong length
- msg = can.Message(arbitration_id=0x080 + 1, data=data, extended_id=False)
+ msg = can.Message(arbitration_id=0x080 + 1, data=data, is_extended_id=False)
self.can_viewer.bus.send(msg)
data = [1, 2, 3, 4, 5, 6, 7, 8]
- msg = can.Message(arbitration_id=0x080 + 1, data=data, extended_id=False)
+ msg = can.Message(arbitration_id=0x080 + 1, data=data, is_extended_id=False)
self.can_viewer.bus.send(msg)
# CANopen HEARTBEAT
data = [0x05] # Operational
- msg = can.Message(arbitration_id=0x700 + 0x7F, data=data, extended_id=False)
+ msg = can.Message(arbitration_id=0x700 + 0x7F, data=data, is_extended_id=False)
self.can_viewer.bus.send(msg)
# Send non-CANopen message
data = [1, 2, 3, 4, 5, 6, 7, 8]
- msg = can.Message(arbitration_id=0x101, data=data, extended_id=False)
+ msg = can.Message(arbitration_id=0x101, data=data, is_extended_id=False)
self.can_viewer.bus.send(msg)
# Send the same command, but with another data length
data = [1, 2, 3, 4, 5, 6]
- msg = can.Message(arbitration_id=0x101, data=data, extended_id=False)
+ 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, extended_id=True)
+ msg = can.Message(arbitration_id=0x123456, data=data, is_extended_id=True)
self.can_viewer.bus.send(msg)
# self.assertTupleEqual(self.can_viewer.parse_canopen_message(msg), (None, None))
# Send the same message again to make sure that resending works and dt is correct
- time.sleep(.1)
+ time.sleep(0.1)
self.can_viewer.bus.send(msg)
# Send error message
@@ -182,41 +217,59 @@ def test_receive(self):
data_structs = {
# For converting the EMCY and HEARTBEAT messages
- 0x080 + 0x01: struct.Struct('ff'),
+ 0x123456: struct.Struct(">ff"),
}
# Receive the messages we just sent in 'test_canopen'
while 1:
msg = self.can_viewer.bus.recv(timeout=0)
if msg is not None:
- self.can_viewer.data_structs = data_structs if msg.arbitration_id != 0x101 else None
+ self.can_viewer.data_structs = (
+ data_structs if msg.arbitration_id != 0x101 else None
+ )
_id = self.can_viewer.draw_can_bus_message(msg)
- if _id['msg'].arbitration_id == 0x101:
+ if _id["msg"].arbitration_id == 0x101:
# Check if the counter is reset when the length has changed
- self.assertEqual(_id['count'], 1)
- elif _id['msg'].arbitration_id == 0x123456:
+ 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)
+ if _id["dt"] == 0:
+ self.assertEqual(_id["count"], 1)
else:
- self.assertTrue(pytest.approx(_id['dt'], 0.1)) # dt should be ~0.1 s
- self.assertEqual(_id['count'], 2)
+ 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
- if _id['count'] == 1:
- self.assertEqual(_id['dt'], 0)
+ if _id["count"] == 1:
+ self.assertEqual(_id["dt"], 0)
else:
break
# Convert it into raw integer values and then pack the data
@staticmethod
- def pack_data(cmd, cmd_to_struct, *args): # type: (int, Dict, Union[*float, *int]) -> bytes
+ def pack_data(
+ cmd, cmd_to_struct, *args
+ ): # type: (int, Dict, Union[*float, *int]) -> bytes
if not cmd_to_struct or len(args) == 0:
# If no arguments are given, then the message does not contain a data package
- return b''
+ return b""
for key in cmd_to_struct.keys():
if cmd == key if isinstance(key, int) else cmd in key:
@@ -227,17 +280,17 @@ def pack_data(cmd, cmd_to_struct, *args): # type: (int, Dict, Union[*float, *in
# The conversion from SI-units to raw values are given in the rest of the tuple
fmt = struct_t.format
- if isinstance(fmt, six.string_types): # pragma: no cover
+ if isinstance(fmt, str): # pragma: no cover
# Needed for Python 3.7
- fmt = six.b(fmt)
+ fmt = fmt.encode()
# Make sure the endian is given as the first argument
- assert six.byte2int(fmt) == ord('<') or six.byte2int(fmt) == ord('>')
+ assert fmt[0] == ord("<") or fmt[0] == ord(">")
# Disable rounding if the format is a float
data = []
- for c, arg, val in zip(six.iterbytes(fmt[1:]), args, value[1:]):
- if c == ord('f'):
+ for c, arg, val in zip(fmt[1:], args, value[1:]):
+ if c == ord("f"):
data.append(arg * val)
else:
data.append(round(arg * val))
@@ -248,7 +301,7 @@ def pack_data(cmd, cmd_to_struct, *args): # type: (int, Dict, Union[*float, *in
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
@@ -276,34 +329,41 @@ def test_pack_unpack(self):
# are divided by the value in order to convert from real units to raw integer values.
data_structs = {
# CANopen node 1
- CANOPEN_TPDO1 + 1: struct.Struct('lL'),
- (CANOPEN_TPDO3 + 2, CANOPEN_TPDO4 + 2): struct.Struct('>LL'),
+ CANOPEN_TPDO2 + 2: struct.Struct(">lL"),
+ (CANOPEN_TPDO3 + 2, CANOPEN_TPDO4 + 2): struct.Struct(">LL"),
} # type: Dict[Union[int, Tuple[int, ...]], Union[struct.Struct, Tuple, None]]
- raw_data = self.pack_data(CANOPEN_TPDO1 + 1, data_structs, -7, 13, -1024, 2048, 0xFFFF)
+ raw_data = self.pack_data(
+ CANOPEN_TPDO1 + 1, data_structs, -7, 13, -1024, 2048, 0xFFFF
+ )
parsed_data = CanViewer.unpack_data(CANOPEN_TPDO1 + 1, data_structs, raw_data)
self.assertListEqual(parsed_data, [-7, 13, -1024, 2048, 0xFFFF])
self.assertTrue(all(isinstance(d, int) for d in parsed_data))
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]))
- self.assertTrue(isinstance(parsed_data[0], float) and isinstance(parsed_data[1], float) and
- isinstance(parsed_data[2], int))
+ assert parsed_data == pytest.approx([12.34, 4.5, 6])
+ self.assertTrue(
+ isinstance(parsed_data[0], float)
+ and isinstance(parsed_data[1], float)
+ and isinstance(parsed_data[2], int)
+ )
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., math.pi)
+ 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., 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)
@@ -311,7 +371,9 @@ def test_pack_unpack(self):
self.assertListEqual(parsed_data, [])
self.assertIsInstance(parsed_data, list)
- raw_data = self.pack_data(CANOPEN_TPDO2 + 2, data_structs, -2147483648, 0xFFFFFFFF)
+ raw_data = self.pack_data(
+ CANOPEN_TPDO2 + 2, data_structs, -2147483648, 0xFFFFFFFF
+ )
parsed_data = CanViewer.unpack_data(CANOPEN_TPDO2 + 2, data_structs, raw_data)
self.assertListEqual(parsed_data, [-2147483648, 0xFFFFFFFF])
@@ -323,59 +385,63 @@ def test_pack_unpack(self):
parsed_data = CanViewer.unpack_data(CANOPEN_TPDO4 + 2, data_structs, raw_data)
self.assertListEqual(parsed_data, [0xFFFFFF, 0xFFFFFFFF])
- # See: http://python-future.org/compatible_idioms.html#long-integers
- from past.builtins import long
- self.assertTrue(all(isinstance(d, (int, long)) for d in parsed_data))
+ self.assertTrue(all(isinstance(d, int) for d in parsed_data))
# Make sure that the ValueError exception is raised
with self.assertRaises(ValueError):
self.pack_data(0x101, data_structs, 1, 2, 3, 4)
with self.assertRaises(ValueError):
- CanViewer.unpack_data(0x102, data_structs, b'\x01\x02\x03\x04\x05\x06\x07\x08')
+ CanViewer.unpack_data(
+ 0x102, data_structs, b"\x01\x02\x03\x04\x05\x06\x07\x08"
+ )
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'])
- self.assertEqual(parsed_args.channel, 'can0')
+ parsed_args, _ = _parse_viewer_args(["-c", "can0"])
+ self.assertEqual(parsed_args.channel, "can0")
- parsed_args, _, _ = parse_args(['--channel', 'PCAN_USBBUS1'])
- self.assertEqual(parsed_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: