ros::object

  • :super propertied-object
  • :slots nil

:init

:md5sum-

:datatype-

ros::time

  • :super ros::object
  • :slots ros::sec-nsec

:init

   &key ((:sec ros::_sec) 0)
   ((:nsec ros::_nsec) 0)

  • ros::time represents ROS time primitive type, which consits of two integers, seconds and nanoseconds

:from-sec

   ros::sec

  • create new ros::time instance from a float seconds representation

:sec &optional ros::s

:nsec &optional ros::s

:sec-nsec

:now

:to-sec

:to-nsec

:from-nsec ros::nsec

:prin1 &optional (ros::strm t) &rest ros::msgs

ros::timer-event

  • :super propertied-object
  • :slots ros::last-expected ros::last-real ros::current-expected ros::current-real ros::last-duration

:init

:prin1 &optional (ros::strm t) &rest ros::msgs

:last-expected &rest args

:last-real &rest args

:current-expected &rest args

:current-real &rest args

:last-duration &rest args

ros::rate

  • frequency

    Construct ros timer for periodic sleeps

ros::ros-error

  • write mesage to error output

ros::get-host

  • Get the hostname where the master runs.

ros::get-uri

  • Get the full URI to the master

ros::ok

  • Check whether it's time to exit.

ros::spin

  • Enter simple event loop

ros::ros-debug

  • write mesage to debug output 

    (ros::ros-debug "this is error ~A" 0)

ros::unsubscribe

  • topicname

    Unsubscribe topic

ros::get-name

  • Returns current node name

ros::unadvertise

  • Unadvertise topic

ros::get-param-cached

  • Get chached parameter

ros::get-namespace

  • Returns current node name space

ros::spin-once

  • &optional groupname ;; spin only group

    Process a single round of callbacks.

ros::ros-info

  • write mesage to info output

ros::resolve-name

  • Returns ros resolved name

ros::get-topic-publisher

  • topicname

    Retuns the name of topic if it already published

ros::create-nodehandle

  • groupname &optional namespace ;;

    Create ros NodeHandle with given group name. 

    (ros::roseus "test")
(ros::create-node-handle "mygroup")
(ros::subscribe "/test" std_msgs::String #'(lambda (m) (print m)) :groupname "mygroup")
(while (ros::ok)  (ros::spin-once "mygroup"))

ros::subscribe

  • topicname message_type callbackfunc args0 ... argsN &optional queuesize %key (:groupname groupname)

    Subscribe to a topic, version for class member function with bare pointer.
    This method connects to the master to register interest in a given topic. The node will automatically be connected with publishers on this topic. On each message receipt, fp is invoked and passed a shared pointer to the message received. This message should not be changed in place, as it is shared with any other subscriptions to this topic.

    This version of subscribe is a convenience function for using function, member function, lmabda function: 
    ;; callback function
(defun string-cb (msg) (print (list 'cb (sys::thread-self) (send msg :data))))
(ros::subscribe "chatter" std_msgs::string #'string-cb)
;; lambda function
(ros::subscribe "chatter" std_msgs::string
                #'(lambda (msg) (ros::ros-info
                                 (format nil "I heard ~A" (send msg :data)))))
;; method call
(defclass string-cb-class
  :super propertied-object
  :slots ())
(defmethod string-cb-class
  (:init () (ros::subscribe "chatter" std_msgs::string #'send self :string-cb))
  (:string-cb (msg) (print (list 'cb self (send msg :data)))))
(setq m (instance string-cb-class :init))

ros::advertise

  • topic message_class &optional queuesize latch
    Advertise a topic.
    This call connects to the master to publicize that the node will be publishing messages on the given topic. This method returns a Publisher that allows you to publish a message on this topic. 
    (ros::advertise "chatter" std_msgs::string 1)

ros::get-topic-subscriber

  • topicname

    Retuns the name of topic if it already subscribed

ros::get-topics

  • Get the list of topics that are being published by all nodes.

ros::advertise-service

  • servicename message_type callback function

    Advertise a service 
    (ros::advertise-service "add_two_ints" roseus::AddTwoInts #'add-two-ints)

ros::unadvertise-service

  • Unadvertise service

ros::get-port

  • Get the port where the master runs.

ros::get-num-publishers

  • Returns the number of publishers this subscriber is connected to.

ros::delete-param

  • key

    Delete parameter from server

ros::ros-fatal

  • write mesage to fatal output

ros::service-exists

  • servicename

    Checks if a service is both advertised and available.

ros::wait-for-service

  • servicename &optional timeout

    Wait for a service to be advertised and available. Blocks until it is.

ros::sleep

  • Sleeps for any leftover time in a cycle. Calculated from the last time sleep, reset, or the constructor was called.

ros::get-num-subscribers

  • Retuns number of subscribers this publish is connected to

ros::rospack-find

  • Returns ros package path

ros::get-param

  • key

    Get parameter

ros::ros-warn

  • write mesage to warn output

ros::get-nodes

  • Retreives the currently-known list of nodes from the master.

ros::has-param

  • Check whether a parameter exists on the parameter server.

ros::service-call

  • servicename message_type &optional persist

    Invoke RPC service 
    (ros::roseus "add_two_ints_client")
(ros::wait-for-service "add_two_ints")
(setq req (instance roseus::AddTwoIntsRequest :init))
(send req :a (random 10))
(send req :b (random 20))
(setq res (ros::service-call "add_two_ints" req t))
(format t "~d + ~d = ~d~~%" (send req :a) (send req :b) (send res :sum))

ros::set-param

  • key value

    Set parameter

ros::rospack-plugins

  • Returns plugins of ros packages

ros::publish

  • topic message

    Publish a message on the topic 
    (ros::roseus "talker")
(ros::advertise "chatter" std_msgs::string 1)
(ros::rate 100)
(while (ros::ok)
  (setq msg (instance std_msgs::string :init))
  (send msg :data (format nil "hello world ~a" (send (ros::time-now) :sec-nsec)))
  (ros::publish "chatter" msg)
  (ros::sleep))

ros::roseus

   name &key (ros::anonymous t)
   (ros::logger ros.roseus)
   (ros::level ros::rosinfo)
   (args lisp::eustop-argument)

  • Register roseus client node with the master under the specified name

ros::time

   &optional (ros::sec 0)

  • Create new ros::time instance

ros::time-now

  • Create new ros::time instance representing current time

ros::time+

   ros::a ros::b

  • add ros::time

ros::time-

   ros::a ros::b

  • substruct ros::time

ros::time=

   ros::a ros::b

  • check if two ros::time is equal

ros::time>

   ros::a ros::b

  • check if given ros::time is greater then the others

ros::time>=

   ros::a ros::b

  • check if given ros::time is greater then or equal to the others

ros::time<

   ros::a ros::b

  • check if given ros::time is less then the others

ros::time<=

   ros::a ros::b

  • check if given ros::time is less the or equal to the others

ros::ros-message-destructuring-bind-parse-arg

   ros::msg ros::params

  • this function returns a list like ((symbol value) (symbol value) ...).
    always the rank of list is 2

ros::_ros-message-destructuring-bind-parse-arg

   ros::msg ros::param

  • this function returns a list like ((symbol value) ((symbol value) ...))

ros::load-ros-package

   ros::pkg

  • load reqruied roseus files for given package

ros::roseus-sigint-handler ros::sig ros::code

ros::roseus-error ros::code ros::msg1 ros::form &optional (ros::msg2)

ros::ros-home-dir

ros::roseus-add-files ros::pkg type

ros::roseus-add-msgs ros::pkg

ros::roseus-add-srvs ros::pkg

ros::resolve-ros-path fname

load fname &rest args

ros::append-name-space &rest args

ros::ros-message-destructuring-bind-flatten-param ros::params

ros::ros-slot-ref ros::inst slot

ros::find-load-msg-path ros::pkg

ros::load-ros-manifest ros::pkg