can_messenger 1.3.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a68f4a339bebc034ffe78e990086ff91d28164962c2877e5d88edb095cbca90
-  data.tar.gz: 7a96c22ccf82cae952123d733805c2efe31dd482ba9bf5d5a66d29cb14572822
+  metadata.gz: d6460da6eaff67f984db1e7f63466b8350140b244c4e7beaea56595a95e7da92
+  data.tar.gz: 7f06c6f54c0e6fc7ea49aff994ad7ad076c7d3a5f98cb50554793751f8941372
 SHA512:
-  metadata.gz: c8302565cc5e889a290a446167bdec8eedd29ba077c63c003f544138c078a94498b258f465387b3c92f8b9b9ffc18ed65810fa70c5dc97e3ba977e62bbc394c4
-  data.tar.gz: a606c71e8606bbccd98e1917bc4c2205037156e3994f152f6b05c3a52fc1037c21f8a38a91814abddb6f4a9bf5a0eb8682a2acaf93e3da0cdb818a2d8d03131f
+  metadata.gz: b1b3bdb759e1ed223c0e08d43c7fdcbf556123c007ecad5dce1b2b4b9b8ac35af289b64a15d16c46939a6ee9028d52b5015f35f4576b14637406884e9e881270
+  data.tar.gz: 1de19b416ecf4733f074c7c704a966313a86c6f16d9a631f7ff14a5b3ebf9b923dfe24930948bbb910554a376e168f49ea1a6c5c8abd324902efbdc9ed65366d

data/README.md

@@ -6,6 +6,7 @@
 ![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.
 
@@ -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:
@@ -168,6 +187,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/dbc.rb

@@ -0,0 +1,516 @@
+# 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)
+      if sign == :signed && value[length - 1] == 1
+        value - (1 << length)
+      else
+        value
+      end
+    end
+  end
+end

data/lib/can_messenger/messenger.rb

@@ -42,6 +42,8 @@ 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|
@@ -54,6 +56,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 +86,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, &block)
       return @logger.error("No block provided to handle messages.") unless block_given?
 
       @listening = true
@@ -76,7 +95,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, &block) while @listening
       end
     end
 
@@ -161,12 +180,17 @@ module CanMessenger
     # @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)
+    def process_message(socket, filter, can_fd, dbc, &block)
       message = 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)
+      if dbc
+        decoded = dbc.decode_can(message[:id], message[:data])
+        message[:decoded] = decoded if decoded
+      end
+
+      block.call(message)
     rescue StandardError => e
       @logger.error("Unexpected error in listening loop: #{e.message}")
     end

data/lib/can_messenger/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CanMessenger
-  VERSION = "1.3.0"
+  VERSION = "1.4.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,14 @@
 --- !ruby/object:Gem::Specification
 name: can_messenger
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.4.0
 platform: ruby
 authors:
 - fk1018
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-07-08 00:00:00.000000000 Z
+date: 2025-07-29 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.
@@ -20,6 +20,7 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/can_messenger.rb
+- lib/can_messenger/dbc.rb
 - lib/can_messenger/messenger.rb
 - lib/can_messenger/version.rb
 homepage: https://github.com/fk1018/can_messenger