can_messenger 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 67c064d4b8899c012642e83b9c348cf72da13eb136bc81283a2acb7116e79897
-  data.tar.gz: ddb8c322325800be6b03813510e1831348e724967e4f05daa9ac0c2b5b32dad3
+  metadata.gz: 3a68f4a339bebc034ffe78e990086ff91d28164962c2877e5d88edb095cbca90
+  data.tar.gz: 7a96c22ccf82cae952123d733805c2efe31dd482ba9bf5d5a66d29cb14572822
 SHA512:
-  metadata.gz: 3d248a72be8fb4b407fa4b79f42fc291658b39340db84c255440cd33b465c02ca7a2d6bf9274a1b52cae8b4cb3b4890d0d2562238040d2365649c1d7d7e0300e
-  data.tar.gz: 7749d6a7544e43db00dfec4a44a967362b449b78bb657da2f7e3afefc04956a466a9348c9414f05c2b72669858e8cecc27f8ac0b32fa2d6c8b58cbaca492e041
+  metadata.gz: c8302565cc5e889a290a446167bdec8eedd29ba077c63c003f544138c078a94498b258f465387b3c92f8b9b9ffc18ed65810fa70c5dc97e3ba977e62bbc394c4
+  data.tar.gz: a606c71e8606bbccd98e1917bc4c2205037156e3994f152f6b05c3a52fc1037c21f8a38a91814abddb6f4a9bf5a0eb8682a2acaf93e3da0cdb818a2d8d03131f

data/README.md

@@ -9,6 +9,10 @@
 
 `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:
@@ -51,13 +55,22 @@ messenger.send_can_message(id: 0x123, data: [0xDE, 0xAD, 0xBE, 0xEF])
 
 > **Note:** Under the hood, the gem now writes CAN frames to a raw socket instead of calling `cansend`. No external dependencies are required beyond raw-socket permissions.
 
-If you need to send an extended CAN frame (29-bit ID), set extended_id: true. The gem then sets the Extended Frame Format (EFF) bit automatically:### Receiving CAN Messages
+If you need to send an extended CAN frame (29-bit ID), set extended_id: true. The gem then sets the Extended Frame Format (EFF) bit automatically:
 
 ```ruby
 messenger.send_can_message(id: 0x123456, data: [0x01, 0x02, 0x03], extended_id: true)
 ```
 
-### Listen to CAN Messages
+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:
 
@@ -147,11 +160,11 @@ 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.

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,11 +41,15 @@ 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)
+      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
+      raise
     rescue StandardError => e
       @logger.error("Error sending CAN message (ID: #{id}): #{e}")
     end
@@ -60,12 +67,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, &block)
       return @logger.error("No block provided to handle messages.") unless block_given?
 
-      with_socket do |socket|
+      @listening = true
+
+      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, &block) while @listening
       end
     end
 
@@ -84,8 +95,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
@@ -96,23 +107,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
@@ -123,13 +143,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
 
@@ -139,8 +161,8 @@ 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)
+      message = receive_message(socket: socket, can_fd: can_fd)
       return if message.nil?
       return if filter && !matches_filter?(message_id: message[:id], filter: filter)
 
@@ -153,11 +175,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
@@ -169,9 +192,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
@@ -181,8 +206,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.0"
+  VERSION = "1.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: can_messenger
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - fk1018
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-02-28 00:00:00.000000000 Z
+date: 2025-07-08 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.