Obbart/RoboGlue_ROS
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Ricompilazione con nuovo nodo TF broadcaster

Browse Source
This commit is contained in:
Emanuele
2019-11-14 17:08:39 +01:00
parent c9108aaa54
commit a3f75e5449
55 changed files with 11305 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

96
devel/share/roseus/ros/ur_msgs/msg/Analog.l Normal file
View File

@@ -0,0 +1,96 @@
;; Auto-generated. Do not edit!
(when (boundp 'ur_msgs::Analog)
(if (not (find-package "UR_MSGS"))
(make-package "UR_MSGS"))
(shadow 'Analog (find-package "UR_MSGS")))
(unless (find-package "UR_MSGS::ANALOG")
(make-package "UR_MSGS::ANALOG"))
(in-package "ROS")
;;//! \htmlinclude Analog.msg.html
(intern "*VOLTAGE*" (find-package "UR_MSGS::ANALOG"))
(shadow '*VOLTAGE* (find-package "UR_MSGS::ANALOG"))
(defconstant ur_msgs::Analog::*VOLTAGE* 0)
(intern "*CURRENT*" (find-package "UR_MSGS::ANALOG"))
(shadow '*CURRENT* (find-package "UR_MSGS::ANALOG"))
(defconstant ur_msgs::Analog::*CURRENT* 1)
(defclass ur_msgs::Analog
:super ros::object
:slots (_pin _domain _state ))
(defmethod ur_msgs::Analog
(:init
(&key
((:pin __pin) 0)
((:domain __domain) 0)
((:state __state) 0.0)
)
(send-super :init)
(setq _pin (round __pin))
(setq _domain (round __domain))
(setq _state (float __state))
self)
(:pin
(&optional __pin)
(if __pin (setq _pin __pin)) _pin)
(:domain
(&optional __domain)
(if __domain (setq _domain __domain)) _domain)
(:state
(&optional __state)
(if __state (setq _state __state)) _state)
(:serialization-length
()
(+
;; uint8 _pin
1
;; uint8 _domain
1
;; float32 _state
4
))
(:serialize
(&optional strm)
(let ((s (if strm strm
(make-string-output-stream (send self :serialization-length)))))
;; uint8 _pin
(write-byte _pin s)
;; uint8 _domain
(write-byte _domain s)
;; float32 _state
(sys::poke _state (send s :buffer) (send s :count) :float) (incf (stream-count s) 4)
;;
(if (null strm) (get-output-stream-string s))))
(:deserialize
(buf &optional (ptr- 0))
;; uint8 _pin
(setq _pin (sys::peek buf ptr- :char)) (incf ptr- 1)
;; uint8 _domain
(setq _domain (sys::peek buf ptr- :char)) (incf ptr- 1)
;; float32 _state
(setq _state (sys::peek buf ptr- :float)) (incf ptr- 4)
;;
self)
)
(setf (get ur_msgs::Analog :md5sum-) "f41c08a810adf63713aec88712cd553d")
(setf (get ur_msgs::Analog :datatype-) "ur_msgs/Analog")
(setf (get ur_msgs::Analog :definition-)
"uint8 VOLTAGE=0
uint8 CURRENT=1
uint8 pin
uint8 domain # can be VOLTAGE or CURRENT
float32 state
")
(provide :ur_msgs/Analog "f41c08a810adf63713aec88712cd553d")

75
devel/share/roseus/ros/ur_msgs/msg/Digital.l Normal file
View File

@@ -0,0 +1,75 @@
;; Auto-generated. Do not edit!
(when (boundp 'ur_msgs::Digital)
(if (not (find-package "UR_MSGS"))
(make-package "UR_MSGS"))
(shadow 'Digital (find-package "UR_MSGS")))
(unless (find-package "UR_MSGS::DIGITAL")
(make-package "UR_MSGS::DIGITAL"))
(in-package "ROS")
;;//! \htmlinclude Digital.msg.html
(defclass ur_msgs::Digital
:super ros::object
:slots (_pin _state ))
(defmethod ur_msgs::Digital
(:init
(&key
((:pin __pin) 0)
((:state __state) nil)
)
(send-super :init)
(setq _pin (round __pin))
(setq _state __state)
self)
(:pin
(&optional __pin)
(if __pin (setq _pin __pin)) _pin)
(:state
(&optional __state)
(if __state (setq _state __state)) _state)
(:serialization-length
()
(+
;; uint8 _pin
1
;; bool _state
1
))
(:serialize
(&optional strm)
(let ((s (if strm strm
(make-string-output-stream (send self :serialization-length)))))
;; uint8 _pin
(write-byte _pin s)
;; bool _state
(if _state (write-byte -1 s) (write-byte 0 s))
;;
(if (null strm) (get-output-stream-string s))))
(:deserialize
(buf &optional (ptr- 0))
;; uint8 _pin
(setq _pin (sys::peek buf ptr- :char)) (incf ptr- 1)
;; bool _state
(setq _state (not (= 0 (sys::peek buf ptr- :char)))) (incf ptr- 1)
;;
self)
)
(setf (get ur_msgs::Digital :md5sum-) "83707be3fa18d2ffe57381ea034aa262")
(setf (get ur_msgs::Digital :datatype-) "ur_msgs/Digital")
(setf (get ur_msgs::Digital :definition-)
"uint8 pin
bool state
")
(provide :ur_msgs/Digital "83707be3fa18d2ffe57381ea034aa262")

185
devel/share/roseus/ros/ur_msgs/msg/IOStates.l Normal file
View File

@@ -0,0 +1,185 @@
;; Auto-generated. Do not edit!
(when (boundp 'ur_msgs::IOStates)
(if (not (find-package "UR_MSGS"))
(make-package "UR_MSGS"))
(shadow 'IOStates (find-package "UR_MSGS")))
(unless (find-package "UR_MSGS::IOSTATES")
(make-package "UR_MSGS::IOSTATES"))
(in-package "ROS")
;;//! \htmlinclude IOStates.msg.html
(defclass ur_msgs::IOStates
:super ros::object
:slots (_digital_in_states _digital_out_states _flag_states _analog_in_states _analog_out_states ))
(defmethod ur_msgs::IOStates
(:init
(&key
((:digital_in_states __digital_in_states) (let (r) (dotimes (i 0) (push (instance ur_msgs::Digital :init) r)) r))
((:digital_out_states __digital_out_states) (let (r) (dotimes (i 0) (push (instance ur_msgs::Digital :init) r)) r))
((:flag_states __flag_states) (let (r) (dotimes (i 0) (push (instance ur_msgs::Digital :init) r)) r))
((:analog_in_states __analog_in_states) (let (r) (dotimes (i 0) (push (instance ur_msgs::Analog :init) r)) r))
((:analog_out_states __analog_out_states) (let (r) (dotimes (i 0) (push (instance ur_msgs::Analog :init) r)) r))
)
(send-super :init)
(setq _digital_in_states __digital_in_states)
(setq _digital_out_states __digital_out_states)
(setq _flag_states __flag_states)
(setq _analog_in_states __analog_in_states)
(setq _analog_out_states __analog_out_states)
self)
(:digital_in_states
(&rest __digital_in_states)
(if (keywordp (car __digital_in_states))
(send* _digital_in_states __digital_in_states)
(progn
(if __digital_in_states (setq _digital_in_states (car __digital_in_states)))
_digital_in_states)))
(:digital_out_states
(&rest __digital_out_states)
(if (keywordp (car __digital_out_states))
(send* _digital_out_states __digital_out_states)
(progn
(if __digital_out_states (setq _digital_out_states (car __digital_out_states)))
_digital_out_states)))
(:flag_states
(&rest __flag_states)
(if (keywordp (car __flag_states))
(send* _flag_states __flag_states)
(progn
(if __flag_states (setq _flag_states (car __flag_states)))
_flag_states)))
(:analog_in_states
(&rest __analog_in_states)
(if (keywordp (car __analog_in_states))
(send* _analog_in_states __analog_in_states)
(progn
(if __analog_in_states (setq _analog_in_states (car __analog_in_states)))
_analog_in_states)))
(:analog_out_states
(&rest __analog_out_states)
(if (keywordp (car __analog_out_states))
(send* _analog_out_states __analog_out_states)
(progn
(if __analog_out_states (setq _analog_out_states (car __analog_out_states)))
_analog_out_states)))
(:serialization-length
()
(+
;; ur_msgs/Digital[] _digital_in_states
(apply #'+ (send-all _digital_in_states :serialization-length)) 4
;; ur_msgs/Digital[] _digital_out_states
(apply #'+ (send-all _digital_out_states :serialization-length)) 4
;; ur_msgs/Digital[] _flag_states
(apply #'+ (send-all _flag_states :serialization-length)) 4
;; ur_msgs/Analog[] _analog_in_states
(apply #'+ (send-all _analog_in_states :serialization-length)) 4
;; ur_msgs/Analog[] _analog_out_states
(apply #'+ (send-all _analog_out_states :serialization-length)) 4
))
(:serialize
(&optional strm)
(let ((s (if strm strm
(make-string-output-stream (send self :serialization-length)))))
;; ur_msgs/Digital[] _digital_in_states
(write-long (length _digital_in_states) s)
(dolist (elem _digital_in_states)
(send elem :serialize s)
)
;; ur_msgs/Digital[] _digital_out_states
(write-long (length _digital_out_states) s)
(dolist (elem _digital_out_states)
(send elem :serialize s)
)
;; ur_msgs/Digital[] _flag_states
(write-long (length _flag_states) s)
(dolist (elem _flag_states)
(send elem :serialize s)
)
;; ur_msgs/Analog[] _analog_in_states
(write-long (length _analog_in_states) s)
(dolist (elem _analog_in_states)
(send elem :serialize s)
)
;; ur_msgs/Analog[] _analog_out_states
(write-long (length _analog_out_states) s)
(dolist (elem _analog_out_states)
(send elem :serialize s)
)
;;
(if (null strm) (get-output-stream-string s))))
(:deserialize
(buf &optional (ptr- 0))
;; ur_msgs/Digital[] _digital_in_states
(let (n)
(setq n (sys::peek buf ptr- :integer)) (incf ptr- 4)
(setq _digital_in_states (let (r) (dotimes (i n) (push (instance ur_msgs::Digital :init) r)) r))
(dolist (elem- _digital_in_states)
(send elem- :deserialize buf ptr-) (incf ptr- (send elem- :serialization-length))
))
;; ur_msgs/Digital[] _digital_out_states
(let (n)
(setq n (sys::peek buf ptr- :integer)) (incf ptr- 4)
(setq _digital_out_states (let (r) (dotimes (i n) (push (instance ur_msgs::Digital :init) r)) r))
(dolist (elem- _digital_out_states)
(send elem- :deserialize buf ptr-) (incf ptr- (send elem- :serialization-length))
))
;; ur_msgs/Digital[] _flag_states
(let (n)
(setq n (sys::peek buf ptr- :integer)) (incf ptr- 4)
(setq _flag_states (let (r) (dotimes (i n) (push (instance ur_msgs::Digital :init) r)) r))
(dolist (elem- _flag_states)
(send elem- :deserialize buf ptr-) (incf ptr- (send elem- :serialization-length))
))
;; ur_msgs/Analog[] _analog_in_states
(let (n)
(setq n (sys::peek buf ptr- :integer)) (incf ptr- 4)
(setq _analog_in_states (let (r) (dotimes (i n) (push (instance ur_msgs::Analog :init) r)) r))
(dolist (elem- _analog_in_states)
(send elem- :deserialize buf ptr-) (incf ptr- (send elem- :serialization-length))
))
;; ur_msgs/Analog[] _analog_out_states
(let (n)
(setq n (sys::peek buf ptr- :integer)) (incf ptr- 4)
(setq _analog_out_states (let (r) (dotimes (i n) (push (instance ur_msgs::Analog :init) r)) r))
(dolist (elem- _analog_out_states)
(send elem- :deserialize buf ptr-) (incf ptr- (send elem- :serialization-length))
))
;;
self)
)
(setf (get ur_msgs::IOStates :md5sum-) "3033784e7041da89491b97cc4c1105b5")
(setf (get ur_msgs::IOStates :datatype-) "ur_msgs/IOStates")
(setf (get ur_msgs::IOStates :definition-)
"Digital[] digital_in_states
Digital[] digital_out_states
Digital[] flag_states
Analog[] analog_in_states
Analog[] analog_out_states
================================================================================
MSG: ur_msgs/Digital
uint8 pin
bool state
================================================================================
MSG: ur_msgs/Analog
uint8 VOLTAGE=0
uint8 CURRENT=1
uint8 pin
uint8 domain # can be VOLTAGE or CURRENT
float32 state
")
(provide :ur_msgs/IOStates "3033784e7041da89491b97cc4c1105b5")

258
devel/share/roseus/ros/ur_msgs/msg/MasterboardDataMsg.l Normal file
View File

@@ -0,0 +1,258 @@
;; Auto-generated. Do not edit!
(when (boundp 'ur_msgs::MasterboardDataMsg)
(if (not (find-package "UR_MSGS"))
(make-package "UR_MSGS"))
(shadow 'MasterboardDataMsg (find-package "UR_MSGS")))
(unless (find-package "UR_MSGS::MASTERBOARDDATAMSG")
(make-package "UR_MSGS::MASTERBOARDDATAMSG"))
(in-package "ROS")
;;//! \htmlinclude MasterboardDataMsg.msg.html
(defclass ur_msgs::MasterboardDataMsg
:super ros::object
:slots (_digital_input_bits _digital_output_bits _analog_input_range0 _analog_input_range1 _analog_input0 _analog_input1 _analog_output_domain0 _analog_output_domain1 _analog_output0 _analog_output1 _masterboard_temperature _robot_voltage_48V _robot_current _master_io_current _master_safety_state _master_onoff_state ))
(defmethod ur_msgs::MasterboardDataMsg
(:init
(&key
((:digital_input_bits __digital_input_bits) 0)
((:digital_output_bits __digital_output_bits) 0)
((:analog_input_range0 __analog_input_range0) 0)
((:analog_input_range1 __analog_input_range1) 0)
((:analog_input0 __analog_input0) 0.0)
((:analog_input1 __analog_input1) 0.0)
((:analog_output_domain0 __analog_output_domain0) 0)
((:analog_output_domain1 __analog_output_domain1) 0)
((:analog_output0 __analog_output0) 0.0)
((:analog_output1 __analog_output1) 0.0)
((:masterboard_temperature __masterboard_temperature) 0.0)
((:robot_voltage_48V __robot_voltage_48V) 0.0)
((:robot_current __robot_current) 0.0)
((:master_io_current __master_io_current) 0.0)
((:master_safety_state __master_safety_state) 0)
((:master_onoff_state __master_onoff_state) 0)
)
(send-super :init)
(setq _digital_input_bits (round __digital_input_bits))
(setq _digital_output_bits (round __digital_output_bits))
(setq _analog_input_range0 (round __analog_input_range0))
(setq _analog_input_range1 (round __analog_input_range1))
(setq _analog_input0 (float __analog_input0))
(setq _analog_input1 (float __analog_input1))
(setq _analog_output_domain0 (round __analog_output_domain0))
(setq _analog_output_domain1 (round __analog_output_domain1))
(setq _analog_output0 (float __analog_output0))
(setq _analog_output1 (float __analog_output1))
(setq _masterboard_temperature (float __masterboard_temperature))
(setq _robot_voltage_48V (float __robot_voltage_48V))
(setq _robot_current (float __robot_current))
(setq _master_io_current (float __master_io_current))
(setq _master_safety_state (round __master_safety_state))
(setq _master_onoff_state (round __master_onoff_state))
self)
(:digital_input_bits
(&optional __digital_input_bits)
(if __digital_input_bits (setq _digital_input_bits __digital_input_bits)) _digital_input_bits)
(:digital_output_bits
(&optional __digital_output_bits)
(if __digital_output_bits (setq _digital_output_bits __digital_output_bits)) _digital_output_bits)
(:analog_input_range0
(&optional __analog_input_range0)
(if __analog_input_range0 (setq _analog_input_range0 __analog_input_range0)) _analog_input_range0)
(:analog_input_range1
(&optional __analog_input_range1)
(if __analog_input_range1 (setq _analog_input_range1 __analog_input_range1)) _analog_input_range1)
(:analog_input0
(&optional __analog_input0)
(if __analog_input0 (setq _analog_input0 __analog_input0)) _analog_input0)
(:analog_input1
(&optional __analog_input1)
(if __analog_input1 (setq _analog_input1 __analog_input1)) _analog_input1)
(:analog_output_domain0
(&optional __analog_output_domain0)
(if __analog_output_domain0 (setq _analog_output_domain0 __analog_output_domain0)) _analog_output_domain0)
(:analog_output_domain1
(&optional __analog_output_domain1)
(if __analog_output_domain1 (setq _analog_output_domain1 __analog_output_domain1)) _analog_output_domain1)
(:analog_output0
(&optional __analog_output0)
(if __analog_output0 (setq _analog_output0 __analog_output0)) _analog_output0)
(:analog_output1
(&optional __analog_output1)
(if __analog_output1 (setq _analog_output1 __analog_output1)) _analog_output1)
(:masterboard_temperature
(&optional __masterboard_temperature)
(if __masterboard_temperature (setq _masterboard_temperature __masterboard_temperature)) _masterboard_temperature)
(:robot_voltage_48V
(&optional __robot_voltage_48V)
(if __robot_voltage_48V (setq _robot_voltage_48V __robot_voltage_48V)) _robot_voltage_48V)
(:robot_current
(&optional __robot_current)
(if __robot_current (setq _robot_current __robot_current)) _robot_current)
(:master_io_current
(&optional __master_io_current)
(if __master_io_current (setq _master_io_current __master_io_current)) _master_io_current)
(:master_safety_state
(&optional __master_safety_state)
(if __master_safety_state (setq _master_safety_state __master_safety_state)) _master_safety_state)
(:master_onoff_state
(&optional __master_onoff_state)
(if __master_onoff_state (setq _master_onoff_state __master_onoff_state)) _master_onoff_state)
(:serialization-length
()
(+
;; uint32 _digital_input_bits
4
;; uint32 _digital_output_bits
4
;; int8 _analog_input_range0
1
;; int8 _analog_input_range1
1
;; float64 _analog_input0
8
;; float64 _analog_input1
8
;; int8 _analog_output_domain0
1
;; int8 _analog_output_domain1
1
;; float64 _analog_output0
8
;; float64 _analog_output1
8
;; float32 _masterboard_temperature
4
;; float32 _robot_voltage_48V
4
;; float32 _robot_current
4
;; float32 _master_io_current
4
;; uint8 _master_safety_state
1
;; uint8 _master_onoff_state
1
))
(:serialize
(&optional strm)
(let ((s (if strm strm
(make-string-output-stream (send self :serialization-length)))))
;; uint32 _digital_input_bits
(write-long _digital_input_bits s)
;; uint32 _digital_output_bits
(write-long _digital_output_bits s)
;; int8 _analog_input_range0
(write-byte _analog_input_range0 s)
;; int8 _analog_input_range1
(write-byte _analog_input_range1 s)
;; float64 _analog_input0
(sys::poke _analog_input0 (send s :buffer) (send s :count) :double) (incf (stream-count s) 8)
;; float64 _analog_input1
(sys::poke _analog_input1 (send s :buffer) (send s :count) :double) (incf (stream-count s) 8)
;; int8 _analog_output_domain0
(write-byte _analog_output_domain0 s)
;; int8 _analog_output_domain1
(write-byte _analog_output_domain1 s)
;; float64 _analog_output0
(sys::poke _analog_output0 (send s :buffer) (send s :count) :double) (incf (stream-count s) 8)
;; float64 _analog_output1
(sys::poke _analog_output1 (send s :buffer) (send s :count) :double) (incf (stream-count s) 8)
;; float32 _masterboard_temperature
(sys::poke _masterboard_temperature (send s :buffer) (send s :count) :float) (incf (stream-count s) 4)
;; float32 _robot_voltage_48V
(sys::poke _robot_voltage_48V (send s :buffer) (send s :count) :float) (incf (stream-count s) 4)
;; float32 _robot_current
(sys::poke _robot_current (send s :buffer) (send s :count) :float) (incf (stream-count s) 4)
;; float32 _master_io_current
(sys::poke _master_io_current (send s :buffer) (send s :count) :float) (incf (stream-count s) 4)
;; uint8 _master_safety_state
(write-byte _master_safety_state s)
;; uint8 _master_onoff_state
(write-byte _master_onoff_state s)
;;
(if (null strm) (get-output-stream-string s))))
(:deserialize
(buf &optional (ptr- 0))
;; uint32 _digital_input_bits
(setq _digital_input_bits (sys::peek buf ptr- :integer)) (incf ptr- 4)
;; uint32 _digital_output_bits
(setq _digital_output_bits (sys::peek buf ptr- :integer)) (incf ptr- 4)
;; int8 _analog_input_range0
(setq _analog_input_range0 (sys::peek buf ptr- :char)) (incf ptr- 1)
(if (> _analog_input_range0 127) (setq _analog_input_range0 (- _analog_input_range0 256)))
;; int8 _analog_input_range1
(setq _analog_input_range1 (sys::peek buf ptr- :char)) (incf ptr- 1)
(if (> _analog_input_range1 127) (setq _analog_input_range1 (- _analog_input_range1 256)))
;; float64 _analog_input0
(setq _analog_input0 (sys::peek buf ptr- :double)) (incf ptr- 8)
;; float64 _analog_input1
(setq _analog_input1 (sys::peek buf ptr- :double)) (incf ptr- 8)
;; int8 _analog_output_domain0
(setq _analog_output_domain0 (sys::peek buf ptr- :char)) (incf ptr- 1)
(if (> _analog_output_domain0 127) (setq _analog_output_domain0 (- _analog_output_domain0 256)))
;; int8 _analog_output_domain1
(setq _analog_output_domain1 (sys::peek buf ptr- :char)) (incf ptr- 1)
(if (> _analog_output_domain1 127) (setq _analog_output_domain1 (- _analog_output_domain1 256)))
;; float64 _analog_output0
(setq _analog_output0 (sys::peek buf ptr- :double)) (incf ptr- 8)
;; float64 _analog_output1
(setq _analog_output1 (sys::peek buf ptr- :double)) (incf ptr- 8)
;; float32 _masterboard_temperature
(setq _masterboard_temperature (sys::peek buf ptr- :float)) (incf ptr- 4)
;; float32 _robot_voltage_48V
(setq _robot_voltage_48V (sys::peek buf ptr- :float)) (incf ptr- 4)
;; float32 _robot_current
(setq _robot_current (sys::peek buf ptr- :float)) (incf ptr- 4)
;; float32 _master_io_current
(setq _master_io_current (sys::peek buf ptr- :float)) (incf ptr- 4)
;; uint8 _master_safety_state
(setq _master_safety_state (sys::peek buf ptr- :char)) (incf ptr- 1)
;; uint8 _master_onoff_state
(setq _master_onoff_state (sys::peek buf ptr- :char)) (incf ptr- 1)
;;
self)
)
(setf (get ur_msgs::MasterboardDataMsg :md5sum-) "807af5dc427082b111fa23d1fd2cd585")
(setf (get ur_msgs::MasterboardDataMsg :datatype-) "ur_msgs/MasterboardDataMsg")
(setf (get ur_msgs::MasterboardDataMsg :definition-)
"# This data structure contains the MasterboardData structure
# used by the Universal Robots controller
#
# MasterboardData is part of the data structure being send on the
# secondary client communications interface
#
# This data structure is send at 10 Hz on TCP port 30002
#
# Documentation can be found on the Universal Robots Support site, article
# number 16496.
uint32 digital_input_bits
uint32 digital_output_bits
int8 analog_input_range0
int8 analog_input_range1
float64 analog_input0
float64 analog_input1
int8 analog_output_domain0
int8 analog_output_domain1
float64 analog_output0
float64 analog_output1
float32 masterboard_temperature
float32 robot_voltage_48V
float32 robot_current
float32 master_io_current
uint8 master_safety_state
uint8 master_onoff_state
")
(provide :ur_msgs/MasterboardDataMsg "807af5dc427082b111fa23d1fd2cd585")

175
devel/share/roseus/ros/ur_msgs/msg/RobotModeDataMsg.l Normal file
View File

@@ -0,0 +1,175 @@
;; Auto-generated. Do not edit!
(when (boundp 'ur_msgs::RobotModeDataMsg)
(if (not (find-package "UR_MSGS"))
(make-package "UR_MSGS"))
(shadow 'RobotModeDataMsg (find-package "UR_MSGS")))
(unless (find-package "UR_MSGS::ROBOTMODEDATAMSG")
(make-package "UR_MSGS::ROBOTMODEDATAMSG"))
(in-package "ROS")
;;//! \htmlinclude RobotModeDataMsg.msg.html
(defclass ur_msgs::RobotModeDataMsg
:super ros::object
:slots (_timestamp _is_robot_connected _is_real_robot_enabled _is_power_on_robot _is_emergency_stopped _is_protective_stopped _is_program_running _is_program_paused ))
(defmethod ur_msgs::RobotModeDataMsg
(:init
(&key
((:timestamp __timestamp) 0)
((:is_robot_connected __is_robot_connected) nil)
((:is_real_robot_enabled __is_real_robot_enabled) nil)
((:is_power_on_robot __is_power_on_robot) nil)
((:is_emergency_stopped __is_emergency_stopped) nil)
((:is_protective_stopped __is_protective_stopped) nil)
((:is_program_running __is_program_running) nil)
((:is_program_paused __is_program_paused) nil)
)
(send-super :init)
(setq _timestamp (round __timestamp))
(setq _is_robot_connected __is_robot_connected)
(setq _is_real_robot_enabled __is_real_robot_enabled)
(setq _is_power_on_robot __is_power_on_robot)
(setq _is_emergency_stopped __is_emergency_stopped)
(setq _is_protective_stopped __is_protective_stopped)
(setq _is_program_running __is_program_running)
(setq _is_program_paused __is_program_paused)
self)
(:timestamp
(&optional __timestamp)
(if __timestamp (setq _timestamp __timestamp)) _timestamp)
(:is_robot_connected
(&optional __is_robot_connected)
(if __is_robot_connected (setq _is_robot_connected __is_robot_connected)) _is_robot_connected)
(:is_real_robot_enabled
(&optional __is_real_robot_enabled)
(if __is_real_robot_enabled (setq _is_real_robot_enabled __is_real_robot_enabled)) _is_real_robot_enabled)
(:is_power_on_robot
(&optional __is_power_on_robot)
(if __is_power_on_robot (setq _is_power_on_robot __is_power_on_robot)) _is_power_on_robot)
(:is_emergency_stopped
(&optional __is_emergency_stopped)
(if __is_emergency_stopped (setq _is_emergency_stopped __is_emergency_stopped)) _is_emergency_stopped)
(:is_protective_stopped
(&optional __is_protective_stopped)
(if __is_protective_stopped (setq _is_protective_stopped __is_protective_stopped)) _is_protective_stopped)
(:is_program_running
(&optional __is_program_running)
(if __is_program_running (setq _is_program_running __is_program_running)) _is_program_running)
(:is_program_paused
(&optional __is_program_paused)
(if __is_program_paused (setq _is_program_paused __is_program_paused)) _is_program_paused)
(:serialization-length
()
(+
;; uint64 _timestamp
8
;; bool _is_robot_connected
1
;; bool _is_real_robot_enabled
1
;; bool _is_power_on_robot
1
;; bool _is_emergency_stopped
1
;; bool _is_protective_stopped
1
;; bool _is_program_running
1
;; bool _is_program_paused
1
))
(:serialize
(&optional strm)
(let ((s (if strm strm
(make-string-output-stream (send self :serialization-length)))))
;; uint64 _timestamp
#+(or :alpha :irix6 :x86_64)
(progn (sys::poke _timestamp (send s :buffer) (send s :count) :long) (incf (stream-count s) 8))
#-(or :alpha :irix6 :x86_64)
(cond ((and (class _timestamp) (= (length (_timestamp . bv)) 2)) ;; bignum
(write-long (ash (elt (_timestamp . bv) 0) 0) s)
(write-long (ash (elt (_timestamp . bv) 1) -1) s))
((and (class _timestamp) (= (length (_timestamp . bv)) 1)) ;; big1
(write-long (elt (_timestamp . bv) 0) s)
(write-long (if (>= _timestamp 0) 0 #xffffffff) s))
(t ;; integer
(write-long _timestamp s)(write-long (if (>= _timestamp 0) 0 #xffffffff) s)))
;; bool _is_robot_connected
(if _is_robot_connected (write-byte -1 s) (write-byte 0 s))
;; bool _is_real_robot_enabled
(if _is_real_robot_enabled (write-byte -1 s) (write-byte 0 s))
;; bool _is_power_on_robot
(if _is_power_on_robot (write-byte -1 s) (write-byte 0 s))
;; bool _is_emergency_stopped
(if _is_emergency_stopped (write-byte -1 s) (write-byte 0 s))
;; bool _is_protective_stopped
(if _is_protective_stopped (write-byte -1 s) (write-byte 0 s))
;; bool _is_program_running
(if _is_program_running (write-byte -1 s) (write-byte 0 s))
;; bool _is_program_paused
(if _is_program_paused (write-byte -1 s) (write-byte 0 s))
;;
(if (null strm) (get-output-stream-string s))))
(:deserialize
(buf &optional (ptr- 0))
;; uint64 _timestamp
#+(or :alpha :irix6 :x86_64)
(setf _timestamp (prog1 (sys::peek buf ptr- :long) (incf ptr- 8)))
#-(or :alpha :irix6 :x86_64)
(setf _timestamp (let ((b0 (prog1 (sys::peek buf ptr- :integer) (incf ptr- 4)))
(b1 (prog1 (sys::peek buf ptr- :integer) (incf ptr- 4))))
(cond ((= b1 -1) b0)
((and (= b1 0)
(<= lisp::most-negative-fixnum b0 lisp::most-positive-fixnum))
b0)
((= b1 0) (make-instance bignum :size 1 :bv (integer-vector b0)))
(t (make-instance bignum :size 2 :bv (integer-vector b0 (ash b1 1)))))))
;; bool _is_robot_connected
(setq _is_robot_connected (not (= 0 (sys::peek buf ptr- :char)))) (incf ptr- 1)
;; bool _is_real_robot_enabled
(setq _is_real_robot_enabled (not (= 0 (sys::peek buf ptr- :char)))) (incf ptr- 1)
;; bool _is_power_on_robot
(setq _is_power_on_robot (not (= 0 (sys::peek buf ptr- :char)))) (incf ptr- 1)
;; bool _is_emergency_stopped
(setq _is_emergency_stopped (not (= 0 (sys::peek buf ptr- :char)))) (incf ptr- 1)
;; bool _is_protective_stopped
(setq _is_protective_stopped (not (= 0 (sys::peek buf ptr- :char)))) (incf ptr- 1)
;; bool _is_program_running
(setq _is_program_running (not (= 0 (sys::peek buf ptr- :char)))) (incf ptr- 1)
;; bool _is_program_paused
(setq _is_program_paused (not (= 0 (sys::peek buf ptr- :char)))) (incf ptr- 1)
;;
self)
)
(setf (get ur_msgs::RobotModeDataMsg :md5sum-) "867308ca39e2cc0644b50db27deb661f")
(setf (get ur_msgs::RobotModeDataMsg :datatype-) "ur_msgs/RobotModeDataMsg")
(setf (get ur_msgs::RobotModeDataMsg :definition-)
"# This data structure contains the RobotModeData structure
# used by the Universal Robots controller
#
# This data structure is send at 10 Hz on TCP port 30002
#
# Note: this message does not carry all fields from the RobotModeData structure as broadcast by the robot controller, but a subset.
uint64 timestamp
bool is_robot_connected
bool is_real_robot_enabled
bool is_power_on_robot
bool is_emergency_stopped
bool is_protective_stopped
bool is_program_running
bool is_program_paused
")
(provide :ur_msgs/RobotModeDataMsg "867308ca39e2cc0644b50db27deb661f")

399
devel/share/roseus/ros/ur_msgs/msg/RobotStateRTMsg.l Normal file
View File

@@ -0,0 +1,399 @@
;; Auto-generated. Do not edit!
(when (boundp 'ur_msgs::RobotStateRTMsg)
(if (not (find-package "UR_MSGS"))
(make-package "UR_MSGS"))
(shadow 'RobotStateRTMsg (find-package "UR_MSGS")))
(unless (find-package "UR_MSGS::ROBOTSTATERTMSG")
(make-package "UR_MSGS::ROBOTSTATERTMSG"))
(in-package "ROS")
;;//! \htmlinclude RobotStateRTMsg.msg.html
(defclass ur_msgs::RobotStateRTMsg
:super ros::object
:slots (_time _q_target _qd_target _qdd_target _i_target _m_target _q_actual _qd_actual _i_actual _tool_acc_values _tcp_force _tool_vector _tcp_speed _digital_input_bits _motor_temperatures _controller_timer _test_value _robot_mode _joint_modes ))
(defmethod ur_msgs::RobotStateRTMsg
(:init
(&key
((:time __time) 0.0)
((:q_target __q_target) (make-array 0 :initial-element 0.0 :element-type :float))
((:qd_target __qd_target) (make-array 0 :initial-element 0.0 :element-type :float))
((:qdd_target __qdd_target) (make-array 0 :initial-element 0.0 :element-type :float))
((:i_target __i_target) (make-array 0 :initial-element 0.0 :element-type :float))
((:m_target __m_target) (make-array 0 :initial-element 0.0 :element-type :float))
((:q_actual __q_actual) (make-array 0 :initial-element 0.0 :element-type :float))
((:qd_actual __qd_actual) (make-array 0 :initial-element 0.0 :element-type :float))
((:i_actual __i_actual) (make-array 0 :initial-element 0.0 :element-type :float))
((:tool_acc_values __tool_acc_values) (make-array 0 :initial-element 0.0 :element-type :float))
((:tcp_force __tcp_force) (make-array 0 :initial-element 0.0 :element-type :float))
((:tool_vector __tool_vector) (make-array 0 :initial-element 0.0 :element-type :float))
((:tcp_speed __tcp_speed) (make-array 0 :initial-element 0.0 :element-type :float))
((:digital_input_bits __digital_input_bits) 0.0)
((:motor_temperatures __motor_temperatures) (make-array 0 :initial-element 0.0 :element-type :float))
((:controller_timer __controller_timer) 0.0)
((:test_value __test_value) 0.0)
((:robot_mode __robot_mode) 0.0)
((:joint_modes __joint_modes) (make-array 0 :initial-element 0.0 :element-type :float))
)
(send-super :init)
(setq _time (float __time))
(setq _q_target __q_target)
(setq _qd_target __qd_target)
(setq _qdd_target __qdd_target)
(setq _i_target __i_target)
(setq _m_target __m_target)
(setq _q_actual __q_actual)
(setq _qd_actual __qd_actual)
(setq _i_actual __i_actual)
(setq _tool_acc_values __tool_acc_values)
(setq _tcp_force __tcp_force)
(setq _tool_vector __tool_vector)
(setq _tcp_speed __tcp_speed)
(setq _digital_input_bits (float __digital_input_bits))
(setq _motor_temperatures __motor_temperatures)
(setq _controller_timer (float __controller_timer))
(setq _test_value (float __test_value))
(setq _robot_mode (float __robot_mode))
(setq _joint_modes __joint_modes)
self)
(:time
(&optional __time)
(if __time (setq _time __time)) _time)
(:q_target
(&optional __q_target)
(if __q_target (setq _q_target __q_target)) _q_target)
(:qd_target
(&optional __qd_target)
(if __qd_target (setq _qd_target __qd_target)) _qd_target)
(:qdd_target
(&optional __qdd_target)
(if __qdd_target (setq _qdd_target __qdd_target)) _qdd_target)
(:i_target
(&optional __i_target)
(if __i_target (setq _i_target __i_target)) _i_target)
(:m_target
(&optional __m_target)
(if __m_target (setq _m_target __m_target)) _m_target)
(:q_actual
(&optional __q_actual)
(if __q_actual (setq _q_actual __q_actual)) _q_actual)
(:qd_actual
(&optional __qd_actual)
(if __qd_actual (setq _qd_actual __qd_actual)) _qd_actual)
(:i_actual
(&optional __i_actual)
(if __i_actual (setq _i_actual __i_actual)) _i_actual)
(:tool_acc_values
(&optional __tool_acc_values)
(if __tool_acc_values (setq _tool_acc_values __tool_acc_values)) _tool_acc_values)
(:tcp_force
(&optional __tcp_force)
(if __tcp_force (setq _tcp_force __tcp_force)) _tcp_force)
(:tool_vector
(&optional __tool_vector)
(if __tool_vector (setq _tool_vector __tool_vector)) _tool_vector)
(:tcp_speed
(&optional __tcp_speed)
(if __tcp_speed (setq _tcp_speed __tcp_speed)) _tcp_speed)
(:digital_input_bits
(&optional __digital_input_bits)
(if __digital_input_bits (setq _digital_input_bits __digital_input_bits)) _digital_input_bits)
(:motor_temperatures
(&optional __motor_temperatures)
(if __motor_temperatures (setq _motor_temperatures __motor_temperatures)) _motor_temperatures)
(:controller_timer
(&optional __controller_timer)
(if __controller_timer (setq _controller_timer __controller_timer)) _controller_timer)
(:test_value
(&optional __test_value)
(if __test_value (setq _test_value __test_value)) _test_value)
(:robot_mode
(&optional __robot_mode)
(if __robot_mode (setq _robot_mode __robot_mode)) _robot_mode)
(:joint_modes
(&optional __joint_modes)
(if __joint_modes (setq _joint_modes __joint_modes)) _joint_modes)
(:serialization-length
()
(+
;; float64 _time
8
;; float64[] _q_target
(* 8 (length _q_target)) 4
;; float64[] _qd_target
(* 8 (length _qd_target)) 4
;; float64[] _qdd_target
(* 8 (length _qdd_target)) 4
;; float64[] _i_target
(* 8 (length _i_target)) 4
;; float64[] _m_target
(* 8 (length _m_target)) 4
;; float64[] _q_actual
(* 8 (length _q_actual)) 4
;; float64[] _qd_actual
(* 8 (length _qd_actual)) 4
;; float64[] _i_actual
(* 8 (length _i_actual)) 4
;; float64[] _tool_acc_values
(* 8 (length _tool_acc_values)) 4
;; float64[] _tcp_force
(* 8 (length _tcp_force)) 4
;; float64[] _tool_vector
(* 8 (length _tool_vector)) 4
;; float64[] _tcp_speed
(* 8 (length _tcp_speed)) 4
;; float64 _digital_input_bits
8
;; float64[] _motor_temperatures
(* 8 (length _motor_temperatures)) 4
;; float64 _controller_timer
8
;; float64 _test_value
8
;; float64 _robot_mode
8
;; float64[] _joint_modes
(* 8 (length _joint_modes)) 4
))
(:serialize
(&optional strm)
(let ((s (if strm strm
(make-string-output-stream (send self :serialization-length)))))
;; float64 _time
(sys::poke _time (send s :buffer) (send s :count) :double) (incf (stream-count s) 8)
;; float64[] _q_target
(write-long (length _q_target) s)
(dotimes (i (length _q_target))
(sys::poke (elt _q_target i) (send s :buffer) (send s :count) :double) (incf (stream-count s) 8)
)
;; float64[] _qd_target
(write-long (length _qd_target) s)
(dotimes (i (length _qd_target))
(sys::poke (elt _qd_target i) (send s :buffer) (send s :count) :double) (incf (stream-count s) 8)
)
;; float64[] _qdd_target
(write-long (length _qdd_target) s)
(dotimes (i (length _qdd_target))
(sys::poke (elt _qdd_target i) (send s :buffer) (send s :count) :double) (incf (stream-count s) 8)
)
;; float64[] _i_target
(write-long (length _i_target) s)
(dotimes (i (length _i_target))
(sys::poke (elt _i_target i) (send s :buffer) (send s :count) :double) (incf (stream-count s) 8)
)
;; float64[] _m_target
(write-long (length _m_target) s)
(dotimes (i (length _m_target))
(sys::poke (elt _m_target i) (send s :buffer) (send s :count) :double) (incf (stream-count s) 8)
)
;; float64[] _q_actual
(write-long (length _q_actual) s)
(dotimes (i (length _q_actual))
(sys::poke (elt _q_actual i) (send s :buffer) (send s :count) :double) (incf (stream-count s) 8)
)
;; float64[] _qd_actual
(write-long (length _qd_actual) s)
(dotimes (i (length _qd_actual))
(sys::poke (elt _qd_actual i) (send s :buffer) (send s :count) :double) (incf (stream-count s) 8)
)
;; float64[] _i_actual
(write-long (length _i_actual) s)
(dotimes (i (length _i_actual))
(sys::poke (elt _i_actual i) (send s :buffer) (send s :count) :double) (incf (stream-count s) 8)
)
;; float64[] _tool_acc_values
(write-long (length _tool_acc_values) s)
(dotimes (i (length _tool_acc_values))
(sys::poke (elt _tool_acc_values i) (send s :buffer) (send s :count) :double) (incf (stream-count s) 8)
)
;; float64[] _tcp_force
(write-long (length _tcp_force) s)
(dotimes (i (length _tcp_force))
(sys::poke (elt _tcp_force i) (send s :buffer) (send s :count) :double) (incf (stream-count s) 8)
)
;; float64[] _tool_vector
(write-long (length _tool_vector) s)
(dotimes (i (length _tool_vector))
(sys::poke (elt _tool_vector i) (send s :buffer) (send s :count) :double) (incf (stream-count s) 8)
)
;; float64[] _tcp_speed
(write-long (length _tcp_speed) s)
(dotimes (i (length _tcp_speed))
(sys::poke (elt _tcp_speed i) (send s :buffer) (send s :count) :double) (incf (stream-count s) 8)
)
;; float64 _digital_input_bits
(sys::poke _digital_input_bits (send s :buffer) (send s :count) :double) (incf (stream-count s) 8)
;; float64[] _motor_temperatures
(write-long (length _motor_temperatures) s)
(dotimes (i (length _motor_temperatures))
(sys::poke (elt _motor_temperatures i) (send s :buffer) (send s :count) :double) (incf (stream-count s) 8)
)
;; float64 _controller_timer
(sys::poke _controller_timer (send s :buffer) (send s :count) :double) (incf (stream-count s) 8)
;; float64 _test_value
(sys::poke _test_value (send s :buffer) (send s :count) :double) (incf (stream-count s) 8)
;; float64 _robot_mode
(sys::poke _robot_mode (send s :buffer) (send s :count) :double) (incf (stream-count s) 8)
;; float64[] _joint_modes
(write-long (length _joint_modes) s)
(dotimes (i (length _joint_modes))
(sys::poke (elt _joint_modes i) (send s :buffer) (send s :count) :double) (incf (stream-count s) 8)
)
;;
(if (null strm) (get-output-stream-string s))))
(:deserialize
(buf &optional (ptr- 0))
;; float64 _time
(setq _time (sys::peek buf ptr- :double)) (incf ptr- 8)
;; float64[] _q_target
(let (n)
(setq n (sys::peek buf ptr- :integer)) (incf ptr- 4)
(setq _q_target (instantiate float-vector n))
(dotimes (i n)
(setf (elt _q_target i) (sys::peek buf ptr- :double)) (incf ptr- 8)
))
;; float64[] _qd_target
(let (n)
(setq n (sys::peek buf ptr- :integer)) (incf ptr- 4)
(setq _qd_target (instantiate float-vector n))
(dotimes (i n)
(setf (elt _qd_target i) (sys::peek buf ptr- :double)) (incf ptr- 8)
))
;; float64[] _qdd_target
(let (n)
(setq n (sys::peek buf ptr- :integer)) (incf ptr- 4)
(setq _qdd_target (instantiate float-vector n))
(dotimes (i n)
(setf (elt _qdd_target i) (sys::peek buf ptr- :double)) (incf ptr- 8)
))
;; float64[] _i_target
(let (n)
(setq n (sys::peek buf ptr- :integer)) (incf ptr- 4)
(setq _i_target (instantiate float-vector n))
(dotimes (i n)
(setf (elt _i_target i) (sys::peek buf ptr- :double)) (incf ptr- 8)
))
;; float64[] _m_target
(let (n)
(setq n (sys::peek buf ptr- :integer)) (incf ptr- 4)
(setq _m_target (instantiate float-vector n))
(dotimes (i n)
(setf (elt _m_target i) (sys::peek buf ptr- :double)) (incf ptr- 8)
))
;; float64[] _q_actual
(let (n)
(setq n (sys::peek buf ptr- :integer)) (incf ptr- 4)
(setq _q_actual (instantiate float-vector n))
(dotimes (i n)
(setf (elt _q_actual i) (sys::peek buf ptr- :double)) (incf ptr- 8)
))
;; float64[] _qd_actual
(let (n)
(setq n (sys::peek buf ptr- :integer)) (incf ptr- 4)
(setq _qd_actual (instantiate float-vector n))
(dotimes (i n)
(setf (elt _qd_actual i) (sys::peek buf ptr- :double)) (incf ptr- 8)
))
;; float64[] _i_actual
(let (n)
(setq n (sys::peek buf ptr- :integer)) (incf ptr- 4)
(setq _i_actual (instantiate float-vector n))
(dotimes (i n)
(setf (elt _i_actual i) (sys::peek buf ptr- :double)) (incf ptr- 8)
))
;; float64[] _tool_acc_values
(let (n)
(setq n (sys::peek buf ptr- :integer)) (incf ptr- 4)
(setq _tool_acc_values (instantiate float-vector n))
(dotimes (i n)
(setf (elt _tool_acc_values i) (sys::peek buf ptr- :double)) (incf ptr- 8)
))
;; float64[] _tcp_force
(let (n)
(setq n (sys::peek buf ptr- :integer)) (incf ptr- 4)
(setq _tcp_force (instantiate float-vector n))
(dotimes (i n)
(setf (elt _tcp_force i) (sys::peek buf ptr- :double)) (incf ptr- 8)
))
;; float64[] _tool_vector
(let (n)
(setq n (sys::peek buf ptr- :integer)) (incf ptr- 4)
(setq _tool_vector (instantiate float-vector n))
(dotimes (i n)
(setf (elt _tool_vector i) (sys::peek buf ptr- :double)) (incf ptr- 8)
))
;; float64[] _tcp_speed
(let (n)
(setq n (sys::peek buf ptr- :integer)) (incf ptr- 4)
(setq _tcp_speed (instantiate float-vector n))
(dotimes (i n)
(setf (elt _tcp_speed i) (sys::peek buf ptr- :double)) (incf ptr- 8)
))
;; float64 _digital_input_bits
(setq _digital_input_bits (sys::peek buf ptr- :double)) (incf ptr- 8)
;; float64[] _motor_temperatures
(let (n)
(setq n (sys::peek buf ptr- :integer)) (incf ptr- 4)
(setq _motor_temperatures (instantiate float-vector n))
(dotimes (i n)
(setf (elt _motor_temperatures i) (sys::peek buf ptr- :double)) (incf ptr- 8)
))
;; float64 _controller_timer
(setq _controller_timer (sys::peek buf ptr- :double)) (incf ptr- 8)
;; float64 _test_value
(setq _test_value (sys::peek buf ptr- :double)) (incf ptr- 8)
;; float64 _robot_mode
(setq _robot_mode (sys::peek buf ptr- :double)) (incf ptr- 8)
;; float64[] _joint_modes
(let (n)
(setq n (sys::peek buf ptr- :integer)) (incf ptr- 4)
(setq _joint_modes (instantiate float-vector n))
(dotimes (i n)
(setf (elt _joint_modes i) (sys::peek buf ptr- :double)) (incf ptr- 8)
))
;;
self)
)
(setf (get ur_msgs::RobotStateRTMsg :md5sum-) "ce6feddd3ccb4ca7dbcd0ff105b603c7")
(setf (get ur_msgs::RobotStateRTMsg :datatype-) "ur_msgs/RobotStateRTMsg")
(setf (get ur_msgs::RobotStateRTMsg :definition-)
"# Data structure for the realtime communications interface (aka Matlab interface)
# used by the Universal Robots controller
#
# This data structure is send at 125 Hz on TCP port 30003
#
# Dokumentation can be found on the Universal Robots Support Wiki
# (http://wiki03.lynero.net/Technical/RealTimeClientInterface?rev=9)
float64 time
float64[] q_target
float64[] qd_target
float64[] qdd_target
float64[] i_target
float64[] m_target
float64[] q_actual
float64[] qd_actual
float64[] i_actual
float64[] tool_acc_values
float64[] tcp_force
float64[] tool_vector
float64[] tcp_speed
float64 digital_input_bits
float64[] motor_temperatures
float64 controller_timer
float64 test_value
float64 robot_mode
float64[] joint_modes
")
(provide :ur_msgs/RobotStateRTMsg "ce6feddd3ccb4ca7dbcd0ff105b603c7")

187
devel/share/roseus/ros/ur_msgs/msg/ToolDataMsg.l Normal file
View File

@@ -0,0 +1,187 @@
;; Auto-generated. Do not edit!
(when (boundp 'ur_msgs::ToolDataMsg)
(if (not (find-package "UR_MSGS"))
(make-package "UR_MSGS"))
(shadow 'ToolDataMsg (find-package "UR_MSGS")))
(unless (find-package "UR_MSGS::TOOLDATAMSG")
(make-package "UR_MSGS::TOOLDATAMSG"))
(in-package "ROS")
;;//! \htmlinclude ToolDataMsg.msg.html
(intern "*ANALOG_INPUT_RANGE_CURRENT*" (find-package "UR_MSGS::TOOLDATAMSG"))
(shadow '*ANALOG_INPUT_RANGE_CURRENT* (find-package "UR_MSGS::TOOLDATAMSG"))
(defconstant ur_msgs::ToolDataMsg::*ANALOG_INPUT_RANGE_CURRENT* 0)
(intern "*ANALOG_INPUT_RANGE_VOLTAGE*" (find-package "UR_MSGS::TOOLDATAMSG"))
(shadow '*ANALOG_INPUT_RANGE_VOLTAGE* (find-package "UR_MSGS::TOOLDATAMSG"))
(defconstant ur_msgs::ToolDataMsg::*ANALOG_INPUT_RANGE_VOLTAGE* 1)
(intern "*TOOL_BOOTLOADER_MODE*" (find-package "UR_MSGS::TOOLDATAMSG"))
(shadow '*TOOL_BOOTLOADER_MODE* (find-package "UR_MSGS::TOOLDATAMSG"))
(defconstant ur_msgs::ToolDataMsg::*TOOL_BOOTLOADER_MODE* 249)
(intern "*TOOL_RUNNING_MODE*" (find-package "UR_MSGS::TOOLDATAMSG"))
(shadow '*TOOL_RUNNING_MODE* (find-package "UR_MSGS::TOOLDATAMSG"))
(defconstant ur_msgs::ToolDataMsg::*TOOL_RUNNING_MODE* 253)
(intern "*TOOL_IDLE_MODE*" (find-package "UR_MSGS::TOOLDATAMSG"))
(shadow '*TOOL_IDLE_MODE* (find-package "UR_MSGS::TOOLDATAMSG"))
(defconstant ur_msgs::ToolDataMsg::*TOOL_IDLE_MODE* 255)
(defclass ur_msgs::ToolDataMsg
:super ros::object
:slots (_analog_input_range2 _analog_input_range3 _analog_input2 _analog_input3 _tool_voltage_48v _tool_output_voltage _tool_current _tool_temperature _tool_mode ))
(defmethod ur_msgs::ToolDataMsg
(:init
(&key
((:analog_input_range2 __analog_input_range2) 0)
((:analog_input_range3 __analog_input_range3) 0)
((:analog_input2 __analog_input2) 0.0)
((:analog_input3 __analog_input3) 0.0)
((:tool_voltage_48v __tool_voltage_48v) 0.0)
((:tool_output_voltage __tool_output_voltage) 0)
((:tool_current __tool_current) 0.0)
((:tool_temperature __tool_temperature) 0.0)
((:tool_mode __tool_mode) 0)
)
(send-super :init)
(setq _analog_input_range2 (round __analog_input_range2))
(setq _analog_input_range3 (round __analog_input_range3))
(setq _analog_input2 (float __analog_input2))
(setq _analog_input3 (float __analog_input3))
(setq _tool_voltage_48v (float __tool_voltage_48v))
(setq _tool_output_voltage (round __tool_output_voltage))
(setq _tool_current (float __tool_current))
(setq _tool_temperature (float __tool_temperature))
(setq _tool_mode (round __tool_mode))
self)
(:analog_input_range2
(&optional __analog_input_range2)
(if __analog_input_range2 (setq _analog_input_range2 __analog_input_range2)) _analog_input_range2)
(:analog_input_range3
(&optional __analog_input_range3)
(if __analog_input_range3 (setq _analog_input_range3 __analog_input_range3)) _analog_input_range3)
(:analog_input2
(&optional __analog_input2)
(if __analog_input2 (setq _analog_input2 __analog_input2)) _analog_input2)
(:analog_input3
(&optional __analog_input3)
(if __analog_input3 (setq _analog_input3 __analog_input3)) _analog_input3)
(:tool_voltage_48v
(&optional __tool_voltage_48v)
(if __tool_voltage_48v (setq _tool_voltage_48v __tool_voltage_48v)) _tool_voltage_48v)
(:tool_output_voltage
(&optional __tool_output_voltage)
(if __tool_output_voltage (setq _tool_output_voltage __tool_output_voltage)) _tool_output_voltage)
(:tool_current
(&optional __tool_current)
(if __tool_current (setq _tool_current __tool_current)) _tool_current)
(:tool_temperature
(&optional __tool_temperature)
(if __tool_temperature (setq _tool_temperature __tool_temperature)) _tool_temperature)
(:tool_mode
(&optional __tool_mode)
(if __tool_mode (setq _tool_mode __tool_mode)) _tool_mode)
(:serialization-length
()
(+
;; int8 _analog_input_range2
1
;; int8 _analog_input_range3
1
;; float64 _analog_input2
8
;; float64 _analog_input3
8
;; float32 _tool_voltage_48v
4
;; uint8 _tool_output_voltage
1
;; float32 _tool_current
4
;; float32 _tool_temperature
4
;; uint8 _tool_mode
1
))
(:serialize
(&optional strm)
(let ((s (if strm strm
(make-string-output-stream (send self :serialization-length)))))
;; int8 _analog_input_range2
(write-byte _analog_input_range2 s)
;; int8 _analog_input_range3
(write-byte _analog_input_range3 s)
;; float64 _analog_input2
(sys::poke _analog_input2 (send s :buffer) (send s :count) :double) (incf (stream-count s) 8)
;; float64 _analog_input3
(sys::poke _analog_input3 (send s :buffer) (send s :count) :double) (incf (stream-count s) 8)
;; float32 _tool_voltage_48v
(sys::poke _tool_voltage_48v (send s :buffer) (send s :count) :float) (incf (stream-count s) 4)
;; uint8 _tool_output_voltage
(write-byte _tool_output_voltage s)
;; float32 _tool_current
(sys::poke _tool_current (send s :buffer) (send s :count) :float) (incf (stream-count s) 4)
;; float32 _tool_temperature
(sys::poke _tool_temperature (send s :buffer) (send s :count) :float) (incf (stream-count s) 4)
;; uint8 _tool_mode
(write-byte _tool_mode s)
;;
(if (null strm) (get-output-stream-string s))))
(:deserialize
(buf &optional (ptr- 0))
;; int8 _analog_input_range2
(setq _analog_input_range2 (sys::peek buf ptr- :char)) (incf ptr- 1)
(if (> _analog_input_range2 127) (setq _analog_input_range2 (- _analog_input_range2 256)))
;; int8 _analog_input_range3
(setq _analog_input_range3 (sys::peek buf ptr- :char)) (incf ptr- 1)
(if (> _analog_input_range3 127) (setq _analog_input_range3 (- _analog_input_range3 256)))
;; float64 _analog_input2
(setq _analog_input2 (sys::peek buf ptr- :double)) (incf ptr- 8)
;; float64 _analog_input3
(setq _analog_input3 (sys::peek buf ptr- :double)) (incf ptr- 8)
;; float32 _tool_voltage_48v
(setq _tool_voltage_48v (sys::peek buf ptr- :float)) (incf ptr- 4)
;; uint8 _tool_output_voltage
(setq _tool_output_voltage (sys::peek buf ptr- :char)) (incf ptr- 1)
;; float32 _tool_current
(setq _tool_current (sys::peek buf ptr- :float)) (incf ptr- 4)
;; float32 _tool_temperature
(setq _tool_temperature (sys::peek buf ptr- :float)) (incf ptr- 4)
;; uint8 _tool_mode
(setq _tool_mode (sys::peek buf ptr- :char)) (incf ptr- 1)
;;
self)
)
(setf (get ur_msgs::ToolDataMsg :md5sum-) "404fc266f37d89f75b372d12fa94a122")
(setf (get ur_msgs::ToolDataMsg :datatype-) "ur_msgs/ToolDataMsg")
(setf (get ur_msgs::ToolDataMsg :definition-)
"# This data structure contains the ToolData structure
# used by the Universal Robots controller
int8 ANALOG_INPUT_RANGE_CURRENT = 0
int8 ANALOG_INPUT_RANGE_VOLTAGE = 1
int8 analog_input_range2 # one of ANALOG_INPUT_RANGE_*
int8 analog_input_range3 # one of ANALOG_INPUT_RANGE_*
float64 analog_input2
float64 analog_input3
float32 tool_voltage_48v
uint8 tool_output_voltage
float32 tool_current
float32 tool_temperature
uint8 TOOL_BOOTLOADER_MODE = 249
uint8 TOOL_RUNNING_MODE = 253
uint8 TOOL_IDLE_MODE = 255
uint8 tool_mode # one of TOOL_*
")
(provide :ur_msgs/ToolDataMsg "404fc266f37d89f75b372d12fa94a122")