Merge branch 'develop' into felixdivo-patch-socketcan

Author: hardbyte

.mergify.yml

@@ -0,0 +1,10 @@
+pull_request_rules:
+  - name: Automatic merge on up to date branch with dual approval
+    conditions:
+      - "#approved-reviews-by>=2"
+      - "status-success=continuous-integration/travis-ci/pr"
+      - "label!=work-in-progress"
+    actions:
+      merge:
+        method: merge
+        strict: true

can/broadcastmanager.py

@@ -5,7 +5,7 @@
 :meth:`can.BusABC.send_periodic`.
 """
 
-from typing import Optional, Sequence, Tuple, Union, TYPE_CHECKING
+from typing import Optional, Sequence, Tuple, Union, Callable, TYPE_CHECKING
 
 from can import typechecking
 
@@ -198,7 +198,7 @@ def __init__(
 class ThreadBasedCyclicSendTask(
     ModifiableCyclicTaskABC, LimitedDurationCyclicSendTaskABC, RestartableCyclicTaskABC
 ):
-    """Fallback cyclic send task using thread."""
+    """Fallback cyclic send task using daemon thread."""
 
     def __init__(
         self,
@@ -207,13 +207,28 @@ def __init__(
         messages: Union[Sequence[Message], Message],
         period: float,
         duration: Optional[float] = None,
+        on_error: Optional[Callable[[Exception], bool]] = None,
     ):
+        """Transmits `messages` with a `period` seconds for `duration` seconds on a `bus`.
+
+        The `on_error` is called if any error happens on `bus` while sending `messages`.
+        If `on_error` present, and returns ``False`` when invoked, thread is
+        stopped immediately, otherwise, thread continuiously tries to send `messages`
+        ignoring errors on a `bus`. Absence of `on_error` means that thread exits immediately
+        on error.
+
+        :param on_error: The callable that accepts an exception if any
+                         error happened on a `bus` while sending `messages`,
+                         it shall return either ``True`` or ``False`` depending
+                         on desired behaviour of `ThreadBasedCyclicSendTask`.
+        """
         super().__init__(messages, period, duration)
         self.bus = bus
         self.send_lock = lock
         self.stopped = True
         self.thread = None
         self.end_time = time.perf_counter() + duration if duration else None
+        self.on_error = on_error
 
         if HAS_EVENTS:
             self.period_ms: int = int(round(period * 1000, 0))
@@ -250,7 +265,11 @@ def _run(self):
                     self.bus.send(self.messages[msg_index])
                 except Exception as exc:
                     log.exception(exc)
-                    break
+                    if self.on_error:
+                        if not self.on_error(exc):
+                            break
+                    else:
+                        break
             if self.end_time is not None and time.perf_counter() >= self.end_time:
                 break
             msg_index = (msg_index + 1) % len(self.messages)

can/io/asc.py

@@ -6,7 +6,7 @@
     - under `test/data/logfile.asc`
 """
 
-from typing import cast, Any, Generator, IO, List, Optional, Tuple, Union
+from typing import cast, Any, Generator, IO, List, Optional, Union, Dict
 from can import typechecking
 
 from datetime import datetime
@@ -53,122 +53,165 @@ def __init__(
         if not self.file:
             raise ValueError("The given file cannot be None")
         self.base = base
+        self._converted_base = self._check_base(base)
+        self.date = None
+        self.timestamps_format = None
+        self.internal_events_logged = None
 
-    @staticmethod
-    def _extract_can_id(str_can_id: str, base: int) -> Tuple[int, bool]:
+    def _extract_header(self):
+        for line in self.file:
+            line = line.strip()
+            lower_case = line.lower()
+            if lower_case.startswith("date"):
+                self.date = line[5:]
+            elif lower_case.startswith("base"):
+                try:
+                    _, base, _, timestamp_format = line.split()
+                except ValueError:
+                    raise Exception("Unsupported header string format: {}".format(line))
+                self.base = base
+                self._converted_base = self._check_base(self.base)
+                self.timestamps_format = timestamp_format
+            elif lower_case.endswith("internal events logged"):
+                self.internal_events_logged = not lower_case.startswith("no")
+                # Currently the last line in the header which is parsed
+                break
+            else:
+                break
+
+    def _extract_can_id(self, str_can_id: str, msg_kwargs: Dict[str, Any]) -> None:
         if str_can_id[-1:].lower() == "x":
-            is_extended = True
-            can_id = int(str_can_id[0:-1], base)
+            msg_kwargs["is_extended_id"] = True
+            can_id = int(str_can_id[0:-1], self._converted_base)
         else:
-            is_extended = False
-            can_id = int(str_can_id, base)
-        return can_id, is_extended
+            msg_kwargs["is_extended_id"] = False
+            can_id = int(str_can_id, self._converted_base)
+        msg_kwargs["arbitration_id"] = can_id
 
     @staticmethod
     def _check_base(base: str) -> int:
         if base not in ["hex", "dec"]:
             raise ValueError('base should be either "hex" or "dec"')
         return BASE_DEC if base == "dec" else BASE_HEX
 
+    def _process_data_string(
+        self, data_str: str, data_length: int, msg_kwargs: Dict[str, Any]
+    ) -> None:
+        frame = bytearray()
+        data = data_str.split()
+        for byte in data[:data_length]:
+            frame.append(int(byte, self._converted_base))
+        msg_kwargs["data"] = frame
+
+    def _process_classic_can_frame(
+        self, line: str, msg_kwargs: Dict[str, Any]
+    ) -> Message:
+
+        # CAN error frame
+        if line.strip()[0:10].lower() == "errorframe":
+            # Error Frame
+            msg_kwargs["is_error_frame"] = True
+        else:
+            abr_id_str, dir, rest_of_message = line.split(None, 2)
+            msg_kwargs["is_rx"] = dir == "Rx"
+            self._extract_can_id(abr_id_str, msg_kwargs)
+
+            if rest_of_message[0].lower() == "r":
+                # CAN Remote Frame
+                msg_kwargs["is_remote_frame"] = True
+                remote_data = rest_of_message.split()
+                if len(remote_data) > 1:
+                    dlc_str = remote_data[1]
+                    if dlc_str.isdigit():
+                        msg_kwargs["dlc"] = int(dlc_str, self._converted_base)
+            else:
+                # Classic CAN Message
+                try:
+                    # There is data after DLC
+                    _, dlc_str, data = rest_of_message.split(None, 2)
+                except ValueError:
+                    # No data after DLC
+                    _, dlc_str = rest_of_message.split(None, 1)
+                    data = ""
+
+                dlc = int(dlc_str, self._converted_base)
+                msg_kwargs["dlc"] = dlc
+                self._process_data_string(data, dlc, msg_kwargs)
+
+        return Message(**msg_kwargs)
+
+    def _process_fd_can_frame(self, line: str, msg_kwargs: Dict[str, Any]) -> Message:
+        channel, dir, rest_of_message = line.split(None, 2)
+        # See ASCWriter
+        msg_kwargs["channel"] = int(channel) - 1
+        msg_kwargs["is_rx"] = dir == "Rx"
+
+        # CAN FD error frame
+        if rest_of_message.strip()[:10].lower() == "errorframe":
+            # Error Frame
+            # TODO: maybe use regex to parse BRS, ESI, etc?
+            msg_kwargs["is_error_frame"] = True
+        else:
+            can_id_str, frame_name_or_brs, rest_of_message = rest_of_message.split(
+                None, 2
+            )
+
+            if frame_name_or_brs.isdigit():
+                brs = frame_name_or_brs
+                esi, dlc_str, data_length_str, data = rest_of_message.split(None, 3)
+            else:
+                brs, esi, dlc_str, data_length_str, data = rest_of_message.split(
+                    None, 4
+                )
+
+            self._extract_can_id(can_id_str, msg_kwargs)
+            msg_kwargs["bitrate_switch"] = brs == "1"
+            msg_kwargs["error_state_indicator"] = esi == "1"
+            dlc = int(dlc_str, self._converted_base)
+            msg_kwargs["dlc"] = dlc
+            data_length = int(data_length_str)
+
+            # CAN remote Frame
+            msg_kwargs["is_remote_frame"] = data_length == 0
+
+            self._process_data_string(data, data_length, msg_kwargs)
+
+        return Message(**msg_kwargs)
+
     def __iter__(self) -> Generator[Message, None, None]:
-        base = self._check_base(self.base)
         # This is guaranteed to not be None since we raise ValueError in __init__
         self.file = cast(IO[Any], self.file)
-        for line in self.file:
-            # logger.debug("ASCReader: parsing line: '%s'", line.splitlines()[0])
-            if line.split(" ")[0] == "base":
-                base = self._check_base(line.split(" ")[1])
+        self._extract_header()
 
+        for line in self.file:
             temp = line.strip()
             if not temp or not temp[0].isdigit():
+                # Could be a comment
                 continue
-            is_fd = False
-            is_rx = True
+            msg_kwargs = {}
             try:
-                timestamp, channel, dummy = temp.split(
-                    None, 2
-                )  # , frameType, dlc, frameData
+                timestamp, channel, rest_of_message = temp.split(None, 2)
+                timestamp = float(timestamp)
+                msg_kwargs["timestamp"] = timestamp
                 if channel == "CANFD":
-                    timestamp, _, channel, direction, dummy = temp.split(None, 4)
-                    is_fd = True
-                    is_rx = direction == "Rx"
+                    msg_kwargs["is_fd"] = True
+                elif channel.isdigit():
+                    # See ASCWriter
+                    msg_kwargs["channel"] = int(channel) - 1
+                else:
+                    # Not a CAN message. Possible values include "statistic", J1939TP
+                    continue
             except ValueError:
-                # we parsed an empty comment
+                # Some other unprocessed or unknown format
                 continue
-            timestamp = float(timestamp)
-            try:
-                # See ASCWriter
-                channel = int(channel) - 1
-            except ValueError:
-                pass
-            if dummy.strip()[0:10].lower() == "errorframe":
-                msg = Message(timestamp=timestamp, is_error_frame=True, channel=channel)
-                yield msg
-            elif (
-                not isinstance(channel, int)
-                or dummy.strip()[0:10].lower() == "statistic:"
-                or dummy.split(None, 1)[0] == "J1939TP"
-            ):
-                pass
-            elif dummy[-1:].lower() == "r":
-                can_id_str, direction, _ = dummy.split(None, 2)
-                can_id_num, is_extended_id = self._extract_can_id(can_id_str, base)
-                msg = Message(
-                    timestamp=timestamp,
-                    arbitration_id=can_id_num & CAN_ID_MASK,
-                    is_extended_id=is_extended_id,
-                    is_remote_frame=True,
-                    is_rx=direction == "Rx",
-                    channel=channel,
-                )
-                yield msg
+
+            if "is_fd" not in msg_kwargs:
+                msg = self._process_classic_can_frame(rest_of_message, msg_kwargs)
             else:
-                brs = None
-                esi = None
-                data_length = 0
-                try:
-                    # this only works if dlc > 0 and thus data is available
-                    if not is_fd:
-                        can_id_str, direction, _, dlc, data = dummy.split(None, 4)
-                        is_rx = direction == "Rx"
-                    else:
-                        can_id_str, frame_name, brs, esi, dlc, data_length, data = dummy.split(
-                            None, 6
-                        )
-                        if frame_name.isdigit():
-                            # Empty frame_name
-                            can_id_str, brs, esi, dlc, data_length, data = dummy.split(
-                                None, 5
-                            )
-                except ValueError:
-                    # but if not, we only want to get the stuff up to the dlc
-                    can_id_str, _, _, dlc = dummy.split(None, 3)
-                    # and we set data to an empty sequence manually
-                    data = ""
-                dlc = int(dlc, base)
-                if is_fd:
-                    # For fd frames, dlc and data length might not be equal and
-                    # data_length is the actual size of the data
-                    dlc = int(data_length)
-                frame = bytearray()
-                data = data.split()
-                for byte in data[0:dlc]:
-                    frame.append(int(byte, base))
-                can_id_num, is_extended_id = self._extract_can_id(can_id_str, base)
-
-                yield Message(
-                    timestamp=timestamp,
-                    arbitration_id=can_id_num & CAN_ID_MASK,
-                    is_extended_id=is_extended_id,
-                    is_remote_frame=False,
-                    dlc=dlc,
-                    data=frame,
-                    is_fd=is_fd,
-                    is_rx=is_rx,
-                    channel=channel,
-                    bitrate_switch=is_fd and brs == "1",
-                    error_state_indicator=is_fd and esi == "1",
-                )
+                msg = self._process_fd_can_frame(rest_of_message, msg_kwargs)
+            if msg is not None:
+                yield msg
+
         self.stop()
 
 
@@ -190,7 +233,7 @@ class ASCWriter(BaseIOHandler, Listener):
             "{id:>8}  {symbolic_name:>32}",
             "{brs}",
             "{esi}",
-            "{dlc}",
+            "{dlc:x}",
             "{data_length:>2}",
             "{data}",
             "{message_duration:>8}",
@@ -281,10 +324,10 @@ def on_message_received(self, msg: Message) -> None:
             self.log_event("{}  ErrorFrame".format(self.channel), msg.timestamp)
             return
         if msg.is_remote_frame:
-            dtype = "r"
+            dtype = "r {:x}".format(msg.dlc)  # New after v8.5
             data: List[str] = []
         else:
-            dtype = "d {}".format(msg.dlc)
+            dtype = "d {:x}".format(msg.dlc)
             data = ["{:02X}".format(byte) for byte in msg.data]
         arb_id = "{:X}".format(msg.arbitration_id)
         if msg.is_extended_id:

can/listener.py

@@ -82,10 +82,10 @@ class BufferedReader(Listener):
     be serviced. The messages can then be fetched with
     :meth:`~can.BufferedReader.get_message`.
 
-    Putting in messages after :meth:`~can.BufferedReader.stop` has be called will raise
+    Putting in messages after :meth:`~can.BufferedReader.stop` has been called will raise
     an exception, see :meth:`~can.BufferedReader.on_message_received`.
 
-    :attr bool is_stopped: ``True`` iff the reader has been stopped
+    :attr bool is_stopped: ``True`` if the reader has been stopped
     """
 
     def __init__(self):

doc/configuration.rst

@@ -43,9 +43,9 @@ On Linux systems the config file is searched in the following paths:
 
 On Windows systems the config file is searched in the following paths:
 
-#. ``~/can.conf``
+#. ``%USERPROFILE%/can.conf``
 #. ``can.ini`` (current working directory)
-#. ``$APPDATA/can.ini``
+#. ``%APPDATA%/can.ini``
 
 The configuration file sets the default interface and channel:
 

test/data/example_data.py

@@ -112,8 +112,10 @@ def sort_messages(messages):
     [
         Message(is_fd=True, data=range(64)),
         Message(is_fd=True, data=range(8)),
-        Message(is_fd=True, bitrate_switch=True),
-        Message(is_fd=True, error_state_indicator=True),
+        Message(is_fd=True, bitrate_switch=True, is_remote_frame=True),
+        Message(is_fd=True, error_state_indicator=True, is_remote_frame=True),
+        Message(is_fd=True, data=range(8), bitrate_switch=True),
+        Message(is_fd=True, data=range(8), error_state_indicator=True),
     ]
 )