can_messenger 1.2.1 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d47c9c4b19c40337cb6b58f380e9a3f07554144a14d23ef4c2589060fd25942e
-  data.tar.gz: 66f58f8fab19fb73ab5124e4036313459ae032282bdd07613dc6156ef86a1379
+  metadata.gz: d6460da6eaff67f984db1e7f63466b8350140b244c4e7beaea56595a95e7da92
+  data.tar.gz: 7f06c6f54c0e6fc7ea49aff994ad7ad076c7d3a5f98cb50554793751f8941372
 SHA512:
-  metadata.gz: a55c719faf6f813ff4aef9004b4b32065297773498bf92291019002520b43c940e304fa5a0244635f42c9152ab3729cbeaa8534d809b2790878ebc9ef9a00244
-  data.tar.gz: '014168fa0419b78aa966c4d1d9a415c2e8e70650323df2c1a4328354099ffacf038cd52ef1c1fc371334e312a91538e985b7ec98727863739aa70c88e449d4d3'
+  metadata.gz: b1b3bdb759e1ed223c0e08d43c7fdcbf556123c007ecad5dce1b2b4b9b8ac35af289b64a15d16c46939a6ee9028d52b5015f35f4576b14637406884e9e881270
+  data.tar.gz: 1de19b416ecf4733f074c7c704a966313a86c6f16d9a631f7ff14a5b3ebf9b923dfe24930948bbb910554a376e168f49ea1a6c5c8abd324902efbdc9ed65366d

data/README.md

@@ -6,9 +6,14 @@
 ![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.
+
 ## Installation
 
 To install `can_messenger`, add it to your application's Gemfile:
@@ -57,6 +62,15 @@ If you need to send an extended CAN frame (29-bit ID), set extended_id: true. Th
 messenger.send_can_message(id: 0x123456, data: [0x01, 0x02, 0x03], extended_id: true)
 ```
 
+If you need to work with **CAN FD** frames (up to 64 data bytes), enable the mode per call or when initializing the messenger:
+
+```ruby
+messenger_fd = CanMessenger::Messenger.new(interface_name: 'can0', can_fd: true)
+messenger_fd.send_can_message(id: 0x123, data: Array.new(12, 0xFF))
+# Or on demand
+messenger.send_can_message(id: 0x123, data: Array.new(12, 0xFF), can_fd: true)
+```
+
 ### Receiving CAN Messages
 
 To listen for incoming messages, set up a listener:
@@ -95,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:
@@ -147,14 +179,15 @@ Before using `can_messenger`, please note the following:
 
 - **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.
-  - 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). If you work with non-standard frames or CAN FD (64-byte data), you’ll need to customize the parsing/sending logic.
+  - 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
 
-- **Send CAN Messages**: Send CAN messages (up to 8 data bytes).
+- **Send CAN Messages**: Send CAN messages (up to 8 data bytes, or 64 bytes with CAN FD enabled).
 - **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

@@ -17,7 +17,9 @@ module CanMessenger
   #   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")
 
     # Initializes a new Messenger instance.
@@ -26,11 +28,12 @@ module CanMessenger
     # @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.
     # @return [void]
-    def initialize(interface_name:, logger: nil, endianness: :big)
+    def initialize(interface_name:, logger: nil, endianness: :big, can_fd: false)
       @interface_name = interface_name
       @logger = logger || Logger.new($stdout)
       @listening = true # Control flag for listening loop
       @endianness    = endianness # :big or :little
+      @can_fd        = can_fd
     end
 
     # Sends a CAN message by writing directly to a raw CAN socket
@@ -38,9 +41,13 @@ module CanMessenger
     # @param [Integer] id The CAN ID of the message (up to 29 bits for extended IDs).
     # @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)
-      with_socket do |socket|
-        frame = build_can_frame(id: id, data: data, extended_id: extended_id)
+    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)
         socket.write(frame)
       end
     rescue ArgumentError
@@ -49,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.
@@ -62,14 +86,16 @@ module CanMessenger
     #   - `:id` [Integer] the CAN message ID
     #   - `:data` [Array<Integer>] the message data bytes
     # @return [void]
-    def start_listening(filter: 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
 
-      with_socket do |socket|
+      use_fd = can_fd.nil? ? @can_fd : can_fd
+
+      with_socket(can_fd: use_fd) do |socket|
         @logger.info("Started listening on #{@interface_name}")
-        process_message(socket, filter, &block) while @listening
+        process_message(socket, filter, use_fd, dbc, &block) while @listening
       end
     end
 
@@ -88,8 +114,8 @@ module CanMessenger
     #
     # @yield [socket] An open CAN socket.
     # @return [void]
-    def with_socket
-      socket = open_can_socket
+    def with_socket(can_fd: @can_fd)
+      socket = open_can_socket(can_fd: can_fd)
       return @logger.error("Failed to open socket, cannot continue operation.") if socket.nil?
 
       yield socket
@@ -100,23 +126,32 @@ module CanMessenger
     # 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
+    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 frame for SocketCAN, big-endian ID, 1-byte DLC, up to 8 data bytes, and 3 padding bytes.
+    # Builds a raw CAN or CAN FD frame for SocketCAN.
     #
     # @param id [Integer] the CAN ID
-    # @param data [Array<Integer>] up to 8 bytes
-    # @return [String] a 16-byte string representing a classic CAN frame
-    def build_can_frame(id:, data:, extended_id: false)
-      raise ArgumentError, "CAN data cannot exceed 8 bytes" if data.size > 8
+    # @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
@@ -127,13 +162,15 @@ module CanMessenger
       # 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, then 3 bytes of padding
+      # 1 byte for DLC/length, then 3 bytes for flags/reserved
       dlc_and_pad = [data.size, 0, 0, 0].pack("C*")
 
-      # Up to 8 data bytes, pad with 0 if fewer
-      payload = data.pack("C*").ljust(8, "\x00")
+      payload = if can_fd
+                  data.pack("C*").ljust(MAX_FD_DATA, "\x00")
+                else
+                  data.pack("C*").ljust(8, "\x00")
+                end
 
-      # Total 16 bytes (4 for ID, 1 for DLC, 3 padding, 8 data)
       id_bytes + dlc_and_pad + payload
     end
 
@@ -143,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)
-      message = receive_message(socket: socket)
+    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
@@ -157,11 +199,12 @@ module CanMessenger
     #
     # @param socket [Socket]
     # @return [Hash, nil]
-    def receive_message(socket:)
-      frame = socket.recv(FRAME_SIZE)
+    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)
+      parse_frame(frame: frame, can_fd: can_fd)
     rescue IO::WaitReadable
       nil
     rescue StandardError => e
@@ -173,9 +216,11 @@ module CanMessenger
     #
     # @param [String] frame
     # @return [Hash, nil]
-    def parse_frame(frame:) # rubocop:disable Metrics/MethodLength
+    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
@@ -185,8 +230,11 @@ module CanMessenger
       # Now mask off everything except the lower 29 bits
       id = raw_id & 0x1FFFFFFF
 
-      # DLC is the lower 4 bits of byte 4
-      data_length = frame[4].ord & 0x0F
+      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

data/lib/can_messenger/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CanMessenger
-  VERSION = "1.2.1"
+  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.2.1
+  version: 1.4.0
 platform: ruby
 authors:
 - fk1018
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-06-05 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