can_messenger 1.3.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a68f4a339bebc034ffe78e990086ff91d28164962c2877e5d88edb095cbca90
-  data.tar.gz: 7a96c22ccf82cae952123d733805c2efe31dd482ba9bf5d5a66d29cb14572822
+  metadata.gz: 15f09405e67a906115972dc84790769875d1dcdb5cbd78a57827ccdf910d7e05
+  data.tar.gz: faa23fc30c89b5a81875ff2664e5f97cac2970cb6161599887a1c02da9b5f36c
 SHA512:
-  metadata.gz: c8302565cc5e889a290a446167bdec8eedd29ba077c63c003f544138c078a94498b258f465387b3c92f8b9b9ffc18ed65810fa70c5dc97e3ba977e62bbc394c4
-  data.tar.gz: a606c71e8606bbccd98e1917bc4c2205037156e3994f152f6b05c3a52fc1037c21f8a38a91814abddb6f4a9bf5a0eb8682a2acaf93e3da0cdb818a2d8d03131f
+  metadata.gz: bb33fdda392ca2acaea5357a661b5b9dda245c41db5b000802e4d12886d58b16c49d5238312aa254f062fdc9f46c9f05b9f140f202a0ad73e1ceda9b81d397ca
+  data.tar.gz: 4823263138efc7d61756d473e2e6235487921f7d8e6d8350260dcd80d491bee6927cbf5606671a242576fdb3f3fb5437212f77c008856c3bfa1d2b9a5b5d4924

data/CHANGELOG.md

@@ -0,0 +1,165 @@
+## [Unreleased]
+
+## [2.0.0] - 2026-02-02
+
+### Changed
+
+- **Breaking:** Require Ruby 4.0.1 or higher.
+- Update CI to run on Ruby 4.0.1.
+- Upgrade RuboCop to support Ruby 4.0 and refresh linting.
+- Minor style cleanups in DBC parsing and message listener block forwarding.
+- Extract SocketCAN logic into a dedicated adapter and add a base adapter interface.
+- Allow injecting a custom adapter into `Messenger` for alternate transports or testing.
+- **Breaking:** Default CAN ID endianness is now native (`:native`) instead of `:big`.
+
+### Fixed
+
+- Close SocketCAN sockets when bind/setsockopt fails to avoid leaks.
+
+## [1.4.0] - 2025-07-25
+
+### Added
+
+- `send_dbc_message` helper for encoding and sending messages defined in DBC files.
+
+### Changed
+
+- `send_can_message` now only accepts raw frame parameters.
+- DBC parsing code split into helper methods for clarity.
+
+### Fixed
+
+- Correct encoding of negative signal values using two's-complement.
+
+## [1.3.0] - 2025-06-27
+
+### Added
+
+- Optional **CAN FD** support for sending and receiving up to 64-byte frames.
+
+### Changed
+
+- Updated APIs to accept a `can_fd:` flag on initialization and message methods.
+
+### Fixed
+
+- (Nothing since last release.)
+
+## [1.2.1] - 2025-06-05
+
+### Changed
+
+- `send_can_message` now raises `ArgumentError` when data length exceeds eight bytes.
+- Updated RBS `initialize` signature to include the `endianness` argument.
+- Fixed formatting in README around extended CAN frames.
+- Clarified spec helper comment.
+
+### Fixed
+
+- Addressed a listener restart bug allowing `start_listening` to be called again.
+
+## [1.2.0] - 2025-02-28
+
+### Added
+
+- **Explicit extended CAN ID support**.
+  - Added an `extended_id: false` parameter to `send_can_message`, which, if set to `true`, sets the Extended Frame Format bit (bit 31) in the CAN ID.
+  - Updated `parse_frame` to detect and report `extended: true` when the EFF bit is set in incoming frames.
+  - Added corresponding tests for sending and receiving extended CAN frames.
+
+### Changed
+
+- _No breaking changes_, but internal refactoring around how CAN IDs are packed and unpacked.
+  - Removed the masking of bit 31 in `unpack_frame_id`, ensuring extended frames are no longer silently treated as standard frames.
+
+### Fixed
+
+- (Nothing since last release.)
+
+## [1.1.0] - 2025-02-10
+
+### Changed
+
+- **Removed dependency on `cansend`**. We now write CAN frames directly via raw sockets.
+- Internal refactoring to support raw-socket–based sending without changing the public API.
+
+### Fixed
+
+## [1.0.3] - 2025-02-09
+
+- Revert release.yml
+
+### Fixed
+
+## [1.0.2] - 2025-02-09
+
+- Bugfix release.yml
+
+## [1.0.1] - 2025-02-09
+
+### Changed
+
+- Updated the README to include an **Important Considerations** section that outlines environment requirements, API changes (keyword arguments and block requirement), threading and socket management notes, and logging behavior.
+- Made minor documentation clarifications and tweaks to help users avoid common pitfalls.
+
+## [1.0.0] - 2025-02-09
+
+### Changed
+
+- **Breaking Change:** Updated the Messenger API to require keyword arguments (e.g., `interface_name:`) for initialization. Existing code using the old API will need to be updated.
+- **Breaking Change:** Updated the send_can_message Method to require keyword arguments (e.g., `id:,data:`) to send messages to the can bus. Existing code using the old API will need to be updated.
+- Refactored `start_listening`.
+- Enhanced error handling throughout the gem with more detailed logging.
+- Updated type signatures (RBS) and documentation to match the new API.
+- Refactored tests to reflect the new API and improved error handling.
+
+## [0.2.3] - 2025-02-01
+
+### Changed
+
+- Updated the internal listening loop in `start_listening` to continue iterating on nil (timeout) responses instead of breaking out, improving reliability.
+- Suppressed log output during tests by injecting a silent logger.
+- Updated the test suite to better handle long-running listening loops and error conditions.
+
+## [0.2.2] - 2024-12-06
+
+### Changed
+
+- Updated README.md to reflect modern debian package install command.
+
+## [0.2.1] - 2024-12-06
+
+### Changed
+
+- Updated `start_listening` RBS signature to include the `filter` parameter, ensuring type definitions match the implementation.
+
+## [0.2.0] - 2024-12-05
+
+### Added
+
+- Filtering support for `start_listening` via a `filter` parameter:
+  - Single CAN ID.
+  - Range of CAN IDs.
+  - Array of CAN IDs.
+
+### Changed
+
+- Refactored `start_listening` to support optional filtering of incoming CAN messages.
+- Documentation updates for `start_listening` in README.
+
+## [0.1.0] - 2024-11-10
+
+- Initial release
+  [2.0.0]: https://github.com/fk1018/can_messenger/compare/v1.3.0...v2.0.0
+  [1.3.0]: https://github.com/fk1018/can_messenger/compare/v1.2.1...v1.3.0
+  [1.2.1]: https://github.com/fk1018/can_messenger/compare/v1.2.0...v1.2.1
+  [1.2.0]: https://github.com/fk1018/can_messenger/compare/v1.1.0...v1.2.0
+  [1.1.0]: https://github.com/fk1018/can_messenger/compare/v1.0.3...v1.1.0
+  [1.0.3]: https://github.com/fk1018/can_messenger/compare/v1.0.1...v1.0.3
+  [1.0.1]: https://github.com/fk1018/can_messenger/compare/v1.0.0...v1.0.1
+  [1.0.0]: https://github.com/fk1018/can_messenger/compare/v0.2.3...v1.0.0
+  [0.2.3]: https://github.com/fk1018/can_messenger/compare/v0.2.2...v0.2.3
+  [0.2.2]: https://github.com/fk1018/can_messenger/compare/v0.2.1...v0.2.2
+  [0.2.1]: https://github.com/fk1018/can_messenger/compare/v0.2.0...v0.2.1
+  [0.2.0]: https://github.com/fk1018/can_messenger/compare/v0.1.0...v0.2.0
+  [0.1.0]: https://github.com/fk1018/can_messenger/releases/tag/v0.1.0

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 fk1018
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -6,12 +6,13 @@
 ![Status](https://img.shields.io/badge/status-stable-green)
 [![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 ![Gem Total Downloads](https://img.shields.io/gem/dt/can_messenger)
+![CodeRabbit Pull Request Reviews](https://img.shields.io/coderabbit/prs/github/fk1018/can_messenger?utm_source=oss&utm_medium=github&utm_campaign=fk1018%2Fcan_messenger&labelColor=171717&color=FF570A&link=https%3A%2F%2Fcoderabbit.ai&label=CodeRabbit+Reviews)
 
 `can_messenger` is a Ruby gem that provides an interface for communicating over the CAN bus, allowing users to send and receive CAN messages `via raw SocketCAN sockets`. This gem is designed for developers who need an easy way to interact with CAN-enabled devices on Linux.
 
 ## Requirements
 
-- Ruby 3.0 or higher.
+- Ruby 4.0.1 or higher.
 
 ## Installation
 
@@ -108,6 +109,24 @@ The `start_listening` method supports filtering incoming messages based on CAN I
   end
   ```
 
+### Working with DBC Files
+
+Parse a DBC file and let the messenger encode and decode messages automatically:
+
+```ruby
+dbc = CanMessenger::DBC.load('example.dbc')
+
+# Encode using signal values
+messenger.send_dbc_message(dbc: dbc, message_name: 'Example', signals: { Speed: 100 })
+
+# Decode received frames
+messenger.start_listening(dbc: dbc) do |msg|
+  if msg[:decoded]
+    puts "#{msg[:decoded][:name]} => #{msg[:decoded][:signals]}"
+  end
+end
+```
+
 ### Stopping the Listener
 
 To stop listening, use:
@@ -116,17 +135,34 @@ To stop listening, use:
 messenger.stop_listening
 ```
 
+### Adapters
+
+`CanMessenger::Messenger` delegates low-level CAN bus operations to an adapter. By default it uses the
+SocketCAN adapter which communicates with Linux CAN interfaces using raw sockets:
+
+```ruby
+messenger = CanMessenger::Messenger.new(interface_name: "can0")
+```
+
+You can provide a custom adapter via the `adapter:` option:
+
+```ruby
+my_adapter = MyCustomAdapter.new(interface_name: "can0", logger: Logger.new($stdout))
+messenger = CanMessenger::Messenger.new(interface_name: "can0", adapter: my_adapter)
+```
+
+To build your own adapter, subclass `CanMessenger::Adapter::Base` and implement the required methods
+`open_socket`, `build_can_frame`, `receive_message`, and `parse_frame`.
+
 ## Important Considerations
 
 Before using `can_messenger`, please note the following:
 
 - **Environment Requirements:**
-
   - **SocketCAN** must be available on your Linux system.
   - **Permissions:** Working with raw sockets may require elevated privileges or membership in a specific group to open and bind to CAN interfaces without running as root.
 
 - **API Changes (v1.0.0 and later):**
-
   - **Keyword Arguments:** The Messenger API now requires keyword arguments. For example, when initializing the Messenger:
 
     ```ruby
@@ -150,16 +186,14 @@ Before using `can_messenger`, please note the following:
     ```
 
 - **Threading & Socket Management:**
-
   - **Blocking Behavior:** The gem uses blocking socket calls and continuously listens for messages. Manage the listener’s lifecycle appropriately, especially in multi-threaded environments. Always call `stop_listening` to gracefully shut down the listener.
   - **Resource Cleanup:** The socket is automatically closed when the listening loop terminates. Stop the listener to avoid resource leaks.
 
 - **Logging:**
-
   - **Default Logger:** If no logger is provided, logs go to standard output. Provide a custom logger if you want more control.
 
 - **CAN Frame Format Assumptions:**
-  - By default, the gem uses **big-endian** packing for CAN IDs. If you integrate with a system using little-endian, you may need to adjust or specify an endianness in the code.
+  - By default, the gem uses **native endianness** for CAN IDs (little-endian on most x86/ARM systems). **Changed in v2.0.0:** this default was previously `:big`. You can override this by passing `endianness: :big` or `endianness: :little`.
   - The gem expects a standard CAN frame layout (16 bytes total, with the first 4 for the ID, followed by 1 byte for DLC, 3 bytes of padding, and up to 8 bytes of data). **CAN FD** frames (up to 64 bytes) are supported when enabled.
 
 ## Features
@@ -168,6 +202,7 @@ Before using `can_messenger`, please note the following:
 - **Receive CAN Messages**: Continuously listen for messages on a CAN interface.
 - **Filtering**: Optional ID filters for incoming messages (single ID, range, or array).
 - **Logging**: Logs errors and events for debugging/troubleshooting.
+- **DBC Parsing**: Parse DBC files to encode messages by name and decode incoming frames.
 
 ## Development
 

data/lib/can_messenger/adapter/base.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module CanMessenger
+  module Adapter
+    # Base adapter defines the interface for CAN bus adapters.
+    # Concrete adapters must implement all of the methods defined here.
+    class Base
+      attr_reader :interface_name, :logger, :endianness
+
+      def self.native_endianness
+        native = pack_uint(1, "I")
+        return :little if native == pack_uint(1, "V")
+        return :big if native == pack_uint(1, "N")
+
+        # Fallback for unusual platforms.
+        native.bytes.first == 1 ? :little : :big
+      end
+
+      def self.pack_uint(value, template)
+        [value].pack(template)
+      end
+      private_class_method :pack_uint
+
+      def initialize(interface_name:, logger:, endianness: :native)
+        @interface_name = interface_name
+        @logger = logger
+        normalized_endianness = normalize_endianness(endianness)
+        @endianness = normalized_endianness == :native ? self.class.native_endianness : normalized_endianness
+      end
+
+      # Open a socket for the underlying interface.
+      # @return [Object] adapter-specific socket
+      def open_socket(can_fd: false)
+        raise NotImplementedError, "open_socket must be implemented in subclasses"
+      end
+
+      # Build a frame ready to be written to the socket.
+      def build_can_frame(id:, data:, extended_id: false, can_fd: false)
+        raise NotImplementedError, "build_can_frame must be implemented in subclasses"
+      end
+
+      # Receive and parse a frame from the socket.
+      def receive_message(socket:, can_fd: false)
+        raise NotImplementedError, "receive_message must be implemented in subclasses"
+      end
+
+      # Parse a raw frame string into a message hash.
+      def parse_frame(frame:, can_fd: false)
+        raise NotImplementedError, "parse_frame must be implemented in subclasses"
+      end
+
+      private
+
+      def normalize_endianness(endianness)
+        normalized = endianness.is_a?(String) ? endianness.strip.downcase.to_sym : endianness
+        return normalized if %i[native little big].include?(normalized)
+
+        raise ArgumentError, "endianness must be :native, :little, or :big"
+      end
+    end
+  end
+end

data/lib/can_messenger/adapter/socketcan.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "socket"
+require_relative "base"
+
+module CanMessenger
+  module Adapter
+    # Adapter implementation for Linux SocketCAN interfaces.
+    class Socketcan < Base
+      FRAME_SIZE = 16
+      CANFD_FRAME_SIZE = 72
+      MIN_FRAME_SIZE = 8
+      MAX_FD_DATA = 64
+      TIMEOUT = [1, 0].pack("l_2")
+
+      # Creates and configures a CAN socket bound to the interface.
+      def open_socket(can_fd: false)
+        socket = Socket.open(Socket::PF_CAN, Socket::SOCK_RAW, Socket::CAN_RAW)
+        configure_socket(socket, can_fd: can_fd)
+        socket
+      rescue StandardError => e
+        close_socket(socket)
+        logger.error("Error creating CAN socket on interface #{interface_name}: #{e}")
+        nil
+      end
+
+      # Builds a raw CAN or CAN FD frame for SocketCAN.
+      def build_can_frame(id:, data:, extended_id: false, can_fd: false) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/PerceivedComplexity
+        if can_fd
+          raise ArgumentError, "CAN FD data cannot exceed #{MAX_FD_DATA} bytes" if data.size > MAX_FD_DATA
+        elsif data.size > 8
+          raise ArgumentError, "CAN data cannot exceed 8 bytes"
+        end
+
+        # Mask the ID to 29 bits
+        can_id = id & 0x1FFFFFFF
+        # Set bit 31 for extended frames
+        can_id |= 0x80000000 if extended_id
+
+        # Pack the ID based on endianness
+        id_bytes = endianness == :big ? [can_id].pack("L>") : [can_id].pack("V")
+
+        dlc_and_pad = [data.size, 0, 0, 0].pack("C*")
+
+        payload = if can_fd
+                    data.pack("C*").ljust(MAX_FD_DATA, "\x00")
+                  else
+                    data.pack("C*").ljust(8, "\x00")
+                  end
+
+        id_bytes + dlc_and_pad + payload
+      end
+
+      # Reads a frame from the socket and parses it into a hash.
+      def receive_message(socket:, can_fd: false)
+        frame_size = can_fd ? CANFD_FRAME_SIZE : FRAME_SIZE
+        frame = socket.recv(frame_size)
+        return nil if frame.nil? || frame.size < MIN_FRAME_SIZE
+
+        parse_frame(frame: frame, can_fd: can_fd)
+      rescue IO::WaitReadable
+        nil
+      rescue StandardError => e
+        logger.error("Error receiving CAN message on interface #{interface_name}: #{e}")
+        nil
+      end
+
+      # Parses a raw CAN frame string into a hash with id, data and extended flag.
+      def parse_frame(frame:, can_fd: nil) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/PerceivedComplexity
+        return nil unless frame && frame.size >= MIN_FRAME_SIZE
+
+        use_fd = can_fd.nil? ? frame.size >= CANFD_FRAME_SIZE : can_fd
+
+        raw_id = unpack_frame_id(frame: frame)
+        extended = raw_id.anybits?(0x80000000)
+        id = raw_id & 0x1FFFFFFF
+
+        data_length = if use_fd
+                        frame[4].ord
+                      else
+                        frame[4].ord & 0x0F
+                      end
+
+        data = if frame.size >= MIN_FRAME_SIZE + data_length
+                 frame[MIN_FRAME_SIZE, data_length].unpack("C*")
+               else
+                 []
+               end
+
+        { id: id, data: data, extended: extended }
+      rescue StandardError => e
+        logger.error("Error parsing CAN frame: #{e}")
+        nil
+      end
+
+      private
+
+      def unpack_frame_id(frame:)
+        if endianness == :big
+          frame[0..3].unpack1("L>")
+        else
+          frame[0..3].unpack1("V")
+        end
+      end
+
+      def configure_socket(socket, can_fd:)
+        socket.bind(Socket.pack_sockaddr_can(interface_name))
+        socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, TIMEOUT)
+        return unless can_fd && Socket.const_defined?(:CAN_RAW_FD_FRAMES)
+
+        socket.setsockopt(Socket.const_defined?(:SOL_CAN_RAW) ? Socket::SOL_CAN_RAW : Socket::CAN_RAW,
+                          Socket::CAN_RAW_FD_FRAMES, 1)
+      end
+
+      def close_socket(socket)
+        return unless socket
+        return if socket.closed?
+
+        socket.close
+      rescue StandardError
+        # Ignore close errors so we can report the original failure.
+      end
+    end
+  end
+end

data/lib/can_messenger/dbc.rb

@@ -0,0 +1,515 @@
+# frozen_string_literal: true
+
+module CanMessenger
+  # DBC (Database CAN) Parser and Encoder/Decoder
+  #
+  # This class provides functionality to parse DBC files and encode/decode CAN messages
+  # according to the signal definitions. DBC files are a standard way to describe
+  # CAN network communication.
+  #
+  # @example Loading and using a DBC file
+  #   dbc = CanMessenger::DBC.load('vehicle.dbc')
+  #
+  #   # Encode a message with signal values
+  #   frame = dbc.encode_can('EngineData', RPM: 2500, Temperature: 85.5)
+  #   # => { id: 0x123, data: [0x09, 0xC4, 0xAB, 0x00, 0x00, 0x00, 0x00, 0x00] }
+  #
+  #   # Decode a received CAN frame
+  #   decoded = dbc.decode_can(0x123, [0x09, 0xC4, 0xAB, 0x00, 0x00, 0x00, 0x00, 0x00])
+  #   # => { name: 'EngineData', signals: { RPM: 2500.0, Temperature: 85.5 } }
+  class DBC
+    attr_reader :messages
+
+    # Loads a DBC file from disk and parses its contents.
+    #
+    # @param [String] path The filesystem path to the DBC file
+    # @return [DBC] A new DBC instance with parsed message definitions
+    # @raise [Errno::ENOENT] If the file doesn't exist
+    # @raise [ArgumentError] If the file contains invalid DBC syntax
+    def self.load(path)
+      new(File.read(path))
+    end
+
+    # Initializes a new DBC instance.
+    #
+    # @param [String] content The DBC file content to parse (optional)
+    def initialize(content = "")
+      @messages = {}
+      parse(content) unless content.empty?
+    end
+
+    # Parses DBC content and populates the messages hash.
+    #
+    # This method processes each line of the DBC content, identifying message
+    # definitions (BO_) and signal definitions (SG_). It builds a complete
+    # message structure with all associated signals.
+    #
+    # @param [String] content The DBC file content to parse
+    # @return [void]
+    def parse(content) # rubocop:disable Metrics/MethodLength
+      current = nil
+      content.each_line do |line|
+        line.strip!
+        next if line.empty? || line.start_with?("BO_TX_BU_")
+
+        if (msg = parse_message_line(line))
+          current = msg
+          @messages[msg.name] = msg
+        elsif current && (sig = parse_signal_line(line, current))
+          current.signals << sig
+        end
+      end
+    end
+
+    # Parses a message definition line from DBC content.
+    #
+    # Message lines follow the format: BO_ <ID> <Name>: <DLC> <Node>
+    #
+    # @param [String] line A single line from the DBC file
+    # @return [Message, nil] A Message object if the line matches, nil otherwise
+    def parse_message_line(line)
+      return unless (m = line.match(/^BO_\s+(\d+)\s+(\w+)\s*:\s*(\d+)/))
+
+      id = m[1].to_i
+      name = m[2]
+      dlc = m[3].to_i
+      Message.new(id, name, dlc)
+    end
+
+    # Parses a signal definition line from DBC content.
+    #
+    # Signal lines follow the format:
+    # SG_ <SignalName> : <StartBit>|<Length>@<Endianness><Sign> (<Factor>,<Offset>) [<Min>|<Max>] "<Unit>" <Receivers>
+    #
+    # @param [String] line A single line from the DBC file
+    # @param [Message] _current The current message being processed (unused but kept for API consistency)
+    # @return [Signal, nil] A Signal object if the line matches, nil otherwise
+    def parse_signal_line(line, _current) # rubocop:disable Metrics/MethodLength
+      return unless (m = line.match(/^SG_\s+(\w+)\s*:\s*(\d+)\|(\d+)@(\d)([+-])\s*\(([^,]+),([^)]+)\)/))
+
+      sig_name = m[1]
+      start_bit = m[2].to_i
+      length = m[3].to_i
+      endian = m[4] == "1" ? :little : :big
+      sign = m[5] == "-" ? :signed : :unsigned
+      factor = m[6].to_f
+      offset = m[7].to_f
+
+      Signal.new(
+        sig_name,
+        start_bit: start_bit,
+        length: length,
+        endianness: endian,
+        sign: sign,
+        factor: factor,
+        offset: offset
+      )
+    end # rubocop:enable Metrics/MethodLength
+
+    # Encodes signal values into a CAN message frame.
+    #
+    # Takes a message name and a hash of signal values, then encodes them
+    # into the appropriate byte array according to the DBC signal definitions.
+    #
+    # @param [String] name The name of the message to encode
+    # @param [Hash<Symbol|String, Numeric>] values Signal names mapped to their values
+    # @return [Hash] A hash containing :id (Integer) and :data (Array<Integer>)
+    # @raise [ArgumentError] If the message name is not found in the DBC
+    #
+    # @example
+    #   frame = dbc.encode_can('EngineData', RPM: 2500, Temperature: 85.5)
+    #   # => { id: 0x123, data: [0x09, 0xC4, 0xAB, 0x00, 0x00, 0x00, 0x00, 0x00] }
+    def encode_can(name, values)
+      msg = @messages[name]
+      raise ArgumentError, "Unknown message #{name}" unless msg
+
+      { id: msg.id, data: msg.encode(values) }
+    end
+
+    # Decodes a CAN message frame into signal values.
+    #
+    # Takes a CAN ID and data bytes, finds the matching message definition,
+    # and decodes the data into individual signal values according to the DBC.
+    #
+    # @param [Integer] id The CAN message ID
+    # @param [Array<Integer>] data The CAN message data bytes
+    # @return [Hash, nil] A hash containing :name (String) and :signals (Hash), or nil if no matching message
+    #
+    # @example
+    #   decoded = dbc.decode_can(0x123, [0x09, 0xC4, 0xAB, 0x00, 0x00, 0x00, 0x00, 0x00])
+    #   # => { name: 'EngineData', signals: { RPM: 2500.0, Temperature: 85.5 } }
+    def decode_can(id, data)
+      msg = @messages.values.find { |m| m.id == id }
+      return nil unless msg
+
+      { name: msg.name, signals: msg.decode(data) }
+    end
+  end
+
+  # Represents a CAN message definition from a DBC file.
+  #
+  # A Message contains the basic message properties (ID, name, data length)
+  # and a collection of Signal objects that define how data is structured
+  # within the message payload.
+  #
+  # @example
+  #   message = Message.new(0x123, 'EngineData', 8)
+  #   message.signals << Signal.new('RPM', start_bit: 0, length: 16, ...)
+  class Message
+    attr_reader :id, :name, :dlc, :signals
+
+    # Initializes a new Message instance.
+    #
+    # @param [Integer] id The CAN message ID (11-bit standard or 29-bit extended)
+    # @param [String] name The symbolic name of the message
+    # @param [Integer] dlc Data Length Code - number of bytes in the message (0-8 for classic CAN)
+    def initialize(id, name, dlc)
+      @id = id
+      @name = name
+      @dlc = dlc
+      @signals = []
+    end
+
+    # Encodes signal values into the message byte array.
+    #
+    # Iterates through all signals in the message and encodes their values
+    # into the appropriate bit positions within the message data bytes.
+    #
+    # @param [Hash<Symbol|String, Numeric>] values Signal names mapped to their values
+    # @return [Array<Integer>] Array of bytes representing the encoded message
+    def encode(values)
+      bytes = Array.new(@dlc, 0)
+      @signals.each do |sig|
+        next unless values.key?(sig.name.to_sym) || values.key?(sig.name.to_s)
+
+        v = values[sig.name.to_sym] || values[sig.name.to_s]
+        sig.encode(bytes, v)
+      end
+      bytes
+    end
+
+    # Decodes message data bytes into individual signal values.
+    #
+    # Extracts and decodes each signal from the message data bytes,
+    # applying the appropriate scaling (factor/offset) to produce
+    # the final engineering unit values.
+    #
+    # @param [Array<Integer>] data The message data bytes to decode
+    # @return [Hash<Symbol, Float>] Signal names mapped to their decoded values
+    def decode(data)
+      res = {}
+      @signals.each do |sig|
+        res[sig.name.to_sym] = sig.decode(data)
+      end
+      res
+    end
+  end
+
+  # Represents a signal within a CAN message.
+  #
+  # A Signal defines how a piece of data is encoded within a CAN message,
+  # including its bit position, length, byte order, signedness, and scaling.
+  # Signals can represent physical values (like temperature, speed) that are
+  # encoded as integers in the CAN frame but scaled to engineering units.
+  #
+  # @example Creating a signal for engine RPM
+  #   rpm_signal = Signal.new('RPM',
+  #     start_bit: 0,      # Starting at bit 0
+  #     length: 16,        # 16 bits long
+  #     endianness: :little, # Little-endian byte order
+  #     sign: :unsigned,   # Unsigned integer
+  #     factor: 0.25,      # Scale by 0.25
+  #     offset: 0          # No offset
+  #   )
+  class Signal # rubocop:disable Metrics/ClassLength
+    attr_reader :name, :start_bit, :length, :endianness, :sign, :factor, :offset
+
+    # Initializes a new Signal instance.
+    #
+    # @param [String] name The signal name
+    # @param [Integer] start_bit The starting bit position within the message (0-based)
+    # @param [Integer] length The number of bits the signal occupies (1-64)
+    # @param [Symbol] endianness Byte order - :little for little-endian, :big for big-endian
+    # @param [Symbol] sign Value type - :unsigned for unsigned integers, :signed for signed integers
+    # @param [Float] factor Scaling factor to convert raw value to engineering units
+    # @param [Float] offset Offset to add after scaling
+    def initialize(name, start_bit:, length:, endianness:, sign:, factor:, offset:) # rubocop:disable Metrics/ParameterLists
+      @name = name
+      @start_bit = start_bit
+      @length = length
+      @endianness = endianness
+      @sign = sign
+      @factor = factor
+      @offset = offset
+    end
+
+    # Encodes a value into the message byte array at this signal's bit position.
+    #
+    # Converts the engineering unit value to a raw integer using the signal's
+    # factor and offset, then places the bits into the appropriate positions
+    # within the message bytes.
+    #
+    # @param [Array<Integer>] bytes The message byte array to modify
+    # @param [Numeric] value The engineering unit value to encode
+    # @return [void]
+    # @raise [ArgumentError] If the value is out of range or signal exceeds message bounds
+    def encode(bytes, value)
+      raw = ((value - offset) / factor).round
+      validate_signal_bounds(bytes.size)
+      insert_bits(bytes, raw)
+    end
+
+    # Decodes this signal's value from the message byte array.
+    #
+    # Extracts the raw integer value from the appropriate bit positions,
+    # then applies the signal's scaling (factor and offset) to convert
+    # it to engineering units.
+    #
+    # @param [Array<Integer>] bytes The message byte array to decode from
+    # @return [Float] The decoded value in engineering units
+    def decode(bytes)
+      raw = extract_bits(bytes)
+      (raw * factor) + offset
+    end
+
+    private
+
+    # Validates that the signal fits within the message boundaries.
+    #
+    # Ensures that all bits used by this signal fall within the message's
+    # data length code (DLC) boundaries.
+    #
+    # @param [Integer] message_size_bytes The size of the message in bytes
+    # @return [void]
+    # @raise [ArgumentError] If signal bits exceed message boundaries or start_bit is negative
+    def validate_signal_bounds(message_size_bytes)
+      max_bit = start_bit + length - 1
+      max_allowed_bit = (message_size_bytes * 8) - 1
+
+      raise ArgumentError, "Signal #{name}: start_bit (#{start_bit}) cannot be negative" if start_bit.negative?
+
+      return unless max_bit > max_allowed_bit
+
+      raise ArgumentError,
+            "Signal #{name}: signal bits #{start_bit}..#{max_bit} exceed message size " \
+            "(#{message_size_bytes} bytes = #{max_allowed_bit + 1} bits)"
+    end
+
+    # Encodes a raw integer value into the message byte array.
+    #
+    # This is the main encoding method that coordinates validation,
+    # value processing, and bit manipulation.
+    #
+    # @param [Array<Integer>] bytes The message byte array to modify
+    # @param [Integer] raw The raw integer value to encode
+    # @return [void]
+    def insert_bits(bytes, raw)
+      validate_raw_value(raw)
+      processed_raw = process_raw_value(raw)
+      write_bits_to_bytes(bytes, processed_raw)
+    end
+
+    # Validates the raw integer value before encoding.
+    #
+    # Performs range checking for both signed and unsigned values
+    # to ensure they fit within the signal's bit length.
+    #
+    # @param [Integer] raw The raw value to validate
+    # @return [void]
+    # @raise [ArgumentError] If the value is out of range for the signal type
+    def validate_raw_value(raw)
+      validate_unsigned_value(raw)
+      validate_signed_value(raw)
+    end
+
+    # Validates unsigned values to ensure they're not negative.
+    #
+    # @param [Integer] raw The raw value to validate
+    # @return [void]
+    # @raise [ArgumentError] If an unsigned value is negative
+    def validate_unsigned_value(raw)
+      return unless sign == :unsigned && raw.negative?
+
+      raise ArgumentError, "Unsigned value cannot be negative: #{raw}"
+    end
+
+    # Validates signed values to ensure they fit in the signal's bit range.
+    #
+    # For signed signals, checks that the value fits within the two's complement
+    # range defined by the signal's bit length.
+    #
+    # @param [Integer] raw The raw value to validate
+    # @return [void]
+    # @raise [ArgumentError] If a signed value exceeds the bit field's range
+    def validate_signed_value(raw)
+      return unless sign == :signed
+
+      min_val = -(1 << (length - 1))
+      max_val = (1 << (length - 1)) - 1
+      return if raw.between?(min_val, max_val)
+
+      raise ArgumentError,
+            "Signed value #{raw} out of range [#{min_val}..#{max_val}] for #{length}-bit field"
+    end
+
+    # Processes the raw value for encoding (handles two's complement conversion).
+    #
+    # For signed negative values, converts them to two's complement representation.
+    # Ensures the final value fits within the signal's bit length.
+    #
+    # @param [Integer] raw The raw value to process
+    # @return [Integer] The processed value ready for bit manipulation
+    def process_raw_value(raw)
+      # Handle signed values: convert negative to two's complement
+      raw = (1 << length) + raw if sign == :signed && raw.negative?
+      # Ensure the value fits in the specified bit length
+      raw & ((1 << length) - 1)
+    end
+
+    # Writes the processed bits into the message byte array.
+    #
+    # Iterates through each bit of the signal and places it in the correct
+    # position within the message bytes, respecting the signal's endianness.
+    #
+    # @param [Array<Integer>] bytes The message byte array to modify
+    # @param [Integer] raw The processed value to write
+    # @return [void]
+    def write_bits_to_bytes(bytes, raw)
+      length.times do |i|
+        bit = (raw >> i) & 1
+        bit_pos = calculate_bit_position(i)
+        byte_index, bit_index = calculate_byte_and_bit_indices(bit_pos)
+
+        validate_bit_position(bit_pos, bytes.size)
+        update_byte_with_bit(bytes, byte_index, bit_index, bit)
+      end
+    end
+
+    # Calculates the bit position for a given bit offset within the signal.
+    #
+    # Handles both little-endian and big-endian bit ordering according
+    # to the signal's endianness setting.
+    #
+    # @param [Integer] bit_offset The offset within the signal (0 to length-1)
+    # @return [Integer] The absolute bit position within the message
+    def calculate_bit_position(bit_offset)
+      if endianness == :little
+        start_bit + bit_offset
+      else
+        # For big-endian signals, the bit numbering within a byte follows MSB-first
+        # ordering. This means that the most significant bit (MSB) is numbered 7,
+        # and the least significant bit (LSB) is numbered 0. To calculate the absolute
+        # bit position, we first determine the position of the MSB in the starting byte.
+        #
+        # The formula ((start_bit / 8) * 8) calculates the starting byte's base bit
+        # position (aligned to the nearest multiple of 8). Adding (7 - (start_bit % 8))
+        # adjusts this base position to point to the MSB of the starting byte.
+        #
+        # Finally, we subtract the bit offset to account for the signal's length and
+        # position within the message.
+        base = ((start_bit / 8) * 8) + (7 - (start_bit % 8))
+        base - bit_offset
+      end
+    end
+
+    # Calculates byte and bit indices from an absolute bit position.
+    #
+    # @param [Integer] bit_pos The absolute bit position within the message
+    # @return [Array<Integer>] A two-element array [byte_index, bit_index]
+    def calculate_byte_and_bit_indices(bit_pos)
+      [bit_pos / 8, bit_pos % 8]
+    end
+
+    # Validates that a bit position is within the message boundaries.
+    #
+    # @param [Integer] bit_pos The bit position to validate
+    # @param [Integer] bytes_size The size of the message in bytes
+    # @return [void]
+    # @raise [ArgumentError] If the bit position is out of bounds
+    def validate_bit_position(bit_pos, bytes_size)
+      byte_index = bit_pos / 8
+      return unless byte_index >= bytes_size || byte_index.negative?
+
+      raise ArgumentError, "Bit position #{bit_pos} out of bounds"
+    end
+
+    # Updates a specific bit within a byte in the message array.
+    #
+    # Sets or clears the specified bit within the target byte, initializing
+    # the byte to 0 if it hasn't been set yet.
+    #
+    # @param [Array<Integer>] bytes The message byte array to modify
+    # @param [Integer] byte_index The index of the byte to modify
+    # @param [Integer] bit_index The bit position within the byte (0-7)
+    # @param [Integer] bit The bit value to set (0 or 1)
+    # @return [void]
+    def update_byte_with_bit(bytes, byte_index, bit_index, bit)
+      bytes[byte_index] ||= 0
+      if bit == 1
+        bytes[byte_index] |= (1 << bit_index)
+      else
+        bytes[byte_index] &= ~(1 << bit_index)
+      end
+    end
+
+    # Extracts the signal value from the message byte array.
+    #
+    # This is the main decoding method that coordinates bit extraction
+    # and sign conversion.
+    #
+    # @param [Array<Integer>] bytes The message byte array to decode from
+    # @return [Integer] The raw integer value extracted from the message
+    def extract_bits(bytes)
+      value = read_bits_from_bytes(bytes)
+      convert_to_signed_if_needed(value)
+    end
+
+    # Reads the raw bits from the message byte array.
+    #
+    # Extracts each bit of the signal from the message bytes, building
+    # up the raw integer value bit by bit.
+    #
+    # @param [Array<Integer>] bytes The message byte array to read from
+    # @return [Integer] The raw unsigned integer value
+    def read_bits_from_bytes(bytes)
+      value = 0
+      length.times do |i|
+        bit_pos = calculate_bit_position(i)
+        byte_index, bit_index = calculate_byte_and_bit_indices(bit_pos)
+
+        validate_extraction_bounds(bit_pos, bytes.size)
+
+        bit = ((bytes[byte_index] || 0) >> bit_index) & 1
+        value |= (bit << i)
+      end
+      value
+    end
+
+    # Validates bit position during extraction to ensure it's within bounds.
+    #
+    # @param [Integer] bit_pos The bit position to validate
+    # @param [Integer] bytes_size The size of the message in bytes
+    # @return [void]
+    # @raise [ArgumentError] If the bit position is out of bounds
+    def validate_extraction_bounds(bit_pos, bytes_size)
+      byte_index = bit_pos / 8
+      return unless byte_index >= bytes_size || byte_index.negative?
+
+      raise ArgumentError, "Bit position #{bit_pos} out of bounds during extraction"
+    end
+
+    # Converts unsigned value to signed if the signal is signed and the MSB is set.
+    #
+    # For signed signals, checks if the most significant bit is set and
+    # converts the value from two's complement representation to a negative integer.
+    #
+    # @param [Integer] value The unsigned integer value to potentially convert
+    # @return [Integer] The final signed or unsigned value
+    def convert_to_signed_if_needed(value)
+      return value unless sign == :signed && length.positive?
+
+      msb_set = (value >> (length - 1)).allbits?(1)
+      msb_set ? value - (1 << length) : value
+    end
+  end
+end

data/lib/can_messenger/messenger.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "socket"
 require "logger"
+require_relative "adapter/socketcan"
 
 module CanMessenger
   # Messenger
@@ -15,25 +15,24 @@ module CanMessenger
   #   messenger.start_listening do |message|
   #     puts "Received: ID=#{message[:id]}, Data=#{message[:data].map { |b| '0x%02X' % b }}"
   #   end
-  class Messenger # rubocop:disable Metrics/ClassLength
-    FRAME_SIZE = 16
-    CANFD_FRAME_SIZE = 72
-    MIN_FRAME_SIZE = 8
-    MAX_FD_DATA = 64
-    TIMEOUT = [1, 0].pack("l_2")
-
+  class Messenger
     # Initializes a new Messenger instance.
     #
     # @param [String] interface_name The CAN interface to use (e.g., 'can0').
     # @param [Logger, nil] logger Optional logger for error handling and debug information.
-    # @param [Symbol] endianness The endianness of the CAN ID (default: :big) can be :big or :little.
+    # @param [Symbol] endianness The endianness of the CAN ID (default: :native) can be :big, :little, or :native.
     # @return [void]
-    def initialize(interface_name:, logger: nil, endianness: :big, can_fd: false)
+    def initialize(interface_name:, logger: nil, endianness: :native, can_fd: false, adapter: Adapter::Socketcan)
       @interface_name = interface_name
       @logger = logger || Logger.new($stdout)
       @listening = true # Control flag for listening loop
-      @endianness    = endianness # :big or :little
+      @endianness    = endianness # :big, :little, or :native
       @can_fd        = can_fd
+      @adapter = if adapter.is_a?(Class)
+                   adapter.new(interface_name: interface_name, logger: @logger, endianness: endianness)
+                 else
+                   adapter
+                 end
     end
 
     # Sends a CAN message by writing directly to a raw CAN socket
@@ -42,10 +41,12 @@ module CanMessenger
     # @param [Array<Integer>] data The data bytes of the CAN message (0 to 8 bytes).
     # @return [void]
     def send_can_message(id:, data:, extended_id: false, can_fd: nil)
+      raise ArgumentError, "id and data are required" if id.nil? || data.nil?
+
       use_fd = can_fd.nil? ? @can_fd : can_fd
 
       with_socket(can_fd: use_fd) do |socket|
-        frame = build_can_frame(id: id, data: data, extended_id: extended_id, can_fd: use_fd)
+        frame = @adapter.build_can_frame(id: id, data: data, extended_id: extended_id, can_fd: use_fd)
         socket.write(frame)
       end
     rescue ArgumentError
@@ -54,6 +55,23 @@ module CanMessenger
       @logger.error("Error sending CAN message (ID: #{id}): #{e}")
     end
 
+    # Encodes and sends a CAN message using a DBC definition
+    #
+    # @param [String] message_name The message name to encode
+    # @param [Hash] signals Values for each signal in the message
+    # @param [CanMessenger::DBC] dbc The DBC instance used for encoding (defaults to @dbc)
+    # @return [void]
+    def send_dbc_message(message_name:, signals:, dbc: @dbc, extended_id: false, can_fd: nil)
+      raise ArgumentError, "dbc is required" if dbc.nil?
+
+      encoded = dbc.encode_can(message_name, signals)
+      send_can_message(id: encoded[:id], data: encoded[:data], extended_id: extended_id, can_fd: can_fd)
+    rescue ArgumentError
+      raise
+    rescue StandardError => e
+      @logger.error("Error sending DBC message #{message_name}: #{e}")
+    end
+
     # Continuously listens for CAN messages on the specified interface.
     #
     # This method listens for incoming CAN messages and applies an optional filter.
@@ -67,7 +85,7 @@ module CanMessenger
     #   - `:id` [Integer] the CAN message ID
     #   - `:data` [Array<Integer>] the message data bytes
     # @return [void]
-    def start_listening(filter: nil, can_fd: nil, &block)
+    def start_listening(filter: nil, can_fd: nil, dbc: nil, &)
       return @logger.error("No block provided to handle messages.") unless block_given?
 
       @listening = true
@@ -76,7 +94,7 @@ module CanMessenger
 
       with_socket(can_fd: use_fd) do |socket|
         @logger.info("Started listening on #{@interface_name}")
-        process_message(socket, filter, use_fd, &block) while @listening
+        process_message(socket, filter, use_fd, dbc, &) while @listening
       end
     end
 
@@ -96,7 +114,7 @@ module CanMessenger
     # @yield [socket] An open CAN socket.
     # @return [void]
     def with_socket(can_fd: @can_fd)
-      socket = open_can_socket(can_fd: can_fd)
+      socket = @adapter.open_socket(can_fd: can_fd)
       return @logger.error("Failed to open socket, cannot continue operation.") if socket.nil?
 
       yield socket
@@ -104,133 +122,25 @@ module CanMessenger
       socket&.close
     end
 
-    # Creates and configures a CAN socket bound to @interface_name.
-    #
-    # @return [Socket, nil] The configured CAN socket, or nil if the socket cannot be opened.
-    def open_can_socket(can_fd: @can_fd) # rubocop:disable Metrics/MethodLength
-      socket = Socket.open(Socket::PF_CAN, Socket::SOCK_RAW, Socket::CAN_RAW)
-      socket.bind(Socket.pack_sockaddr_can(@interface_name))
-      socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, TIMEOUT)
-      if can_fd && Socket.const_defined?(:CAN_RAW_FD_FRAMES)
-        socket.setsockopt(Socket.const_defined?(:SOL_CAN_RAW) ? Socket::SOL_CAN_RAW : Socket::CAN_RAW,
-                          Socket::CAN_RAW_FD_FRAMES, 1)
-      end
-      socket
-    rescue StandardError => e
-      @logger.error("Error creating CAN socket on interface #{@interface_name}: #{e}")
-      nil
-    end
-
-    # Builds a raw CAN or CAN FD frame for SocketCAN.
-    #
-    # @param id [Integer] the CAN ID
-    # @param data [Array<Integer>] data bytes (up to 8 for classic, 64 for CAN FD)
-    # @param can_fd [Boolean] whether to build a CAN FD frame
-    # @return [String] the packed CAN frame
-    def build_can_frame(id:, data:, extended_id: false, can_fd: false) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/PerceivedComplexity
-      if can_fd
-        raise ArgumentError, "CAN FD data cannot exceed #{MAX_FD_DATA} bytes" if data.size > MAX_FD_DATA
-      elsif data.size > 8
-        raise ArgumentError, "CAN data cannot exceed 8 bytes"
-      end
-
-      # Mask the ID to 29 bits
-      can_id = id & 0x1FFFFFFF
-
-      # If extended_id == true, set bit 31 (CAN_EFF_FLAG)
-      can_id |= 0x80000000 if extended_id
-
-      # Pack the 4‐byte ID (big-endian or little-endian)
-      id_bytes = @endianness == :big ? [can_id].pack("L>") : [can_id].pack("V")
-
-      # 1 byte for DLC/length, then 3 bytes for flags/reserved
-      dlc_and_pad = [data.size, 0, 0, 0].pack("C*")
-
-      payload = if can_fd
-                  data.pack("C*").ljust(MAX_FD_DATA, "\x00")
-                else
-                  data.pack("C*").ljust(8, "\x00")
-                end
-
-      id_bytes + dlc_and_pad + payload
-    end
-
     # Processes a single CAN message from `socket`. Applies filter, yields to block if it matches.
     #
     # @param socket [Socket] The CAN socket.
     # @param filter [Integer, Range, Array<Integer>, nil] Optional filter for CAN IDs.
     # @yield [message] Yields the message if it passes filtering.
     # @return [void]
-    def process_message(socket, filter, can_fd)
-      message = receive_message(socket: socket, can_fd: can_fd)
+    def process_message(socket, filter, can_fd, dbc, &block)
+      message = @adapter.receive_message(socket: socket, can_fd: can_fd)
       return if message.nil?
       return if filter && !matches_filter?(message_id: message[:id], filter: filter)
 
-      yield(message)
-    rescue StandardError => e
-      @logger.error("Unexpected error in listening loop: #{e.message}")
-    end
-
-    # Reads a frame from the socket and parses it into { id:, data: }, or nil if none is received.
-    #
-    # @param socket [Socket]
-    # @return [Hash, nil]
-    def receive_message(socket:, can_fd: false)
-      frame_size = can_fd ? CANFD_FRAME_SIZE : FRAME_SIZE
-      frame = socket.recv(frame_size)
-      return nil if frame.nil? || frame.size < MIN_FRAME_SIZE
-
-      parse_frame(frame: frame, can_fd: can_fd)
-    rescue IO::WaitReadable
-      nil
-    rescue StandardError => e
-      @logger.error("Error receiving CAN message on interface #{@interface_name}: #{e}")
-      nil
-    end
-
-    # Parses a raw CAN frame into { id: Integer, data: Array<Integer> }, or nil on error.
-    #
-    # @param [String] frame
-    # @return [Hash, nil]
-    def parse_frame(frame:, can_fd: nil) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/PerceivedComplexity
-      return nil unless frame && frame.size >= MIN_FRAME_SIZE
-
-      use_fd = can_fd.nil? ? frame.size >= CANFD_FRAME_SIZE : can_fd
-
-      raw_id = unpack_frame_id(frame: frame)
-
-      # Determine if EFF bit is set
-      extended = raw_id.anybits?(0x80000000)
-      # or raw_id.anybits?(0x80000000) if your Ruby version supports `Integer#anybits?`
-
-      # Now mask off everything except the lower 29 bits
-      id = raw_id & 0x1FFFFFFF
-
-      data_length = if use_fd
-                      frame[4].ord
-                    else
-                      frame[4].ord & 0x0F
-                    end
-
-      # Extract data
-      data = if frame.size >= MIN_FRAME_SIZE + data_length
-               frame[MIN_FRAME_SIZE, data_length].unpack("C*")
-             else
-               []
-             end
+      if dbc
+        decoded = dbc.decode_can(message[:id], message[:data])
+        message[:decoded] = decoded if decoded
+      end
 
-      { id: id, data: data, extended: extended }
+      block.call(message)
     rescue StandardError => e
-      @logger.error("Error parsing CAN frame: #{e}")
-      nil
-    end
-
-    def unpack_frame_id(frame:)
-      if @endianness == :big
-        frame[0..3].unpack1("L>")
-      else
-        frame[0..3].unpack1("V")
-      end
+      @logger.error("Unexpected error in listening loop: #{e.message}")
     end
 
     # Checks whether the given message ID matches the specified filter.

data/lib/can_messenger/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CanMessenger
-  VERSION = "1.3.0"
+  VERSION = "2.0.0"
 end

data/lib/can_messenger.rb

@@ -3,6 +3,7 @@
 
 require_relative "can_messenger/version"
 require_relative "can_messenger/messenger"
+require_relative "can_messenger/dbc"
 
 module CanMessenger
   class Error < StandardError; end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: can_messenger
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 2.0.0
 platform: ruby
 authors:
 - fk1018
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-07-08 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: CanMessenger provides an interface to send and receive messages over
   the CAN bus, useful for applications requiring CAN communication in Ruby.
@@ -18,8 +17,13 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
+- LICENSE.txt
 - README.md
 - lib/can_messenger.rb
+- lib/can_messenger/adapter/base.rb
+- lib/can_messenger/adapter/socketcan.rb
+- lib/can_messenger/dbc.rb
 - lib/can_messenger/messenger.rb
 - lib/can_messenger/version.rb
 homepage: https://github.com/fk1018/can_messenger
@@ -31,7 +35,6 @@ metadata:
   source_code_uri: https://github.com/fk1018/can_messenger
   changelog_uri: https://github.com/fk1018/can_messenger/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -39,15 +42,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: 4.0.1
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 4.0.3
 specification_version: 4
 summary: A simple Ruby wrapper to read and write CAN bus messages.
 test_files: []