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

239
devel/share/gennodejs/ros/jog_msgs/msg/JogFrame.js Normal file
View File

@@ -0,0 +1,239 @@
// Auto-generated. Do not edit!
// (in-package jog_msgs.msg)
"use strict";
const _serializer = _ros_msg_utils.Serialize;
const _arraySerializer = _serializer.Array;
const _deserializer = _ros_msg_utils.Deserialize;
const _arrayDeserializer = _deserializer.Array;
const _finder = _ros_msg_utils.Find;
const _getByteLength = _ros_msg_utils.getByteLength;
let geometry_msgs = _finder('geometry_msgs');
let std_msgs = _finder('std_msgs');
//-----------------------------------------------------------
class JogFrame {
constructor(initObj={}) {
if (initObj === null) {
// initObj === null is a special case for deserialization where we don't initialize fields
this.header = null;
this.group_name = null;
this.link_name = null;
this.linear_delta = null;
this.angular_delta = null;
this.avoid_collisions = null;
}
else {
if (initObj.hasOwnProperty('header')) {
this.header = initObj.header
}
else {
this.header = new std_msgs.msg.Header();
}
if (initObj.hasOwnProperty('group_name')) {
this.group_name = initObj.group_name
}
else {
this.group_name = '';
}
if (initObj.hasOwnProperty('link_name')) {
this.link_name = initObj.link_name
}
else {
this.link_name = '';
}
if (initObj.hasOwnProperty('linear_delta')) {
this.linear_delta = initObj.linear_delta
}
else {
this.linear_delta = new geometry_msgs.msg.Vector3();
}
if (initObj.hasOwnProperty('angular_delta')) {
this.angular_delta = initObj.angular_delta
}
else {
this.angular_delta = new geometry_msgs.msg.Vector3();
}
if (initObj.hasOwnProperty('avoid_collisions')) {
this.avoid_collisions = initObj.avoid_collisions
}
else {
this.avoid_collisions = false;
}
}
}
static serialize(obj, buffer, bufferOffset) {
// Serializes a message object of type JogFrame
// Serialize message field [header]
bufferOffset = std_msgs.msg.Header.serialize(obj.header, buffer, bufferOffset);
// Serialize message field [group_name]
bufferOffset = _serializer.string(obj.group_name, buffer, bufferOffset);
// Serialize message field [link_name]
bufferOffset = _serializer.string(obj.link_name, buffer, bufferOffset);
// Serialize message field [linear_delta]
bufferOffset = geometry_msgs.msg.Vector3.serialize(obj.linear_delta, buffer, bufferOffset);
// Serialize message field [angular_delta]
bufferOffset = geometry_msgs.msg.Vector3.serialize(obj.angular_delta, buffer, bufferOffset);
// Serialize message field [avoid_collisions]
bufferOffset = _serializer.bool(obj.avoid_collisions, buffer, bufferOffset);
return bufferOffset;
}
static deserialize(buffer, bufferOffset=[0]) {
//deserializes a message object of type JogFrame
let len;
let data = new JogFrame(null);
// Deserialize message field [header]
data.header = std_msgs.msg.Header.deserialize(buffer, bufferOffset);
// Deserialize message field [group_name]
data.group_name = _deserializer.string(buffer, bufferOffset);
// Deserialize message field [link_name]
data.link_name = _deserializer.string(buffer, bufferOffset);
// Deserialize message field [linear_delta]
data.linear_delta = geometry_msgs.msg.Vector3.deserialize(buffer, bufferOffset);
// Deserialize message field [angular_delta]
data.angular_delta = geometry_msgs.msg.Vector3.deserialize(buffer, bufferOffset);
// Deserialize message field [avoid_collisions]
data.avoid_collisions = _deserializer.bool(buffer, bufferOffset);
return data;
}
static getMessageSize(object) {
let length = 0;
length += std_msgs.msg.Header.getMessageSize(object.header);
length += object.group_name.length;
length += object.link_name.length;
return length + 57;
}
static datatype() {
// Returns string type for a message object
return 'jog_msgs/JogFrame';
}
static md5sum() {
//Returns md5sum for a message object
return 'e342f29bf6beaf00261bdae365abfff9';
}
static messageDefinition() {
// Returns full string definition for message
return `
# This is a message to hold data to jog by specifying a target
# frame. It uses MoveIt! kinematics, so you need to specify the
# JointGroup name to use in group_name. (lienar|angular)_delta is the
# amount of displacement.
# header message. You must set frame_id to define the reference
# coordinate system of the displacament
Header header
# Name of JointGroup of MoveIt!
string group_name
# Target link name to jog. The link must be in the JoingGroup
string link_name
# Linear displacement vector to jog. The refrence frame is defined by
# frame_id in header. Unit is in meter.
geometry_msgs/Vector3 linear_delta
# Angular displacement vector to jog. The refrence frame is defined by
# frame_id in header. Unit is in radian.
geometry_msgs/Vector3 angular_delta
# It uses avoid_collisions option of MoveIt! kinematics. If it is
# true, the robot doesn't move if any collisions occured.
bool avoid_collisions
================================================================================
MSG: std_msgs/Header
# Standard metadata for higher-level stamped data types.
# This is generally used to communicate timestamped data
# in a particular coordinate frame.
#
# sequence ID: consecutively increasing ID
uint32 seq
#Two-integer timestamp that is expressed as:
# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')
# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')
# time-handling sugar is provided by the client library
time stamp
#Frame this data is associated with
# 0: no frame
# 1: global frame
string frame_id
================================================================================
MSG: geometry_msgs/Vector3
# This represents a vector in free space.
# It is only meant to represent a direction. Therefore, it does not
# make sense to apply a translation to it (e.g., when applying a
# generic rigid transformation to a Vector3, tf2 will only apply the
# rotation). If you want your data to be translatable too, use the
# geometry_msgs/Point message instead.
float64 x
float64 y
float64 z
`;
}
static Resolve(msg) {
// deep-construct a valid message object instance of whatever was passed in
if (typeof msg !== 'object' || msg === null) {
msg = {};
}
const resolved = new JogFrame(null);
if (msg.header !== undefined) {
resolved.header = std_msgs.msg.Header.Resolve(msg.header)
}
else {
resolved.header = new std_msgs.msg.Header()
}
if (msg.group_name !== undefined) {
resolved.group_name = msg.group_name;
}
else {
resolved.group_name = ''
}
if (msg.link_name !== undefined) {
resolved.link_name = msg.link_name;
}
else {
resolved.link_name = ''
}
if (msg.linear_delta !== undefined) {
resolved.linear_delta = geometry_msgs.msg.Vector3.Resolve(msg.linear_delta)
}
else {
resolved.linear_delta = new geometry_msgs.msg.Vector3()
}
if (msg.angular_delta !== undefined) {
resolved.angular_delta = geometry_msgs.msg.Vector3.Resolve(msg.angular_delta)
}
else {
resolved.angular_delta = new geometry_msgs.msg.Vector3()
}
if (msg.avoid_collisions !== undefined) {
resolved.avoid_collisions = msg.avoid_collisions;
}
else {
resolved.avoid_collisions = false
}
return resolved;
}
};
module.exports = JogFrame;

164
devel/share/gennodejs/ros/jog_msgs/msg/JogJoint.js Normal file
View File

@@ -0,0 +1,164 @@
// Auto-generated. Do not edit!
// (in-package jog_msgs.msg)
"use strict";
const _serializer = _ros_msg_utils.Serialize;
const _arraySerializer = _serializer.Array;
const _deserializer = _ros_msg_utils.Deserialize;
const _arrayDeserializer = _deserializer.Array;
const _finder = _ros_msg_utils.Find;
const _getByteLength = _ros_msg_utils.getByteLength;
let std_msgs = _finder('std_msgs');
//-----------------------------------------------------------
class JogJoint {
constructor(initObj={}) {
if (initObj === null) {
// initObj === null is a special case for deserialization where we don't initialize fields
this.header = null;
this.joint_names = null;
this.deltas = null;
}
else {
if (initObj.hasOwnProperty('header')) {
this.header = initObj.header
}
else {
this.header = new std_msgs.msg.Header();
}
if (initObj.hasOwnProperty('joint_names')) {
this.joint_names = initObj.joint_names
}
else {
this.joint_names = [];
}
if (initObj.hasOwnProperty('deltas')) {
this.deltas = initObj.deltas
}
else {
this.deltas = [];
}
}
}
static serialize(obj, buffer, bufferOffset) {
// Serializes a message object of type JogJoint
// Serialize message field [header]
bufferOffset = std_msgs.msg.Header.serialize(obj.header, buffer, bufferOffset);
// Serialize message field [joint_names]
bufferOffset = _arraySerializer.string(obj.joint_names, buffer, bufferOffset, null);
// Serialize message field [deltas]
bufferOffset = _arraySerializer.float64(obj.deltas, buffer, bufferOffset, null);
return bufferOffset;
}
static deserialize(buffer, bufferOffset=[0]) {
//deserializes a message object of type JogJoint
let len;
let data = new JogJoint(null);
// Deserialize message field [header]
data.header = std_msgs.msg.Header.deserialize(buffer, bufferOffset);
// Deserialize message field [joint_names]
data.joint_names = _arrayDeserializer.string(buffer, bufferOffset, null)
// Deserialize message field [deltas]
data.deltas = _arrayDeserializer.float64(buffer, bufferOffset, null)
return data;
}
static getMessageSize(object) {
let length = 0;
length += std_msgs.msg.Header.getMessageSize(object.header);
object.joint_names.forEach((val) => {
length += 4 + val.length;
});
length += 8 * object.deltas.length;
return length + 8;
}
static datatype() {
// Returns string type for a message object
return 'jog_msgs/JogJoint';
}
static md5sum() {
//Returns md5sum for a message object
return '8d2aa14be64b51cf6374d198bfd489b2';
}
static messageDefinition() {
// Returns full string definition for message
return `
# This is a message to hold data to jog by specifying joint
# displacement. You only need to set relative displacement to joint
# angles (or displacements for linear joints).
# header message. You must set frame_id to define the reference
# coordinate system of the displacament
Header header
# Name list of the joints. You don't need to specify all joint of the
# robot. Joint names are case-sensitive.
string[] joint_names
# Relative displacement of the joints to jog. The order must be
# identical to joint_names. Unit is in radian for revolutive joints,
# meter for linear joints.
float64[] deltas
================================================================================
MSG: std_msgs/Header
# Standard metadata for higher-level stamped data types.
# This is generally used to communicate timestamped data
# in a particular coordinate frame.
#
# sequence ID: consecutively increasing ID
uint32 seq
#Two-integer timestamp that is expressed as:
# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')
# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')
# time-handling sugar is provided by the client library
time stamp
#Frame this data is associated with
# 0: no frame
# 1: global frame
string frame_id
`;
}
static Resolve(msg) {
// deep-construct a valid message object instance of whatever was passed in
if (typeof msg !== 'object' || msg === null) {
msg = {};
}
const resolved = new JogJoint(null);
if (msg.header !== undefined) {
resolved.header = std_msgs.msg.Header.Resolve(msg.header)
}
else {
resolved.header = new std_msgs.msg.Header()
}
if (msg.joint_names !== undefined) {
resolved.joint_names = msg.joint_names;
}
else {
resolved.joint_names = []
}
if (msg.deltas !== undefined) {
resolved.deltas = msg.deltas;
}
else {
resolved.deltas = []
}
return resolved;
}
};
module.exports = JogJoint;

135
devel/share/gennodejs/ros/ur_msgs/msg/Analog.js Normal file
View File

@@ -0,0 +1,135 @@
// Auto-generated. Do not edit!
// (in-package ur_msgs.msg)
"use strict";
const _serializer = _ros_msg_utils.Serialize;
const _arraySerializer = _serializer.Array;
const _deserializer = _ros_msg_utils.Deserialize;
const _arrayDeserializer = _deserializer.Array;
const _finder = _ros_msg_utils.Find;
const _getByteLength = _ros_msg_utils.getByteLength;
//-----------------------------------------------------------
class Analog {
constructor(initObj={}) {
if (initObj === null) {
// initObj === null is a special case for deserialization where we don't initialize fields
this.pin = null;
this.domain = null;
this.state = null;
}
else {
if (initObj.hasOwnProperty('pin')) {
this.pin = initObj.pin
}
else {
this.pin = 0;
}
if (initObj.hasOwnProperty('domain')) {
this.domain = initObj.domain
}
else {
this.domain = 0;
}
if (initObj.hasOwnProperty('state')) {
this.state = initObj.state
}
else {
this.state = 0.0;
}
}
}
static serialize(obj, buffer, bufferOffset) {
// Serializes a message object of type Analog
// Serialize message field [pin]
bufferOffset = _serializer.uint8(obj.pin, buffer, bufferOffset);
// Serialize message field [domain]
bufferOffset = _serializer.uint8(obj.domain, buffer, bufferOffset);
// Serialize message field [state]
bufferOffset = _serializer.float32(obj.state, buffer, bufferOffset);
return bufferOffset;
}
static deserialize(buffer, bufferOffset=[0]) {
//deserializes a message object of type Analog
let len;
let data = new Analog(null);
// Deserialize message field [pin]
data.pin = _deserializer.uint8(buffer, bufferOffset);
// Deserialize message field [domain]
data.domain = _deserializer.uint8(buffer, bufferOffset);
// Deserialize message field [state]
data.state = _deserializer.float32(buffer, bufferOffset);
return data;
}
static getMessageSize(object) {
return 6;
}
static datatype() {
// Returns string type for a message object
return 'ur_msgs/Analog';
}
static md5sum() {
//Returns md5sum for a message object
return 'f41c08a810adf63713aec88712cd553d';
}
static messageDefinition() {
// Returns full string definition for message
return `
uint8 VOLTAGE=0
uint8 CURRENT=1
uint8 pin
uint8 domain # can be VOLTAGE or CURRENT
float32 state
`;
}
static Resolve(msg) {
// deep-construct a valid message object instance of whatever was passed in
if (typeof msg !== 'object' || msg === null) {
msg = {};
}
const resolved = new Analog(null);
if (msg.pin !== undefined) {
resolved.pin = msg.pin;
}
else {
resolved.pin = 0
}
if (msg.domain !== undefined) {
resolved.domain = msg.domain;
}
else {
resolved.domain = 0
}
if (msg.state !== undefined) {
resolved.state = msg.state;
}
else {
resolved.state = 0.0
}
return resolved;
}
};
// Constants for message
Analog.Constants = {
VOLTAGE: 0,
CURRENT: 1,
}
module.exports = Analog;

107
devel/share/gennodejs/ros/ur_msgs/msg/Digital.js Normal file
View File

@@ -0,0 +1,107 @@
// Auto-generated. Do not edit!
// (in-package ur_msgs.msg)
"use strict";
const _serializer = _ros_msg_utils.Serialize;
const _arraySerializer = _serializer.Array;
const _deserializer = _ros_msg_utils.Deserialize;
const _arrayDeserializer = _deserializer.Array;
const _finder = _ros_msg_utils.Find;
const _getByteLength = _ros_msg_utils.getByteLength;
//-----------------------------------------------------------
class Digital {
constructor(initObj={}) {
if (initObj === null) {
// initObj === null is a special case for deserialization where we don't initialize fields
this.pin = null;
this.state = null;
}
else {
if (initObj.hasOwnProperty('pin')) {
this.pin = initObj.pin
}
else {
this.pin = 0;
}
if (initObj.hasOwnProperty('state')) {
this.state = initObj.state
}
else {
this.state = false;
}
}
}
static serialize(obj, buffer, bufferOffset) {
// Serializes a message object of type Digital
// Serialize message field [pin]
bufferOffset = _serializer.uint8(obj.pin, buffer, bufferOffset);
// Serialize message field [state]
bufferOffset = _serializer.bool(obj.state, buffer, bufferOffset);
return bufferOffset;
}
static deserialize(buffer, bufferOffset=[0]) {
//deserializes a message object of type Digital
let len;
let data = new Digital(null);
// Deserialize message field [pin]
data.pin = _deserializer.uint8(buffer, bufferOffset);
// Deserialize message field [state]
data.state = _deserializer.bool(buffer, bufferOffset);
return data;
}
static getMessageSize(object) {
return 2;
}
static datatype() {
// Returns string type for a message object
return 'ur_msgs/Digital';
}
static md5sum() {
//Returns md5sum for a message object
return '83707be3fa18d2ffe57381ea034aa262';
}
static messageDefinition() {
// Returns full string definition for message
return `
uint8 pin
bool state
`;
}
static Resolve(msg) {
// deep-construct a valid message object instance of whatever was passed in
if (typeof msg !== 'object' || msg === null) {
msg = {};
}
const resolved = new Digital(null);
if (msg.pin !== undefined) {
resolved.pin = msg.pin;
}
else {
resolved.pin = 0
}
if (msg.state !== undefined) {
resolved.state = msg.state;
}
else {
resolved.state = false
}
return resolved;
}
};
module.exports = Digital;

246
devel/share/gennodejs/ros/ur_msgs/msg/IOStates.js Normal file
View File

@@ -0,0 +1,246 @@
// Auto-generated. Do not edit!
// (in-package ur_msgs.msg)
"use strict";
const _serializer = _ros_msg_utils.Serialize;
const _arraySerializer = _serializer.Array;
const _deserializer = _ros_msg_utils.Deserialize;
const _arrayDeserializer = _deserializer.Array;
const _finder = _ros_msg_utils.Find;
const _getByteLength = _ros_msg_utils.getByteLength;
let Digital = require('./Digital.js');
let Analog = require('./Analog.js');
//-----------------------------------------------------------
class IOStates {
constructor(initObj={}) {
if (initObj === null) {
// initObj === null is a special case for deserialization where we don't initialize fields
this.digital_in_states = null;
this.digital_out_states = null;
this.flag_states = null;
this.analog_in_states = null;
this.analog_out_states = null;
}
else {
if (initObj.hasOwnProperty('digital_in_states')) {
this.digital_in_states = initObj.digital_in_states
}
else {
this.digital_in_states = [];
}
if (initObj.hasOwnProperty('digital_out_states')) {
this.digital_out_states = initObj.digital_out_states
}
else {
this.digital_out_states = [];
}
if (initObj.hasOwnProperty('flag_states')) {
this.flag_states = initObj.flag_states
}
else {
this.flag_states = [];
}
if (initObj.hasOwnProperty('analog_in_states')) {
this.analog_in_states = initObj.analog_in_states
}
else {
this.analog_in_states = [];
}
if (initObj.hasOwnProperty('analog_out_states')) {
this.analog_out_states = initObj.analog_out_states
}
else {
this.analog_out_states = [];
}
}
}
static serialize(obj, buffer, bufferOffset) {
// Serializes a message object of type IOStates
// Serialize message field [digital_in_states]
// Serialize the length for message field [digital_in_states]
bufferOffset = _serializer.uint32(obj.digital_in_states.length, buffer, bufferOffset);
obj.digital_in_states.forEach((val) => {
bufferOffset = Digital.serialize(val, buffer, bufferOffset);
});
// Serialize message field [digital_out_states]
// Serialize the length for message field [digital_out_states]
bufferOffset = _serializer.uint32(obj.digital_out_states.length, buffer, bufferOffset);
obj.digital_out_states.forEach((val) => {
bufferOffset = Digital.serialize(val, buffer, bufferOffset);
});
// Serialize message field [flag_states]
// Serialize the length for message field [flag_states]
bufferOffset = _serializer.uint32(obj.flag_states.length, buffer, bufferOffset);
obj.flag_states.forEach((val) => {
bufferOffset = Digital.serialize(val, buffer, bufferOffset);
});
// Serialize message field [analog_in_states]
// Serialize the length for message field [analog_in_states]
bufferOffset = _serializer.uint32(obj.analog_in_states.length, buffer, bufferOffset);
obj.analog_in_states.forEach((val) => {
bufferOffset = Analog.serialize(val, buffer, bufferOffset);
});
// Serialize message field [analog_out_states]
// Serialize the length for message field [analog_out_states]
bufferOffset = _serializer.uint32(obj.analog_out_states.length, buffer, bufferOffset);
obj.analog_out_states.forEach((val) => {
bufferOffset = Analog.serialize(val, buffer, bufferOffset);
});
return bufferOffset;
}
static deserialize(buffer, bufferOffset=[0]) {
//deserializes a message object of type IOStates
let len;
let data = new IOStates(null);
// Deserialize message field [digital_in_states]
// Deserialize array length for message field [digital_in_states]
len = _deserializer.uint32(buffer, bufferOffset);
data.digital_in_states = new Array(len);
for (let i = 0; i < len; ++i) {
data.digital_in_states[i] = Digital.deserialize(buffer, bufferOffset)
}
// Deserialize message field [digital_out_states]
// Deserialize array length for message field [digital_out_states]
len = _deserializer.uint32(buffer, bufferOffset);
data.digital_out_states = new Array(len);
for (let i = 0; i < len; ++i) {
data.digital_out_states[i] = Digital.deserialize(buffer, bufferOffset)
}
// Deserialize message field [flag_states]
// Deserialize array length for message field [flag_states]
len = _deserializer.uint32(buffer, bufferOffset);
data.flag_states = new Array(len);
for (let i = 0; i < len; ++i) {
data.flag_states[i] = Digital.deserialize(buffer, bufferOffset)
}
// Deserialize message field [analog_in_states]
// Deserialize array length for message field [analog_in_states]
len = _deserializer.uint32(buffer, bufferOffset);
data.analog_in_states = new Array(len);
for (let i = 0; i < len; ++i) {
data.analog_in_states[i] = Analog.deserialize(buffer, bufferOffset)
}
// Deserialize message field [analog_out_states]
// Deserialize array length for message field [analog_out_states]
len = _deserializer.uint32(buffer, bufferOffset);
data.analog_out_states = new Array(len);
for (let i = 0; i < len; ++i) {
data.analog_out_states[i] = Analog.deserialize(buffer, bufferOffset)
}
return data;
}
static getMessageSize(object) {
let length = 0;
length += 2 * object.digital_in_states.length;
length += 2 * object.digital_out_states.length;
length += 2 * object.flag_states.length;
length += 6 * object.analog_in_states.length;
length += 6 * object.analog_out_states.length;
return length + 20;
}
static datatype() {
// Returns string type for a message object
return 'ur_msgs/IOStates';
}
static md5sum() {
//Returns md5sum for a message object
return '3033784e7041da89491b97cc4c1105b5';
}
static messageDefinition() {
// Returns full string definition for message
return `
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
`;
}
static Resolve(msg) {
// deep-construct a valid message object instance of whatever was passed in
if (typeof msg !== 'object' || msg === null) {
msg = {};
}
const resolved = new IOStates(null);
if (msg.digital_in_states !== undefined) {
resolved.digital_in_states = new Array(msg.digital_in_states.length);
for (let i = 0; i < resolved.digital_in_states.length; ++i) {
resolved.digital_in_states[i] = Digital.Resolve(msg.digital_in_states[i]);
}
}
else {
resolved.digital_in_states = []
}
if (msg.digital_out_states !== undefined) {
resolved.digital_out_states = new Array(msg.digital_out_states.length);
for (let i = 0; i < resolved.digital_out_states.length; ++i) {
resolved.digital_out_states[i] = Digital.Resolve(msg.digital_out_states[i]);
}
}
else {
resolved.digital_out_states = []
}
if (msg.flag_states !== undefined) {
resolved.flag_states = new Array(msg.flag_states.length);
for (let i = 0; i < resolved.flag_states.length; ++i) {
resolved.flag_states[i] = Digital.Resolve(msg.flag_states[i]);
}
}
else {
resolved.flag_states = []
}
if (msg.analog_in_states !== undefined) {
resolved.analog_in_states = new Array(msg.analog_in_states.length);
for (let i = 0; i < resolved.analog_in_states.length; ++i) {
resolved.analog_in_states[i] = Analog.Resolve(msg.analog_in_states[i]);
}
}
else {
resolved.analog_in_states = []
}
if (msg.analog_out_states !== undefined) {
resolved.analog_out_states = new Array(msg.analog_out_states.length);
for (let i = 0; i < resolved.analog_out_states.length; ++i) {
resolved.analog_out_states[i] = Analog.Resolve(msg.analog_out_states[i]);
}
}
else {
resolved.analog_out_states = []
}
return resolved;
}
};
module.exports = IOStates;

384
devel/share/gennodejs/ros/ur_msgs/msg/MasterboardDataMsg.js Normal file
View File

@@ -0,0 +1,384 @@
// Auto-generated. Do not edit!
// (in-package ur_msgs.msg)
"use strict";
const _serializer = _ros_msg_utils.Serialize;
const _arraySerializer = _serializer.Array;
const _deserializer = _ros_msg_utils.Deserialize;
const _arrayDeserializer = _deserializer.Array;
const _finder = _ros_msg_utils.Find;
const _getByteLength = _ros_msg_utils.getByteLength;
//-----------------------------------------------------------
class MasterboardDataMsg {
constructor(initObj={}) {
if (initObj === null) {
// initObj === null is a special case for deserialization where we don't initialize fields
this.digital_input_bits = null;
this.digital_output_bits = null;
this.analog_input_range0 = null;
this.analog_input_range1 = null;
this.analog_input0 = null;
this.analog_input1 = null;
this.analog_output_domain0 = null;
this.analog_output_domain1 = null;
this.analog_output0 = null;
this.analog_output1 = null;
this.masterboard_temperature = null;
this.robot_voltage_48V = null;
this.robot_current = null;
this.master_io_current = null;
this.master_safety_state = null;
this.master_onoff_state = null;
}
else {
if (initObj.hasOwnProperty('digital_input_bits')) {
this.digital_input_bits = initObj.digital_input_bits
}
else {
this.digital_input_bits = 0;
}
if (initObj.hasOwnProperty('digital_output_bits')) {
this.digital_output_bits = initObj.digital_output_bits
}
else {
this.digital_output_bits = 0;
}
if (initObj.hasOwnProperty('analog_input_range0')) {
this.analog_input_range0 = initObj.analog_input_range0
}
else {
this.analog_input_range0 = 0;
}
if (initObj.hasOwnProperty('analog_input_range1')) {
this.analog_input_range1 = initObj.analog_input_range1
}
else {
this.analog_input_range1 = 0;
}
if (initObj.hasOwnProperty('analog_input0')) {
this.analog_input0 = initObj.analog_input0
}
else {
this.analog_input0 = 0.0;
}
if (initObj.hasOwnProperty('analog_input1')) {
this.analog_input1 = initObj.analog_input1
}
else {
this.analog_input1 = 0.0;
}
if (initObj.hasOwnProperty('analog_output_domain0')) {
this.analog_output_domain0 = initObj.analog_output_domain0
}
else {
this.analog_output_domain0 = 0;
}
if (initObj.hasOwnProperty('analog_output_domain1')) {
this.analog_output_domain1 = initObj.analog_output_domain1
}
else {
this.analog_output_domain1 = 0;
}
if (initObj.hasOwnProperty('analog_output0')) {
this.analog_output0 = initObj.analog_output0
}
else {
this.analog_output0 = 0.0;
}
if (initObj.hasOwnProperty('analog_output1')) {
this.analog_output1 = initObj.analog_output1
}
else {
this.analog_output1 = 0.0;
}
if (initObj.hasOwnProperty('masterboard_temperature')) {
this.masterboard_temperature = initObj.masterboard_temperature
}
else {
this.masterboard_temperature = 0.0;
}
if (initObj.hasOwnProperty('robot_voltage_48V')) {
this.robot_voltage_48V = initObj.robot_voltage_48V
}
else {
this.robot_voltage_48V = 0.0;
}
if (initObj.hasOwnProperty('robot_current')) {
this.robot_current = initObj.robot_current
}
else {
this.robot_current = 0.0;
}
if (initObj.hasOwnProperty('master_io_current')) {
this.master_io_current = initObj.master_io_current
}
else {
this.master_io_current = 0.0;
}
if (initObj.hasOwnProperty('master_safety_state')) {
this.master_safety_state = initObj.master_safety_state
}
else {
this.master_safety_state = 0;
}
if (initObj.hasOwnProperty('master_onoff_state')) {
this.master_onoff_state = initObj.master_onoff_state
}
else {
this.master_onoff_state = 0;
}
}
}
static serialize(obj, buffer, bufferOffset) {
// Serializes a message object of type MasterboardDataMsg
// Serialize message field [digital_input_bits]
bufferOffset = _serializer.uint32(obj.digital_input_bits, buffer, bufferOffset);
// Serialize message field [digital_output_bits]
bufferOffset = _serializer.uint32(obj.digital_output_bits, buffer, bufferOffset);
// Serialize message field [analog_input_range0]
bufferOffset = _serializer.int8(obj.analog_input_range0, buffer, bufferOffset);
// Serialize message field [analog_input_range1]
bufferOffset = _serializer.int8(obj.analog_input_range1, buffer, bufferOffset);
// Serialize message field [analog_input0]
bufferOffset = _serializer.float64(obj.analog_input0, buffer, bufferOffset);
// Serialize message field [analog_input1]
bufferOffset = _serializer.float64(obj.analog_input1, buffer, bufferOffset);
// Serialize message field [analog_output_domain0]
bufferOffset = _serializer.int8(obj.analog_output_domain0, buffer, bufferOffset);
// Serialize message field [analog_output_domain1]
bufferOffset = _serializer.int8(obj.analog_output_domain1, buffer, bufferOffset);
// Serialize message field [analog_output0]
bufferOffset = _serializer.float64(obj.analog_output0, buffer, bufferOffset);
// Serialize message field [analog_output1]
bufferOffset = _serializer.float64(obj.analog_output1, buffer, bufferOffset);
// Serialize message field [masterboard_temperature]
bufferOffset = _serializer.float32(obj.masterboard_temperature, buffer, bufferOffset);
// Serialize message field [robot_voltage_48V]
bufferOffset = _serializer.float32(obj.robot_voltage_48V, buffer, bufferOffset);
// Serialize message field [robot_current]
bufferOffset = _serializer.float32(obj.robot_current, buffer, bufferOffset);
// Serialize message field [master_io_current]
bufferOffset = _serializer.float32(obj.master_io_current, buffer, bufferOffset);
// Serialize message field [master_safety_state]
bufferOffset = _serializer.uint8(obj.master_safety_state, buffer, bufferOffset);
// Serialize message field [master_onoff_state]
bufferOffset = _serializer.uint8(obj.master_onoff_state, buffer, bufferOffset);
return bufferOffset;
}
static deserialize(buffer, bufferOffset=[0]) {
//deserializes a message object of type MasterboardDataMsg
let len;
let data = new MasterboardDataMsg(null);
// Deserialize message field [digital_input_bits]
data.digital_input_bits = _deserializer.uint32(buffer, bufferOffset);
// Deserialize message field [digital_output_bits]
data.digital_output_bits = _deserializer.uint32(buffer, bufferOffset);
// Deserialize message field [analog_input_range0]
data.analog_input_range0 = _deserializer.int8(buffer, bufferOffset);
// Deserialize message field [analog_input_range1]
data.analog_input_range1 = _deserializer.int8(buffer, bufferOffset);
// Deserialize message field [analog_input0]
data.analog_input0 = _deserializer.float64(buffer, bufferOffset);
// Deserialize message field [analog_input1]
data.analog_input1 = _deserializer.float64(buffer, bufferOffset);
// Deserialize message field [analog_output_domain0]
data.analog_output_domain0 = _deserializer.int8(buffer, bufferOffset);
// Deserialize message field [analog_output_domain1]
data.analog_output_domain1 = _deserializer.int8(buffer, bufferOffset);
// Deserialize message field [analog_output0]
data.analog_output0 = _deserializer.float64(buffer, bufferOffset);
// Deserialize message field [analog_output1]
data.analog_output1 = _deserializer.float64(buffer, bufferOffset);
// Deserialize message field [masterboard_temperature]
data.masterboard_temperature = _deserializer.float32(buffer, bufferOffset);
// Deserialize message field [robot_voltage_48V]
data.robot_voltage_48V = _deserializer.float32(buffer, bufferOffset);
// Deserialize message field [robot_current]
data.robot_current = _deserializer.float32(buffer, bufferOffset);
// Deserialize message field [master_io_current]
data.master_io_current = _deserializer.float32(buffer, bufferOffset);
// Deserialize message field [master_safety_state]
data.master_safety_state = _deserializer.uint8(buffer, bufferOffset);
// Deserialize message field [master_onoff_state]
data.master_onoff_state = _deserializer.uint8(buffer, bufferOffset);
return data;
}
static getMessageSize(object) {
return 62;
}
static datatype() {
// Returns string type for a message object
return 'ur_msgs/MasterboardDataMsg';
}
static md5sum() {
//Returns md5sum for a message object
return '807af5dc427082b111fa23d1fd2cd585';
}
static messageDefinition() {
// Returns full string definition for message
return `
# 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
`;
}
static Resolve(msg) {
// deep-construct a valid message object instance of whatever was passed in
if (typeof msg !== 'object' || msg === null) {
msg = {};
}
const resolved = new MasterboardDataMsg(null);
if (msg.digital_input_bits !== undefined) {
resolved.digital_input_bits = msg.digital_input_bits;
}
else {
resolved.digital_input_bits = 0
}
if (msg.digital_output_bits !== undefined) {
resolved.digital_output_bits = msg.digital_output_bits;
}
else {
resolved.digital_output_bits = 0
}
if (msg.analog_input_range0 !== undefined) {
resolved.analog_input_range0 = msg.analog_input_range0;
}
else {
resolved.analog_input_range0 = 0
}
if (msg.analog_input_range1 !== undefined) {
resolved.analog_input_range1 = msg.analog_input_range1;
}
else {
resolved.analog_input_range1 = 0
}
if (msg.analog_input0 !== undefined) {
resolved.analog_input0 = msg.analog_input0;
}
else {
resolved.analog_input0 = 0.0
}
if (msg.analog_input1 !== undefined) {
resolved.analog_input1 = msg.analog_input1;
}
else {
resolved.analog_input1 = 0.0
}
if (msg.analog_output_domain0 !== undefined) {
resolved.analog_output_domain0 = msg.analog_output_domain0;
}
else {
resolved.analog_output_domain0 = 0
}
if (msg.analog_output_domain1 !== undefined) {
resolved.analog_output_domain1 = msg.analog_output_domain1;
}
else {
resolved.analog_output_domain1 = 0
}
if (msg.analog_output0 !== undefined) {
resolved.analog_output0 = msg.analog_output0;
}
else {
resolved.analog_output0 = 0.0
}
if (msg.analog_output1 !== undefined) {
resolved.analog_output1 = msg.analog_output1;
}
else {
resolved.analog_output1 = 0.0
}
if (msg.masterboard_temperature !== undefined) {
resolved.masterboard_temperature = msg.masterboard_temperature;
}
else {
resolved.masterboard_temperature = 0.0
}
if (msg.robot_voltage_48V !== undefined) {
resolved.robot_voltage_48V = msg.robot_voltage_48V;
}
else {
resolved.robot_voltage_48V = 0.0
}
if (msg.robot_current !== undefined) {
resolved.robot_current = msg.robot_current;
}
else {
resolved.robot_current = 0.0
}
if (msg.master_io_current !== undefined) {
resolved.master_io_current = msg.master_io_current;
}
else {
resolved.master_io_current = 0.0
}
if (msg.master_safety_state !== undefined) {
resolved.master_safety_state = msg.master_safety_state;
}
else {
resolved.master_safety_state = 0
}
if (msg.master_onoff_state !== undefined) {
resolved.master_onoff_state = msg.master_onoff_state;
}
else {
resolved.master_onoff_state = 0
}
return resolved;
}
};
module.exports = MasterboardDataMsg;

228
devel/share/gennodejs/ros/ur_msgs/msg/RobotModeDataMsg.js Normal file
View File

@@ -0,0 +1,228 @@
// Auto-generated. Do not edit!
// (in-package ur_msgs.msg)
"use strict";
const _serializer = _ros_msg_utils.Serialize;
const _arraySerializer = _serializer.Array;
const _deserializer = _ros_msg_utils.Deserialize;
const _arrayDeserializer = _deserializer.Array;
const _finder = _ros_msg_utils.Find;
const _getByteLength = _ros_msg_utils.getByteLength;
//-----------------------------------------------------------
class RobotModeDataMsg {
constructor(initObj={}) {
if (initObj === null) {
// initObj === null is a special case for deserialization where we don't initialize fields
this.timestamp = null;
this.is_robot_connected = null;
this.is_real_robot_enabled = null;
this.is_power_on_robot = null;
this.is_emergency_stopped = null;
this.is_protective_stopped = null;
this.is_program_running = null;
this.is_program_paused = null;
}
else {
if (initObj.hasOwnProperty('timestamp')) {
this.timestamp = initObj.timestamp
}
else {
this.timestamp = 0;
}
if (initObj.hasOwnProperty('is_robot_connected')) {
this.is_robot_connected = initObj.is_robot_connected
}
else {
this.is_robot_connected = false;
}
if (initObj.hasOwnProperty('is_real_robot_enabled')) {
this.is_real_robot_enabled = initObj.is_real_robot_enabled
}
else {
this.is_real_robot_enabled = false;
}
if (initObj.hasOwnProperty('is_power_on_robot')) {
this.is_power_on_robot = initObj.is_power_on_robot
}
else {
this.is_power_on_robot = false;
}
if (initObj.hasOwnProperty('is_emergency_stopped')) {
this.is_emergency_stopped = initObj.is_emergency_stopped
}
else {
this.is_emergency_stopped = false;
}
if (initObj.hasOwnProperty('is_protective_stopped')) {
this.is_protective_stopped = initObj.is_protective_stopped
}
else {
this.is_protective_stopped = false;
}
if (initObj.hasOwnProperty('is_program_running')) {
this.is_program_running = initObj.is_program_running
}
else {
this.is_program_running = false;
}
if (initObj.hasOwnProperty('is_program_paused')) {
this.is_program_paused = initObj.is_program_paused
}
else {
this.is_program_paused = false;
}
}
}
static serialize(obj, buffer, bufferOffset) {
// Serializes a message object of type RobotModeDataMsg
// Serialize message field [timestamp]
bufferOffset = _serializer.uint64(obj.timestamp, buffer, bufferOffset);
// Serialize message field [is_robot_connected]
bufferOffset = _serializer.bool(obj.is_robot_connected, buffer, bufferOffset);
// Serialize message field [is_real_robot_enabled]
bufferOffset = _serializer.bool(obj.is_real_robot_enabled, buffer, bufferOffset);
// Serialize message field [is_power_on_robot]
bufferOffset = _serializer.bool(obj.is_power_on_robot, buffer, bufferOffset);
// Serialize message field [is_emergency_stopped]
bufferOffset = _serializer.bool(obj.is_emergency_stopped, buffer, bufferOffset);
// Serialize message field [is_protective_stopped]
bufferOffset = _serializer.bool(obj.is_protective_stopped, buffer, bufferOffset);
// Serialize message field [is_program_running]
bufferOffset = _serializer.bool(obj.is_program_running, buffer, bufferOffset);
// Serialize message field [is_program_paused]
bufferOffset = _serializer.bool(obj.is_program_paused, buffer, bufferOffset);
return bufferOffset;
}
static deserialize(buffer, bufferOffset=[0]) {
//deserializes a message object of type RobotModeDataMsg
let len;
let data = new RobotModeDataMsg(null);
// Deserialize message field [timestamp]
data.timestamp = _deserializer.uint64(buffer, bufferOffset);
// Deserialize message field [is_robot_connected]
data.is_robot_connected = _deserializer.bool(buffer, bufferOffset);
// Deserialize message field [is_real_robot_enabled]
data.is_real_robot_enabled = _deserializer.bool(buffer, bufferOffset);
// Deserialize message field [is_power_on_robot]
data.is_power_on_robot = _deserializer.bool(buffer, bufferOffset);
// Deserialize message field [is_emergency_stopped]
data.is_emergency_stopped = _deserializer.bool(buffer, bufferOffset);
// Deserialize message field [is_protective_stopped]
data.is_protective_stopped = _deserializer.bool(buffer, bufferOffset);
// Deserialize message field [is_program_running]
data.is_program_running = _deserializer.bool(buffer, bufferOffset);
// Deserialize message field [is_program_paused]
data.is_program_paused = _deserializer.bool(buffer, bufferOffset);
return data;
}
static getMessageSize(object) {
return 15;
}
static datatype() {
// Returns string type for a message object
return 'ur_msgs/RobotModeDataMsg';
}
static md5sum() {
//Returns md5sum for a message object
return '867308ca39e2cc0644b50db27deb661f';
}
static messageDefinition() {
// Returns full string definition for message
return `
# 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
`;
}
static Resolve(msg) {
// deep-construct a valid message object instance of whatever was passed in
if (typeof msg !== 'object' || msg === null) {
msg = {};
}
const resolved = new RobotModeDataMsg(null);
if (msg.timestamp !== undefined) {
resolved.timestamp = msg.timestamp;
}
else {
resolved.timestamp = 0
}
if (msg.is_robot_connected !== undefined) {
resolved.is_robot_connected = msg.is_robot_connected;
}
else {
resolved.is_robot_connected = false
}
if (msg.is_real_robot_enabled !== undefined) {
resolved.is_real_robot_enabled = msg.is_real_robot_enabled;
}
else {
resolved.is_real_robot_enabled = false
}
if (msg.is_power_on_robot !== undefined) {
resolved.is_power_on_robot = msg.is_power_on_robot;
}
else {
resolved.is_power_on_robot = false
}
if (msg.is_emergency_stopped !== undefined) {
resolved.is_emergency_stopped = msg.is_emergency_stopped;
}
else {
resolved.is_emergency_stopped = false
}
if (msg.is_protective_stopped !== undefined) {
resolved.is_protective_stopped = msg.is_protective_stopped;
}
else {
resolved.is_protective_stopped = false
}
if (msg.is_program_running !== undefined) {
resolved.is_program_running = msg.is_program_running;
}
else {
resolved.is_program_running = false
}
if (msg.is_program_paused !== undefined) {
resolved.is_program_paused = msg.is_program_paused;
}
else {
resolved.is_program_paused = false
}
return resolved;
}
};
module.exports = RobotModeDataMsg;

453
devel/share/gennodejs/ros/ur_msgs/msg/RobotStateRTMsg.js Normal file
View File

@@ -0,0 +1,453 @@
// Auto-generated. Do not edit!
// (in-package ur_msgs.msg)
"use strict";
const _serializer = _ros_msg_utils.Serialize;
const _arraySerializer = _serializer.Array;
const _deserializer = _ros_msg_utils.Deserialize;
const _arrayDeserializer = _deserializer.Array;
const _finder = _ros_msg_utils.Find;
const _getByteLength = _ros_msg_utils.getByteLength;
//-----------------------------------------------------------
class RobotStateRTMsg {
constructor(initObj={}) {
if (initObj === null) {
// initObj === null is a special case for deserialization where we don't initialize fields
this.time = null;
this.q_target = null;
this.qd_target = null;
this.qdd_target = null;
this.i_target = null;
this.m_target = null;
this.q_actual = null;
this.qd_actual = null;
this.i_actual = null;
this.tool_acc_values = null;
this.tcp_force = null;
this.tool_vector = null;
this.tcp_speed = null;
this.digital_input_bits = null;
this.motor_temperatures = null;
this.controller_timer = null;
this.test_value = null;
this.robot_mode = null;
this.joint_modes = null;
}
else {
if (initObj.hasOwnProperty('time')) {
this.time = initObj.time
}
else {
this.time = 0.0;
}
if (initObj.hasOwnProperty('q_target')) {
this.q_target = initObj.q_target
}
else {
this.q_target = [];
}
if (initObj.hasOwnProperty('qd_target')) {
this.qd_target = initObj.qd_target
}
else {
this.qd_target = [];
}
if (initObj.hasOwnProperty('qdd_target')) {
this.qdd_target = initObj.qdd_target
}
else {
this.qdd_target = [];
}
if (initObj.hasOwnProperty('i_target')) {
this.i_target = initObj.i_target
}
else {
this.i_target = [];
}
if (initObj.hasOwnProperty('m_target')) {
this.m_target = initObj.m_target
}
else {
this.m_target = [];
}
if (initObj.hasOwnProperty('q_actual')) {
this.q_actual = initObj.q_actual
}
else {
this.q_actual = [];
}
if (initObj.hasOwnProperty('qd_actual')) {
this.qd_actual = initObj.qd_actual
}
else {
this.qd_actual = [];
}
if (initObj.hasOwnProperty('i_actual')) {
this.i_actual = initObj.i_actual
}
else {
this.i_actual = [];
}
if (initObj.hasOwnProperty('tool_acc_values')) {
this.tool_acc_values = initObj.tool_acc_values
}
else {
this.tool_acc_values = [];
}
if (initObj.hasOwnProperty('tcp_force')) {
this.tcp_force = initObj.tcp_force
}
else {
this.tcp_force = [];
}
if (initObj.hasOwnProperty('tool_vector')) {
this.tool_vector = initObj.tool_vector
}
else {
this.tool_vector = [];
}
if (initObj.hasOwnProperty('tcp_speed')) {
this.tcp_speed = initObj.tcp_speed
}
else {
this.tcp_speed = [];
}
if (initObj.hasOwnProperty('digital_input_bits')) {
this.digital_input_bits = initObj.digital_input_bits
}
else {
this.digital_input_bits = 0.0;
}
if (initObj.hasOwnProperty('motor_temperatures')) {
this.motor_temperatures = initObj.motor_temperatures
}
else {
this.motor_temperatures = [];
}
if (initObj.hasOwnProperty('controller_timer')) {
this.controller_timer = initObj.controller_timer
}
else {
this.controller_timer = 0.0;
}
if (initObj.hasOwnProperty('test_value')) {
this.test_value = initObj.test_value
}
else {
this.test_value = 0.0;
}
if (initObj.hasOwnProperty('robot_mode')) {
this.robot_mode = initObj.robot_mode
}
else {
this.robot_mode = 0.0;
}
if (initObj.hasOwnProperty('joint_modes')) {
this.joint_modes = initObj.joint_modes
}
else {
this.joint_modes = [];
}
}
}
static serialize(obj, buffer, bufferOffset) {
// Serializes a message object of type RobotStateRTMsg
// Serialize message field [time]
bufferOffset = _serializer.float64(obj.time, buffer, bufferOffset);
// Serialize message field [q_target]
bufferOffset = _arraySerializer.float64(obj.q_target, buffer, bufferOffset, null);
// Serialize message field [qd_target]
bufferOffset = _arraySerializer.float64(obj.qd_target, buffer, bufferOffset, null);
// Serialize message field [qdd_target]
bufferOffset = _arraySerializer.float64(obj.qdd_target, buffer, bufferOffset, null);
// Serialize message field [i_target]
bufferOffset = _arraySerializer.float64(obj.i_target, buffer, bufferOffset, null);
// Serialize message field [m_target]
bufferOffset = _arraySerializer.float64(obj.m_target, buffer, bufferOffset, null);
// Serialize message field [q_actual]
bufferOffset = _arraySerializer.float64(obj.q_actual, buffer, bufferOffset, null);
// Serialize message field [qd_actual]
bufferOffset = _arraySerializer.float64(obj.qd_actual, buffer, bufferOffset, null);
// Serialize message field [i_actual]
bufferOffset = _arraySerializer.float64(obj.i_actual, buffer, bufferOffset, null);
// Serialize message field [tool_acc_values]
bufferOffset = _arraySerializer.float64(obj.tool_acc_values, buffer, bufferOffset, null);
// Serialize message field [tcp_force]
bufferOffset = _arraySerializer.float64(obj.tcp_force, buffer, bufferOffset, null);
// Serialize message field [tool_vector]
bufferOffset = _arraySerializer.float64(obj.tool_vector, buffer, bufferOffset, null);
// Serialize message field [tcp_speed]
bufferOffset = _arraySerializer.float64(obj.tcp_speed, buffer, bufferOffset, null);
// Serialize message field [digital_input_bits]
bufferOffset = _serializer.float64(obj.digital_input_bits, buffer, bufferOffset);
// Serialize message field [motor_temperatures]
bufferOffset = _arraySerializer.float64(obj.motor_temperatures, buffer, bufferOffset, null);
// Serialize message field [controller_timer]
bufferOffset = _serializer.float64(obj.controller_timer, buffer, bufferOffset);
// Serialize message field [test_value]
bufferOffset = _serializer.float64(obj.test_value, buffer, bufferOffset);
// Serialize message field [robot_mode]
bufferOffset = _serializer.float64(obj.robot_mode, buffer, bufferOffset);
// Serialize message field [joint_modes]
bufferOffset = _arraySerializer.float64(obj.joint_modes, buffer, bufferOffset, null);
return bufferOffset;
}
static deserialize(buffer, bufferOffset=[0]) {
//deserializes a message object of type RobotStateRTMsg
let len;
let data = new RobotStateRTMsg(null);
// Deserialize message field [time]
data.time = _deserializer.float64(buffer, bufferOffset);
// Deserialize message field [q_target]
data.q_target = _arrayDeserializer.float64(buffer, bufferOffset, null)
// Deserialize message field [qd_target]
data.qd_target = _arrayDeserializer.float64(buffer, bufferOffset, null)
// Deserialize message field [qdd_target]
data.qdd_target = _arrayDeserializer.float64(buffer, bufferOffset, null)
// Deserialize message field [i_target]
data.i_target = _arrayDeserializer.float64(buffer, bufferOffset, null)
// Deserialize message field [m_target]
data.m_target = _arrayDeserializer.float64(buffer, bufferOffset, null)
// Deserialize message field [q_actual]
data.q_actual = _arrayDeserializer.float64(buffer, bufferOffset, null)
// Deserialize message field [qd_actual]
data.qd_actual = _arrayDeserializer.float64(buffer, bufferOffset, null)
// Deserialize message field [i_actual]
data.i_actual = _arrayDeserializer.float64(buffer, bufferOffset, null)
// Deserialize message field [tool_acc_values]
data.tool_acc_values = _arrayDeserializer.float64(buffer, bufferOffset, null)
// Deserialize message field [tcp_force]
data.tcp_force = _arrayDeserializer.float64(buffer, bufferOffset, null)
// Deserialize message field [tool_vector]
data.tool_vector = _arrayDeserializer.float64(buffer, bufferOffset, null)
// Deserialize message field [tcp_speed]
data.tcp_speed = _arrayDeserializer.float64(buffer, bufferOffset, null)
// Deserialize message field [digital_input_bits]
data.digital_input_bits = _deserializer.float64(buffer, bufferOffset);
// Deserialize message field [motor_temperatures]
data.motor_temperatures = _arrayDeserializer.float64(buffer, bufferOffset, null)
// Deserialize message field [controller_timer]
data.controller_timer = _deserializer.float64(buffer, bufferOffset);
// Deserialize message field [test_value]
data.test_value = _deserializer.float64(buffer, bufferOffset);
// Deserialize message field [robot_mode]
data.robot_mode = _deserializer.float64(buffer, bufferOffset);
// Deserialize message field [joint_modes]
data.joint_modes = _arrayDeserializer.float64(buffer, bufferOffset, null)
return data;
}
static getMessageSize(object) {
let length = 0;
length += 8 * object.q_target.length;
length += 8 * object.qd_target.length;
length += 8 * object.qdd_target.length;
length += 8 * object.i_target.length;
length += 8 * object.m_target.length;
length += 8 * object.q_actual.length;
length += 8 * object.qd_actual.length;
length += 8 * object.i_actual.length;
length += 8 * object.tool_acc_values.length;
length += 8 * object.tcp_force.length;
length += 8 * object.tool_vector.length;
length += 8 * object.tcp_speed.length;
length += 8 * object.motor_temperatures.length;
length += 8 * object.joint_modes.length;
return length + 96;
}
static datatype() {
// Returns string type for a message object
return 'ur_msgs/RobotStateRTMsg';
}
static md5sum() {
//Returns md5sum for a message object
return 'ce6feddd3ccb4ca7dbcd0ff105b603c7';
}
static messageDefinition() {
// Returns full string definition for message
return `
# 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
`;
}
static Resolve(msg) {
// deep-construct a valid message object instance of whatever was passed in
if (typeof msg !== 'object' || msg === null) {
msg = {};
}
const resolved = new RobotStateRTMsg(null);
if (msg.time !== undefined) {
resolved.time = msg.time;
}
else {
resolved.time = 0.0
}
if (msg.q_target !== undefined) {
resolved.q_target = msg.q_target;
}
else {
resolved.q_target = []
}
if (msg.qd_target !== undefined) {
resolved.qd_target = msg.qd_target;
}
else {
resolved.qd_target = []
}
if (msg.qdd_target !== undefined) {
resolved.qdd_target = msg.qdd_target;
}
else {
resolved.qdd_target = []
}
if (msg.i_target !== undefined) {
resolved.i_target = msg.i_target;
}
else {
resolved.i_target = []
}
if (msg.m_target !== undefined) {
resolved.m_target = msg.m_target;
}
else {
resolved.m_target = []
}
if (msg.q_actual !== undefined) {
resolved.q_actual = msg.q_actual;
}
else {
resolved.q_actual = []
}
if (msg.qd_actual !== undefined) {
resolved.qd_actual = msg.qd_actual;
}
else {
resolved.qd_actual = []
}
if (msg.i_actual !== undefined) {
resolved.i_actual = msg.i_actual;
}
else {
resolved.i_actual = []
}
if (msg.tool_acc_values !== undefined) {
resolved.tool_acc_values = msg.tool_acc_values;
}
else {
resolved.tool_acc_values = []
}
if (msg.tcp_force !== undefined) {
resolved.tcp_force = msg.tcp_force;
}
else {
resolved.tcp_force = []
}
if (msg.tool_vector !== undefined) {
resolved.tool_vector = msg.tool_vector;
}
else {
resolved.tool_vector = []
}
if (msg.tcp_speed !== undefined) {
resolved.tcp_speed = msg.tcp_speed;
}
else {
resolved.tcp_speed = []
}
if (msg.digital_input_bits !== undefined) {
resolved.digital_input_bits = msg.digital_input_bits;
}
else {
resolved.digital_input_bits = 0.0
}
if (msg.motor_temperatures !== undefined) {
resolved.motor_temperatures = msg.motor_temperatures;
}
else {
resolved.motor_temperatures = []
}
if (msg.controller_timer !== undefined) {
resolved.controller_timer = msg.controller_timer;
}
else {
resolved.controller_timer = 0.0
}
if (msg.test_value !== undefined) {
resolved.test_value = msg.test_value;
}
else {
resolved.test_value = 0.0
}
if (msg.robot_mode !== undefined) {
resolved.robot_mode = msg.robot_mode;
}
else {
resolved.robot_mode = 0.0
}
if (msg.joint_modes !== undefined) {
resolved.joint_modes = msg.joint_modes;
}
else {
resolved.joint_modes = []
}
return resolved;
}
};
module.exports = RobotStateRTMsg;

260
devel/share/gennodejs/ros/ur_msgs/msg/ToolDataMsg.js Normal file
View File

@@ -0,0 +1,260 @@
// Auto-generated. Do not edit!
// (in-package ur_msgs.msg)
"use strict";
const _serializer = _ros_msg_utils.Serialize;
const _arraySerializer = _serializer.Array;
const _deserializer = _ros_msg_utils.Deserialize;
const _arrayDeserializer = _deserializer.Array;
const _finder = _ros_msg_utils.Find;
const _getByteLength = _ros_msg_utils.getByteLength;
//-----------------------------------------------------------
class ToolDataMsg {
constructor(initObj={}) {
if (initObj === null) {
// initObj === null is a special case for deserialization where we don't initialize fields
this.analog_input_range2 = null;
this.analog_input_range3 = null;
this.analog_input2 = null;
this.analog_input3 = null;
this.tool_voltage_48v = null;
this.tool_output_voltage = null;
this.tool_current = null;
this.tool_temperature = null;
this.tool_mode = null;
}
else {
if (initObj.hasOwnProperty('analog_input_range2')) {
this.analog_input_range2 = initObj.analog_input_range2
}
else {
this.analog_input_range2 = 0;
}
if (initObj.hasOwnProperty('analog_input_range3')) {
this.analog_input_range3 = initObj.analog_input_range3
}
else {
this.analog_input_range3 = 0;
}
if (initObj.hasOwnProperty('analog_input2')) {
this.analog_input2 = initObj.analog_input2
}
else {
this.analog_input2 = 0.0;
}
if (initObj.hasOwnProperty('analog_input3')) {
this.analog_input3 = initObj.analog_input3
}
else {
this.analog_input3 = 0.0;
}
if (initObj.hasOwnProperty('tool_voltage_48v')) {
this.tool_voltage_48v = initObj.tool_voltage_48v
}
else {
this.tool_voltage_48v = 0.0;
}
if (initObj.hasOwnProperty('tool_output_voltage')) {
this.tool_output_voltage = initObj.tool_output_voltage
}
else {
this.tool_output_voltage = 0;
}
if (initObj.hasOwnProperty('tool_current')) {
this.tool_current = initObj.tool_current
}
else {
this.tool_current = 0.0;
}
if (initObj.hasOwnProperty('tool_temperature')) {
this.tool_temperature = initObj.tool_temperature
}
else {
this.tool_temperature = 0.0;
}
if (initObj.hasOwnProperty('tool_mode')) {
this.tool_mode = initObj.tool_mode
}
else {
this.tool_mode = 0;
}
}
}
static serialize(obj, buffer, bufferOffset) {
// Serializes a message object of type ToolDataMsg
// Serialize message field [analog_input_range2]
bufferOffset = _serializer.int8(obj.analog_input_range2, buffer, bufferOffset);
// Serialize message field [analog_input_range3]
bufferOffset = _serializer.int8(obj.analog_input_range3, buffer, bufferOffset);
// Serialize message field [analog_input2]
bufferOffset = _serializer.float64(obj.analog_input2, buffer, bufferOffset);
// Serialize message field [analog_input3]
bufferOffset = _serializer.float64(obj.analog_input3, buffer, bufferOffset);
// Serialize message field [tool_voltage_48v]
bufferOffset = _serializer.float32(obj.tool_voltage_48v, buffer, bufferOffset);
// Serialize message field [tool_output_voltage]
bufferOffset = _serializer.uint8(obj.tool_output_voltage, buffer, bufferOffset);
// Serialize message field [tool_current]
bufferOffset = _serializer.float32(obj.tool_current, buffer, bufferOffset);
// Serialize message field [tool_temperature]
bufferOffset = _serializer.float32(obj.tool_temperature, buffer, bufferOffset);
// Serialize message field [tool_mode]
bufferOffset = _serializer.uint8(obj.tool_mode, buffer, bufferOffset);
return bufferOffset;
}
static deserialize(buffer, bufferOffset=[0]) {
//deserializes a message object of type ToolDataMsg
let len;
let data = new ToolDataMsg(null);
// Deserialize message field [analog_input_range2]
data.analog_input_range2 = _deserializer.int8(buffer, bufferOffset);
// Deserialize message field [analog_input_range3]
data.analog_input_range3 = _deserializer.int8(buffer, bufferOffset);
// Deserialize message field [analog_input2]
data.analog_input2 = _deserializer.float64(buffer, bufferOffset);
// Deserialize message field [analog_input3]
data.analog_input3 = _deserializer.float64(buffer, bufferOffset);
// Deserialize message field [tool_voltage_48v]
data.tool_voltage_48v = _deserializer.float32(buffer, bufferOffset);
// Deserialize message field [tool_output_voltage]
data.tool_output_voltage = _deserializer.uint8(buffer, bufferOffset);
// Deserialize message field [tool_current]
data.tool_current = _deserializer.float32(buffer, bufferOffset);
// Deserialize message field [tool_temperature]
data.tool_temperature = _deserializer.float32(buffer, bufferOffset);
// Deserialize message field [tool_mode]
data.tool_mode = _deserializer.uint8(buffer, bufferOffset);
return data;
}
static getMessageSize(object) {
return 32;
}
static datatype() {
// Returns string type for a message object
return 'ur_msgs/ToolDataMsg';
}
static md5sum() {
//Returns md5sum for a message object
return '404fc266f37d89f75b372d12fa94a122';
}
static messageDefinition() {
// Returns full string definition for message
return `
# 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_*
`;
}
static Resolve(msg) {
// deep-construct a valid message object instance of whatever was passed in
if (typeof msg !== 'object' || msg === null) {
msg = {};
}
const resolved = new ToolDataMsg(null);
if (msg.analog_input_range2 !== undefined) {
resolved.analog_input_range2 = msg.analog_input_range2;
}
else {
resolved.analog_input_range2 = 0
}
if (msg.analog_input_range3 !== undefined) {
resolved.analog_input_range3 = msg.analog_input_range3;
}
else {
resolved.analog_input_range3 = 0
}
if (msg.analog_input2 !== undefined) {
resolved.analog_input2 = msg.analog_input2;
}
else {
resolved.analog_input2 = 0.0
}
if (msg.analog_input3 !== undefined) {
resolved.analog_input3 = msg.analog_input3;
}
else {
resolved.analog_input3 = 0.0
}
if (msg.tool_voltage_48v !== undefined) {
resolved.tool_voltage_48v = msg.tool_voltage_48v;
}
else {
resolved.tool_voltage_48v = 0.0
}
if (msg.tool_output_voltage !== undefined) {
resolved.tool_output_voltage = msg.tool_output_voltage;
}
else {
resolved.tool_output_voltage = 0
}
if (msg.tool_current !== undefined) {
resolved.tool_current = msg.tool_current;
}
else {
resolved.tool_current = 0.0
}
if (msg.tool_temperature !== undefined) {
resolved.tool_temperature = msg.tool_temperature;
}
else {
resolved.tool_temperature = 0.0
}
if (msg.tool_mode !== undefined) {
resolved.tool_mode = msg.tool_mode;
}
else {
resolved.tool_mode = 0
}
return resolved;
}
};
// Constants for message
ToolDataMsg.Constants = {
ANALOG_INPUT_RANGE_CURRENT: 0,
ANALOG_INPUT_RANGE_VOLTAGE: 1,
TOOL_BOOTLOADER_MODE: 249,
TOOL_RUNNING_MODE: 253,
TOOL_IDLE_MODE: 255,
}
module.exports = ToolDataMsg;

256
devel/share/gennodejs/ros/ur_msgs/srv/SetIO.js Normal file
View File

@@ -0,0 +1,256 @@
// Auto-generated. Do not edit!
// (in-package ur_msgs.srv)
"use strict";
const _serializer = _ros_msg_utils.Serialize;
const _arraySerializer = _serializer.Array;
const _deserializer = _ros_msg_utils.Deserialize;
const _arrayDeserializer = _deserializer.Array;
const _finder = _ros_msg_utils.Find;
const _getByteLength = _ros_msg_utils.getByteLength;
//-----------------------------------------------------------
//-----------------------------------------------------------
class SetIORequest {
constructor(initObj={}) {
if (initObj === null) {
// initObj === null is a special case for deserialization where we don't initialize fields
this.fun = null;
this.pin = null;
this.state = null;
}
else {
if (initObj.hasOwnProperty('fun')) {
this.fun = initObj.fun
}
else {
this.fun = 0;
}
if (initObj.hasOwnProperty('pin')) {
this.pin = initObj.pin
}
else {
this.pin = 0;
}
if (initObj.hasOwnProperty('state')) {
this.state = initObj.state
}
else {
this.state = 0.0;
}
}
}
static serialize(obj, buffer, bufferOffset) {
// Serializes a message object of type SetIORequest
// Serialize message field [fun]
bufferOffset = _serializer.int8(obj.fun, buffer, bufferOffset);
// Serialize message field [pin]
bufferOffset = _serializer.int8(obj.pin, buffer, bufferOffset);
// Serialize message field [state]
bufferOffset = _serializer.float32(obj.state, buffer, bufferOffset);
return bufferOffset;
}
static deserialize(buffer, bufferOffset=[0]) {
//deserializes a message object of type SetIORequest
let len;
let data = new SetIORequest(null);
// Deserialize message field [fun]
data.fun = _deserializer.int8(buffer, bufferOffset);
// Deserialize message field [pin]
data.pin = _deserializer.int8(buffer, bufferOffset);
// Deserialize message field [state]
data.state = _deserializer.float32(buffer, bufferOffset);
return data;
}
static getMessageSize(object) {
return 6;
}
static datatype() {
// Returns string type for a service object
return 'ur_msgs/SetIORequest';
}
static md5sum() {
//Returns md5sum for a message object
return '85200c86fbe60ea3e047bae3d6574bfd';
}
static messageDefinition() {
// Returns full string definition for message
return `
int8 FUN_SET_DIGITAL_OUT = 1
int8 FUN_SET_FLAG = 2
int8 FUN_SET_ANALOG_OUT = 3
int8 FUN_SET_TOOL_VOLTAGE = 4
int8 STATE_OFF = 0
int8 STATE_ON = 1
int8 STATE_TOOL_VOLTAGE_0V = 0
int8 STATE_TOOL_VOLTAGE_12V = 12
int8 STATE_TOOL_VOLTAGE_24V = 24
int8 fun
int8 pin
float32 state
`;
}
static Resolve(msg) {
// deep-construct a valid message object instance of whatever was passed in
if (typeof msg !== 'object' || msg === null) {
msg = {};
}
const resolved = new SetIORequest(null);
if (msg.fun !== undefined) {
resolved.fun = msg.fun;
}
else {
resolved.fun = 0
}
if (msg.pin !== undefined) {
resolved.pin = msg.pin;
}
else {
resolved.pin = 0
}
if (msg.state !== undefined) {
resolved.state = msg.state;
}
else {
resolved.state = 0.0
}
return resolved;
}
};
// Constants for message
SetIORequest.Constants = {
FUN_SET_DIGITAL_OUT: 1,
FUN_SET_FLAG: 2,
FUN_SET_ANALOG_OUT: 3,
FUN_SET_TOOL_VOLTAGE: 4,
STATE_OFF: 0,
STATE_ON: 1,
STATE_TOOL_VOLTAGE_0V: 0,
STATE_TOOL_VOLTAGE_12V: 12,
STATE_TOOL_VOLTAGE_24V: 24,
}
class SetIOResponse {
constructor(initObj={}) {
if (initObj === null) {
// initObj === null is a special case for deserialization where we don't initialize fields
this.success = null;
}
else {
if (initObj.hasOwnProperty('success')) {
this.success = initObj.success
}
else {
this.success = false;
}
}
}
static serialize(obj, buffer, bufferOffset) {
// Serializes a message object of type SetIOResponse
// Serialize message field [success]
bufferOffset = _serializer.bool(obj.success, buffer, bufferOffset);
return bufferOffset;
}
static deserialize(buffer, bufferOffset=[0]) {
//deserializes a message object of type SetIOResponse
let len;
let data = new SetIOResponse(null);
// Deserialize message field [success]
data.success = _deserializer.bool(buffer, bufferOffset);
return data;
}
static getMessageSize(object) {
return 1;
}
static datatype() {
// Returns string type for a service object
return 'ur_msgs/SetIOResponse';
}
static md5sum() {
//Returns md5sum for a message object
return '358e233cde0c8a8bcfea4ce193f8fc15';
}
static messageDefinition() {
// Returns full string definition for message
return `
bool success
`;
}
static Resolve(msg) {
// deep-construct a valid message object instance of whatever was passed in
if (typeof msg !== 'object' || msg === null) {
msg = {};
}
const resolved = new SetIOResponse(null);
if (msg.success !== undefined) {
resolved.success = msg.success;
}
else {
resolved.success = false
}
return resolved;
}
};
module.exports = {
Request: SetIORequest,
Response: SetIOResponse,
md5sum() { return 'e1b580ccf43a938f2efbbb98bbe3e277'; },
datatype() { return 'ur_msgs/SetIO'; }
};

168
devel/share/gennodejs/ros/ur_msgs/srv/SetPayload.js Normal file
View File

@@ -0,0 +1,168 @@
// Auto-generated. Do not edit!
// (in-package ur_msgs.srv)
"use strict";
const _serializer = _ros_msg_utils.Serialize;
const _arraySerializer = _serializer.Array;
const _deserializer = _ros_msg_utils.Deserialize;
const _arrayDeserializer = _deserializer.Array;
const _finder = _ros_msg_utils.Find;
const _getByteLength = _ros_msg_utils.getByteLength;
//-----------------------------------------------------------
//-----------------------------------------------------------
class SetPayloadRequest {
constructor(initObj={}) {
if (initObj === null) {
// initObj === null is a special case for deserialization where we don't initialize fields
this.payload = null;
}
else {
if (initObj.hasOwnProperty('payload')) {
this.payload = initObj.payload
}
else {
this.payload = 0.0;
}
}
}
static serialize(obj, buffer, bufferOffset) {
// Serializes a message object of type SetPayloadRequest
// Serialize message field [payload]
bufferOffset = _serializer.float32(obj.payload, buffer, bufferOffset);
return bufferOffset;
}
static deserialize(buffer, bufferOffset=[0]) {
//deserializes a message object of type SetPayloadRequest
let len;
let data = new SetPayloadRequest(null);
// Deserialize message field [payload]
data.payload = _deserializer.float32(buffer, bufferOffset);
return data;
}
static getMessageSize(object) {
return 4;
}
static datatype() {
// Returns string type for a service object
return 'ur_msgs/SetPayloadRequest';
}
static md5sum() {
//Returns md5sum for a message object
return 'd12269f931817591aa52047629ca66ca';
}
static messageDefinition() {
// Returns full string definition for message
return `
float32 payload
`;
}
static Resolve(msg) {
// deep-construct a valid message object instance of whatever was passed in
if (typeof msg !== 'object' || msg === null) {
msg = {};
}
const resolved = new SetPayloadRequest(null);
if (msg.payload !== undefined) {
resolved.payload = msg.payload;
}
else {
resolved.payload = 0.0
}
return resolved;
}
};
class SetPayloadResponse {
constructor(initObj={}) {
if (initObj === null) {
// initObj === null is a special case for deserialization where we don't initialize fields
this.success = null;
}
else {
if (initObj.hasOwnProperty('success')) {
this.success = initObj.success
}
else {
this.success = false;
}
}
}
static serialize(obj, buffer, bufferOffset) {
// Serializes a message object of type SetPayloadResponse
// Serialize message field [success]
bufferOffset = _serializer.bool(obj.success, buffer, bufferOffset);
return bufferOffset;
}
static deserialize(buffer, bufferOffset=[0]) {
//deserializes a message object of type SetPayloadResponse
let len;
let data = new SetPayloadResponse(null);
// Deserialize message field [success]
data.success = _deserializer.bool(buffer, bufferOffset);
return data;
}
static getMessageSize(object) {
return 1;
}
static datatype() {
// Returns string type for a service object
return 'ur_msgs/SetPayloadResponse';
}
static md5sum() {
//Returns md5sum for a message object
return '358e233cde0c8a8bcfea4ce193f8fc15';
}
static messageDefinition() {
// Returns full string definition for message
return `
bool success
`;
}
static Resolve(msg) {
// deep-construct a valid message object instance of whatever was passed in
if (typeof msg !== 'object' || msg === null) {
msg = {};
}
const resolved = new SetPayloadResponse(null);
if (msg.success !== undefined) {
resolved.success = msg.success;
}
else {
resolved.success = false
}
return resolved;
}
};
module.exports = {
Request: SetPayloadRequest,
Response: SetPayloadResponse,
md5sum() { return '7f12eb632882cb73e5721178d0073e39'; },
datatype() { return 'ur_msgs/SetPayload'; }
};

173
devel/share/gennodejs/ros/ur_msgs/srv/SetSpeedSliderFraction.js Normal file
View File

@@ -0,0 +1,173 @@
// Auto-generated. Do not edit!
// (in-package ur_msgs.srv)
"use strict";
const _serializer = _ros_msg_utils.Serialize;
const _arraySerializer = _serializer.Array;
const _deserializer = _ros_msg_utils.Deserialize;
const _arrayDeserializer = _deserializer.Array;
const _finder = _ros_msg_utils.Find;
const _getByteLength = _ros_msg_utils.getByteLength;
//-----------------------------------------------------------
//-----------------------------------------------------------
class SetSpeedSliderFractionRequest {
constructor(initObj={}) {
if (initObj === null) {
// initObj === null is a special case for deserialization where we don't initialize fields
this.speed_slider_fraction = null;
}
else {
if (initObj.hasOwnProperty('speed_slider_fraction')) {
this.speed_slider_fraction = initObj.speed_slider_fraction
}
else {
this.speed_slider_fraction = 0.0;
}
}
}
static serialize(obj, buffer, bufferOffset) {
// Serializes a message object of type SetSpeedSliderFractionRequest
// Serialize message field [speed_slider_fraction]
bufferOffset = _serializer.float64(obj.speed_slider_fraction, buffer, bufferOffset);
return bufferOffset;
}
static deserialize(buffer, bufferOffset=[0]) {
//deserializes a message object of type SetSpeedSliderFractionRequest
let len;
let data = new SetSpeedSliderFractionRequest(null);
// Deserialize message field [speed_slider_fraction]
data.speed_slider_fraction = _deserializer.float64(buffer, bufferOffset);
return data;
}
static getMessageSize(object) {
return 8;
}
static datatype() {
// Returns string type for a service object
return 'ur_msgs/SetSpeedSliderFractionRequest';
}
static md5sum() {
//Returns md5sum for a message object
return '64134244ab4dfc72a3406fe06d580274';
}
static messageDefinition() {
// Returns full string definition for message
return `
float64 speed_slider_fraction
`;
}
static Resolve(msg) {
// deep-construct a valid message object instance of whatever was passed in
if (typeof msg !== 'object' || msg === null) {
msg = {};
}
const resolved = new SetSpeedSliderFractionRequest(null);
if (msg.speed_slider_fraction !== undefined) {
resolved.speed_slider_fraction = msg.speed_slider_fraction;
}
else {
resolved.speed_slider_fraction = 0.0
}
return resolved;
}
};
class SetSpeedSliderFractionResponse {
constructor(initObj={}) {
if (initObj === null) {
// initObj === null is a special case for deserialization where we don't initialize fields
this.success = null;
}
else {
if (initObj.hasOwnProperty('success')) {
this.success = initObj.success
}
else {
this.success = false;
}
}
}
static serialize(obj, buffer, bufferOffset) {
// Serializes a message object of type SetSpeedSliderFractionResponse
// Serialize message field [success]
bufferOffset = _serializer.bool(obj.success, buffer, bufferOffset);
return bufferOffset;
}
static deserialize(buffer, bufferOffset=[0]) {
//deserializes a message object of type SetSpeedSliderFractionResponse
let len;
let data = new SetSpeedSliderFractionResponse(null);
// Deserialize message field [success]
data.success = _deserializer.bool(buffer, bufferOffset);
return data;
}
static getMessageSize(object) {
return 1;
}
static datatype() {
// Returns string type for a service object
return 'ur_msgs/SetSpeedSliderFractionResponse';
}
static md5sum() {
//Returns md5sum for a message object
return '358e233cde0c8a8bcfea4ce193f8fc15';
}
static messageDefinition() {
// Returns full string definition for message
return `
bool success
`;
}
static Resolve(msg) {
// deep-construct a valid message object instance of whatever was passed in
if (typeof msg !== 'object' || msg === null) {
msg = {};
}
const resolved = new SetSpeedSliderFractionResponse(null);
if (msg.success !== undefined) {
resolved.success = msg.success;
}
else {
resolved.success = false
}
return resolved;
}
};
module.exports = {
Request: SetSpeedSliderFractionRequest,
Response: SetSpeedSliderFractionResponse,
md5sum() { return '172aeb6c49379a44cf68480fa5bfad3c'; },
datatype() { return 'ur_msgs/SetSpeedSliderFraction'; }
};