pscan-pythoncan 0.1.0__cp38-abi3-win_amd64.whl

pscan_pythoncan/__init__.py

@@ -0,0 +1,235 @@
+import logging
+import time
+import can
+from typing import Optional, List, Tuple, Sequence
+
+# Import the Rust extension
+from . import pscan_pythoncan_ext
+
+log = logging.getLogger("can.pscan")
+
+
+class PscanBus(can.BusABC):
+    """
+    PSCAN Hardware interface for python-can.
+
+    Provides native USB access to PSCAN CAN adapters via a Rust backend.
+
+    Usage::
+
+        # Auto-detect single device
+        bus = can.Bus(interface='pscan', bitrate=500000)
+
+        # Open by user-friendly name
+        bus = can.Bus(interface='pscan', name='MyBMS', bitrate=500000)
+
+        # Open by serial number
+        bus = can.Bus(interface='pscan', serial='P1P.IN:XFG:H001', bitrate=500000)
+
+        # With options
+        bus = can.Bus(interface='pscan', bitrate=250000, sample_point=800, listen_only=True)
+    """
+
+    def __init__(
+        self,
+        channel: str = 'PSCAN_USB1',
+        serial: str = None,
+        name: str = None,
+        bitrate: int = 500000,
+        sample_point: int = 875,
+        listen_only: bool = False,
+        loopback: bool = False,
+        can_filters=None,
+        **kwargs
+    ):
+        """
+        :param channel: Channel name (used for python-can compatibility)
+        :param serial: Serial number of the PSCAN device
+        :param name: User-friendly device name (alternative to serial)
+        :param bitrate: Bitrate in bps (default: 500000)
+        :param sample_point: Sample point in permille (default: 875 = 87.5%)
+        :param listen_only: Enable listen-only mode (no TX, no ACK)
+        :param loopback: Enable loopback mode (TX frames are echoed to RX)
+        :param can_filters: Message filters, see :meth:`~can.BusABC.set_filters`
+        """
+        # Priority: name > serial > auto-detect first device
+        if name:
+            self._dev = pscan_pythoncan_ext.NativePscanDevice.open_by_name(name)
+            self.channel_info = f"PSCAN: name={name}"
+        else:
+            self._dev = pscan_pythoncan_ext.NativePscanDevice(serial)
+            self.channel_info = f"PSCAN: {serial or 'Auto'}"
+
+        # Set CAN controller mode before starting bus
+        ctrlmode = 0
+        if listen_only:
+            ctrlmode |= 0x02  # CAN_CTRLMODE_LISTENONLY
+        if loopback:
+            ctrlmode |= 0x01  # CAN_CTRLMODE_LOOPBACK
+        if ctrlmode != 0:
+            self._dev.set_mode(ctrlmode)
+
+        self._dev.set_bitrate(bitrate, sample_point)
+        self._dev.set_bus_state(True)
+        self._listen_only = listen_only
+
+        # Call super().__init__ last — it sets _is_shutdown=False and applies filters
+        super().__init__(channel=channel, can_filters=can_filters, **kwargs)
+
+    def send(self, msg: can.Message, timeout: Optional[float] = None) -> None:
+        """Transmit a CAN message.
+
+        :param msg: Message to send
+        :param timeout: Timeout in seconds (default: 0.05s = 50ms)
+        :raises can.CanOperationError: If send fails
+        :raises NotImplementedError: If CAN FD message is passed
+        """
+        if self._listen_only:
+            raise can.CanOperationError("Cannot send in listen-only mode")
+
+        if msg.is_fd:
+            raise NotImplementedError("CAN FD not yet supported by PSCAN-USB")
+
+        # Convert timeout: None -> 50ms default, else seconds -> ms
+        if timeout is None:
+            timeout_ms = 50
+        else:
+            timeout_ms = max(1, int(timeout * 1000))
+
+        try:
+            self._dev.send_frame(
+                msg.arbitration_id,
+                msg.is_extended_id,
+                msg.is_remote_frame,
+                msg.is_error_frame,
+                list(msg.data),
+                timeout_ms
+            )
+        except Exception as e:
+            raise can.CanOperationError(f"Send failed: {e}") from e
+
+    def _recv_internal(self, timeout: Optional[float]) -> Tuple[Optional[can.Message], bool]:
+        """
+        Read a message from the hardware.
+
+        Returns (message, already_filtered) tuple.
+        Handles multi-frame USB reads via Rust-side buffering.
+        """
+        # Calculate timeout in ms
+        timeout_ms = 0
+        if timeout is not None:
+            if timeout < 0:
+                timeout = 0
+            timeout_ms = int(timeout * 1000)
+            if timeout_ms == 0 and timeout > 0:
+                timeout_ms = 1  # Minimum 1ms
+
+        try:
+            res = self._dev.receive_frame(timeout_ms)
+            if res is None:
+                return None, False
+
+            ts_us, arb_id, is_ext, is_rtr, is_err, dlc, data = res
+
+            msg = can.Message(
+                timestamp=ts_us / 1_000_000.0,
+                arbitration_id=arb_id,
+                is_extended_id=is_ext,
+                is_remote_frame=is_rtr,
+                is_error_frame=is_err,
+                dlc=dlc,
+                data=data,
+                channel=self.channel_info,
+            )
+            return msg, True  # True = filtering already done in Rust
+        except Exception as e:
+            log.error("Error receiving CAN frame: %s", e)
+            raise can.CanOperationError(f"Receive failed: {e}") from e
+
+    def _apply_filters(self, filters) -> None:
+        """Push filters to the Rust backend for high-performance filtering.
+
+        Filters are applied in Rust before frames reach Python,
+        using pscan-core's SoftFilter/SoftFilterSet implementation.
+
+        :param filters: List of filter dicts with 'can_id', 'can_mask', and optional 'extended' keys.
+        """
+        if not filters:
+            self._dev.clear_filters()
+            return
+
+        rust_filters = []
+        for f in filters:
+            can_id = f.get('can_id', 0)
+            can_mask = f.get('can_mask', 0)
+            extended = f.get('extended', None)  # None = match both std and ext
+            rust_filters.append((can_id, can_mask, extended))
+
+        self._dev.set_filters(rust_filters)
+
+    @property
+    def state(self) -> can.BusState:
+        """Return the current state of the CAN bus hardware.
+
+        Mapping: ErrorActive -> ACTIVE, ErrorWarning/Passive -> PASSIVE, BusOff -> ERROR
+        """
+        try:
+            state_val, _, _ = self._dev.get_bus_state()
+            if state_val == 0:  # ErrorActive
+                return can.BusState.ACTIVE
+            elif state_val in (1, 2):  # ErrorWarning, ErrorPassive
+                return can.BusState.PASSIVE
+            else:  # BusOff(3), Stopped(4), Sleeping(5)
+                return can.BusState.ERROR
+        except Exception:
+            return can.BusState.ERROR
+
+    @state.setter
+    def state(self, new_state: can.BusState) -> None:
+        """Set the bus state.
+
+        :param new_state: ACTIVE to go bus-on, ERROR to go bus-off
+        """
+        if new_state == can.BusState.ACTIVE:
+            self._dev.set_bus_state(True)
+        elif new_state == can.BusState.ERROR:
+            self._dev.set_bus_state(False)
+        else:
+            # PASSIVE — set listen-only mode
+            self._dev.set_mode(0x02)
+
+    def flush_tx_buffer(self) -> None:
+        """Discard all pending messages in the TX queue."""
+        self._dev.flush_tx_queue()
+
+    @staticmethod
+    def _detect_available_configs() -> List[dict]:
+        """Detect all connected PSCAN devices.
+
+        :return: List of configs suitable for PscanBus constructor.
+        """
+        try:
+            serials = pscan_pythoncan_ext.list_devices()
+            return [
+                {"interface": "pscan", "channel": "PSCAN_USB1", "serial": sn}
+                for sn in serials
+            ]
+        except Exception:
+            return []
+
+    def shutdown(self) -> None:
+        """Shut down the bus: stop bus, release device, then clean up base class."""
+        if self._is_shutdown:
+            return
+
+        # Device cleanup FIRST, before super().shutdown() sets the guard flag
+        if self._dev is not None:
+            try:
+                time.sleep(0.05)
+                self._dev.set_bus_state(False)
+            except Exception as e:
+                log.warning("Error during bus shutdown: %s", e)
+            finally:
+                self._dev = None
+
+        super().shutdown()

pscan_pythoncan-0.1.0.dist-info/METADATA

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: pscan-pythoncan
+Version: 0.1.0
+Requires-Dist: python-can>=4.0.0
+Summary: Native Python-CAN hardware backend for PSCAN USB devices
+Author-email: PSCAN <info@pscan.com>
+Requires-Python: >=3.8

pscan_pythoncan-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+pscan_pythoncan/__init__.py,sha256=9xAm3Uxgdm8q_Nf5Meo8wCZfQYr7QwH3keM7drmRKdw,8365
+pscan_pythoncan/pscan_pythoncan_ext.pyd,sha256=uqublQoFUKoQ6jVuyPACX8IwPwocUN_lXe-OyT0z34I,540672
+pscan_pythoncan-0.1.0.dist-info/METADATA,sha256=SAX94aMfCNbFxRM8KaB6hhsJLs7D6sgkMjuMwv3c_OQ,218
+pscan_pythoncan-0.1.0.dist-info/WHEEL,sha256=pR3QVM8fbZ6NHAmOlF_iyjo3X1LezoW7fOuSwC4jKRw,95
+pscan_pythoncan-0.1.0.dist-info/entry_points.txt,sha256=QBXFh4buwsUQEy-p6XVEgujEqrKFnaZSPZ3CtRiOnhg,47
+pscan_pythoncan-0.1.0.dist-info/sboms/pscan-pythoncan.cyclonedx.json,sha256=EZ6xLzzudZ7G1DtxpvFN8kx_osmUnXz2mxF81-6amuI,40459
+pscan_pythoncan-0.1.0.dist-info/RECORD,,

pscan_pythoncan-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.12.6)
+Root-Is-Purelib: false
+Tag: cp38-abi3-win_amd64

pscan_pythoncan-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[can.interface]
+pscan=pscan_pythoncan:PscanBus