454 lines
14 KiB
JavaScript
454 lines
14 KiB
JavaScript
// 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;
|