oscura 0.5.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

oscura/analyzers/protocols/can.py

@@ -142,11 +142,11 @@ class CANDecoder(AsyncDecoder):
     desc = "CAN 2.0A/B bus decoder"
     license = "MIT"
 
-    channels = [  # noqa: RUF012
+    channels = [
         ChannelDef("can", "CAN", "CAN bus signal (CAN_H - CAN_L or single-ended)"),
     ]
 
-    options = [  # noqa: RUF012
+    options = [
         OptionDef(
             "bitrate",
             "Bit Rate",
@@ -273,7 +273,7 @@ class CANDecoder(AsyncDecoder):
         data: NDArray[np.bool_],
         samples_per_bit: int,
     ) -> list[int]:
-        """Find potential frame start positions.
+        """Find potential frame start positions using vectorized edge detection.
 
         CAN frames start with a Start of Frame (SOF) bit, which is a
         dominant (0) bit following bus idle (recessive/1).
@@ -285,26 +285,37 @@ class CANDecoder(AsyncDecoder):
         Returns:
             List of sample indices for potential frame starts.
         """
-        frame_starts = []
-
-        # Look for falling edges (1 -> 0) after idle period
+        # Optimize using vectorized operations instead of loop
         min_idle_bits = 3  # Minimum idle time before frame
         min_idle_samples = min_idle_bits * samples_per_bit
 
-        i = min_idle_samples
-        while i < len(data) - samples_per_bit:
-            # Check if previous samples are mostly high (idle)
-            idle_region = data[max(0, i - min_idle_samples) : i]
+        # Detect all falling edges (1 -> 0) using vectorized comparison
+        falling_edges = np.where(data[:-1] & ~data[1:])[0] + 1
+
+        frame_starts = []
+
+        # Check each falling edge for idle condition
+        for edge_idx in falling_edges:
+            if edge_idx < min_idle_samples or edge_idx >= len(data) - samples_per_bit:
+                continue
+
+            # Check if previous samples are mostly high (idle) using vectorized mean
+            idle_region = data[edge_idx - min_idle_samples : edge_idx]
             if np.mean(idle_region) > 0.8:  # Mostly recessive
-                # Check for falling edge (SOF)
-                if data[i - 1] and not data[i]:
-                    frame_starts.append(i)
-                    # Skip ahead to avoid detecting same frame
-                    i += samples_per_bit * 20  # Skip at least 20 bits
-                    continue
-            i += 1
+                frame_starts.append(int(edge_idx))
+
+        # Filter out closely spaced detections (same frame)
+        if not frame_starts:
+            return []
+
+        filtered_starts = [frame_starts[0]]
+        min_frame_gap = samples_per_bit * 20  # Minimum gap between frames
 
-        return frame_starts
+        for start in frame_starts[1:]:
+            if start - filtered_starts[-1] >= min_frame_gap:
+                filtered_starts.append(start)
+
+        return filtered_starts
 
     def _decode_frame(
         self,
@@ -407,127 +418,34 @@ class CANDecoder(AsyncDecoder):
         Returns:
             Parsed CANFrame or None if invalid.
         """
-        errors = []
+        errors: list[str] = []
 
         try:
-            pos = 0
-
-            # SOF (should be 0)
-            if pos >= len(bits):
+            pos = self._parse_sof(bits, errors)
+            if pos is None:
                 return None
-            sof = bits[pos]
-            pos += 1
-
-            if sof != 0:
-                errors.append("Invalid SOF")
 
-            # Arbitration field
-            if pos + 11 > len(bits):
+            arb_result = self._parse_arbitration_field(bits, pos)
+            if arb_result[0] is None:
                 return None
+            arb_id, is_extended, is_remote, pos = arb_result
 
-            # First 11 bits of ID
-            arb_id = 0
-            for i in range(11):
-                arb_id = (arb_id << 1) | bits[pos + i]
-            pos += 11
-
-            # RTR bit (for standard) or SRR bit (for extended)
-            if pos >= len(bits):
+            dlc_result = self._parse_dlc(bits, pos)
+            if dlc_result[0] is None:
                 return None
-            rtr_or_srr = bits[pos]
-            pos += 1
+            dlc, data_len, pos = dlc_result
 
-            # IDE bit
-            if pos >= len(bits):
-                return None
-            ide = bits[pos]
-            pos += 1
-
-            is_extended = bool(ide)
-            is_remote = False
-
-            if is_extended:
-                # Extended frame: 18 more ID bits
-                if pos + 18 > len(bits):
-                    return None
-
-                # ID extension (18 bits)
-                for i in range(18):
-                    arb_id = (arb_id << 1) | bits[pos + i]
-                pos += 18
-
-                # RTR bit
-                if pos >= len(bits):
-                    return None
-                is_remote = bool(bits[pos])
-                pos += 1
-
-                # r1, r0 reserved bits
-                pos += 2
-            else:
-                # Standard frame
-                is_remote = bool(rtr_or_srr)
-                # r0 reserved bit
-                pos += 1
-
-            # DLC (4 bits)
-            if pos + 4 > len(bits):
+            data_result = self._parse_data_field(bits, pos, data_len, is_remote)
+            if data_result[0] is None:
                 return None
+            data, pos = data_result
 
-            dlc = 0
-            for i in range(4):
-                dlc = (dlc << 1) | bits[pos + i]
-            pos += 4
-
-            # Limit DLC to 8
-            data_len = min(dlc, 8)
-
-            # Data field (0-8 bytes)
-            if not is_remote:
-                if pos + data_len * 8 > len(bits):
-                    return None
-
-                data_bytes = bytearray()
-                for byte_idx in range(data_len):
-                    byte_val = 0
-                    for bit_idx in range(8):
-                        byte_val = (byte_val << 1) | bits[pos + byte_idx * 8 + bit_idx + bit_idx]
-                    data_bytes.append(byte_val)
-                    pos += 8
-
-                data = bytes(data_bytes)
-            else:
-                data = b""
-
-            # CRC field (15 bits)
-            if pos + 15 > len(bits):
+            crc_result = self._parse_crc_field(bits, pos, errors)
+            if crc_result[0] is None:
                 return None
+            crc_received, crc_computed, pos = crc_result
 
-            crc_received = 0
-            for i in range(15):
-                crc_received = (crc_received << 1) | bits[pos + i]
-            pos += 15
-
-            # Compute CRC on frame bits before CRC field
-            # CRC covers SOF through data field
-            crc_data_end = pos - 15
-            crc_computed = self._compute_crc(bits[:crc_data_end])
-
-            if crc_received != crc_computed:
-                errors.append(
-                    f"CRC error: received 0x{crc_received:04X}, computed 0x{crc_computed:04X}"
-                )
-
-            # CRC delimiter (should be 1)
-            if pos < len(bits) and bits[pos] != 1:
-                errors.append("CRC delimiter error")
-            pos += 1
-
-            # ACK slot and delimiter
-            pos += 2
-
-            # EOF (7 recessive bits)
-            # We don't strictly check this
+            pos = self._parse_ack_eof(bits, pos, errors)
 
             end_time = start_time + pos * (1.0 / self._bitrate)
 
@@ -547,6 +465,218 @@ class CANDecoder(AsyncDecoder):
         except (IndexError, ValueError):
             return None
 
+    def _parse_sof(self, bits: list[int], errors: list[str]) -> int | None:
+        """Parse Start of Frame bit.
+
+        Args:
+            bits: Bit array.
+            errors: Error list to append to.
+
+        Returns:
+            Position after SOF, or None if invalid.
+        """
+        if len(bits) < 1:
+            return None
+
+        sof = bits[0]
+        if sof != 0:
+            errors.append("Invalid SOF")
+
+        return 1
+
+    def _parse_arbitration_field(
+        self, bits: list[int], pos: int
+    ) -> tuple[int, bool, bool, int] | tuple[None, None, None, None]:
+        """Parse CAN arbitration field (ID, RTR, IDE).
+
+        Args:
+            bits: Bit array.
+            pos: Current position.
+
+        Returns:
+            Tuple of (arb_id, is_extended, is_remote, new_pos) or (None, None, None, None).
+        """
+        if pos + 11 > len(bits):
+            return None, None, None, None
+
+        # First 11 bits of ID
+        arb_id = self._extract_bits_as_int(bits, pos, 11)
+        pos += 11
+
+        # RTR/SRR bit
+        if pos >= len(bits):
+            return None, None, None, None
+        rtr_or_srr = bits[pos]
+        pos += 1
+
+        # IDE bit
+        if pos >= len(bits):
+            return None, None, None, None
+        ide = bits[pos]
+        pos += 1
+
+        is_extended = bool(ide)
+
+        if is_extended:
+            try:
+                arb_id, is_remote, pos = self._parse_extended_id(bits, pos, arb_id)
+            except IndexError:
+                return None, None, None, None
+        else:
+            is_remote = bool(rtr_or_srr)
+            pos += 1  # r0 reserved bit
+
+        return arb_id, is_extended, is_remote, pos
+
+    def _parse_extended_id(self, bits: list[int], pos: int, base_id: int) -> tuple[int, bool, int]:
+        """Parse extended CAN ID (18 additional bits).
+
+        Args:
+            bits: Bit array.
+            pos: Current position.
+            base_id: Base 11-bit ID.
+
+        Returns:
+            Tuple of (full_id, is_remote, new_pos).
+
+        Raises:
+            IndexError: If insufficient bits available.
+        """
+        if pos + 18 > len(bits):
+            raise IndexError("Insufficient bits for extended ID")
+
+        # ID extension (18 bits)
+        id_ext = self._extract_bits_as_int(bits, pos, 18)
+        arb_id = (base_id << 18) | id_ext
+        pos += 18
+
+        # RTR bit
+        if pos >= len(bits):
+            raise IndexError("Insufficient bits for RTR")
+        is_remote = bool(bits[pos])
+        pos += 1
+
+        # r1, r0 reserved bits
+        pos += 2
+
+        return arb_id, is_remote, pos
+
+    def _parse_dlc(
+        self, bits: list[int], pos: int
+    ) -> tuple[int, int, int] | tuple[None, None, None]:
+        """Parse Data Length Code.
+
+        Args:
+            bits: Bit array.
+            pos: Current position.
+
+        Returns:
+            Tuple of (dlc, data_len, new_pos) or (None, None, None).
+        """
+        if pos + 4 > len(bits):
+            return None, None, None
+
+        dlc = self._extract_bits_as_int(bits, pos, 4)
+        pos += 4
+
+        data_len = min(dlc, 8)  # Limit to 8 bytes
+        return dlc, data_len, pos
+
+    def _parse_data_field(
+        self, bits: list[int], pos: int, data_len: int, is_remote: bool
+    ) -> tuple[bytes, int] | tuple[None, None]:
+        """Parse CAN data field.
+
+        Args:
+            bits: Bit array.
+            pos: Current position.
+            data_len: Number of data bytes.
+            is_remote: True if remote frame.
+
+        Returns:
+            Tuple of (data_bytes, new_pos) or (None, None).
+        """
+        if is_remote:
+            return b"", pos
+
+        if pos + data_len * 8 > len(bits):
+            return None, None
+
+        data_bytes = bytearray()
+        for _ in range(data_len):
+            byte_val = self._extract_bits_as_int(bits, pos, 8)
+            data_bytes.append(byte_val)
+            pos += 8
+
+        return bytes(data_bytes), pos
+
+    def _parse_crc_field(
+        self, bits: list[int], pos: int, errors: list[str]
+    ) -> tuple[int, int, int] | tuple[None, None, None]:
+        """Parse CRC field and validate.
+
+        Args:
+            bits: Bit array.
+            pos: Current position.
+            errors: Error list to append to.
+
+        Returns:
+            Tuple of (crc_received, crc_computed, new_pos) or (None, None, None).
+        """
+        if pos + 15 > len(bits):
+            return None, None, None
+
+        crc_received = self._extract_bits_as_int(bits, pos, 15)
+        crc_data_end = pos
+        pos += 15
+
+        crc_computed = self._compute_crc(bits[:crc_data_end])
+
+        if crc_received != crc_computed:
+            errors.append(
+                f"CRC error: received 0x{crc_received:04X}, computed 0x{crc_computed:04X}"
+            )
+
+        # CRC delimiter (should be 1)
+        if pos < len(bits) and bits[pos] != 1:
+            errors.append("CRC delimiter error")
+        pos += 1
+
+        return crc_received, crc_computed, pos
+
+    def _parse_ack_eof(self, bits: list[int], pos: int, errors: list[str]) -> int:
+        """Parse ACK and EOF fields.
+
+        Args:
+            bits: Bit array.
+            pos: Current position.
+            errors: Error list to append to.
+
+        Returns:
+            Position after ACK/EOF.
+        """
+        # ACK slot and delimiter
+        pos += 2
+
+        # EOF (7 recessive bits) - not strictly checked
+        return pos
+
+    def _extract_bits_as_int(self, bits: list[int], start: int, count: int) -> int:
+        """Extract consecutive bits as integer (MSB first).
+
+        Args:
+            bits: Bit array.
+            start: Start position.
+            count: Number of bits.
+
+        Returns:
+            Integer value.
+        """
+        value = 0
+        for i in range(count):
+            value = (value << 1) | bits[start + i]
+        return value
+
     def _compute_crc(self, bits: list[int]) -> int:
         """Compute CAN CRC-15.
 

oscura/analyzers/protocols/can_fd.py

@@ -120,16 +120,16 @@ class CANFDDecoder(AsyncDecoder):
     longname = "CAN with Flexible Data-rate"
     desc = "CAN-FD protocol decoder"
 
-    channels = [  # noqa: RUF012
+    channels = [
         ChannelDef("can", "CAN", "CAN bus signal", required=True),
     ]
 
-    optional_channels = [  # noqa: RUF012
+    optional_channels = [
         ChannelDef("can_h", "CAN_H", "CAN High differential signal", required=False),
         ChannelDef("can_l", "CAN_L", "CAN Low differential signal", required=False),
     ]
 
-    options = [  # noqa: RUF012
+    options = [
         OptionDef(
             "nominal_bitrate",
             "Nominal bitrate",
@@ -146,7 +146,7 @@ class CANFDDecoder(AsyncDecoder):
         ),
     ]
 
-    annotations = [  # noqa: RUF012
+    annotations = [
         ("sof", "Start of Frame"),
         ("arbitration", "Arbitration field"),
         ("control", "Control field"),
@@ -299,111 +299,138 @@ class CANFDDecoder(AsyncDecoder):
         Returns:
             (frame, end_index) tuple.
         """
-        errors = []  # type: ignore[var-annotated]
-        bit_idx = sof_idx
-        current_bit_period = nominal_bit_period
-
-        # Sample bits (simplified - ignores bit stuffing for brevity)
-        def sample_bits(count: int) -> list[int]:
-            nonlocal bit_idx
-            bits = []
-            for _ in range(count):
-                sample_idx = int(bit_idx + current_bit_period / 2)
-                if sample_idx < len(data):
-                    bits.append(0 if data[sample_idx] else 1)  # Dominant=1, Recessive=0
-                    bit_idx += current_bit_period  # type: ignore[assignment]
-                else:
-                    return bits
-            return bits
-
-        # Arbitration field (11 bits for standard, 29 for extended)
-        arb_bits = sample_bits(11)
+        decoder_state = _CANFDDecoderState(sof_idx, nominal_bit_period, data, data_bit_period)
+
+        arbitration_id, is_extended = decoder_state.decode_arbitration_field()
+        if arbitration_id is None:
+            return None, decoder_state.get_bit_idx()
+
+        is_fd, brs, esi, dlc = decoder_state.decode_control_field(is_extended)
+        if dlc is None:
+            return None, decoder_state.get_bit_idx()
+
+        data_length = CANFD_DLC_TO_LENGTH.get(dlc, 0)
+        data_bytes = decoder_state.decode_data_field(data_length, is_fd, brs)
+        crc = decoder_state.decode_crc_field(data_length)
+        decoder_state.decode_end_of_frame()
+
+        frame = CANFDFrame(
+            arbitration_id=arbitration_id,
+            is_extended=is_extended,
+            is_fd=is_fd,
+            brs=brs,
+            esi=esi,
+            dlc=dlc,
+            data=bytes(data_bytes),
+            crc=crc,
+            timestamp=sof_idx / sample_rate,
+            errors=[],
+        )
+
+        return frame, decoder_state.get_bit_idx()
+
+
+class _CANFDDecoderState:
+    """State tracker for CAN-FD frame decoding."""
+
+    def __init__(
+        self,
+        sof_idx: int,
+        nominal_bit_period: float,
+        data: NDArray[np.bool_],
+        data_bit_period: float,
+    ):
+        self.bit_idx: float = float(sof_idx)
+        self.current_bit_period = nominal_bit_period
+        self.nominal_bit_period = nominal_bit_period
+        self.data_bit_period = data_bit_period
+        self.data = data
+
+    def sample_bits(self, count: int) -> list[int]:
+        """Sample specified number of bits."""
+        bits = []
+        for _ in range(count):
+            sample_idx_raw = self.bit_idx + self.current_bit_period / 2
+            sample_idx = int(sample_idx_raw)
+            if sample_idx < len(self.data):
+                bits.append(0 if self.data[sample_idx] else 1)
+                self.bit_idx += self.current_bit_period
+            else:
+                return bits
+        return bits
+
+    def bits_to_int(self, bits: list[int]) -> int:
+        """Convert bit list to integer."""
+        value = 0
+        for bit in bits:
+            value = (value << 1) | bit
+        return value
+
+    def decode_arbitration_field(self) -> tuple[int | None, bool]:
+        """Decode arbitration field and determine if extended frame."""
+        arb_bits = self.sample_bits(11)
         if len(arb_bits) < 11:
-            return None, int(bit_idx)
+            return None, False
 
-        arbitration_id = 0
-        for bit in arb_bits:
-            arbitration_id = (arbitration_id << 1) | bit
+        arbitration_id = self.bits_to_int(arb_bits)
 
-        # Check for extended frame (IDE bit)
-        ide_bits = sample_bits(1)
-        is_extended = ide_bits[0] == 1 if ide_bits else False
+        ide_bits = self.sample_bits(1)
+        is_extended = bool(ide_bits[0]) if ide_bits else False
 
         if is_extended:
-            # Extended ID: read additional 18 bits
-            ext_bits = sample_bits(18)
-            for bit in ext_bits:
-                arbitration_id = (arbitration_id << 1) | bit
+            ext_bits = self.sample_bits(18)
+            arbitration_id = (arbitration_id << 18) | self.bits_to_int(ext_bits)
+
+        return arbitration_id, is_extended
 
-        # Control field
-        # FDF (EDL), res, BRS, ESI, DLC (4 bits)
-        ctrl_bits = sample_bits(7 if not is_extended else 6)
+    def decode_control_field(self, is_extended: bool) -> tuple[bool, bool, bool, int | None]:
+        """Decode control field."""
+        ctrl_bits = self.sample_bits(7 if not is_extended else 6)
 
         if len(ctrl_bits) < (7 if not is_extended else 6):
-            return None, int(bit_idx)
+            return False, False, False, None
 
-        # FDF/EDL bit - first bit of control field regardless of frame type
-        fdf = ctrl_bits[0]
-        is_fd = fdf == 1
+        is_fd = ctrl_bits[0] == 1
         brs = ctrl_bits[2] == 1 if len(ctrl_bits) > 2 else False
         esi = ctrl_bits[3] == 1 if len(ctrl_bits) > 3 else False
 
-        # DLC (4 bits)
         dlc_start = 3 if not is_extended else 2
         dlc_bits = (
             ctrl_bits[dlc_start : dlc_start + 4]
             if len(ctrl_bits) >= dlc_start + 4
             else [0, 0, 0, 0]
         )
-        dlc = 0
-        for bit in dlc_bits:
-            dlc = (dlc << 1) | bit
+        dlc = self.bits_to_int(dlc_bits)
 
-        # Get data length from DLC
-        data_length = CANFD_DLC_TO_LENGTH.get(dlc, 0)
+        return is_fd, brs, esi, dlc
 
-        # Switch to data bitrate if BRS is set
+    def decode_data_field(self, data_length: int, is_fd: bool, brs: bool) -> list[int]:
+        """Decode data field."""
         if is_fd and brs:
-            current_bit_period = data_bit_period
+            self.current_bit_period = self.data_bit_period
 
-        # Data field
         data_bytes = []
         for _ in range(data_length):
-            byte_bits = sample_bits(8)
+            byte_bits = self.sample_bits(8)
             if len(byte_bits) == 8:
-                byte_val = 0
-                for bit in byte_bits:
-                    byte_val = (byte_val << 1) | bit
-                data_bytes.append(byte_val)
-
-        # CRC field (CRC-17 for <=16 bytes, CRC-21 for >16 bytes)
-        crc_length = 17 if data_length <= 16 else 21
-        crc_bits = sample_bits(crc_length)
-        crc = 0
-        for bit in crc_bits:
-            crc = (crc << 1) | bit
+                data_bytes.append(self.bits_to_int(byte_bits))
 
-        # Switch back to nominal bitrate for CRC delimiter, ACK, EOF
-        current_bit_period = nominal_bit_period
+        return data_bytes
 
-        # CRC delimiter, ACK slot, ACK delimiter, EOF (7 bits)
-        sample_bits(10)
+    def decode_crc_field(self, data_length: int) -> int:
+        """Decode CRC field."""
+        crc_length = 17 if data_length <= 16 else 21
+        crc_bits = self.sample_bits(crc_length)
+        return self.bits_to_int(crc_bits)
 
-        # Create frame
-        frame = CANFDFrame(
-            arbitration_id=arbitration_id,
-            is_extended=is_extended,
-            is_fd=is_fd,
-            brs=brs,
-            esi=esi,
-            dlc=dlc,
-            data=bytes(data_bytes),
-            crc=crc,
-            timestamp=sof_idx / sample_rate,
-            errors=errors,
-        )
+    def decode_end_of_frame(self) -> None:
+        """Decode end of frame."""
+        self.current_bit_period = self.nominal_bit_period
+        self.sample_bits(10)
 
-        return frame, int(bit_idx)
+    def get_bit_idx(self) -> int:
+        """Get current bit index."""
+        return int(self.bit_idx)
 
 
 def decode_can_fd(