can_messenger 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6aab35f0ccd4fcbd716ddb9cb553555c1c524eef3ca917d5cf43539b8bb55ff0
-  data.tar.gz: 1f2ebb1af8cf741ceba5c1e2033faa807ed4f8f58e1c44dcbacfe7adba60a9dc
+  metadata.gz: b21a6826af91cc61f6ea94c5cae6d2ba38cc32749d8e4acce38c7c897ff78501
+  data.tar.gz: 585849cf70fbc1f24e6d2e32aa6d0334a6d8addc90ef5b9c0433740621447208
 SHA512:
-  metadata.gz: 4f20347545fdfa495b80fc7475e611e0aa80bcc47a8a4bca26844f07a677327949001dd28b24422a402a49bd864ce2ecdde00968cc0ee9f150da4a968d1617a6
-  data.tar.gz: 712bbb367ea096d2a9e57d1649bafb75c90b51652a789a907cdc1f8984ea965959b24f46ac083340816364ac023cf0efae10c1b7e378f4535c40e3324045f248
+  metadata.gz: a356542e08412d91b8607f679b8414dcc10d23119cf1b529631eeb5f0c058ec4525b8df2e8bda120acfc74fb4020f6feef8cce9c54d9d6fe305da1e9229cc6b8
+  data.tar.gz: 8d9572376e9d5d3f9c2c7edacb0b3f2e4287ae11cc48122b06d6337b3e9858621558def72efa74fd9b06382b6e1475b3716696eb96ec20ecaf154d43719b39c6

data/README.md

@@ -1,5 +1,12 @@
 # CanMessenger
 
+[![Gem Version](https://badge.fury.io/rb/can_messenger.svg?icon=si%3Arubygems&icon_color=%23e77682)](https://badge.fury.io/rb/can_messenger)
+[![Build Status](https://github.com/fk1018/can_messenger/actions/workflows/ruby.yml/badge.svg)](https://github.com/fk1018/can_messenger/actions)
+[![Test Coverage](https://codecov.io/gh/fk1018/can_messenger/branch/main/graph/badge.svg)](https://codecov.io/gh/fk1018/can_messenger)
+![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)
+
 `can_messenger` is a Ruby gem that provides an interface for communicating over the CAN bus, allowing users to send and receive CAN messages. This gem is designed for developers who need an easy way to interact with CAN-enabled devices.
 
 ## Installation
@@ -44,9 +51,9 @@ messenger = CanMessenger::Messenger.new('can0')
 
 To send a message:
 
-```ruby
-messenger.send_can_message(0x123, [0xDE, 0xAD, 0xBE, 0xEF])
-```
+    ```ruby
+    messenger.send_can_message(0x123, [0xDE, 0xAD, 0xBE, 0xEF])
+    ```
 
 ### Receiving CAN Messages
 
@@ -54,8 +61,38 @@ To listen for incoming messages, set up a listener:
 
 ```ruby
 messenger.start_listening do |message|
-puts "Received: ID=#{message[:id]}, Data=#{message[:data]}"
+    puts "Received: ID=#{message[:id]}, Data=#{message[:data]}"
+end
+```
+
+#### Listening with Filters
+
+The `start_listening` method supports filtering incoming messages based on CAN ID:
+
+Single CAN ID:
+
+```ruby
+messenger.start_listening(filter: 0x123) do |message|
+  puts "Received filtered message: #{message}"
+end
+```
+
+Range of CAN IDs:
+
+```ruby
+messenger.start_listening(filter: 0x100..0x200) do |message|
+  puts "Received filtered message: #{message}"
 end
+
+```
+
+Array of CAN IDs:
+
+```ruby
+messenger.start_listening(filter: [0x123, 0x456, 0x789]) do |message|
+  puts "Received filtered message: #{message}"
+end
+
 ```
 
 ### Stopping the Listener
@@ -92,4 +129,4 @@ The gem is available as open-source under the terms of the MIT License.
 
 ## Author
 
-Developed by Fredrick Khoury.
+Developed by fk1018.

data/lib/can_messenger/messenger.rb

@@ -43,16 +43,23 @@ module CanMessenger
 
     # Continuously listens for CAN messages on the specified interface.
     #
-    # Yields each message as a hash with keys :id and :data.
+    # This method listens for incoming CAN messages and applies an optional filter.
+    # The filter can be a specific CAN ID or a range of IDs. Only messages that match
+    # the filter are yielded to the provided block.
+    #
+    # @param [Integer, Range, nil] filter Optional filter for CAN IDs. Pass a single ID (e.g., 0x123)
+    #   or a range (e.g., 0x100..0x200). If no filter is provided, all messages are processed.
     # @yield [Hash] Each received message in the format { id: Integer, data: Array<Integer> }.
     # @return [void]
-    def start_listening
+    def start_listening(filter: nil)
       @logger.info("Started listening on #{@can_interface}")
       socket = create_socket
       while @listening
         message = receive_message(socket)
         break unless message # Exit loop if no message
 
+        next if filter && !matches_filter?(message[:id], filter) # Apply filter if specified
+
         yield(message)
       end
     ensure
@@ -115,5 +122,29 @@ module CanMessenger
       @logger.error("Error parsing CAN frame: #{e}")
       nil
     end
+
+    # Checks if a message ID matches the given filter.
+    #
+    # Supported filters:
+    # - A single ID (e.g., 0x123)
+    # - A range of IDs (e.g., 0x100..0x200)
+    # - An array of IDs (e.g., [0x123, 0x200, 0x300])
+    #
+    # @param [Integer] message_id The ID of the incoming CAN message.
+    # @param [Integer, Range, Array<Integer>, nil] filter The filter to apply.
+    #   If nil, the method always returns true.
+    # @return [Boolean] True if the message ID matches the filter, false otherwise.
+    def matches_filter?(message_id, filter)
+      case filter
+      when Integer
+        message_id == filter
+      when Range
+        filter.cover?(message_id)
+      when Array
+        filter.include?(message_id)
+      else
+        true # No filter or unrecognized filter
+      end
+    end
   end
 end

data/lib/can_messenger/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: can_messenger
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - fk1018
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-11-11 00:00:00.000000000 Z
+date: 2024-12-06 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.