Class: ROS::Node

Inherits:
Object
  • Object
show all
Includes:
Name
Defined in:
lib/ros/node.rb

Overview

main interface of rosruby.

Examples:

Sample for Publisher

node = ROS::Node.new('/rosruby/sample_publisher')
publisher = node.advertise('/chatter', Std_msgs::String)
sleep(1)
msg = Std_msgs::String.new
i = 0
while node.ok?
  msg.data = "Hello, rosruby!: #{i}"
  publisher.publish(msg)

Sample for Subscriber

node = ROS::Node.new('/rosruby/sample_subscriber')
node.subscribe('/chatter', Std_msgs::String) do |msg|
  puts "message come! = \'#{msg.data}\'"
end

while node.ok?
  node.spin_once
  sleep(1)
end

Constant Summary

@@shutdown_hook =

for node shutdown hook

[]

Constants included from Name

ROS::Name::SEP

Instance Attribute Summary (collapse)

Instance Method Summary (collapse)

Methods included from Name

#anonymous_name, #canonicalize_name, #expand_local_name, #resolve_name_with_call_id

Constructor Details

- (Node) initialize(node_name, options = {})

initialization of ROS node get env, parse args, and start slave xmlrpc servers.

Parameters:

  • node_name (String) —

    name of this node

  • options (Hash) (defaults to: {}) —

    options

Options Hash (options):

  • :anonymous (Boolean) — default: false —

    use anonymous name if true. anonymous node generates a unique name



64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
 
# File 'lib/ros/node.rb', line 64

def initialize(node_name, options={})
  @remappings = {}
  # @host is rewrited by ARGS[ROS_IP] or ARGS[ROS_HOSTNAME]
  @host = Socket.gethostname
  get_env
  if options[:anonymous]
    node_name = anonymous_name(node_name)
  end
  @node_name = resolve_name(node_name)
  @remappings = parse_args(ARGV)
  if not @master_uri
    raise 'ROS_MASTER_URI is nos set. please check environment variables'
  end

  @manager = GraphManager.new(@node_name, @master_uri, @host)
  @parameter = ParameterManager.new(@master_uri, @node_name, @remappings)

  if not @manager.check_master_connection
    puts "Unable to immediately register with master node [#{@master_uri}]: master may not be running yet. Will keep trying."
    while not @manager.check_master_connection
      sleep(1)
    end
  end

  if not options[:nologger]
    @logger = ::ROS::Log.new(self)
  end
  # use sim time
  ROS::Time.initialize_with_sim_or_wall(self)

  # because xmlrpc server use signal trap, after serve, it have to trap sig      trap_signals
  ObjectSpace.define_finalizer(self, proc {|id| self.shutdown})
end

Instance Attribute Details

- (String) host (readonly)

hostname of this node.

Returns:

  • (String) —

    host name



119
120
121
 
# File 'lib/ros/node.rb', line 119

def host
  @host
end

- (String) master_uri (readonly)

URI of master

Returns:

  • (String) —

    uri string of master



109
110
111
 
# File 'lib/ros/node.rb', line 109

def master_uri
  @master_uri
end

- (String) node_name (readonly)

name of this node (caller_id).

Returns:

  • (String) —

    name of this node (=caller_id)



123
124
125
 
# File 'lib/ros/node.rb', line 123

def node_name
  @node_name
end

Instance Method Details

start publishing the topic.

Parameters:

  • topic_name (String) —

    name of topic (string)

  • topic_type (Class) —

    topic class

  • options (Hash) (defaults to: {}) —

    :latched, :resolve

Options Hash (options):

  • :latched (Boolean) — default: false —

    latched topic

  • :resolve (Boolean) — default: true —

    resolve topic_name or not. This is for publish /rosout with namespaced node.

Returns:



195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
 
# File 'lib/ros/node.rb', line 195

def advertise(topic_name, topic_type, options={})
  if options[:no_resolve]
    name = topic_name
  else
    name = resolve_name(topic_name)
  end
  publisher = Publisher.new(@node_name,
                            name,
                            topic_type,
                            options[:latched],
                            @manager.host)
  @manager.add_publisher(publisher)
  trap_signals
  publisher
end

start service server.

Parameters:

  • service_name (String) —

    name of this service (string)

  • service_type (Service) —

    service class

  • callback (Proc) —

    service definition

Returns:



218
219
220
221
222
223
224
225
226
227
 
# File 'lib/ros/node.rb', line 218

def advertise_service(service_name, service_type, &callback)
  server = ::ROS::ServiceServer.new(@node_name,
                                    resolve_name(service_name),
                                    service_type,
                                    callback,
                                    @manager.host)
  @manager.add_service_server(server)
  trap_signals
  server
end

- (Boolean) delete_param(key)

delete the parameter for 'key'

Parameters:

  • key (String) —

    key for delete

Returns:

  • (Boolean) —

    true if success, false if it is not exist



173
174
175
 
# File 'lib/ros/node.rb', line 173

def delete_param(key)
  @parameter.delete_param(expand_local_name(@node_name, key))
end

- (String, ...) get_param(key, default = nil)

get the param for key. You can set default value. That is uesed when the key is not set yet.

Parameters:

  • key (String) —

    key for search the parameters

  • default (String, Integer, Float, Boolean) (defaults to: nil) —

    default value

Returns:

  • (String, Integer, Float, Boolean) —

    parameter value for key



141
142
143
144
145
146
147
148
149
 
# File 'lib/ros/node.rb', line 141

def get_param(key, default=nil)
  key = expand_local_name(@node_name, key)
  param = @parameter.get_param(key)
  if param
    param
  else
    default
  end
end

- (Array) get_param_names

get all parameters.

Returns:

  • (Array) —

    all parameter list



156
157
158
 
# File 'lib/ros/node.rb', line 156

def get_param_names
  @parameter.get_param_names
end

- (Array) get_published_topics

get all topics by this node.

Returns:

  • (Array) —

    topic names



369
370
371
372
373
 
# File 'lib/ros/node.rb', line 369

def get_published_topics
  @manager.publishers.map do |pub|
    pub.topic_name
  end
end

- (Boolean) has_param(key)

check if the parameter server has the param for 'key'.

Parameters:

  • key (String) —

    key for check

Returns:

  • (Boolean) —

    true if exits



164
165
166
 
# File 'lib/ros/node.rb', line 164

def has_param(key)
  @parameter.has_param(expand_local_name(@node_name, key))
end

- (Node) logdebug(message)

outputs log message for DEBUG

Parameters:

  • message (String) —

    message for output

Returns:



324
325
326
327
328
 
# File 'lib/ros/node.rb', line 324

def logdebug(message)
  file, line, function = caller[0].split(':')
  @logger.log('DEBUG', message, file, function, line.to_i)
  self
end

- (Node) logerror(message) Also known as: logerr

outputs log message for ERROR.

Parameters:

  • message (String) —

    message for output

Returns:



346
347
348
349
350
 
# File 'lib/ros/node.rb', line 346

def logerror(message)
  file, line, function = caller[0].split(':')
  @logger.log('ERROR', message, file, function, line.to_i)
  self
end

- (Node) logfatal(message)

outputs log message for FATAL.

Parameters:

  • message (String) —

    message for output

Returns:



359
360
361
362
363
 
# File 'lib/ros/node.rb', line 359

def logfatal(message)
  file, line, function = caller[0].split(':')
  @logger.log('FATAL', message, file, function, line.to_i)
  self
end

- (Node) loginfo(message)

outputs log message for INFO (INFORMATION).

Parameters:

  • message (String) —

    message for output

Returns:



314
315
316
317
318
 
# File 'lib/ros/node.rb', line 314

def loginfo(message)
  file, line, function = caller[0].split(':')
  @logger.log('INFO', message, file, function, line.to_i)
  self
end

- (Node) logwarn(message)

outputs log message for WARN (WARING).

Parameters:

  • message (String) —

    message for output

Returns:



335
336
337
338
339
 
# File 'lib/ros/node.rb', line 335

def logwarn(message)
  file, line, function = caller[0].split(':')
  @logger.log('WARN', message, file, function, line.to_i)
  self
end

- (Boolean) ok?

Is this node running? Please use for 'while loop' and so on..

Returns:

  • (Boolean) —

    true if node is running.



103
104
105
 
# File 'lib/ros/node.rb', line 103

def ok?
  @manager.is_ok?
end

- (String) resolve_name(name)

resolve the name by this node's remapping rule.

Parameters:

  • name (String) —

    name for resolved

Returns:

  • (String) —

    resolved name



130
131
132
 
# File 'lib/ros/node.rb', line 130

def resolve_name(name)
  resolve_name_with_call_id(@node_name, @ns, name, @remappings)
end

- (ServiceClient) service(service_name, service_type)

create service client.

Parameters:

  • service_name (String) —

    name of this service (string)

  • service_type (Class) —

    service class

Returns:



243
244
245
246
247
248
 
# File 'lib/ros/node.rb', line 243

def service(service_name, service_type)
  ROS::ServiceClient.new(@master_uri,
                         @node_name,
                         resolve_name(service_name),
                         service_type)
end

- (Boolean) set_param(key, value)

set parameter for 'key'.

Parameters:

  • key (String) —

    key of parameter

  • value (String, Integer, Float, Boolean) —

    value of parameter

Returns:

  • (Boolean) —

    return true if succeed



182
183
184
 
# File 'lib/ros/node.rb', line 182

def set_param(key, value)
  @parameter.set_param(expand_local_name(@node_name, key), value)
end

- (Node) shutdown

unregister to master and shutdown all connections.

Returns:



298
299
300
301
302
303
304
305
306
307
308
 
# File 'lib/ros/node.rb', line 298

def shutdown
  if ok?
    begin
      @manager.shutdown
    rescue => message
      p message
      puts 'ignoring errors while shutdown'
    end
  end
  self
end

- (String) slave_uri

get node URI

Returns:

  • (String) —

    uri of this node’s api



113
114
115
 
# File 'lib/ros/node.rb', line 113

def slave_uri
  @manager.get_uri
end

- (Object) spin

spin forever.



288
289
290
291
292
293
 
# File 'lib/ros/node.rb', line 288

def spin
  while ok?
    spin_once
    sleep(0.01)
  end
end

- (Object) spin_once

spin once. This invoke subscription/service_server callbacks



281
282
283
 
# File 'lib/ros/node.rb', line 281

def spin_once
  @manager.spin_once
end

- (Subscriber) subscribe(topic_name, topic_type, &callback)

start to subscribe a topic.

Parameters:

  • topic_name (String) —

    name of topic (string)

  • topic_type (Class) —

    Topic instance

Returns:



256
257
258
259
260
261
262
263
264
 
# File 'lib/ros/node.rb', line 256

def subscribe(topic_name, topic_type, &callback)
  sub = Subscriber.new(@node_name,
                       resolve_name(topic_name),
                       topic_type,
                       callback)
  @manager.add_subscriber(sub)
  trap_signals
  sub
end

- (ParameterSubscriber) subscribe_parameter(param, &callback)

subscribe to the parameter.

Parameters:

  • param (String) —

    name of parameter to subscribe

  • callback (Proc) —

    callback when parameter updated

Returns:



272
273
274
275
276
 
# File 'lib/ros/node.rb', line 272

def subscribe_parameter(param, &callback)
  sub = ParameterSubscriber.new(param, callback)
  @manager.add_parameter_subscriber(sub)
  sub
end

- (Boolean) wait_for_service(service_name, timeout_sec = nil)

wait until start the service.

Parameters:

  • service_name (String) —

    name of service for waiting

  • timeout_sec (Float) (defaults to: nil) —

    time out seconds. default infinity.

Returns:

  • (Boolean) —

    true if success, false if timeout



234
235
236
 
# File 'lib/ros/node.rb', line 234

def wait_for_service(service_name, timeout_sec=nil)
  @manager.wait_for_service(service_name, timeout_sec)
end