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

Filet temporaei eliminati prima della ricompilazione

Browse Source
This commit is contained in:
Emanuele
2019-11-14 16:10:59 +01:00
parent e3b88fe742
commit c9108aaa54
54 changed files with 0 additions and 11303 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1,135 +0,0 @@
// 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
View File

@@ -1,107 +0,0 @@
// 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
View File

@@ -1,246 +0,0 @@
// 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
View File

@@ -1,384 +0,0 @@
// 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
View File

@@ -1,228 +0,0 @@
// 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
View File

@@ -1,453 +0,0 @@
// 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
View File

@@ -1,260 +0,0 @@
// 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;