rclrb 1.1.0

data/lib/rclrb/node.rb

@@ -0,0 +1,143 @@
+module Rclrb
+  ##
+  # The node class is the center piece of RCL, it allows to create subscriptions, publishers timers,
+  # and services server and clients.
+  class Node
+    attr_reader :subscriptions, :timers, :services, :default_callback_group
+    ##
+    # Create a node with the given +name+,
+    def initialize(name)
+      @node_handle = CApi::RclNodeT.new()
+      @services = []
+      @subscriptions = []
+      @timers = []
+      options = CApi.rcl_node_get_default_options()
+      @default_callback_group = MutuallyExclusiveCallbackGroup.new
+      CApi.handle_result(CApi.rcl_node_init(@node_handle, name, "", Rclrb.rcl_context(), options))
+    end
+
+    rclrb_finalize_with :@node_handle do |node_handle|
+      CApi.handle_result CApi.rcl_node_fini node_handle
+    end
+    
+    ##
+    # Get the namespace for this node
+    def get_namespace
+      return CApi.rcl_node_get_namespace @node_handle
+    end
+
+    ##
+    # Create a new Publisher and return it.
+    #
+    # Parameters:
+    # * +msg_type+ The type of ROS messages the publisher will publish.
+    # * +topic+ (string) The name of the topic the publisher will publish to.
+    # * +qos_profile+ (QoSProfile or int) A QoSProfile or a history depth to apply to the publisher. In the case that a history depth is provided, the QoS history is set to RMW_QOS_POLICY_HISTORY_KEEP_LAST, the QoS history depth is set to the value of the parameter, and all other QoS settings are set to their default values.
+    # * +callback_group+ (optional CallbackGroup) The callback group for the publisher’s event handlers. If None, then the node’s default callback group is used.
+    def create_publisher(msg_type, topic, qos_profile, callback_group=nil, event_callbacks=nil)
+      callback_group = @default_callback_group if callback_group.nil?
+      ## * +event_callbacks+ (Optional) – User-defined callbacks for middleware events.
+      if event_callbacks != nil
+        raise RclError.new("event_callbacks are not supported yet")
+      end
+      handle = CApi::rcl_get_zero_initialized_publisher()
+      publisher = Publisher.new(handle, @node_handle, msg_type, topic, qos_profile, callback_group, event_callbacks)
+      return publisher
+    end
+
+    ##
+    # Create a new Subscription and return it. This function will also add the Subscription object to @subscriptions.
+    # To unsubscribe it is necesserary to call tje unsubscribe function with the handle to the subscriber.
+    #
+    # Parameters:
+    # * +msg_type+ The type of ROS messages the subscription will subscribe to.
+    # * +topic+ (string) – The name of the topic the subscription will subscribe to.
+    # * +callback+ (block) – A user-defined callback function that is called when a message is received by the subscription.
+    # * +qos_profile+ (QoSProfile or int) – A QoSProfile or a history depth to apply to the subscription. In the case that a history depth is provided, the QoS history is set to RMW_QOS_POLICY_HISTORY_KEEP_LAST, the QoS history depth is set to the value of the parameter, and all other QoS settings are set to their default values.
+    # * +callback_group (optional CallbackGroup) – The callback group for the subscription. If None, then the nodes default callback group is used.
+    def create_subscription(msg_type, topic, qos_profile, callback_group = nil, event_callbacks = nil, raw = false, &callback)
+      callback_group = @default_callback_group if callback_group.nil?
+      # * +event_callbacks (Optional[SubscriptionEventCallbacks]) – User-defined callbacks for middleware events.
+      if event_callbacks != nil
+        raise RclError.new("event_callbacks are not supported yet")
+      end
+      # * +raw (bool) – If True, then received messages will be stored in raw binary representation.
+      if raw != false
+        raise RclError.new("raw is not supported yet")
+      end
+
+      handle = CApi::rcl_get_zero_initialized_subscription()
+      subscription = Subscription.new(handle, @node_handle, msg_type, topic, callback, qos_profile, callback_group, event_callbacks, raw)
+      @subscriptions.append subscription
+      return subscription
+    end
+
+    ##
+    # Unsubscribe
+    # * +subscription+ a subscription created by create_subscription
+    def remove_subscription(subscription)
+      @subscriptions.remove subscription
+    end
+
+    ##
+    # Create a new service server.
+    #
+    # Parameters:
+    # * +srv_type+: The service type.
+    # * +srv_name+ (str): The name of the service.
+    # * +callback+ (block): A user-defined callback function that is called when a service request received by the server, it expects a request and response argument.
+    # * +qos_profile+ (QoSProfile): The quality of service profile to apply the service server.
+    # * +callback_group+ (optional CallbackGroup): The callback group for the service server. If None, then the nodes default callback group is used.
+    def create_service(srv_type, srv_name, qos_profile=QoSProfileServicesDefault, callback_group=nil, &callback)
+      callback_group = @default_callback_group if callback_group.nil?
+      handle = CApi::rcl_get_zero_initialized_service()
+      service = Service.new(handle, @node_handle, srv_type, srv_name, callback, qos_profile, callback_group)
+      @services.append(service)
+      return service
+    end
+
+    ##
+    # Unsubscribe
+    # * +service+ a service created by create_service
+    def remove_service(service)
+      @services.remove service
+    end
+
+    ##
+    # Create a new service client.
+    # Parameters:
+    # * +srv_type+: The service type.
+    # * +srv_name+ (str): The name of the service.
+    # * +qos_profile+ (optional QoSProfile): The quality of service profile to apply the service client.
+    # * +callback_group+ (optional CallbackGroup): The callback group for the service client. If None, then the nodes default callback group is used
+    def create_client(srv_type, srv_name, qos_profile=QoSProfileServicesDefault)
+      handle = CApi::rcl_get_zero_initialized_client()
+      client = Client.new(handle, @node_handle, srv_type, srv_name, qos_profile)
+      return client
+    end
+
+    ##
+    # Create a new timer.
+    # The timer will be started and every timer_period_sec number of seconds the provided callback function will be called.
+    #
+    # Parameters:
+    # * +timer_period_sec+ (float): The period (s) of the timer.
+    # * +callback+ (block): A user-defined callback function that is called when the timer expires.
+    # * +callback_group+ (optional CallbackGroup): The callback group for the timer. If None, then the nodes default callback group is used.
+    # * +clock+ (optional Clock): The clock which the timer gets time from.
+    def create_timer(timer_period_sec, callback_group=nil, clock=Rclrb::RosClock, &callback)
+      callback_group = @default_callback_group if callback_group.nil?
+      handle = CApi::rcl_get_zero_initialized_timer()
+      timer = Timer.new(handle, @node_handle, timer_period_sec, callback, callback_group, clock)
+      @timers.append(timer)
+      return timer
+    end
+
+    ##
+    # Stop a timer
+    # * +timer+ a timer created by create_timer
+    def remove_timer(timer)
+      @timers.remove timer
+    end
+  end
+end

data/lib/rclrb/publisher.rb

@@ -0,0 +1,40 @@
+module Rclrb
+  ##
+  # Represent a ROS publisher
+  class Publisher
+    attr_reader :msg_type
+    # Construct a new publisher, this should not be called directly, instead use Node.create_publisher.
+    def initialize(publisher_handle, node_handle, msg_type, topic, qos_profile, callback_group, event_callbacks)
+      @publisher_handle = publisher_handle
+      @node_handle = node_handle
+      @msg_type = msg_type
+      @topic = topic
+      @qos_profile = qos_profile
+
+      publisher_ops = CApi.rcl_publisher_get_default_options()
+      publisher_ops[:qos] = QoSProfile.get_profile(qos_profile).ros_profile
+      CApi.handle_result(CApi.rcl_publisher_init(@publisher_handle, node_handle, msg_type.type_support(), @topic, publisher_ops))
+    end
+
+    rclrb_finalize_with :@publisher_handle, :@node_handle do |publisher_handle, node_handle|
+      CApi.handle_result CApi.rcl_publisher_fini publisher_handle, node_handle
+    end
+
+    ##
+    # Publish a message. If +msg+ has the wrong type, an exception is triggered.
+    def pub(msg)
+      raise InvalidMessageTypeError.new msg.class, @msg_type unless msg.kind_of? @msg_type
+      ros_msg = @msg_type.get_ros_message msg
+      CApi.handle_result(CApi.rcl_publish(@publisher_handle, ros_msg, nil), lambda { @msg_type.destroy_ros_message ros_msg})
+    end
+
+    ##
+    # Return the number of subscription to that topic.
+    def subscription_count()
+      count = CApi::SizeTPtr.new
+      CApi.handle_result CApi.rcl_publisher_get_subscription_count(@publisher_handle, count)
+      return count[:value]
+    end
+  end
+end
+  

data/lib/rclrb/qos.rb

@@ -0,0 +1,116 @@
+module Rclrb
+  module QosReliabilityPolicy
+    ## Implementation specific default
+    SystemDefault = :RMW_QOS_POLICY_RELIABILITY_SYSTEM_DEFAULT
+    ## Guarantee that samples are delivered, may retry multiple times
+    Reliable = :RMW_QOS_POLICY_RELIABILITY_RELIABLE
+    ## Attempt to deliver samples, but some may be lost if the network is not robust
+    BestEffort = :RMW_QOS_POLICY_RELIABILITY_BEST_EFFORT
+    ## Reliability policy has not yet been set
+    Unknown = :RMW_QOS_POLICY_RELIABILITY_UNKNOWN
+  end
+  module QosDurabilityPolicy
+    ## Implementation specific default
+    SystemDefault = :RMW_QOS_POLICY_DURABILITY_SYSTEM_DEFAULT
+    ## The rmw publisher is responsible for persisting samples for “late-joining” subscribers
+    TransientLocal = :RMW_QOS_POLICY_DURABILITY_TRANSIENT_LOCAL
+    ## Samples are not persistent
+    Volatile = :RMW_QOS_POLICY_DURABILITY_VOLATILE
+    ## History policy has not yet been set
+    Unknown = :RMW_QOS_POLICY_DURABILITY_UNKNOWN
+  end
+  module QosLivelinessPolicy
+    ## Implementation specific default
+    SystemDefault = :RMW_QOS_POLICY_LIVELINESS_SYSTEM_DEFAULT
+    ## The signal that establishes a Topic is alive comes from the ROS rmw layer
+    Automatic = :RMW_QOS_POLICY_LIVELINESS_AUTOMATIC
+    ## The signal that establishes a Topic is alive is at the Topic level. Only publishing a message
+    # on the Topic or an explicit signal from the application to assert liveliness on the Topic
+    # will mark the Topic as being alive.
+    ManualByTopic = :RMW_QOS_POLICY_LIVELINESS_MANUAL_BY_TOPIC
+    ## History policy has not yet been set
+    Unknown = :RMW_QOS_POLICY_LIVELINESS_UNKNOWN
+  end
+  module QosHistoryPolicy
+    ## Implementation default for history policy
+    SystemDefault = :RMW_QOS_POLICY_HISTORY_SYSTEM_DEFAULT
+    ## Only store up to a maximum number of samples, dropping oldest once max is exceeded
+    KeepLast = :RMW_QOS_POLICY_HISTORY_KEEP_LAST
+    ## Store all samples, subject to resource limits
+    KeepAll = :RMW_QOS_POLICY_HISTORY_KEEP_ALL
+    # History policy has not yet been set
+    Unknown = :RMW_QOS_POLICY_HISTORY_UNKNOWN
+  end
+  ##
+  # Represent the QoS profile of a topic, service or action. Look at QoSProfileSensorData,
+  # QoSProfileParameters, QoSProfileDefault, QoSProfileServicesDefault, QoSProfileParameterEvents,
+  # or QoSProfileSystemDefault.
+  class QoSProfile
+    attr_reader :ros_profile
+    #
+    #
+    # Parameters:
+    # * +depth+ Size of the message queue.
+    # * +history+ History QoS policy setting
+    # * +reliability+ Reliabiilty QoS policy setting
+    # * +durability+ Durability QoS policy setting
+    # * +deadline+ The period at which messages are expected to be sent/received
+    # * +lifespan+ The age at which messages are considered expired and no longer valid
+    # * +liveliness+ Liveliness QoS policy setting
+    # * +liveliness_lease_duration+ The time within which the RMW node or publisher must show that it is alive
+    # * +avoid_ros_namespace_conventions+ If true, any ROS specific namespacing conventions will be circumvented
+    def initialize(depth:, history: QosHistoryPolicy::KeepLast, reliability: QosReliabilityPolicy::Reliable,
+                   durability: QosDurabilityPolicy::Volatile, deadline: nil, lifespan: nil,
+                   liveliness: QosLivelinessPolicy::SystemDefault, liveliness_lease_duration: nil,
+                   avoid_ros_namespace_conventions: false)
+      @ros_profile = CApi::RmwQoSProfileT.new
+      @ros_profile[:depth] = depth
+      @ros_profile[:history] = history
+      @ros_profile[:reliability] = reliability
+      @ros_profile[:durability] = durability
+      unless deadline.nil?
+        s, n = deadline.to_sec_nsec
+        @ros_profile[:deadline][:sec] = s
+        @ros_profile[:deadline][:nsec] = n
+      end
+      unless lifespan.nil?
+        s, n = lifespan.to_sec_nsec
+        @ros_profile[:lifespan][:sec] = s
+        @ros_profile[:lifespan][:nsec] = n
+      end
+      @ros_profile[:lifespan]
+      @ros_profile[:liveliness] = liveliness
+      unless liveliness_lease_duration.nil?
+        s, n = liveliness_lease_duration.to_sec_nsec
+        @ros_profile[:liveliness_lease_duration][:sec] = s
+        @ros_profile[:liveliness_lease_duration][:nsec] = n
+      end
+    end
+    def QoSProfile.get_profile p
+      return p if p.kind_of? QoSProfile
+      return QoSProfile.new depth: p 
+    end
+  end
+
+  ## Qos profile to be used for sensor data,
+  QoSProfileSensorData = QoSProfile.new depth: 5, reliability: QosReliabilityPolicy::BestEffort
+
+  ## Qos profile to be used for parameters.
+  QoSProfileParameters = QoSProfile.new depth: 1000
+
+  ## Default Qos profile for topics.
+  QoSProfileDefault = QoSProfile.new depth: 10
+
+  ## Default Qos profile for services.
+  QoSProfileServicesDefault = QoSProfile.new depth: 10
+
+  ## Default Qos profile for events.
+  QoSProfileParameterEvents = QoSProfile.new depth: 1000
+
+  ## Default Qos profile using system default (RMW implementation specific).
+  QoSProfileSystemDefault = QoSProfile.new depth: 5, history: QosHistoryPolicy::SystemDefault,
+                  reliability: QosReliabilityPolicy::SystemDefault,
+                  durability: QosDurabilityPolicy::SystemDefault,
+                  liveliness: QosLivelinessPolicy::SystemDefault
+
+end

data/lib/rclrb/service.rb

@@ -0,0 +1,46 @@
+module Rclrb
+  ##
+  # Represent a ROS service
+  class Service
+    attr_reader :srv_type, :service_handle
+    # Construct a new service, this should not be called directly, instead use Node.create_service.
+    def initialize(service_handle, node_handle, srv_type, srv_name, callback, qos_profile, callback_group)
+      @service_handle = service_handle
+      @srv_type = srv_type
+      @srv_name = srv_name
+      @callback = callback
+      @callback_group = callback_group
+      @qos_profile = qos_profile
+      callback_group.add self
+
+      service_ops = CApi.rcl_service_get_default_options()
+      service_ops[:qos] = QoSProfile.get_profile(qos_profile).ros_profile
+      CApi.handle_result CApi.rcl_service_init(@service_handle, node_handle, srv_type.type_support(), @srv_name, service_ops)
+    end
+
+    rclrb_finalize_with :@service_handle, :@node_handle do |service_handle, node_handle|
+      CApi.handle_result CApi.rcl_service_fini service_handle, node_handle
+    end
+
+    def spin(wait_set = nil)
+      wait_set.add self if wait_set
+      request_id = CApi::RmwRequestIdT.new
+      ros_req = @srv_type::Request::FFIType.new
+      status = CApi.rcl_take_request @service_handle, request_id, ros_req
+
+      if status == CApi::RCL_RET_OK
+        request = @srv_type::Request.parse_ros_message ros_req
+        @srv_type::Request.destroy_ros_message ros_req
+        response = @srv_type::Response.new
+        @callback.call request, response
+        ros_resp = @srv_type::Response.get_ros_message response
+        CApi.handle_result CApi.rcl_send_response(@service_handle, request_id, ros_resp), lambda { @srv_type::Response.destroy_ros_message ros_resp}
+
+      elsif status == CApi::RCL_RET_SERVICE_TAKE_FAILED
+        # no service received
+      else
+        CApi.handle_result(status)
+      end
+    end
+  end
+end

data/lib/rclrb/subscription.rb

@@ -0,0 +1,45 @@
+module Rclrb
+  ##
+  # Represent a ROS subscription to a topic
+  class Subscription
+    attr_reader :msg_type, :subscription_handle
+    # Construct a new subscription, this should not be called directly, instead use Node.create_subscription.
+    def initialize(subscription_handle, node_handle, msg_type, topic, callback, qos_profile, callback_group, event_callbacks, raw)
+      @subscription_handle = subscription_handle
+      @node_handle = node_handle
+      @msg_type = msg_type
+      @topic = topic
+      @callback = callback
+      @qos_profile = qos_profile
+      @raw = raw
+      callback_group.add self
+      
+      subscription_ops = CApi.rcl_subscription_get_default_options()
+      subscription_ops[:qos] = QoSProfile.get_profile(qos_profile).ros_profile
+      CApi.handle_result CApi.rcl_subscription_init(@subscription_handle, node_handle, msg_type.type_support(), @topic, subscription_ops)
+    end
+    rclrb_finalize_with :@subscription_handle, :@node_handle do |subscription_handle, node_handle|
+      CApi.handle_result CApi.rcl_subscription_fini(subscription_handle, node_handle)
+    end
+    def raw?
+      return @raw
+    end
+
+    def spin(wait_set = nil)
+      wait_set.add self if wait_set
+      message_info = CApi::RmwMessageInfoT.new
+      data = @msg_type::FFIType.new
+      status = CApi.rcl_take @subscription_handle, data, message_info, nil
+
+      if status == CApi::RCL_RET_OK
+        msg = @msg_type.parse_ros_message data
+        @msg_type.destroy_ros_message data
+        @callback.call(msg)
+      elsif status == CApi::RCL_RET_SUBSCRIPTION_TAKE_FAILED
+        # no message received
+      else
+        CApi.handle_result status
+      end
+    end
+  end
+end

data/lib/rclrb/time.rb

@@ -0,0 +1,32 @@
+module Rclrb
+  ##
+  # Represent time.
+  class Time
+    ##
+    # Initialise time, +time+ is given in seconds
+    def initialize time = 0
+      @time_sec = time
+    end
+    ##
+    # Create a time objects from seconds
+    def Time.from_sec sec
+      return Time.new sec
+    end
+    ##
+    # Create a time objects from seconds and nanoseconds
+    def Time.from_sec_nsec sec, nsec
+      return Time.new sec + nsec * 1e-9
+    end
+    ##
+    # Return the time in seconds
+    def to_sec
+      return @time_sec
+    end
+    ##
+    # Return the time in second and nanoseconds (as integers)
+    def to_sec_nsec
+      si = @time_sec.to_i
+      return si, ((@time_sec - si) * 1e9).to_i
+    end
+  end
+end

data/lib/rclrb/timer.rb

@@ -0,0 +1,31 @@
+module Rclrb
+  ##
+  # Represent a ROS Timer
+  class Timer
+    attr_reader :timer_handle
+    # Construct a new timer, this should not be called directly, instead use Node.create_subscription.
+    def initialize(handle, node_handle, timer_period_sec, callback, callback_group, clock)
+      @callback_proc = Proc.new do |timer, time|
+        callback.call time
+      end
+      @timer_handle = handle
+      @node_handle = node_handle
+      callback_group.add self
+
+      CApi.handle_result(CApi.rcl_timer_init(handle, clock.handle, Rclrb.rcl_context, timer_period_sec*1e9, @callback_proc, Rclrb.rcl_allocator))
+    end
+
+    rclrb_finalize_with :@timer_handle, :@node_handle do |timer_handle, node_handle|
+      CApi.handle_result CApi.rcl_timer_fini timer_handle, node_handle
+    end
+
+    def spin(wait_set = nil)
+      wait_set.add self if wait_set
+      is_ready = CApi::BoolPtr.new
+      CApi.handle_result(CApi.rcl_timer_is_ready @timer_handle, is_ready)
+      if is_ready[:value]
+        CApi.handle_result(CApi.rcl_timer_call @timer_handle)
+      end
+    end
+  end
+end

data/lib/rclrb/version.rb

@@ -0,0 +1,3 @@
+module Rclrb
+  VERSION="1.1.0"
+end

data/lib/rclrb/wait_set.rb

@@ -0,0 +1,62 @@
+module Rclrb
+  ##
+  # This class is use to Wait for events.
+  class WaitSet
+    def initialize
+      @subscriptions = []
+      @services = []
+      @clients = []
+      @timers = []
+    end
+    ##
+    # Wait for an event on +ẃhat+, every +timeout+ evaluate +block+ and if the value
+    # returned is true, then exit the function otherwise continue waiting. 
+    def WaitSet.wait_for what, timeout = -1, &block
+      ws = WaitSet.new
+      ws.add what
+      until block.call
+        ws.wait timeout
+      end
+    end
+    ##
+    # Add an item (Subscription, Service...) to the wait set
+    def add(what)
+      if what.kind_of? Subscription
+        @subscriptions.append what
+      elsif what.kind_of? Service
+        @services.append what
+      elsif what.kind_of? Client
+        @clients.append what
+      elsif what.kind_of? Timer
+        @timers.append what
+      end
+    end
+    ##
+    # Wait until +timeout+ or an event occured in one of the item added with add.
+    # If +timeout+ is equalt to -1, this function will block until an event occured or indefinitely.
+    def wait(timeout = -1)
+      ws = CApi.rcl_get_zero_initialized_wait_set
+      CApi.handle_result CApi.rcl_wait_set_init(ws, @subscriptions.size, 1, @timers.size, @clients.size, @services.size, 0, Rclrb.rcl_context, Rclrb.rcl_allocator)
+      begin
+        @subscriptions.each() { |x| CApi.handle_result CApi.rcl_wait_set_add_subscription(ws, x.subscription_handle, nil)}
+        CApi.handle_result CApi.rcl_wait_set_add_guard_condition(ws, Rclrb.rcl_signal_guard_condition.guard_condition_handle, nil)
+        @services.each() { |x| CApi.handle_result CApi.rcl_wait_set_add_service(ws, x.service_handle, nil)}
+        @clients.each() { |x| CApi.handle_result CApi.rcl_wait_set_add_client(ws, x.client_handle, nil)}
+        @timers.each() { |x| CApi.handle_result CApi.rcl_wait_set_add_timer(ws, x.timer_handle, nil)}
+        # Wait has to run in a seperate thread to allow for signals to work
+        status = nil
+        t = Thread.new do
+          status = CApi.rcl_wait(ws, timeout)
+        end
+        t.join
+        if status != CApi::RCL_RET_OK and status != CApi::RCL_RET_TIMEOUT
+          CApi.handle_result status
+        end
+      rescue RclError
+        CApi.handle_result CApi.rcl_wait_set_fini(ws)
+        raise
+      end
+      CApi.handle_result CApi.rcl_wait_set_fini(ws)
+    end
+  end
+end

data/lib/rclrb.rb

@@ -0,0 +1,43 @@
+require 'erb'
+
+require_relative 'rclrb/common'
+require_relative 'rclrb/internal'
+require_relative 'rclrb/version'
+
+require_relative 'rclrb/capi'
+
+require_relative 'rclrb/callback_group'
+require_relative 'rclrb/clock'
+require_relative 'rclrb/client'
+require_relative 'rclrb/init'
+require_relative 'rclrb/executor'
+require_relative 'rclrb/fields'
+require_relative 'rclrb/future'
+require_relative 'rclrb/guard_condition'
+require_relative 'rclrb/interfaces'
+require_relative 'rclrb/node'
+require_relative 'rclrb/publisher'
+require_relative 'rclrb/qos'
+require_relative 'rclrb/subscription'
+require_relative 'rclrb/time'
+require_relative 'rclrb/timer'
+require_relative 'rclrb/service'
+require_relative 'rclrb/wait_set'
+
+module Kernel
+  # make an alias of the original require
+  alias_method :rclrb_original_require, :require
+
+  # rewrite require
+  LoadedRosInterfacePackages = []
+  def require name
+    begin
+      rclrb_original_require name
+    rescue LoadError
+      unless LoadedRosInterfacePackages.include? name
+        raise unless Rclrb::Interfaces.load_definitions name
+        LoadedRosInterfacePackages.append(name)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: rclrb
+version: !ruby/object:Gem::Version
+  version: 1.1.0
+platform: ruby
+authors:
+- Cyrille Berger
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2023-09-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: 'Allows to communicate with ROS program.
+
+  '
+email: 
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- COPYING
+files:
+- COPYING
+- README.md
+- lib/rclrb.rb
+- lib/rclrb/callback_group.rb
+- lib/rclrb/capi.rb
+- lib/rclrb/client.rb
+- lib/rclrb/clock.rb
+- lib/rclrb/common.rb
+- lib/rclrb/executor.rb
+- lib/rclrb/fields.rb
+- lib/rclrb/future.rb
+- lib/rclrb/guard_condition.rb
+- lib/rclrb/init.rb
+- lib/rclrb/interfaces.rb
+- lib/rclrb/internal.rb
+- lib/rclrb/node.rb
+- lib/rclrb/publisher.rb
+- lib/rclrb/qos.rb
+- lib/rclrb/service.rb
+- lib/rclrb/subscription.rb
+- lib/rclrb/time.rb
+- lib/rclrb/timer.rb
+- lib/rclrb/version.rb
+- lib/rclrb/wait_set.rb
+homepage: https://gitlab.com/cyloncore/rclrb
+licenses:
+- MPL-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.5
+signing_key: 
+specification_version: 4
+summary: Ruby bindings for Ros Communication Library (ROS2)
+test_files: []