can_messenger 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6aab35f0ccd4fcbd716ddb9cb553555c1c524eef3ca917d5cf43539b8bb55ff0
+  data.tar.gz: 1f2ebb1af8cf741ceba5c1e2033faa807ed4f8f58e1c44dcbacfe7adba60a9dc
+SHA512:
+  metadata.gz: 4f20347545fdfa495b80fc7475e611e0aa80bcc47a8a4bca26844f07a677327949001dd28b24422a402a49bd864ce2ecdde00968cc0ee9f150da4a968d1617a6
+  data.tar.gz: 712bbb367ea096d2a9e57d1649bafb75c90b51652a789a907cdc1f8984ea965959b24f46ac083340816364ac023cf0efae10c1b7e378f4535c40e3324045f248

data/README.md

@@ -0,0 +1,95 @@
+# CanMessenger
+
+`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
+
+This gem relies on `cansend` from the `can-utils` package, which is typically available on Linux-based systems. Make sure to install `can-utils` before using `can_messenger`:
+
+```bash
+sudo apt-get install can-utils
+```
+
+To install `can_messenger`, add it to your application's Gemfile:
+
+```ruby
+gem 'can_messenger'
+```
+
+Then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself with:
+
+```bash
+gem install can_messenger
+```
+
+## Usage
+
+### Initializing the Messenger
+
+To create a new instance of `CanMessenger` and start sending messages:
+
+```ruby
+require 'can_messenger'
+
+messenger = CanMessenger::Messenger.new('can0')
+```
+
+### Sending CAN Messages
+
+To send a message:
+
+```ruby
+messenger.send_can_message(0x123, [0xDE, 0xAD, 0xBE, 0xEF])
+```
+
+### Receiving CAN Messages
+
+To listen for incoming messages, set up a listener:
+
+```ruby
+messenger.start_listening do |message|
+puts "Received: ID=#{message[:id]}, Data=#{message[:data]}"
+end
+```
+
+### Stopping the Listener
+
+To stop listening, use:
+
+```ruby
+messenger.stop_listening
+```
+
+## Features
+
+- **Send CAN Messages**: Send data to specified CAN IDs.
+- **Receive CAN Messages**: Continuously listen for messages on a CAN interface.
+- **Logging**: Logs errors and events for debugging and troubleshooting.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests.
+
+To install this gem onto your local machine, run:
+
+```bash
+bundle exec rake install
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at [https://github.com/fk1018/can_messenger](https://github.com/fk1018/can_messenger).
+
+## License
+
+The gem is available as open-source under the terms of the MIT License.
+
+## Author
+
+Developed by Fredrick Khoury.

data/lib/can_messenger/messenger.rb

@@ -0,0 +1,119 @@
+# lib/can_messenger/messenger.rb
+# frozen_string_literal: true
+
+require "socket"
+require "logger"
+
+module CanMessenger
+  # Messenger
+  #
+  # This class provides an interface to send and receive CAN bus messages.
+  # It supports sending messages with specific CAN IDs and listening for incoming messages.
+  #
+  # @example
+  #   socket = CanMessenger::Messenger.new('can0')
+  #   socket.send_can_message(0x123, [0xDE, 0xAD, 0xBE, 0xEF])
+  #   socket.start_listening do |message|
+  #     puts "Received: ID=#{message[:id]}, Data=#{message[:data].map { |b| '0x%02X' % b }}"
+  #   end
+  class Messenger
+    # Initializes a new Messenger instance.
+    #
+    # @param [String] can_interface The CAN interface to use (e.g., 'can0').
+    # @param [Logger] logger Optional logger for error handling and debug information.
+    def initialize(can_interface, logger = nil)
+      @can_interface = can_interface
+      @logger = logger || Logger.new($stdout)
+      @listening = true # Control flag for listening loop
+    end
+
+    # Sends a CAN message using the `cansend` command.
+    #
+    # @param [Integer] id The CAN ID of the message.
+    # @param [Array<Integer>] data The data bytes of the CAN message.
+    # @return [void]
+    def send_can_message(id, data)
+      hex_id = format("%03X", id)
+      hex_data = data.map { |byte| format("%02X", byte) }.join
+      command = "cansend #{@can_interface} #{hex_id}##{hex_data}"
+      system(command)
+    rescue StandardError => e
+      @logger.error("Error sending CAN message (ID: #{id}): #{e}")
+    end
+
+    # Continuously listens for CAN messages on the specified interface.
+    #
+    # Yields each message as a hash with keys :id and :data.
+    # @yield [Hash] Each received message in the format { id: Integer, data: Array<Integer> }.
+    # @return [void]
+    def start_listening
+      @logger.info("Started listening on #{@can_interface}")
+      socket = create_socket
+      while @listening
+        message = receive_message(socket)
+        break unless message # Exit loop if no message
+
+        yield(message)
+      end
+    ensure
+      socket&.close
+    end
+
+    # Stops the listening loop by setting @listening to false.
+    #
+    # This method can be called from an external thread or signal handler.
+    # @return [void]
+    def stop_listening
+      @listening = false
+      @logger.info("Stopped listening on #{@can_interface}")
+    end
+
+    private
+
+    # Creates and configures a CAN socket.
+    #
+    # @return [Socket] The configured CAN socket.
+    def create_socket
+      socket = Socket.open(Socket::PF_CAN, Socket::SOCK_RAW, Socket::CAN_RAW)
+      socket.bind(Socket.pack_sockaddr_can(@can_interface))
+      socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, [1, 0].pack("l_2"))
+      socket
+    rescue StandardError => e
+      @logger.error("Error creating CAN socket on interface #{@can_interface}: #{e}")
+    end
+
+    # Receives a CAN message from the socket and parses it.
+    #
+    # @param [Socket] socket The CAN socket to read from.
+    # @return [Hash, nil] Parsed message in the format { id: Integer, data: Array<Integer> },
+    # or nil if no message is received or an error occurs.
+    def receive_message(socket)
+      frame = socket.recv(16)
+      return nil if frame.nil? || frame.size < 8
+
+      parse_frame(frame)
+    rescue IO::WaitReadable
+      nil
+    rescue StandardError => e
+      @logger.error("Error receiving CAN message on interface #{@can_interface}: #{e}")
+      nil
+    end
+
+    # Parses a raw CAN frame into a message hash.
+    #
+    # @param [String] frame The raw CAN frame.
+    # @return [Hash, nil] Parsed message with :id and :data keys, or nil if the frame is incomplete.
+    def parse_frame(frame)
+      return nil unless frame && frame.size >= 8
+
+      id = frame[0..3].unpack1("L>") & 0x1FFFFFFF
+      data_length = frame[4].ord & 0x0F
+      data = (frame[8, data_length].unpack("C*") if frame.size >= 8 + data_length)
+
+      { id: id, data: data }
+    rescue StandardError => e
+      @logger.error("Error parsing CAN frame: #{e}")
+      nil
+    end
+  end
+end

data/lib/can_messenger/version.rb

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

data/lib/can_messenger.rb

@@ -0,0 +1,9 @@
+# lib/can_messenger.rb
+# frozen_string_literal: true
+
+require_relative "can_messenger/version"
+require_relative "can_messenger/messenger"
+
+module CanMessenger
+  class Error < StandardError; end
+end

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: can_messenger
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- fk1018
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2024-11-11 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.
+email:
+- fk1018@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/can_messenger.rb
+- lib/can_messenger/messenger.rb
+- lib/can_messenger/version.rb
+homepage: https://github.com/fk1018/can_messenger
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/fk1018/can_messenger
+  source_code_uri: https://github.com/fk1018/can_messenger
+  changelog_uri: https://github.com/fk1018/can_messenger/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key: 
+specification_version: 4
+summary: A simple Ruby wrapper to read and write CAN bus messages.
+test_files: []