code stringlengths 1 1.49M | vector listlengths 0 7.38k | snippet listlengths 0 7.38k |
|---|---|---|
#! /usr/bin/python
import sys
import numpy as np
import copy
import roslib
roslib.load_manifest("hrl_pr2_arms")
roslib.load_manifest("kelsey_sandbox")
import rospy
from visualization_msgs.msg import Marker, MarkerArray
from geometry_msgs.msg import Point, Quaternion, Vector3, PoseStamped
from std_msgs.msg import ColorRGBA
from sensor_msgs.msg import JointState
import tf.transformations as tf_trans
from hrl_generic_arms.pose_converter import PoseConverter
from spheroid_space import SpheroidSpace
JOINT_STATE_INDS_R = [17, 18, 16, 20, 19, 21, 22]
JOINT_STATE_INDS_L = [29, 30, 28, 32, 31, 33, 34]
class SpheroidViz:
def __init__(self):
ellipse_rot = np.mat([[-1., 0., 0.], [0., -1., 0.], [0., 0., 1.]])
self.sspace = SpheroidSpace(0.15, np.mat([0.78, -0.18, 0.1]).T, ellipse_rot)
self.colors = [ColorRGBA(1., 0., 0., 1.), ColorRGBA(0., 1., 0., 1.)]
self.vis_pub = rospy.Publisher("/force_torque_markers_array", MarkerArray)
self.pose_pub = rospy.Publisher("/spheroid_poses", PoseStamped)
m = Marker()
m.header.frame_id = "torso_lift_link"
m.header.stamp = rospy.Time()
m.ns = "force_torque"
m.id = 0
m.type = Marker.ARROW
m.action = Marker.ADD
#m.points.append(Point(0, 0, 0))
m.scale = Vector3(0.01, 0.01, 0.01)
m.color = self.colors[0]
#self.vis_pub.publish(m)
self.m = m
self.ma = MarkerArray()
def publish_vector(self, m_id):
new_m = copy.deepcopy(self.m)
new_m.id = m_id
u, v, p = 1.0, np.random.uniform(0, np.pi), np.random.uniform(0, 2 * np.pi)
pos = self.sspace.spheroidal_to_cart((u, v, p))
new_m.points.append(Point(*pos))
df_du = self.sspace.partial_u((u, v, p))
df_du *= 0.1 / np.linalg.norm(df_du)
new_m.points.append(Point(*(pos+df_du)))
self.ma.markers.append(new_m)
self.vis_pub.publish(self.ma)
rot_gripper = np.pi/4.
pos, rot = self.sspace.spheroidal_to_pose((u,v,p), rot_gripper)
ps_msg = PoseConverter.to_pose_stamped_msg("torso_lift_link", pos, rot)
self.pose_pub.publish(ps_msg)
def main():
rospy.init_node("test_markers")
jfv = SpheroidViz()
i = 0
while not rospy.is_shutdown():
jfv.publish_vector(i)
i += 1
rospy.sleep(0.1)
return
if __name__ == "__main__":
main()
| [
[
1,
0,
0.0375,
0.0125,
0,
0.66,
0,
509,
0,
1,
0,
0,
509,
0,
0
],
[
1,
0,
0.05,
0.0125,
0,
0.66,
0.0556,
954,
0,
1,
0,
0,
954,
0,
0
],
[
1,
0,
0.0625,
0.0125,
0,
0.... | [
"import sys",
"import numpy as np",
"import copy",
"import roslib",
"roslib.load_manifest(\"hrl_pr2_arms\")",
"roslib.load_manifest(\"kelsey_sandbox\")",
"import rospy",
"from visualization_msgs.msg import Marker, MarkerArray",
"from geometry_msgs.msg import Point, Quaternion, Vector3, PoseStamped",... |
#! /usr/bin/python
import sys
from PyQt4 import QtCore, QtGui, uic
import roslib
roslib.load_manifest("std_msgs")
roslib.load_manifest("rospy")
roslib.load_manifest("smach_ros")
import rospy
from std_msgs.msg import Bool
from smach_msgs.msg import SmachContainerStatus
from servoing_ui import Ui_Frame as QTServoingFrame
disabled_button_ss = """QPushButton { font: 75 18pt;
background-color: rgb(190, 190, 190);}"""
STATUS_DICT = { "UI_FIND_TAG_WAIT" : "Navigate the robot so it can see\nthe AR tag.",
"FIND_AR_TAG" : "Locating tag...",
"UI_SERVO_WAIT" : "Confirm the robot has found the\ntag in rviz.",
"SERVOING" : "Servoing to tag..."}
class ServoingFrame(QtGui.QFrame):
def __init__(self):
super(ServoingFrame, self).__init__()
self.init_ui()
rospy.Subscriber("/pr2_servo/smach/container_status", SmachContainerStatus,
self.smach_status_cb)
self.cur_smach_state = None
self.find_tag_pub = rospy.Publisher("/pr2_ar_servo/find_tag", Bool)
self.tag_confirm_pub = rospy.Publisher("/pr2_ar_servo/tag_confirm", Bool)
self.preempt_pub = rospy.Publisher("/pr2_ar_servo/preempt", Bool)
def smach_status_cb(self, msg):
for state in msg.active_states:
if state == self.cur_smach_state:
continue
if state in STATUS_DICT:
self.ui.state_information.setText(STATUS_DICT[state])
self.cur_smach_state = state
if state == "UI_FIND_TAG_WAIT" or state == "FIND_AR_TAG":
self.enable_button(self.ui.find_ar_tag, self.find_ar_tag_ss)
self.disable_button(self.ui.begin_servoing)
if state == "UI_SERVO_WAIT":
self.enable_button(self.ui.begin_servoing, self.begin_servoing_ss)
self.disable_button(self.ui.find_ar_tag)
if state == "SERVOING":
self.disable_button(self.ui.find_ar_tag)
self.disable_button(self.ui.begin_servoing)
def enable_button(self, button, ss):
button.setStyleSheet(ss)
button.setEnabled(True)
def disable_button(self, button):
button.setStyleSheet(disabled_button_ss)
button.setDisabled(True)
def init_ui(self):
self.ui = QTServoingFrame()
self.ui.setupUi(self)
self.ui.stop_moving.clicked.connect(self.stop_moving_clk)
self.ui.find_ar_tag.clicked.connect(self.find_ar_tag_clk)
self.ui.begin_servoing.clicked.connect(self.begin_servoing_clk)
self.ui.state_information.setText("State Information")
self.stop_moving_ss = self.ui.stop_moving.styleSheet()
self.find_ar_tag_ss = self.ui.find_ar_tag.styleSheet()
self.begin_servoing_ss = self.ui.begin_servoing.styleSheet()
def stop_moving_clk(self):
self.preempt_pub.publish(Bool(True))
def find_ar_tag_clk(self):
self.find_tag_pub.publish(Bool(True))
def begin_servoing_clk(self):
self.tag_confirm_pub.publish(Bool(True))
def main():
rospy.init_node("servoing_interface")
app = QtGui.QApplication(sys.argv)
sframe = ServoingFrame()
sframe.show()
sys.exit(app.exec_())
if __name__ == "__main__":
main()
| [
[
1,
0,
0.033,
0.011,
0,
0.66,
0,
509,
0,
1,
0,
0,
509,
0,
0
],
[
1,
0,
0.044,
0.011,
0,
0.66,
0.0714,
154,
0,
3,
0,
0,
154,
0,
0
],
[
1,
0,
0.0659,
0.011,
0,
0.66,... | [
"import sys",
"from PyQt4 import QtCore, QtGui, uic",
"import roslib",
"roslib.load_manifest(\"std_msgs\")",
"roslib.load_manifest(\"rospy\")",
"roslib.load_manifest(\"smach_ros\")",
"import rospy",
"from std_msgs.msg import Bool",
"from smach_msgs.msg import SmachContainerStatus",
"from servoing_... |
#! /usr/bin/python
import sys
from PyQt4 import QtCore, QtGui, uic
import roslib
roslib.load_manifest("rospy")
roslib.load_manifest("std_msgs")
import rospy
from std_msgs.msg import String
from arm_cart_control_gui import Ui_Frame as QTArmControlGUIFrame
from arm_cart_control_backend import MOVE_BUTTONS, MONITOR_RATE, MOVE_STATE_TOPIC, LOAD_ARM_TOPIC
ARM_STYLESHEET = """image: url(:/resources/arm_%s_%s.png);
background-image: url(:/resources/empty.png);"""
class ArmCartControlGUIFrame(QtGui.QFrame):
def __init__(self):
super(ArmCartControlGUIFrame, self).__init__()
self.move_state_pub = rospy.Publisher(MOVE_STATE_TOPIC, String)
self.arm_state_pub = rospy.Publisher(LOAD_ARM_TOPIC, String)
self.cur_arm = "l"
self.init_ui()
self.arm_left_clk()
def init_ui(self):
self.ui = QTArmControlGUIFrame()
self.ui.setupUi(self)
self.ui.arm_left.clicked.connect(self.arm_left_clk)
self.ui.arm_right.clicked.connect(self.arm_right_clk)
self.monitor_timer = QtCore.QTimer(self)
QtCore.QObject.connect(self.monitor_timer, QtCore.SIGNAL("timeout()"), self.monitor_cb)
self.monitor_timer.start(MONITOR_RATE)
def monitor_cb(self):
move_button = ""
for button in MOVE_BUTTONS:
exec("is_down = self.ui.%s.isDown()" % button)
if is_down:
move_button = button
self.move_state_pub.publish(String(move_button))
self.arm_state_pub.publish(String(self.cur_arm))
def arm_left_clk(self):
self.ui.arm_left.setDisabled(True)
self.ui.arm_right.setEnabled(True)
self.ui.arm_left.setStyleSheet(ARM_STYLESHEET % ("left", "on"))
self.ui.arm_right.setStyleSheet(ARM_STYLESHEET % ("right", "off"))
self.cur_arm = "l"
def arm_right_clk(self):
self.arm_state_pub.publish(String("r"))
self.ui.arm_right.setDisabled(True)
self.ui.arm_left.setEnabled(True)
self.ui.arm_left.setStyleSheet(ARM_STYLESHEET % ("left", "off"))
self.ui.arm_right.setStyleSheet(ARM_STYLESHEET % ("right", "on"))
self.cur_arm = "r"
def main():
rospy.init_node("arm_cart_control_interface")
app = QtGui.QApplication(sys.argv)
frame = ArmCartControlGUIFrame()
frame.show()
sys.exit(app.exec_())
if __name__ == "__main__":
main()
| [
[
1,
0,
0.0423,
0.0141,
0,
0.66,
0,
509,
0,
1,
0,
0,
509,
0,
0
],
[
1,
0,
0.0563,
0.0141,
0,
0.66,
0.0833,
154,
0,
3,
0,
0,
154,
0,
0
],
[
1,
0,
0.0845,
0.0141,
0,
... | [
"import sys",
"from PyQt4 import QtCore, QtGui, uic",
"import roslib",
"roslib.load_manifest(\"rospy\")",
"roslib.load_manifest(\"std_msgs\")",
"import rospy",
"from std_msgs.msg import String",
"from arm_cart_control_gui import Ui_Frame as QTArmControlGUIFrame",
"from arm_cart_control_backend impor... |
# -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'servoing_ui.ui'
#
# Created: Fri Jan 27 04:16:54 2012
# by: PyQt4 UI code generator 4.7.2
#
# WARNING! All changes made in this file will be lost!
from PyQt4 import QtCore, QtGui
class Ui_Frame(object):
def setupUi(self, Frame):
Frame.setObjectName("Frame")
Frame.resize(403, 274)
Frame.setFrameShape(QtGui.QFrame.StyledPanel)
Frame.setFrameShadow(QtGui.QFrame.Raised)
self.stop_moving = QtGui.QPushButton(Frame)
self.stop_moving.setEnabled(True)
self.stop_moving.setGeometry(QtCore.QRect(30, 20, 141, 131))
palette = QtGui.QPalette()
brush = QtGui.QBrush(QtGui.QColor(18, 33, 126))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.WindowText, brush)
brush = QtGui.QBrush(QtGui.QColor(193, 193, 193))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Button, brush)
brush = QtGui.QBrush(QtGui.QColor(18, 33, 126))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Text, brush)
brush = QtGui.QBrush(QtGui.QColor(18, 33, 126))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.ButtonText, brush)
brush = QtGui.QBrush(QtGui.QColor(197, 197, 197))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Base, brush)
brush = QtGui.QBrush(QtGui.QColor(163, 163, 163))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Window, brush)
brush = QtGui.QBrush(QtGui.QColor(255, 57, 252))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Highlight, brush)
brush = QtGui.QBrush(QtGui.QColor(18, 33, 126))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.WindowText, brush)
brush = QtGui.QBrush(QtGui.QColor(193, 193, 193))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Button, brush)
brush = QtGui.QBrush(QtGui.QColor(18, 33, 126))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Text, brush)
brush = QtGui.QBrush(QtGui.QColor(18, 33, 126))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.ButtonText, brush)
brush = QtGui.QBrush(QtGui.QColor(197, 197, 197))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Base, brush)
brush = QtGui.QBrush(QtGui.QColor(163, 163, 163))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Window, brush)
brush = QtGui.QBrush(QtGui.QColor(255, 57, 252))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Highlight, brush)
brush = QtGui.QBrush(QtGui.QColor(18, 33, 126))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.WindowText, brush)
brush = QtGui.QBrush(QtGui.QColor(193, 193, 193))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Button, brush)
brush = QtGui.QBrush(QtGui.QColor(18, 33, 126))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Text, brush)
brush = QtGui.QBrush(QtGui.QColor(18, 33, 126))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.ButtonText, brush)
brush = QtGui.QBrush(QtGui.QColor(163, 163, 163))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Base, brush)
brush = QtGui.QBrush(QtGui.QColor(163, 163, 163))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Window, brush)
brush = QtGui.QBrush(QtGui.QColor(255, 57, 252))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Highlight, brush)
self.stop_moving.setPalette(palette)
self.stop_moving.setStyleSheet("font: 75 18pt \"AlArabiya\";\n"
"selection-background-color: rgb(255, 57, 252);\n"
"background-color: rgb(255, 0, 0);\n"
"color: rgb(18, 33, 126);")
self.stop_moving.setObjectName("stop_moving")
self.find_ar_tag = QtGui.QPushButton(Frame)
self.find_ar_tag.setGeometry(QtCore.QRect(190, 20, 181, 61))
self.find_ar_tag.setStyleSheet("font: 75 18pt \"AlArabiya\";\n"
"background-color: rgb(55, 168, 255);")
self.find_ar_tag.setObjectName("find_ar_tag")
self.begin_servoing = QtGui.QPushButton(Frame)
self.begin_servoing.setGeometry(QtCore.QRect(190, 90, 181, 61))
self.begin_servoing.setStyleSheet("font: 75 18pt \"AlArabiya\";\n"
"background-color: rgb(34, 255, 78);")
self.begin_servoing.setObjectName("begin_servoing")
self.state_information = QtGui.QLabel(Frame)
self.state_information.setGeometry(QtCore.QRect(30, 160, 341, 91))
self.state_information.setStyleSheet("font: 16pt \"AlArabiya\";")
self.state_information.setObjectName("state_information")
self.retranslateUi(Frame)
QtCore.QMetaObject.connectSlotsByName(Frame)
def retranslateUi(self, Frame):
Frame.setWindowTitle(QtGui.QApplication.translate("Frame", "Frame", None, QtGui.QApplication.UnicodeUTF8))
self.stop_moving.setText(QtGui.QApplication.translate("Frame", "Stop\n"
"Moving", None, QtGui.QApplication.UnicodeUTF8))
self.find_ar_tag.setText(QtGui.QApplication.translate("Frame", "Find AR Tag", None, QtGui.QApplication.UnicodeUTF8))
self.begin_servoing.setText(QtGui.QApplication.translate("Frame", "Begin Servoing", None, QtGui.QApplication.UnicodeUTF8))
self.state_information.setText(QtGui.QApplication.translate("Frame", "State Information\n"
"", None, QtGui.QApplication.UnicodeUTF8))
| [
[
1,
0,
0.0855,
0.0085,
0,
0.66,
0,
154,
0,
2,
0,
0,
154,
0,
0
],
[
3,
0,
0.547,
0.8974,
0,
0.66,
1,
206,
0,
2,
0,
0,
186,
0,
99
],
[
2,
1,
0.5128,
0.812,
1,
0.51,
... | [
"from PyQt4 import QtCore, QtGui",
"class Ui_Frame(object):\n def setupUi(self, Frame):\n Frame.setObjectName(\"Frame\")\n Frame.resize(403, 274)\n Frame.setFrameShape(QtGui.QFrame.StyledPanel)\n Frame.setFrameShadow(QtGui.QFrame.Raised)\n self.stop_moving = QtGui.QPushButton... |
#! /usr/bin/python
import sys
import numpy as np
import roslib
roslib.load_manifest("hrl_pr2_arms")
roslib.load_manifest("kelsey_sandbox")
import rospy
from visualization_msgs.msg import Marker
from geometry_msgs.msg import Point, Quaternion, Vector3
from std_msgs.msg import ColorRGBA
from sensor_msgs.msg import JointState
import urdf_interface as urdf
import kdl_parser as kdlp
from hrl_pr2_arms.kdl_arm_kinematics import KDLArmKinematics
JOINT_STATE_INDS_R = [17, 18, 16, 20, 19, 21, 22]
JOINT_STATE_INDS_L = [29, 30, 28, 32, 31, 33, 34]
class JointForceViz:
def __init__(self, arm):
self.arm = arm
self.vis_pub = rospy.Publisher("force_torque_markers", Marker)
if arm == 'r':
self.arm_inds = JOINT_STATE_INDS_R
else:
self.arm_inds = JOINT_STATE_INDS_L
model = urdf.create_model_from_file("/etc/ros/diamondback/urdf/robot.xml")
tree = kdlp.tree_from_urdf_model(model)
chain = tree.getChain("torso_lift_link", "r_gripper_tool_frame")
link_dict = {0:0, 1:1, 2:2, 3:3, 4:4, 5:5, 6:6, 7:11}
self.kinematics = KDLArmKinematics(chain=chain, link_dict=link_dict)
self.colors = [ColorRGBA(1., 0., 0., 1.), ColorRGBA(0., 1., 0., 1.)]
rospy.Subscriber("joint_states", JointState, self.joint_states_cb)
self.last_CI = np.zeros((6, 6))
self.last_q_pos = np.zeros((7, 1))
def joint_states_cb(self, msg):
q_pos = np.mat([msg.position[i] for i in self.arm_inds]).T
#q_vel = np.mat([msg.velocity[i] for i in self.arm_inds]).T
q_vel = (q_pos - self.last_q_pos) / 0.01
q_effort = np.mat([msg.effort[i] for i in self.arm_inds]).T
fk_pos, fk_rot = self.kinematics.FK(q_pos)
J = self.kinematics.jacobian(q_pos)
F, res, rank, sing = np.linalg.lstsq(J.T, q_effort)
#print "Force:", F[0:3]
#print "Torque:", F[3:6]
self.publish_vector(fk_pos, 0.01 * F[0:3], 0)
self.publish_vector(fk_pos, 0.04 * F[3:6], 1)
H = self.kinematics.inertia(q_pos)
CI = self.kinematics.cart_inertia(q_pos)
#print q_vel
#print np.round(np.log10(np.fabs(CI)))
#print np.linalg.norm(H, 2), np.linalg.norm(CI, 2), np.linalg.cond(J * np.linalg.inv(H) * J.T), np.linalg.cond(H)
x_vel = J * q_vel
#print np.linalg.norm(x_vel[:3],2)
#print np.linalg.norm(x_vel, 2)
#print np.linalg.norm((CI - self.last_CI) / 0.01 * x_vel, 2)
print np.linalg.norm((CI * x_vel)[:3], 2)
#print np.around(CI * x_vel, 3)
self.last_CI = CI
self.last_q_pos = q_pos
def publish_vector(self, loc, v, m_id):
m = Marker()
m.header.frame_id = "torso_lift_link"
m.header.stamp = rospy.Time()
m.ns = "force_torque"
m.id = m_id
m.type = Marker.ARROW
m.action = Marker.ADD
m.points.append(Point(*loc))
m.points.append(Point(*(loc + v)))
m.scale = Vector3(0.01, 0.02, 0.01)
m.color = self.colors[m_id]
self.vis_pub.publish(m)
def main():
assert sys.argv[1] in ['r', 'l']
rospy.init_node("test_markers")
jfv = JointForceViz(sys.argv[1])
rospy.spin()
return
if __name__ == "__main__":
main()
| [
[
1,
0,
0.0326,
0.0109,
0,
0.66,
0,
509,
0,
1,
0,
0,
509,
0,
0
],
[
1,
0,
0.0435,
0.0109,
0,
0.66,
0.0588,
954,
0,
1,
0,
0,
954,
0,
0
],
[
1,
0,
0.0652,
0.0109,
0,
... | [
"import sys",
"import numpy as np",
"import roslib",
"roslib.load_manifest(\"hrl_pr2_arms\")",
"roslib.load_manifest(\"kelsey_sandbox\")",
"import rospy",
"from visualization_msgs.msg import Marker",
"from geometry_msgs.msg import Point, Quaternion, Vector3",
"from std_msgs.msg import ColorRGBA",
... |
#! /usr/bin/python
import sys
import numpy as np
import roslib
roslib.load_manifest("hrl_pr2_arms")
roslib.load_manifest("kelsey_sandbox")
import rospy
from visualization_msgs.msg import Marker
from geometry_msgs.msg import Point, Quaternion, Vector3
from std_msgs.msg import ColorRGBA
from sensor_msgs.msg import JointState
import urdf_interface as urdf
import kdl_parser as kdlp
from hrl_pr2_arms.kdl_arm_kinematics import KDLArmKinematics
JOINT_STATE_INDS_R = [17, 18, 16, 20, 19, 21, 22]
JOINT_STATE_INDS_L = [29, 30, 28, 32, 31, 33, 34]
class JointForceViz:
def __init__(self, arm):
self.arm = arm
self.vis_pub = rospy.Publisher("force_torque_markers", Marker)
if arm == 'r':
self.arm_inds = JOINT_STATE_INDS_R
else:
self.arm_inds = JOINT_STATE_INDS_L
model = urdf.create_model_from_file("/etc/ros/diamondback/urdf/robot.xml")
tree = kdlp.tree_from_urdf_model(model)
chain = tree.getChain("torso_lift_link", "r_gripper_tool_frame")
link_dict = {0:0, 1:1, 2:2, 3:3, 4:4, 5:5, 6:6, 7:11}
self.kinematics = KDLArmKinematics(chain=chain, link_dict=link_dict)
self.colors = [ColorRGBA(1., 0., 0., 1.), ColorRGBA(0., 1., 0., 1.)]
rospy.Subscriber("joint_states", JointState, self.joint_states_cb)
def joint_states_cb(self, msg):
q_pos = np.mat([msg.position[i] for i in self.arm_inds]).T
q_vel = np.mat([msg.velocity[i] for i in self.arm_inds]).T
q_effort = np.mat([msg.effort[i] for i in self.arm_inds]).T
fk_pos, fk_rot = self.kinematics.FK(q_pos)
J = self.kinematics.jacobian(q_pos)
F, res, rank, sing = np.linalg.lstsq(J.T, q_effort)
#print "Force:", F[0:3]
#print "Torque:", F[3:6]
self.publish_vector(fk_pos, 0.01 * F[0:3], 0)
self.publish_vector(fk_pos, 0.04 * F[3:6], 1)
def publish_vector(self, loc, v, m_id):
m = Marker()
m.header.frame_id = "torso_lift_link"
m.header.stamp = rospy.Time()
m.ns = "force_torque"
m.id = m_id
m.type = Marker.ARROW
m.action = Marker.ADD
m.points.append(Point(*loc))
m.points.append(Point(*(loc + v)))
m.scale = Vector3(0.01, 0.02, 0.01)
m.color = self.colors[m_id]
self.vis_pub.publish(m)
def main():
assert sys.argv[1] in ['r', 'l']
rospy.init_node("test_markers")
jfv = JointForceViz(sys.argv[1])
rospy.spin()
return
if __name__ == "__main__":
main()
| [
[
1,
0,
0.0405,
0.0135,
0,
0.66,
0,
509,
0,
1,
0,
0,
509,
0,
0
],
[
1,
0,
0.0541,
0.0135,
0,
0.66,
0.0588,
954,
0,
1,
0,
0,
954,
0,
0
],
[
1,
0,
0.0811,
0.0135,
0,
... | [
"import sys",
"import numpy as np",
"import roslib",
"roslib.load_manifest(\"hrl_pr2_arms\")",
"roslib.load_manifest(\"kelsey_sandbox\")",
"import rospy",
"from visualization_msgs.msg import Marker",
"from geometry_msgs.msg import Point, Quaternion, Vector3",
"from std_msgs.msg import ColorRGBA",
... |
#! /usr/bin/python
import numpy as np, math
import sys
import os
from threading import RLock
import threading
import roslib; roslib.load_manifest('hrl_pr2_lib')
import rospy
import actionlib
from std_msgs.msg import String
from geometry_msgs.msg import Point, Pose, Quaternion, PoseStamped, PointStamped
import random
import hrl_lib.util
from hrl_lib.rutils import GenericListener
import hrl_lib.viz as viz
from hrl_lib import tf_utils
from hrl_lib.keyboard_input import KeyboardInput
from hrl_lib.transforms import rotX, rotY, rotZ
from hrl_lib.data_process import signal_list_variance
from tf.transformations import *
from hrl_pr2_lib.pr2_arms import PR2Arms
from hrl_pr2_lib.perception_monitor import ArmPerceptionMonitor, generate_mean_grasp
from visualization_msgs.msg import MarkerArray, Marker
import dynamic_reconfigure.client
import tf
# from pr2_gripper_reactive_approach.controller_manager import ControllerManager
from hrl_pr2_lib.hrl_controller_manager import HRLControllerManager as ControllerManager
from pr2_controllers_msgs.msg import JointTrajectoryGoal, PointHeadAction, PointHeadGoal
import object_manipulator.convert_functions as cf
from object_manipulator.cluster_bounding_box_finder import ClusterBoundingBoxFinder
from tabletop_object_detector.srv import TabletopDetection
from tabletop_object_detector.msg import TabletopDetectionResult
from laser_interface.pkg import CURSOR_TOPIC, MOUSE_DOUBLE_CLICK_TOPIC
#SETUP_POS = (0.62, 0.0, 0.035)
#SETUP_POS_ANGS = [-0.6260155429349421, -0.53466276262236689, -1.9803303473514324, -1.1593322538276705, -0.89803655400181404, -1.4467120153069799, -2.728422563953746]
#MAX_JERK = 0.2
NUM_X = 7#3#9#7 #4#7
NUM_Y = 11#3#15#9 #4#20
NUM_N = 3 #4
NUM_ROT = 6
# near to far, left to right
RECT = ((0.45, 0.25), (0.70, -0.25))#((0.4, 0.35), (0.8, -0.35))#((0.45, 0.10), (0.65, -0.10))#((0.4, 0.20), (0.7, -0.20))#((0.4, 0.35), (0.8, -0.35)) #((0.55, 0.10), (0.7, -0.10)) #((0.4, -0.77), (0.75, 0.23))
ARM = 0 # right arm
if ARM == 0:
armc = 'r'
else:
armc = 'l'
HOVER_Z = -0.10
GRASP_DIST = 0.30
GRASP_VELOCITY = 0.28 # 0.15
GRIPPER_POINT = np.array([0.23, 0.0, 0.0])
JOINTS_BIAS = [0., -.25, -1., 0., 0., 0.5, 0.]
BIAS_RADIUS = 0.012
GRASP_TIME = 2.0
SETUP_VELOCITY = 0.4 # 0.15
STD_DEV = 2.3 #3.5 #1.9
NOISE_DEV = 0.0
DETECT_ERROR = -0.02
STD_DEV_DICT = { "accelerometer" : np.array([2.4, 2.9, 2.9]),
"joint_angles" : np.array([2.8, 2.8, 3.8, 2.8, 400.0, 1.25, 400.0]),
"joint_efforts" : np.array([30.0, 15.0, 11.0, 16.0, 12.0, 3.0, 125.0]),
"joint_velocities" : np.array([3.4, 6.4, 18.4, 3.4, 3.4, 3.4, 3.4]),
"r_finger_periph_pressure" : np.array([60.0]*6),
"r_finger_pad_pressure" : np.array([60.0]*15),
"l_finger_periph_pressure" : np.array([60.0]*6),
"l_finger_pad_pressure" : np.array([60.0]*15) }
TOL_THRESH_DICT = { "accelerometer" : np.array([0.3, 0.3, 0.3]),
"joint_velocities" : np.array([0.45]*7),
"joint_angles" : np.array([0.05, 0.05, 0.05, 0.05, 0.05, 0.04, 0.05]),
"joint_efforts" : np.array([3.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]),
"r_finger_periph_pressure" : np.array([10.0]*6),
"r_finger_pad_pressure" : np.array([10.0]*15),
"l_finger_periph_pressure" : np.array([10.0]*6),
"l_finger_pad_pressure" : np.array([10.0]*15) }
PERCEPT_MON_LIST = None #["accelerometer"]
PERCEPT_GRASP_LIST = None
PRESSURE_LIST =["r_finger_periph_pressure",
"r_finger_pad_pressure",
"l_finger_periph_pressure",
"l_finger_pad_pressure"]
# "joint_efforts" ] #["joint_angles"]#["joint_velocities"] #["r_finger_periph_pressure"] #["joint_efforts"] #["joint_angles"]
##STD_DEV_DICT = None
MONITOR_WINDOW = 50
PICKLES_LOC = "//src//hrl_pr2_lib//pickles//"
GRASP_CONFIGS_FILE = "grasp_configs.pickle"
GRASP_DATA_FILE = "grasp_data.pickle"
GRASP_MODELS_FILE = "grasp_models.pickle"
GRASP_MODELS_TRIMMED_FILE = "grasp_models_trimmed.pickle"
ZEROS_FILE = "current_zeros.pickle"
SQR_DIFF_MAP = "sqr_diff_map.pickle"
GRASP_IND_PREFIX = "model_indexed//grasp_model"
GRASP_INDEX_FILE = "model_indexed//grasp_model_index.pickle"
GRASP_DATA_INDEX_FILE = "data_indexed//grasp_data_index.pickle"
GRASP_DATA_PREFIX = "data_indexed//grasp_data"
TEST_DATA_FILE = "test_data.pickle"
node_name = "simple_grasp_learner"
def log(str):
rospy.loginfo(node_name + ": " + str)
def load_pickle(fn):
global PACKAGE_LOC
return hrl_lib.util.load_pickle(PACKAGE_LOC + PICKLES_LOC + fn)
def save_pickle(p, fn):
global PACKAGE_LOC
hrl_lib.util.save_pickle(p, PACKAGE_LOC + PICKLES_LOC + fn)
def file_exists(fn):
global PACKAGE_LOC
return os.path.exists(PACKAGE_LOC + PICKLES_LOC + fn)
def setup_package_loc():
global PACKAGE_LOC
import os
grep = os.popen("rospack find hrl_pr2_lib|grep hrl_pr2_lib")
PACKAGE_LOC = grep.readlines()[0].rstrip()
def save_parameters(param_filename):
params = { "ARM" : ARM,
"NUM_X" : NUM_X,
"NUM_Y" : NUM_Y,
"NUM_N" : NUM_N,
"NUM_ROT" : NUM_ROT,
"RECT" : RECT,
"HOVER_Z" : HOVER_Z,
"GRASP_DIST" : GRASP_DIST,
"GRASP_TIME" : GRASP_TIME,
"GRASP_VELOCITY" : GRASP_VELOCITY,
"SETUP_VELOCITY" : SETUP_VELOCITY,
"STD_DEV" : STD_DEV,
"NOISE_DEV" : NOISE_DEV,
"GRIPPER_POINT" : GRIPPER_POINT,
"JOINTS_BIAS" : JOINTS_BIAS,
"BIAS_RADIUS" : BIAS_RADIUS,
"DETECT_ERROR" : DETECT_ERROR,
"STD_DEV_DICT" : STD_DEV_DICT,
"PICKLES_LOC" : PICKLES_LOC,
"GRASP_CONFIGS_FILE" : GRASP_CONFIGS_FILE,
"GRASP_DATA_FILE" : GRASP_DATA_FILE,
"GRASP_MODELS_FILE" : GRASP_MODELS_FILE,
"ZEROS_FILE" : ZEROS_FILE,
"SQR_DIFF_MAP" : SQR_DIFF_MAP,
"GRASP_IND_PREFIX" : GRASP_IND_PREFIX,
"GRASP_INDEX_FILE" : GRASP_INDEX_FILE,
"TEST_DATA_FILE" : TEST_DATA_FILE,
"MONITOR_WINDOW" : MONITOR_WINDOW,
"PERCEPT_MON_LIST" : PERCEPT_MON_LIST }
save_pickle(params, param_filename)
def load_parameters():
params = load_pickle(param_filename)
for k in params:
globals()[k] = params[k]
##
# Transforms the given position by the offset position in the given quaternion
# rotation frame
#
# @param pos the current positions
# @param quat quaternion representing the rotation of the frame
# @param off_point offset to move the position inside the quat's frame
# @return the new position as a matrix column
def transform_in_frame(pos, quat, off_point):
invquatmat = np.mat(quaternion_matrix(quat))
invquatmat[0:3,3] = np.mat(pos).T
trans = np.matrix([off_point[0],off_point[1],off_point[2],1.]).T
transpos = invquatmat * trans
return transpos.T.A[0,0:3]
# def get_setup_pos_angs():
# arms = PR2Arms()
# arms.move_arm(ARM, SETUP_POS, rotY(np.pi / 2.), 4.)
# arms.wait_for_arm_completion(ARM)
# print arms.get_joint_angles(ARM)
def get_xyr_list():
grasp_xyr_list = []
for x in np.linspace(RECT[0][0], RECT[1][0], NUM_X):
for y in np.linspace(RECT[0][1], RECT[1][1], NUM_Y):
for r in np.linspace(0., np.pi, NUM_ROT+1)[0:-1]:
grasp_xyr_list += [(x,y,r)]
return grasp_xyr_list
def create_gripper_pose(x, y, z, quat):
point = [x, y, z]
point = transform_in_frame(point, np.array(quat), -GRIPPER_POINT).tolist()
pose = point + quat
goal_pose = cf.create_pose_stamped(pose, "torso_lift_link")
goal_pose.header.stamp = rospy.Time.now()
return goal_pose
def get_gripper_pose(gripper_rot):
gripper_rot = normalize_rot(gripper_rot)
quat1 = quaternion_about_axis(np.pi/2., (0, 1, 0))
quat2 = quaternion_about_axis(gripper_rot, (0, 0, 1))
quat = quaternion_multiply(quat2, quat1)
return quat
def create_goal_pose(x, y, z, gripper_pose):
point = [x, y, z]
point = transform_in_frame(point, gripper_pose, -GRIPPER_POINT).tolist()
pose = point + gripper_pose.tolist()
goal_pose = cf.create_pose_stamped(pose, "torso_lift_link")
goal_pose.header.stamp = rospy.Time.now()
return goal_pose
def move_to_grasp_pos(cm, grasp_pose, block=True):
grasp_pose.header.stamp = rospy.Time.now()
cm.move_cartesian_ik(grasp_pose, collision_aware = False, blocking = block,
step_size = .005, pos_thres = .02, rot_thres = .1,
settling_time = rospy.Duration(1.0),
vel = SETUP_VELOCITY)
def upward_lift(cm, grasp_pose, block=True):
grasp_pose.header.stamp = rospy.Time.now()
cm.move_cartesian_ik(grasp_pose, collision_aware = False, blocking = block,
step_size = .005, pos_thres = .02, rot_thres = .1,
settling_time = rospy.Duration(1.0),
vel = GRASP_VELOCITY,
joints_bias = -np.array(JOINTS_BIAS), bias_radius = BIAS_RADIUS)
def downward_grasp(cm, goal_pose, block=True):
goal_pose.header.stamp = rospy.Time.now()
return cm.move_cartesian_ik(goal_pose, collision_aware = False, blocking = block,
step_size = .005, pos_thres = .02, rot_thres = .1,
settling_time = rospy.Duration(GRASP_TIME),
joints_bias = JOINTS_BIAS, bias_radius = BIAS_RADIUS,
vel = GRASP_VELOCITY)
def save_grasp_configurations():
arms = PR2Arms()
grasp_xyr_list = get_xy_list()
grasp_configs = []
setup = False
for xy in grasp_xyr_list:
# if not setup:
# # Move to setup position in the middle of the grasp space
# print "Setting up"
# arms.set_joint_angles(ARM, SETUP_POS_ANGS, 3.)
# arms.wait_for_arm_completion(ARM)
# rospy.sleep(0.5)
# setup = True
if arms.can_move_arm(ARM, [xy[0], xy[1], HOVER_Z], rotY(np.pi / 2.)):
print "Moving to pos (%1.2f, %1.2f)" % xy
arms.grasp_biased_move_arm(ARM, [xy[0], xy[1], HOVER_Z], rotY(np.pi / 2.), 3.)
arms.wait_for_arm_completion(ARM)
rospy.sleep(0.5)
angs = arms.get_joint_angles(ARM)
grasp_configs += [(xy, angs)]
setup = False
else:
print "Can't move to to pos (%1.2f, %1.2f)" % xy
# grasp_configs += [(xy, None)]
save_pickle(grasp_configs, GRASP_CONFIGS_FILE)
print "Configurations:"
print_configs(grasp_configs)
def print_configs(grasp_configs):
for config in grasp_configs:
if config[1] is not None:
print "(%1.2f, %1.2f):" % config[0], ", ".join(["%1.2f" % x for x in config[1]])
else:
print "(%1.2f, %1.2f):" % config[0], "No config"
def trim_bad_grasps(filename):
grasp_configs = load_pickle(filename)
print_configs(grasp_configs)
new_configs = []
for config in grasp_configs:
if config[1] is not None:
new_configs += [config]
print_configs(new_configs)
save_pickle(new_configs, filename)
def pauser(ki):
if ki.kbhit():
ch = ki.getch()
if ch == 'p':
print "PAUSED"
while not rospy.is_shutdown() and ch != 'c':
ch = ki.getch()
rospy.sleep(0.1)
print "CONTINUING"
def write_index_file(prefix = GRASP_DATA_PREFIX, index = GRASP_DATA_INDEX_FILE):
grasp_xyr_list = get_xyr_list()
grasps = []
for xyr in grasp_xyr_list:
filename = prefix + "%04d-%04d-%04d.pickle" % (int(xyr[0]*100),int(xyr[1]*100),int(xyr[2]*100))
if file_exists(filename):
grasps.append([xyr, filename])
save_pickle(grasps, index)
def collect_grasp_data(ki, generate_models=False, skip_grasp=False):
cm = ControllerManager(armc)
apm = ArmPerceptionMonitor(ARM, tf_listener=cm.tf_listener, percept_mon_list=None)
# if restart:
# grasp_data = load_pickle(GRASP_DATA)
# grasp_xyr_list = zip(*grasp_data)[0]
# else:
# grasp_xyr_list = get_xy_list()
# grasp_data = []
grasp_xyr_list = get_xyr_list()
grasp_data = []
grasp_index = []
print "Opening gripper"
cm.command_gripper(0.08, -1.0, False)
cm.gripper_action_client.wait_for_result(rospy.Duration(4.0))
for c, xyr in enumerate(grasp_xyr_list):
# if c < 257:
# continue
if rospy.is_shutdown():
return
print "---------------------------------------------------"
print "%1.2f completion" % (float(c) / len(grasp_xyr_list))
zeros = None
# Do grasping num_n times
for i in range(NUM_N):
pauser(ki)
# Move to grasp position
print "Moving to grasp position (%1.2f, %1.2f, %1.2f)" % xyr
grasp_pose = create_goal_pose(xyr[0], xyr[1], HOVER_Z, get_gripper_pose(xyr[2]))
setup_result = cm.move_arm_pose_biased(grasp_pose, JOINTS_BIAS, SETUP_VELOCITY,
blocking = True)
rospy.sleep(0.5)
if skip_grasp:
break
if setup_result is not None:
if zeros is None:
# wait for a bit to get the zeros here
rospy.sleep(0.5)
zeros = apm.get_zeros(0.6)
goal_pose = create_goal_pose(xyr[0], xyr[1],
HOVER_Z - GRASP_DIST, get_gripper_pose(xyr[2]))
# start gathering data
apm.start_training()
# move arm down
print "Moving arm down"
sttime = rospy.Time.now().to_sec()
result = downward_grasp(cm, goal_pose, block=True)
endtime = rospy.Time.now().to_sec()
print "dur:", endtime - sttime
print result
print "Finished moving arm"
length = apm.stop_training()
print "length:", length
print "len/dur", length / (endtime - sttime)
rospy.sleep(0.5)
else:
break
# can't move to initial position
if setup_result is None or skip_grasp:
continue
fn = None
if result != "no solution" and generate_models:
models = apm.generate_models()
else:
models = None
if result != "no solution":
# grasp_data += [(xyr, None, apm.datasets, models, zeros)]
fn = save_grasp([xyr, None, apm.datasets, models, zeros], GRASP_DATA_PREFIX)
else:
print "Grasp Failed, not adding data"
grasp_index.append([xyr, fn])
apm.clear_vars()
print "Saving Data"
#save_pickle(grasp_data, GRASP_DATA_FILE)
save_pickle(grasp_index, GRASP_DATA_INDEX_FILE)
print "Data save complete"
return None #grasp_data
def load_data_and_generate(grasp_data):
ret = []
n = 0
for grasp in grasp_data:
apm = ArmPerceptionMonitor(ARM, percept_mon_list=PERCEPT_MON_LIST)
apm.datasets = grasp[2]
apm.generate_models()
ret += [(grasp[0], grasp[1], grasp[2], apm.models, grasp[4])]
n += 1
print "Generated %d models" % (n)
# save_pickle(ret, GRASP_MODELS_FILE)
return ret
def generate_space_models():
mean_grasps = []
grasps = []
grasp_xyr_list = get_xyr_list()
for grasp in grasp_data:
mean_grasps.append([grasp[0], generate_mean_grasp(grasp[2])])
def dist1(o):
return np.fabs(o[0][0] - x) + np.fabs(o[0][1] - y)
xs = (RECT[1][0] - RECT[0][0]) / (NUM_X - 1)
ys = (RECT[0][1] - RECT[1][1]) / (NUM_Y - 1)
rs = np.pi / NUM_R
st = [RECT[0][0] + xs/2., RECT[1][1] + ys/2., rs]
num_gen = 0
for i in range(NUM_X - 1):
for j in range(NUM_Y - 1):
for k in range(NUM_R):
print "Number of models generated:", num_gen
num_gen += 1
pauser()
close_models = []
def dist1(o):
return np.fabs(o[0][0] - st[0]) + np.fabs(o[0][1] - st[1])
def rotdist(o):
if np.allclose(o[0][2], 0.0):
# for loop around
return min(np.fabs(np.pi - st[2]), np.fabs(0. - st[2]))
else:
return np.fabs(o[0][2] - st[2])
for i, dist in enumerate(map(dist1, mean_grasps)):
if np.allclose(dist, (xs/2. + ys/2.), 0.0001) and np.allclose(rotdist(xyr_index[i]), rs/2., 0.0001):
close_models += [mean_grasps[i]]
if len(close_models) < 5:
print "Rejecting %1.2f, %1.2f, %1.2f with number close models = %d", (
st[0], st[1], st[2], len(close_models))
continue
# find the average case over the several runs
models = {}
for p in close_models:
lens = [len(m) for m in close_models[p]]
max_len = np.max(lens)
signals = zip(*close_models[p])
ammodels, vmodels = [], []
for signal in signals:
avg_means_model = np.array([0.] * max_len)
sqr_means_model = np.array([0.] * max_len)
for i in range(max_len):
n = 0
for j in range(len(signal)):
if i < len(signal[j]):
avg_means_model[i] += close_models[j][i]
sqr_means_model[i] += close_models[j][i] ** 2
n += 1
avg_means_model[i] /= n
sqr_means_model[i] /= n
vars_model = signal_smooth(sqr_means_model, 30) - avg_means_model
ammodels.append(avg_means_model)
vmodels.append(vars_model)
models[p] = {}
models[p]["mean"] = zip(*ammodels)
models[p]["variance"] = zip(*vmodels)
grasp = [st, None, None, models, None]
save_grasp(grasp, GRASP_IND_PREFIX)
st[2] += rs
st[1] += ys
st[0] += xs
# def test_monitor(grasp_data):
# apm = ArmPerceptionMonitor(ARM)
# j = 0
# while grasp_data[j][1] is None:
# j += 1
# apm.models = grasp_data[j][3]
# def print_warn():
# print "Warning! Outside model"
# apm.begin_monitoring(contingency=print_warn)
# raw_input()
# apm.end_monitoring()
def save_current_zeros(filename=ZEROS_FILE):
apm = ArmPerceptionMonitor(ARM, percept_mon_list=PERCEPT_MON_LIST)
zeros = apm.get_zeros()
print "Zeros:", zeros
save_pickle(zeros, filename)
def load_current_zeros(filename=ZEROS_FILE):
return load_pickle(filename)
def is_obj_in_gripper(cm=None):
if cm is None:
cm = ControllerManager(armc)
return cm.get_current_gripper_opening() > 0.01
def open_gripper(cm=None, blocking = False):
if cm is None:
cm = ControllerManager(armc)
cm.command_gripper(0.08, -1.0, False)
if blocking:
cm.gripper_action_client.wait_for_result(rospy.Duration(4.0))
def perform_grasp(x, y, z=None, gripper_rot = np.pi / 2., grasp=None, is_place=False,
is_grasp=True, collide = True, return_pose=True,
zeros = None, grasp_data=None, cm=None, apm=None):
print "Performing grasp (%1.2f, %1.2f), rotation: %1.2f" % (x, y, gripper_rot)
gripper_rot = normalize_rot(gripper_rot)
if cm is None:
cm = ControllerManager(armc)
if apm is None:
apm = ArmPerceptionMonitor(ARM, percept_mon_list=PERCEPT_GRASP_LIST)
if grasp is None:
grasp = get_grasp_model(x, y, gripper_rot, grasp_data = grasp_data)
#apm.datasets = grasp[2]
#apm.models = grasp[3]
#apm.model_zeros = grasp[4]
#print "Model zeros:", grasp[4]
print "Beginning grasp"
result = "no solution"
iters = 0
while True:
# Move to grasp position
print "Moving to initial grasp position"
# cm.command_joint_trajectory([grasp[1]], SETUP_VELOCITY, blocking = True)
# print "Moving to final grasp position"
grasp_pose = create_goal_pose(x, y, HOVER_Z, get_gripper_pose(gripper_rot))
cm.move_arm_pose_biased(grasp_pose, JOINTS_BIAS, SETUP_VELOCITY, blocking = False)
if not is_place and is_grasp:
# open gripper
print "Opening gripper"
cm.command_gripper(0.08, -1.0, False)
cm.gripper_action_client.wait_for_result(rospy.Duration(2.0))
cm.wait_joint_trajectory_done()
rospy.sleep(0.5)
#if zeros is None:
# zeros = apm.get_zeros(0.6)
# print "Current zeros:", zeros
goal_pose = create_goal_pose(x, y, HOVER_Z - GRASP_DIST, get_gripper_pose(gripper_rot))
class Collision():
def __init__(self):
self.collided = False
# start gathering data
def on_collision(self):
print "Collision!"
self.collided = True
while not cm.check_joint_trajectory_done():
cm.joint_action_client.cancel_all_goals()
rospy.sleep(0.01)
if rospy.is_shutdown():
return None
col = Collision()
def rotate_acceleration(data):
return data
data -= zeros["accelerometer"]
a = gripper_rot
data[1] = np.cos(a) * data[1] - np.sin(a) * data[2]
data[2] = np.sin(a) * data[1] + np.cos(a) * data[2]
data += zeros["accelerometer"]
return data
transforms = { "accelerometer" : rotate_acceleration }
while not rospy.is_shutdown() and len(grasp) < 5:
rospy.sleep(0.1)
apm.begin_monitoring(grasp[3],
model_zeros = grasp[4],
contingency=col.on_collision, window_size=MONITOR_WINDOW,
current_zeros=zeros, std_dev_default=STD_DEV,
std_dev_dict = STD_DEV_DICT,
tol_thresh_dict = TOL_THRESH_DICT,
noise_dev_default=NOISE_DEV, collide=collide,
transform_dict = transforms)
# move arm down
print "Moving arm down"
startt = rospy.Time.now().to_sec()
result = downward_grasp(cm, goal_pose, block = False)
print "Grasp result:", result
if result == "no solution":
# Jiggle it to see if it works
apm.end_monitoring()
dx = random.uniform(-0.015, 0.015)
dy = random.uniform(-0.015, 0.015)
x += dx
y += dy
iters += 1
# Tried too many times
if iters == 4:
print "Cannot find IK solution!!!" * 8
return
else:
continue
else:
break
if z is None:
while not cm.check_joint_trajectory_done():
if col.collided:
cm.joint_action_client.cancel_all_goals()
rospy.sleep(0.01)
if rospy.is_shutdown():
return None
else:
while not cm.check_joint_trajectory_done():
if col.collided:
cm.joint_action_client.cancel_all_goals()
wrist_pose = cm.get_current_wrist_pose_stamped("torso_lift_link")
p = wrist_pose.pose.position
o = wrist_pose.pose.orientation
affector_pos = transform_in_frame([p.x, p.y, p.z],
[o.x, o.y, o.z, o.w], GRIPPER_POINT)
if affector_pos[2] <= z:
print "Reached z position"
print "Affector position:", affector_pos
while not cm.check_joint_trajectory_done():
cm.joint_action_client.cancel_all_goals()
rospy.sleep(0.01)
break
rospy.sleep(0.01)
if rospy.is_shutdown():
return None
endt = rospy.Time.now().to_sec()
print "Grasp duration:", startt - endt
print "Finished moving arm"
avg_list = apm.end_monitoring()
rospy.sleep(0.1)
global z_sum
for k in apm.z_avg:
if not k in z_sum:
z_sum[k] = np.copy(apm.z_avg[k])
else:
z_sum[k] += apm.z_avg[k]
if not is_place and is_grasp:
print "Closing gripper"
cm.command_gripper(0.0, 30.0, True)
print "Gripper closed"
elif is_place:
print "Opening gripper"
cm.command_gripper(0.08, -1.0, True)
print "Gripper opened"
if return_pose and is_grasp:
print "Moving back to grasp position"
cm.move_arm_pose_biased(grasp_pose, JOINTS_BIAS, SETUP_VELOCITY, blocking = True)
#upward_lift(cm, grasp_pose, block=True)
print "Grasp complete!"
return grasp, avg_list, col.collided, zeros
# def perform_template_grasp(grasp):
# cm = ControllerManager(armc)
# apm = ArmPerceptionMonitor(ARM, percept_mon_list=["accelerometer"])
#
# apm.datasets = grasp[2]
# apm.models = grasp[3]
#
# # Move to grasp position
# print "Moving to grasp position"
# cm.command_joint(grasp[1])
# cm.wait_joint_trajectory_done()
# rospy.sleep(0.5)
#
# goal_pose = create_goal_pose(grasp[0][0], grasp[0][1], HOVER_Z - GRASP_DIST)
#
# # start gathering data
# def print_collision():
# print "Collision!"
# cm.freeze_arm()
# apm.begin_monitoring(contingency=print_collision, window_size=MONITOR_WINDOW)
#
# # move arm down
# print "Moving arm down"
# downward_grasp(cm, goal_pose, block = False)
# cm.wait_joint_trajectory_done()
# print "Finished moving arm"
#
# avg_list = apm.end_monitoring()
# rospy.sleep(0.5)
#
# return avg_list
def display_grasp_data(grasps, percept="accelerometer", indicies=range(3),
std_dev=STD_DEV, noise_dev_add=NOISE_DEV, monitor_data=[],
std_dev_dict=STD_DEV_DICT,
tol_thresh_dict=TOL_THRESH_DICT,
model_zeros=None, monitor_zeros=None,
plot_data=False, colors=None):
import matplotlib.pyplot as plt
if colors is None:
colors = ['r', 'b', 'g', 'c']
j = 0
rows = len(grasps)
cols = len(indicies)
for i, grasp in enumerate(grasps):
models = grasp[3]
means = models[percept]["mean"]
vars = models[percept]["variance"]
maxs = models[percept]["max"]
mins = models[percept]["min"]
if "smoothed_signals" in models[percept]:
signals = models[percept]["smoothed_signals"]
zip_signals = [ zip(*sig) for sig in signals ]
else:
signals = None
zip_signals = []
if "noise_variance" in models[percept]:
noise_var = models[percept]["noise_variance"]
noise_dev = np.sqrt(noise_var)
else:
noise_var = None
noise_dev = None
print "noise variance", noise_var
zip_means = np.array(zip(*means))
zip_vars = np.array(zip(*vars))
zip_maxs = np.array(zip(*maxs))
zip_mins = np.array(zip(*mins))
# print "monitor_data", monitor_data
zip_monitors = []
for d in monitor_data:
zip_monitors += [zip(*d[percept])]
graph_means, graph_devs, mmax, mmin = [], [], [], []
for w in indicies:
graph_means += [zip_means[w]]
graph_devs += [np.sqrt(zip_vars[w])]
if std_dev_dict is not None and percept in std_dev_dict:
std_dev = std_dev_dict[percept][w]
if tol_thresh_dict is not None and percept in tol_thresh_dict:
tol_thresh = tol_thresh_dict[percept][w]
else:
tol_thresh = 0.
if noise_dev is not None:
noise_dev_term = noise_dev[w] * noise_dev_add
else:
noise_dev_term = 0.
# mmax += graph_means[w] + graph_devs[w] * std_dev + noise_dev_term
# + tol_thresh]
# mmin += [graph_means[w] - graph_devs[w] * std_dev - noise_dev_term
# - tol_thresh]
for k in range(len(indicies)):
plt.subplot(rows, cols, i*cols + 1 + k)
cnum = 0
if plot_data:
for stream in grasp[2][percept]:
# s_mag = [np.sqrt(x[1][0]**2 + x[1][1]**2 + x[1][2]**2) for x in stream]
# plt.plot(s_mag,colors[cnum])
plt.plot([x[1][k] for x in stream],colors[cnum])
cnum += 1
cnum %= len(colors)
for sig in zip_signals:
if indicies[k] < len(sig):
plt.plot(sig[indicies[k]], colors[2])
if i < len(zip_monitors):
zip_monitor = zip_monitors[i]
len_diff = len(graph_means[k]) - len(zip_monitor[indicies[k]])
add_vals = [zip_monitor[indicies[k]][0]] * MONITOR_WINDOW
# add_vals = [zip_monitor[indicies[k]][0]] * len_diff
print len_diff
g = np.array(add_vals + list(zip_monitor[indicies[k]]))
# g += grasp[4][percept][indicies[k]] - monitor_zeros[i][percept][indicies[k]]
plt.plot(g.tolist(),colors[3])
plt.plot(graph_means[k], colors[0])
plt.plot(zip_maxs[indicies[k]], colors[1])
plt.plot(zip_mins[indicies[k]], colors[1])
# plt.plot(mmax[k], colors[1])
# plt.plot(mmin[k], colors[1])
plt.title("%1.2f, %1.2f: coord %d" % (grasp[0][0], grasp[0][1], k))
j += 1
plt.show()
def die():
sys.exit()
def test_num_samples(percept="accelerometer"):
# This function proves that adding more than 3-4 grasps per location is unnecessary
# Grasping trajectories are very repeatable given a specific grasping location.
# The issue comes from more from shifting of the actual trajectory from expected
# given a grasping location just a few cm off. The models can handle the trajectory
# so long as it is not much more than 5cm away from the training model.
grasp_data = load_pickle(GRASP_DATA_FILE)[0:1]
data_list = grasp_data[0][2][percept]
for i in [3, 6, 9]:
apm = ArmPerceptionMonitor(ARM, percept_mon_list=PERCEPT_MON_LIST)
grasp_data[0][2][percept] = data_list[0:i+1]
apm.datasets = grasp_data[0][2]
apm.generate_models()
grasp_data[0][3][percept] = apm.models[percept]
if i != 3:
colors = ['m', 'y', 'k', 'r']
else:
colors = None
display_grasp_data(grasp_data, percept, rows=1)
def detect_tabletop_objects():
cbbf = ClusterBoundingBoxFinder()
object_detector = rospy.ServiceProxy("/object_detection", TabletopDetection)
detects = object_detector(True, False).detection
object_detector.close()
if detects.result != 4:
print "Detection failed (err %d)" % (detects.result)
return []
table_z = detects.table.pose.pose.position.z
objects = []
for cluster in detects.clusters:
(object_points,
object_bounding_box_dims,
object_bounding_box,
object_to_base_link_frame,
object_to_cluster_frame) = cbbf.find_object_frame_and_bounding_box(cluster)
# print "bounding box:", object_bounding_box
(object_pos, object_quat) = cf.mat_to_pos_and_quat(object_to_cluster_frame)
angs = euler_from_quaternion(object_quat)
print "angs:", angs
# position is half of height
object_pos[2] = table_z + object_bounding_box[1][2] / 2. + DETECT_ERROR
print "pos:", object_pos
print "table_z:", table_z
objects += [[object_pos, angs[2]]]
return objects
def grasp_object(obj, grasp=None, collide=True, is_place=False, zeros=None, cm=None, apm=None):
if collide:
return perform_grasp(obj[0][0], obj[0][1], is_place=is_place,
gripper_rot=obj[1], grasp=grasp, zeros=zeros, cm=cm, apm=apm)
else:
return perform_grasp(obj[0][0], obj[0][1], z=obj[0][2], is_place=is_place,
gripper_rot=obj[1], grasp=grasp, zeros=zeros, cm=cm, apm=apm)
def grasp_closest_object(x, y, grasp=None, collide=True, repeat=True, zeros=None, cm=None, apm=None):
def dist(o):
return (o[0][0] - x) ** 2 + (o[0][1] - y) ** 2
grasped = False
num_tries = 0
point_head([x,y,-0.2])
while not grasped and num_tries < 4:
print "Detect in"
change_projector_mode(True)
rospy.sleep(0.6)
detect_tries = 0
objects = None
while (objects is None or len(objects) == 0):
objects = detect_tabletop_objects()
rospy.sleep(0.6)
detect_tries += 1
if detect_tries == 3 and (objects is None or len(objects) == 0):
print "Cannot detect any objects"
return None, None, None, None, None
print "Detect out"
if len(objects) > 0:
obj = min(objects, key=dist)
# Get better look
if True:
point_head(obj[0])
rospy.sleep(0.2)
print "Detect2 in"
objects = detect_tabletop_objects()
print "Detect2 out"
obj = min(objects, key=dist)
change_projector_mode(False)
(grasp, avg_list, collided, zeros) = grasp_object(obj, grasp=grasp,
collide=collide, zeros=zeros, cm=cm, apm=apm)
rospy.sleep(0.2)
grasped = is_obj_in_gripper(cm)
if repeat and not grasped:
num_tries += 1
continue
if grasped:
print "Grasp success!"
return obj, grasp, avg_list, collided, zeros
else:
print "Grasp failure"
return obj, grasp, avg_list, collided, zeros
else:
print "No objects near point"
return None, None, None, None, None
def grasp_demo():
cm = ControllerManager(armc)
apm = ArmPerceptionMonitor(ARM, percept_mon_list=PERCEPT_MON_LIST)
grasps, avg_lists = [], []
(obj1, grasp, avg_list, collided, zeros) = grasp_closest_object(0.45, 0.1, cm=cm, apm=apm)
grasps += [grasp]
avg_lists += [avg_list]
obj1pl = [[obj1[0][0], obj1[0][1] - 0.18], obj1[1]]
(grasp, avg_list, collided, zeros) = grasp_object(obj1pl, is_place=True, zeros=zeros, cm=cm, apm=apm)
grasps += [grasp]
avg_lists += [avg_list]
(obj2, grasp, avg_list, collided, zeros) = grasp_closest_object(0.7, 0.1, zeros=zeros, cm=cm, apm=apm)
grasps += [grasp]
avg_lists += [avg_list]
(grasp, avg_list, collided, zeros) = grasp_object(obj1, is_place=True, zeros=zeros, cm=cm, apm=apm)
grasps += [grasp]
avg_lists += [avg_list]
(obj3, grasp, avg_list, collided, zeros) = grasp_closest_object(obj1pl[0][0], obj1pl[0][1], zeros=zeros, cm=cm, apm=apm)
grasps += [grasp]
avg_lists += [avg_list]
(grasp, avg_list, collided, zeros) = grasp_object(obj2, is_place=True, zeros=zeros, cm=cm, apm=apm)
grasps += [grasp]
avg_lists += [avg_list]
display_grasp_data(grasps[0:3], "accelerometer", monitor_data=avg_lists[0:3])
display_grasp_data(grasps[3:-1], "accelerometer", monitor_data=avg_lists[3:-1])
def trim_test_data(grasp_data=None):
if grasp_data is None:
grasp_data = load_pickle(GRASP_DATA_FILE)
new_data = []
for grasp in grasp_data:
new_data += [(grasp[0], grasp[1], None, grasp[3], grasp[4])]
save_pickle(new_data, GRASP_MODELS_FILE)
return new_data
def save_grasp(grasp, prefix):
filename = prefix + "%04d-%04d-%04d.pickle" % (int(grasp[0][0]*100),int(grasp[0][1]*100),int(grasp[0][2]*100))
save_pickle(grasp, filename)
return filename
def split_model_data(data=None):
if data is None:
data = load_pickle(GRASP_MODELS_FILE)
xyr_index = []
n = 1
for grasp in data:
filename = GRASP_IND_PREFIX + "%03d-%03d-%03d.pickle" % (int(grasp[0][0]*100),int(grasp[0][1]*100),int(grasp[0][2]*100))
xyr_index += [[grasp[0], filename]]
save_pickle(grasp, filename)
n += 1
save_pickle(xyr_index, GRASP_INDEX_FILE)
def resample_split_model_data(apm, models=None, sampling_rate=4):
if models is None:
models = load_pickle(GRASP_MODELS_FILE)
new_models = []
for model in models:
new_model = apm.resample_and_thin_data(model[3], sampling_rate)
new_models.append([model[0], None, None, new_model, model[4]])
split_model_data(new_models)
def normalize_rot(gripper_rot):
while gripper_rot >= np.pi:
gripper_rot -= np.pi
while gripper_rot < 0.:
gripper_rot += np.pi
return gripper_rot
def grasp_loader(filename):
class GLoader(threading.Thread):
def __init__(self):
threading.Thread.__init__(self)
self.grasp = []
def run(self):
tg = load_pickle(filename)
for v in tg:
self.grasp.append(v)
gl = GLoader()
gl.start()
return gl.grasp
def load_grasp(xyr, xyr_index = GRASP_DATA_INDEX_FILE):
return get_grasp_model(xyr[0], xyr[1], xyr[2], xyr_index = xyr_index, no_wait=False)
def get_grasp_model(x, y, r, xyr_index = None, grasp_data = None, no_wait = True):
r = normalize_rot(r)
if grasp_data is None:
if xyr_index is None:
xyr_index = load_pickle(GRASP_INDEX_FILE)
else:
xyr_index = grasp_data
if len(xyr_index) > 0:
def dist(o):
if np.allclose(o[0][2], 0.0):
# for loop around
rot_dist = min((np.pi - r) ** 2, (0. - r) ** 2)
else:
rot_dist = (o[0][2] - r) ** 2
return (o[0][0] - x) ** 2 + (o[0][1] - y) ** 2 + rot_dist
xyr = min(xyr_index, key=dist)
print "Distance to grasp model:", dist(xyr), "rotation diff:", xyr[0][2] - r
if grasp_data is None:
if not no_wait:
return load_pickle(xyr[1])
return grasp_loader(xyr[1])
else:
return xyr
else:
print "Bad index file"
return None
def load_grasp(x, y, r, xyr_index = None):
if xyr_index is None:
xyr_index = load_pickle(GRASP_INDEX_FILE)
for xyr in xyr_index:
if np.allclose([x, y, r], xyr[0]):
return load_pickle(xyr[1])
return None
def compute_sqr_diff_map(percept="accelerometer"):
xys = get_xy_list()
def get_xy(i, j):
return xys[i * NUM_Y + j]
def model_sqr_err(m1, xy, i, j):
n = 0
sum = 0.
cxy = get_xy(i, j)
g2 = get_grasp_model(cxy[0], cxy[1])
if np.allclose(g2[0], xy):
return [-1.]
m2 = g2[3][percept]["mean"]
for i in range(min(len(m1),len(m2))):
sum += (m1[i] - m2[i]) ** 2
n += 1
return sum / n
xy_index = load_pickle(GRASP_INDEX_FILE)
if len(xys) > 0:
map = []
for i in range(NUM_X):
map += [[]]
for j in range(NUM_Y):
cen_xy = get_xy(i, j)
cen_grasp = get_grasp_model(cen_xy[0], cen_xy[1])
cen_grasp_model = cen_grasp[3][percept]["mean"]
if not np.allclose(cen_xy, cen_grasp[0]):
map[-1] += [0.]
continue
else:
err = 0.
n = 0
new_err = model_sqr_err(cen_grasp_model, cen_xy, i+1, j)
if new_err[0] != -1.:
err += new_err
n += 1
new_err = model_sqr_err(cen_grasp_model, cen_xy, i-1, j)
if new_err[0] != -1.:
err += new_err
n += 1
new_err = model_sqr_err(cen_grasp_model, cen_xy, i, j+1)
if new_err[0] != -1.:
err += new_err
n += 1
new_err = model_sqr_err(cen_grasp_model, cen_xy, i, j-1)
if new_err[0] != -1.:
err += new_err
n += 1
err = np.linalg.norm(err) ** 2 / len(err)
if n > 0:
map[-1] += [err / n]
else:
map[-1] += [0.]
return map
else:
print "Bad index file"
return None
def sqr_diff_viz():
# save_pickle(compute_sqr_diff_map(), SQR_DIFF_MAP)
map = load_pickle(SQR_DIFF_MAP)
map.reverse()
maxarg = max([max(row) for row in map])
print np.mat(map)
for i in range(len(map)):
for j in range(len(map[i])):
if map[i][j] == -1.:
map[i][j] = maxarg*1.5
import matplotlib.pyplot as plt
fig = plt.figure()
ax = fig.add_subplot(111)
ax.matshow(map)
plt.show()
def process_data(grasp_data=None):
print "Loading data"
if grasp_data is None:
grasp_data = load_pickle(GRASP_DATA_FILE)
print "Data loaded, generating models"
grasp_data = load_data_and_generate(grasp_data)
print "Saving models"
print "Trimming test data"
model_data = trim_test_data(grasp_data)
print "Splitting models"
split_model_data(model_data)
print "Done processing data"
def calc_model(x, y, r, window_len= 200, samples=50, xyr_index = None, resample = 10):
if xyr_index is None:
xyr_index = load_pickle(GRASP_INDEX_FILE)
xs = (RECT[1][0] - RECT[0][0]) / (NUM_X - 1)
ys = (RECT[0][1] - RECT[1][1]) / (NUM_Y - 1)
rs = np.pi / NUM_ROT
def dist1(o):
return np.fabs(o[0][0] - x) + np.fabs(o[0][1] - y)
def dist2(o):
return (o[0][0] - x) ** 2 + (o[0][1] - y) ** 2
def rotdist(o):
if np.allclose(o[0][2], 0.0):
# for loop around
return min(np.fabs(np.pi - r), np.fabs(0. - r))
else:
return np.fabs(o[0][2] - r)
n = 1
close_models = []
for i, dist in enumerate(map(dist1, xyr_index)):
if np.allclose([x, y, r], xyr_index[i][0]):
close_models = [[xyr_index[i][0], load_pickle(xyr_index[i][1])]]
break
if dist < xs + ys and rotdist(xyr_index[i]) < rs:
close_models += [[xyr_index[i][0], load_pickle(xyr_index[i][1])]]
ret_models = {}
for k in close_models[0][1][3]:
close_stream_means = []
minlen = min([len(cm[1][3][k]["mean"]) for cm in close_models])
for close_model in close_models:
mean = close_model[1][3][k]["mean"][0:minlen]
stream_means = zip(*mean)
close_stream_means += [[close_model[0], np.array(stream_means)]]
expected_means, expected_vars = [], []
for i in range(len(close_stream_means[0][1])):
close_signals = []
sum = np.array([0.]*len(close_stream_means[0][1][0]))
distsum = 0.
for close_stream in close_stream_means:
close_signals += [close_stream[1][i]]
dist = dist2(close_stream)
sum += close_stream[1][i] / dist
distsum += 1. / dist
expected_mean = sum / distsum
expected_var = signal_list_variance(close_signals, expected_mean,
window_len, samples,
resample)
expected_means += [expected_mean[::resample]]
expected_vars += [expected_var]
ret_model = { "mean" : zip(*expected_means), "variance" : zip(*expected_vars) }
ret_models[k] = ret_model
return [[x, y, r], None, None, ret_models, None]
def random_grasp():
xs = (RECT[1][0] - RECT[0][0]) / (NUM_X - 1)
ys = (RECT[0][1] - RECT[1][1]) / (NUM_Y - 1)
x = random.uniform(RECT[0][0]-xs/2., RECT[1][0]+xs/2.)
y = random.uniform(RECT[1][1]-ys/2., RECT[0][1]+ys/2.)
r = random.uniform(0., np.pi)
return x, y, r
def random_known_grasp():
xyr_index = load_pickle(GRASP_INDEX_FILE)
ind = random.randint(0,len(xyr_index)-1)
return xyr_index[ind][0]
def test_random_grasps(num_grasps=100):
cm = ControllerManager(armc)
apm = ArmPerceptionMonitor(ARM, percept_mon_list=PERCEPT_GRASP_LIST)
monitor_data = []
grasps = []
collided_list = []
num_collided = 0
test_data = []
zeros = None
open_gripper(cm=cm)
for i in range(num_grasps):
if rospy.is_shutdown():
break
x, y, rot = random_grasp()
(grasp, monitor, collided, zeros) = perform_grasp(x, y, gripper_rot = rot,
collide=False, is_grasp = False,
zeros=zeros, cm=cm, apm=apm)
test_data += [{"loc" : (x, y, rot),
#"model" : grasp,
"monitor" : monitor,
"collided" : collided,
"zeros" : zeros}]
if collided:
print "COLLIDED\n"*10
num_collided += 1
print "Accuracy: %d collisions out of %d grasps (%1.2f)" % (num_collided, num_grasps, 1. - float(num_collided) / num_grasps)
save_pickle(test_data, TEST_DATA_FILE)
def calc_false_pos(test_data=None, xyr_index=None, apm=None):
if test_data is None:
test_data = load_pickle(TEST_DATA_FILE)
if apm is None:
apm = ArmPerceptionMonitor(ARM, percept_mon_list=PERCEPT_GRASP_LIST)
num_collisions = 0
indicies = {}
for test in test_data:
model = get_grasp_model(test["loc"][0], test["loc"][1], test["loc"][2],
xyr_index=xyr_index)
collision = apm.simulate_monitoring(test["monitor"], models=model[3],
model_zeros = test["zeros"],
window_size=MONITOR_WINDOW,
std_dev_default=STD_DEV,
std_dev_dict = STD_DEV_DICT,
tol_thresh_dict = TOL_THRESH_DICT,
noise_dev_default=NOISE_DEV)
if collision is not None:
num_collisions += 1
k, index, diff = collision
if not k in indicies:
indicies[k] = [0]*len(model[3][k]["mean"][0])
indicies[k][index] += 1
print "Accuracy: %d collisions out of %d grasps (%1.2f)" % (num_collisions, len(test_data), 1. - float(num_collisions) / len(test_data))
print indicies
return float(num_collisions) / len(test_data)
# def dynamic_parameter_tune(alpha = 0.1, dev_seed = 1.2, seed_dict=None):
# global STD_DEV_DICT
# x_old = { "accelerometer" : [dev_seed]*3,
# "joint_angles" : [dev_seed]*7,
# "joint_velocities" : [dev_seed]*7,
# "joint_efforts" : [dev_seed]*7,
# "r_finger_periph_pressure" : [dev_seed]*6,
# "r_finger_pad_pressure" : [dev_seed]*15,
# "l_finger_periph_pressure" : [dev_seed]*6,
# "l_finger_pad_pressure" : [dev_seed]*15, ]
# for k in STD_DEV_DICT:
# STD_DEV_DICT[k] = np.array(STD_DEV_DICT[k])
# test_data = load_pickle(TEST_DATA_FILE)
# apm = ArmPerceptionMonitor(ARM, percept_mon_list=PERCEPT_GRASP_LIST)
# def F(x):
# sum = 0.
# for k in x:
# sum += np.sum(x[k])
# global STD_DEV_DICT
# STD_DEV_DICT = x
# print "Evaluating:", x
# fp = calc_false_pos(test_data=test_data)
# print "False positive rate:", fp
# return fp + alpha * sum
# def add_x(x, delta, step):
#
# def get_grad(x_old, F_old, x_new, F_new):
# grad = {}
# for k in old:
# grad[k] = (F_new - F_old) / (new[k] - old[k])
#
# step = 0.2
# F_old = F(x_old)
# x_new = copy.deepcopy(x_old)
# for k in x_new:
# x_new[k] += step
# F_new = F(x_new)
#
#
# for k in
#
#
# for dev in devs:
# fp = calc_false_pos(test_data=test_data)
# print "std dev:", dev
# fp_rate += [fp]
def visualize_objs():
objs = detect_tabletop_objects()
pubm = rospy.Publisher('grasp_obj_positions', Marker)
pubma = rospy.Publisher('grasp_obj_positions_array', MarkerArray)
markers = []
for obj in objs:
pos, angle = np.mat(obj[0]).T, obj[1]
marker = viz.single_marker(pos, np.mat(quaternion_about_axis(angle, (0, 0, 1))).T, "arrow", "torso_lift_link")
marker.header.stamp = rospy.Time.now()
markers.append(marker)
pubm.publish(marker)
ma = MarkerArray(markers)
i = 0
while not rospy.is_shutdown():
pubm.publish(markers[i])
rospy.sleep(2.1)
i = (i + 1) % len(markers)
print objs
rospy.spin()
def get_laser_dclick(tf_listener, frame = "/torso_lift_link", delay_time = 3.0):
c3d_lis = GenericListener("c3dlisnode", PointStamped, CURSOR_TOPIC, 10.0)
dc_lis = GenericListener("dclisnode", String, MOUSE_DOUBLE_CLICK_TOPIC, 10.0)
print "Waiting for laser click..."
while not rospy.is_shutdown():
if dc_lis.read(allow_duplication = False, willing_to_wait = False) is not None:
print "DC"
msg = c3d_lis.read(allow_duplication = True, willing_to_wait = False)
print msg
if msg is not None:
if rospy.Time.now().to_sec() - msg.header.stamp.to_sec() <= delay_time:
now = rospy.Time.now()
tf_listener.waitForTransform(msg.header.frame_id, frame,
now, rospy.Duration(4.0))
tfmat = tf_utils.transform(frame, msg.header.frame_id, tf_listener)
tfmat *= np.mat([[msg.point.x], [msg.point.y], [msg.point.z], [1.0]])
pt = tfmat[0:3,3]
#(trans, rot) = tf_listener.lookupTransform(msg.header.frame_id, frame, now)
#pt = [msg.point.x - trans[0], msg.point.y - trans[1], msg.point.z - trans[2]]
print "pt", pt
return pt[0,0], pt[1,0], pt[2,0]
rospy.sleep(0.01)
return None
def point_head(point, velocity = 0.6, frame="/torso_lift_link", block = True):
head_action_client = actionlib.SimpleActionClient("/head_traj_controller/point_head_action", PointHeadAction)
head_action_client.wait_for_server()
goal = PointHeadGoal()
goal.target = cf.create_point_stamped(point, frame)
goal.pointing_frame = "/narrow_stereo_optical_frame"
goal.max_velocity = velocity
head_action_client.send_goal(goal)
if not block:
return 0
finished_within_time = head_action_client.wait_for_result(rospy.Duration(20))
if not finished_within_time:
head_action_client.cancel_goal()
rospy.logerr("timed out when asking the head to point to a new goal")
return 0
return 1
def hand_over_object(x, y, z, cm, apm, offset = 0.2, blocking = True):
pt = np.array([x,y,z])
quat = quaternion_about_axis(0.9, (0, 0, 1))
dist = np.linalg.norm(pt)
start_angles = cm.get_current_arm_angles()
print start_angles
ptnorm = pt / dist
dist -= offset
joints = None
while not rospy.is_shutdown() and pt[0] > 0.2:
pt = dist * ptnorm
print "dist", dist
pose = create_gripper_pose(pt[0], pt[1], pt[2], quat.tolist())
print pose
HANDOFF_BIAS = [0., -.25, -100., 200., 0.0, 200.0, 0.]
joints = cm.ik_utilities.run_biased_ik(pose, HANDOFF_BIAS, num_iters=30)
if joints is not None:
break
dist -= 0.1
# joints = [-0.1, -0.15, -1.2, -0.7, 0., -0.2, 0.]
cm.command_joint_trajectory([joints], 0.27, blocking = blocking)
def change_projector_mode(on):
client = dynamic_reconfigure.client.Client("camera_synchronizer_node")
node_config = client.get_configuration()
node_config["projector_mode"] = 2
if on:
node_config["narrow_stereo_trig_mode"] = 3
else:
node_config["narrow_stereo_trig_mode"] = 4
client.update_configuration(node_config)
def move_to_setup(cm, blocking = True):
joints = [-0.62734204881265387, -0.34601608409943324, -1.4620635485239604, -1.2729772622637399, -7.5123303230158518, -1.5570651396529178, -5.5929916630672727]
cm.command_joint_trajectory([joints], 0.62, blocking = blocking)
def laser_interface_demo():
cm = ControllerManager(armc)
apm = ArmPerceptionMonitor(ARM, percept_mon_list=PERCEPT_GRASP_LIST)
move_to_setup(cm)
x, y, z = get_laser_dclick(cm.tf_listener)
# x, y, z = 0.7, 0.0, -0.3
point_head([x,y,z], block = True)
grasp_closest_object(x, y, cm=cm, apm=apm)
change_projector_mode(on=False)
x, y, z = get_laser_dclick(cm.tf_listener)
# x, y, z = 1.2, 0.0, 0.3
point_head([x,y,z+0.2], block = True)
# hand_over_object(x, y, z, cm, apm)
def monitor_pressure():
apm = ArmPerceptionMonitor(ARM, percept_mon_list=PRESSURE_LIST)
rospy.sleep(1.0)
models = {}
for k in PRESSURE_LIST:
if "periph" in k:
models[k] = {}
models[k]["mean"] = np.array([np.array([0.]*6)])
models[k]["variance"] = np.array([np.array([40.]*6)])
if "pad" in k:
models[k] = {}
models[k]["mean"] = np.array([np.array([0.]*15)])
models[k]["variance"] = np.array([np.array([40.]*15)])
apm.begin_monitoring(models, only_pressure=True)
print "Monitoring pressure..."
while not rospy.is_shutdown() and not apm.failure:
rospy.sleep(0.01)
print "Pressure triggered"
#
# def double_click_listener(self, msg):
# """
# Waits until a double click message is sent, then executes appropriate pick
# or place operation. Uses latest cursor3d message.
#
# @param msg: Latest cursor3d message
# @type msg: PointStamped
# """
# pt = self.latest_cursor
# if pt == None:
# return
# dclick_delay = rospy.Time.now().to_sec() - self.latest_cursor.header.stamp.to_sec()
# if dclick_delay < MAX_DELAY:
# rospy.loginfo("cursor3d target acquired.")
# self.papm.tf_listener.waitForTransform(self.latest_cursor.header.frame_id, "base_footprint", rospy.Time.now(), rospy.Duration(4.0))
# pt_loc = self.papm.tf_listener.transformPoint('base_footprint', pt)
#
# if not self.hasobject:
# success = lp.pick_up_object_near_point(pt_loc)
# if success:
# rospy.loginfo("Success with pickup! Waiting for target placement...")
# self.hasobject = True
# else:
# rospy.loginfo("Failure. Exiting...")
# rospy.signal_shutdown("SS")
# else:
# target_pose = create_pose_stamped([pt_loc.point.x, pt_loc.point.y, pt_loc.point.z, 0.0, 0.0, 0.0, 1.0],
# 'base_link')
# success = lp.place_object((RECT_DIM_X, RECT_DIM_Y), target_pose)
# if success:
# rospy.loginfo("Success with placement! Exiting...")
# else:
# rospy.loginfo("Failure placing. Exiting...")
# rospy.signal_shutdown("SS")
def main():
rospy.init_node(node_name)
# rospy.on_shutdown(die)
setup_package_loc()
ki = KeyboardInput()
#x, y, z = get_laser_dclick()
#laser_interface_demo()
#return 0
generate_space_models()
return 0
# grasp_data = load_pickle(GRASP_DATA_FILE)
# for grasp in grasp_data:
# for k in grasp[2]:
# print len(grasp[2][k][0])
# return
# write_index_file()
# return 0
#visualize_objs()
#return 0
# grasp_data = collect_grasp_data(ki, generate_models=False, skip_grasp=False)
# return 0
# process_data() #load_pickle(GRASP_DATA_FILE)) #load_pickle(GRASP_DATA_FILE))
# return 0
#trim_test_data()
# return 0
# apm = ArmPerceptionMonitor(ARM, percept_mon_list=PERCEPT_GRASP_LIST)
# resample_split_model_data(apm)
# return 0
#split_model_data()
#return 0
# print get_grasp_model(0., 0.)
# return 0
#grasp_demo()
#return 0
#test_random_grasps(250)
#return 0
# grasp = calc_model(0.6, 0.0, 0.08)
# display_grasp_data([grasp], "accelerometer")
# return 0
#global STD_DEV_DICT
#xdev = 2.5
#devs = np.linspace(1.5, 4., 18)
#fp_rate = []
#test_data = load_pickle(TEST_DATA_FILE)
#for dev in devs:
# STD_DEV_DICT = {"accelerometer" : [xdev, dev, dev] }
# fp = calc_false_pos(test_data=test_data)
# print "std dev:", dev
# fp_rate += [fp]
#print devs
#print fp_rate
#return 0
#monitor_data = []
#grasp_data = load_data_and_generate(load_pickle(GRASP_DATA_FILE))
#save_pickle(grasp_data, GRASP_DATA_FILE)
#grasp_data = load_pickle(GRASP_DATA_FILE)
#display_grasp_data(grasp_data[0], "accelerometer", monitor_data=monitor_data, rows=1)
#return 0
# print detect_tabletop_objects()
# return 0
# sqr_diff_viz()
# return 0
# get_setup_pos_angs()
# print_configs(load_pickle(GRASP_CONFIGS_FILE))
# save_grasp_configurations()
# return 0
# import random
# data = load_pickle(GRASP_CONFIGS_FILE)
# random.shuffle(data)
cm = ControllerManager(armc)
apm = ArmPerceptionMonitor(ARM, percept_mon_list=PERCEPT_GRASP_LIST)
#monitor_pressure()
#return 0
# while not rospy.is_shutdown():
# x, y, z = get_laser_dclick(cm.tf_listener)
# if x > 0.92 and z > 0.04:
# point_head([x, y, z], block = False)
# hand_over_object(x, y, z + 0.1, cm, apm)
# monitor_pressure()
# open_gripper(cm=cm)
# return 0
# data = load_pickle(GRASP_CONFIGS_FILE)
# new_data = []
# xys = get_xy_list()
# for grasp in data:
# for xy in xys:
# if np.allclose(xy, grasp[0]):
# new_data += [grasp]
# print "length:", len(new_data)
# collect_grasp_data(new_data)
# collect_grasp_data(load_pickle(GRASP_CONFIGS_FILE))
# return 0
# trim_bad_grasps("gcb2.pickle")
# return 0
# save_current_zeros()
# return 0
# test_num_samples()
# return 0
# print "Generating data"
# grasp_data = load_data_and_generate(load_pickle(GRASP_DATA_FILE))
# save_pickle(grasp_data, GRASP_DATA_FILE)
# print "Done generating data"
# return 0
# grasp_data = load_pickle(GRASP_MODELS_FILE)
#grasp = get_grasp_model(0., 0.)
# monitor_data += [grasp_closest_object(0.48, 0.07, cm=cm, apm=apm)]
# monitor_data += [grasp_closest_object(grasp_data, 0.48, 0.07, cm=cm, apm=apm)]
# grasp_data = load_pickle(GRASP_DATA_FILE)
# print grasp_data[0][0]
# monitor_data = perform_template_grasp(grasp_data[0])
# display_grasp_data(grasp_data, "accelerometer", monitor_data=monitor_data, rows=1)
# display_grasp_data(grasp_data, "r_finger_periph_pressure", rows=1)
# monitor_data = perform_grasp(grasp_data, .58, .14, gripper_rot = 0.)
open_gripper(cm = cm)
monitor_data = []
monitor_zeros = []
grasps = []
collided_list = []
num_grasps = 100
num_collided = 0
zeros = None
global z_sum
z_sum = {}
for i in range(num_grasps):
point_head([0.5, 0.0, -0.2], block=False)
#move_to_setup(cm)
if rospy.is_shutdown():
break
#x, y, rot = random.uniform(.45, .65), random.uniform(-.2, .2), random.uniform(0., 3.14)
if False:
#rot = 0.
#global STD_DEV_DICT
#STD_DEV_DICT = None
if False:
x, y, rot = random_grasp()
else:
x, y, rot = random_known_grasp()
(grasp, monitor, collided, zeros) = perform_grasp(x, y, gripper_rot = rot,
collide=True, is_grasp = False,
#grasp_data = grasp_data,
zeros=zeros, cm=cm, apm=apm)
elif False:
x, y = 0.5, 0.0
(obj, grasp, monitor, collided, zeros) = grasp_closest_object(x, y, collide=True, zeros=zeros, cm=cm, apm=apm)
rospy.sleep(0.3)
if is_obj_in_gripper(cm):
x, y, rot = random_grasp()
perform_grasp(x, y, gripper_rot=rot, zeros = zeros, collide=True, is_place=True,
cm=cm, apm=apm)
else:
obj = None
while obj is None:
x, y, z = get_laser_dclick(cm.tf_listener)
(obj, grasp, monitor, collided, zeros) = grasp_closest_object(x, y, collide=True, zeros=zeros, cm=cm, apm=apm)
x, y, z = get_laser_dclick(cm.tf_listener)
print " X Y Z"
print x, y, z
if x > 0.92 and z > 0.04:
point_head([x, y, z], block = False)
hand_over_object(x, y, z + 0.1, cm, apm)
monitor_pressure()
open_gripper(cm=cm)
else:
perform_grasp(x, y, gripper_rot=obj[1], zeros = zeros, collide=True, is_place=True,
cm=cm, apm=apm)
move_to_setup(cm, blocking = False)
grasps += [grasp]
monitor_data += [monitor]
collided_list += [collided]
monitor_zeros += [zeros]
if collided:
print "COLLIDED"
print "COLLIDED"
print "COLLIDED"
num_collided += 1
rospy.sleep(2.0)
if ki.kbhit():
if PERCEPT_GRASP_LIST is None:
percept = "joint_efforts"
else:
percept = PERCEPT_GRASP_LIST[0]
display_grasp_data(grasps[-3:], percept, monitor_data=monitor_data[-3:], monitor_zeros=monitor_zeros[-3:])
# print monitor_data[-3:]
break
print "Accuracy: %d collisions out of %d grasps (%1.2f)" % (num_collided, num_grasps, 1. - float(num_collided) / num_grasps)
test_data = [grasps, monitor_data, collided_list]
for k in z_sum:
print z_sum[k] / num_grasps
return 0
save_pickle(test_data, "test_runs.pickle")
# if False:
# new_grasp = get_grasp_model(x+.05, y)
# if new_grasp is not None:
# grasps += [new_grasp]
# new_grasp = get_grasp_model(x-.05, y)
# if new_grasp is not None:
# grasps += [new_grasp]
# new_grasp = get_grasp_model(x, y+.05)
# if new_grasp is not None:
# grasps += [new_grasp]
# new_grasp = get_grasp_model(x, y-.05)
# if new_grasp is not None:
# grasps += [new_grasp]
# new_monitor_data = []
# for j in range(len(monitor_data)):
# ret_mon = []
# for i in range(len(monitor_data[j]["accelerometer"])):
# ret_mon += [np.sqrt(monitor_data[j]["accelerometer"][i][1] ** 2 + monitor_data[j]["accelerometer"][i][2] ** 2)]
# new_monitor_data += [np.array(ret_mon)]
# for i in range(3000):
# monitor_data[0]["accelerometer"][i][1] = new_monitor_data[0][i] - new_monitor_data[1][i]
# monitor_data[1]["accelerometer"][i][1] = 0.
# monitor_data[2]["accelerometer"][i][1] = 0.
# monitor_data += [perform_grasp(grasp_data, .55, .15, gripper_rot = 0., is_place=True)]
# monitor_data += [perform_grasp(grasp_data, .56, .10, gripper_rot = 0.)]
# monitor_data += [perform_grasp(grasp_data, .57, .10, gripper_rot = 0.)]
# monitor_data += [perform_grasp(grasp_data, .58, .10, gripper_rot = 0.)]
# for i in range(2):
# monitor_data += [perform_grasp(grasp_data, .55, .10, gripper_rot = 0., cm=cm, apm=apm)]
# monitor_data += [perform_grasp(grasp_data, .55, .15, gripper_rot = 0., is_place=True, cm=cm, apm=apm)]
# monitor_data += [perform_grasp(grasp_data, .55, .15, gripper_rot = 0., cm=cm, apm=apm)]
# monitor_data += [perform_grasp(grasp_data, .55, .10, gripper_rot = 0., is_place=True, cm=cm, apm=apm)]
# monitor_data += [perform_grasp(grasp_data, .55, .10, z=HOVER_Z-0.14, gripper_rot = 0., is_place=False, cm=cm, apm=apm)]
display_grasp_data(grasps, "accelerometer", monitor_data=monitor_data)
raw_input()
open_gripper(cm=cm)
# test_monitor(load_pickle(GRASP_DATA_FILE))
return 0
if __name__ == "__main__":
sys.exit(main())
| [
[
1,
0,
0.0011,
0.0006,
0,
0.66,
0,
954,
0,
2,
0,
0,
954,
0,
0
],
[
1,
0,
0.0017,
0.0006,
0,
0.66,
0.0077,
509,
0,
1,
0,
0,
509,
0,
0
],
[
1,
0,
0.0023,
0.0006,
0,
... | [
"import numpy as np, math",
"import sys",
"import os",
"from threading import RLock",
"import threading",
"import roslib; roslib.load_manifest('hrl_pr2_lib')",
"import roslib; roslib.load_manifest('hrl_pr2_lib')",
"import rospy",
"import actionlib",
"from std_msgs.msg import String",
"from geome... |
#! /usr/bin/python
import numpy as np, math
import scipy.stats as stats
from threading import RLock
import roslib; roslib.load_manifest('hrl_pr2_lib')
import rospy
from hrl_lib.util import save_pickle, load_pickle
from hrl_lib.msg import FloatArray
from hrl_lib.rutils import GenericListener, ros_to_dict, RateCaller
from hrl_lib.data_process import signal_smooth, signal_variance, signal_list_variance
from tf.transformations import *
from std_msgs.msg import Float64MultiArray
from pr2_msgs.msg import AccelerometerState, PressureState
from sensor_msgs.msg import JointState
import threading
import functools as ft
import Queue
import time, string
node_name = "arm_perception_monitor"
def log(str):
rospy.loginfo(node_name + ": " + str)
##
# Processes the AccelerometerState message, returning an average of the
# sample values and the timestamp in nanoseconds
#
# @param msg AccelometerState message
# @return (t, (x, y, z))
def accel_state_processor(msg):
xyz = np.array([0.]*3)
if msg.samples is None or len(msg.samples) == 0:
return None
for samp in msg.samples:
xyz[0] += samp.x
xyz[1] += samp.y
xyz[2] += samp.z
xyz[0] /= len(msg.samples)
xyz[1] /= len(msg.samples)
xyz[2] /= len(msg.samples)
return (msg.header.stamp.to_nsec(), xyz)
r_jt_idx_list = [17, 18, 16, 20, 19, 21, 22]
l_jt_idx_list = [31, 32, 30, 34, 33, 35, 36]
joint_nm_list = ['shoulder_pan', 'shoulder_lift', 'upper_arm_roll',
'elbow_flex', 'forearm_roll', 'wrist_flex',
'wrist_roll']
##
# Callback for /joint_states topic. Updates current joint
# angles and efforts for the arms constantly
#
# @param data JointState message recieved from the /joint_states topic
def joints_state_processor(msg, right_arm=True, angles_velocities_efforts=0):
ret = np.array([0.] * 7)
for i,nm in enumerate(joint_nm_list):
if right_arm:
idx = r_jt_idx_list[i]
if msg.name[idx] != 'r_'+nm+'_joint':
raise RuntimeError('joint angle name does not match. Expected: %s, Actual: %s i: %d'%('r_'+nm+'_joint', msg.name[idx], i))
if angles_velocities_efforts == 1:
ret[i] = msg.velocity[idx]
elif angles_velocities_efforts == 2:
ret[i] = msg.effort[idx]
else:
ret[i] = msg.position[idx]
else:
idx = l_jt_idx_list[i]
if msg.name[idx] != 'l_'+nm+'_joint':
raise RuntimeError('joint angle name does not match. Expected: %s, Actual: %s i: %d'%('r_'+nm+'_joint', msg.name[idx], i))
if angles_velocities_efforts == 1:
ret[i] = msg.velocity[idx]
elif angles_velocities_efforts == 2:
ret[i] = msg.effort[idx]
else:
ret[i] = msg.position[idx]
return (msg.header.stamp.to_nsec(), ret)
def pressure_state_processor(msg, right_finger_tip=True, indicies=None):
ret = np.array([0.] * len(indicies))
if indicies is None:
indicies = range(len(msg.r_finger_tip))
for i, ind in enumerate(indicies):
if right_finger_tip:
ret[i] = msg.r_finger_tip[ind]
else:
ret[i] = msg.l_finger_tip[ind]
return (msg.header.stamp.to_nsec(), ret)
##
# Periodically logs the output of a callback function by calling it at a certain
# rate and gathering up the results into a list
class PeriodicLogger():
##
# initializes the logger but doesn't start it
#
# @param callback the function to be called each time
# @param rate the rate in seconds at which to call the callback
# @param args the function arguments to pass into the callback
def __init__(self, callback, rate=0.01, args=None):
self.ret = []
self.cb = callback
self.rate = rate
self.args = args
self.is_running = False
self.max_calls = None
self.num_calls = 0
self.beg_time = 0.
self.thread = None
##
# begins the logger
# @param max_calls the maximum number of times to call the callback
def start(self, max_calls=None):
if self.is_running:
return
self.max_calls = max_calls
self.is_running = True
self.num_calls = 0
self.beg_time = rospy.Time.now().to_sec()
self.thread = threading.Timer(self.rate, self._run)
self.thread.start()
def _run(self):
if not self.is_running:
return
act_time = self.beg_time + self.rate * (self.num_calls + 2)
interval = act_time - rospy.Time.now().to_sec()
self.thread = threading.Timer(interval, self._run)
self.thread.start()
if self.args is None:
retval = self.cb()
else:
retval = self.cb(*self.args)
self.ret += [retval]
self.num_calls += 1
# break if we have called the sufficent number of times
if self.max_calls is not None:
if self.num_calls == self.max_calls:
self.is_running = False
return
##
# stops the monitor
# @return the result of the monitor
def stop(self):
self.thread.cancel()
if not self.is_running:
return None
self.is_running = False
return self.ret
##
# If max_calls sets to automatically terminate, return the ret vals
def get_ret_vals(self):
if self.is_running:
return None
return self.ret
##
# Periodically monitors the output of a callback function by calling it at a certain
# rate and compares it with a provided model to insure the value doesn't vary greatly
# within a degree of tolerance provided by the variance function
class PeriodicMonitor():
##
# initializes the monitor but doesn't start it
#
# @param callback the function to be called each time
# @param rate the rate in seconds at which to call the callback
# @param args the function arguments to pass into the callback
def __init__(self, callback, rate=0.01, args=None):
self.ret = []
self.cb = callback
self.rate = rate
self.args = args
self.is_running = False
self.num_calls = 0
self.beg_time = 0.
self.thread = None
self.mean_model = None
self.variance_model = None
self.std_devs = 0.
self.failure = False
##
# begins the monitor
# TODO DOCS
# @param max_calls the maximum number of times to call the callback
def start(self, mean_model, variance_model, std_devs=2.5, max_calls=None,
contingency=None, contingency_args=None):
if len(mean_model) != len(variance_model):
log("Models must be of same length")
return
if self.is_running:
return
self.is_running = True
self.mean_model = mean_model
self.variance_model = variance_model
self.std_devs = std_devs
self.max_calls = max_calls
self.contingency = contingency
self.contincency_args = contingency_args
self.model_index = 0
self.failure = False
self.num_calls = 0
self.beg_time = rospy.Time.now().to_sec()
self.thread = threading.Timer(self.rate, self._run)
self.thread.start()
def _run(self):
if not self.is_running:
return
act_time = self.beg_time + self.rate * (self.num_calls + 2)
interval = act_time - rospy.Time.now().to_sec()
self.thread = threading.Timer(interval, self._run)
self.thread.start()
if self.args is None:
retval = self.cb()
else:
retval = self.cb(*self.args)
# go through each coordinate in the vector
for coord_i in len(retval[1]):
diff = abs(retval[1][coord_i] - self.mean_model[self.model_index][coord_i])
deviation = np.sqrt(self.variance_model[self.model_index][coord_i])
if diff > self.std_devs * deviation:
# signal is outside allowable range
self.failure = True
self.is_running = False
# call contingency function
if contingency_args is None:
self.contingency()
else:
self.contingency(*contingency_args)
return
self.ret += [retval]
self.model_index += 1
if self.model_index == len(self.mean_model):
self.is_running = False
return
# break if we have called the sufficent number of times
if not self.max_calls is None:
self.max_calls -= 1
if self.max_calls == 0:
self.is_running = False
return
##
# stops the monitor
# @return the result of the monitor
def stop(self):
self.thread.cancel()
if not self.is_running:
return None
self.is_running = False
return self.ret
##
# If max_calls sets to automatically terminate, return the ret vals
def get_ret_vals(self):
if self.is_running:
return None
return self.ret
# TODO DOCS
def has_failed():
return self.failure
# TODO DOCS
def wait_for_completion(rate=0.01):
while self.is_running and not rospy.is_shutdown():
rospy.sleep(rate)
return not self.failure
##
# Monitors perception channels on the robot arms. Important: rate must be the same for both
# training and monitoring. Values are gathered timestep by timestep.
#
# Usecase:
# apm = ArmPerceptionMonitor(0)
# for trajectory in trajectories:
# apm.start_training()
# trajectory.run()
# trajectory.wait_for_completion()
# apm.stop_training()
# mean_function, variance_function = apm.generate_model(...)
#
class ArmPerceptionMonitor( ):
##
# Initializes the listeners on the perception topics
#
# @param arm 0 if right, 1 if left
# @param rate the rate at which the perception should capture states
# @param percept_mon_list list of perceptions to monitor; if None, do all
def __init__(self, arm, tf_listener=None, rate=0.001,
percept_mon_list=None, model_zeros=None):
log("Initializing arm perception listeners")
self.rate = rate
if arm == 0:
armc = "r"
is_right_arm = True
else:
armc = "l"
is_right_arm = False
self.model_zeros = model_zeros
self.perceptions = {}
self.perception_names = [ "accelerometer",
"joint_angles",
"joint_velocities",
"joint_efforts",
"r_finger_periph_pressure",
"r_finger_pad_pressure",
"l_finger_periph_pressure",
"l_finger_pad_pressure",
"gripper_pose"]
if percept_mon_list is None:
percept_mon_list = self.perception_names
if "accelerometer" in percept_mon_list:
accel_listener = GenericListener("accel_mon_node", AccelerometerState,
"accelerometer/" + armc + "_gripper_motor",
rate, accel_state_processor)
self.perceptions["accelerometer"] = accel_listener.read
if "joint_angles" in percept_mon_list:
joint_angles_processor = ft.partial(joints_state_processor,
right_arm=is_right_arm,
angles_velocities_efforts=0)
joint_angles_listener = GenericListener("joint_angles_mon_node", JointState,
"joint_states", rate, joint_angles_processor)
self.perceptions["joint_angles"] = joint_angles_listener.read
if "joint_velocities" in percept_mon_list:
joint_velocities_processor = ft.partial(joints_state_processor,
right_arm=is_right_arm,
angles_velocities_efforts=1)
joint_velocities_listener = GenericListener("joint_efforts_mon_node", JointState,
"joint_states", rate, joint_velocities_processor)
self.perceptions["joint_velocities"] = joint_velocities_listener.read
if "joint_efforts" in percept_mon_list:
joint_efforts_processor = ft.partial(joints_state_processor,
right_arm=is_right_arm,
angles_velocities_efforts=2)
joint_efforts_listener = GenericListener("joint_efforts_mon_node", JointState,
"joint_states", rate, joint_efforts_processor)
self.perceptions["joint_efforts"] = joint_efforts_listener.read
if "r_finger_periph_pressure" in percept_mon_list:
r_finger_periph_pressure_processor = ft.partial(pressure_state_processor,
right_finger_tip=True, indicies=range(1,7))
r_finger_periph_pressure_listener = GenericListener("pressure_mon_node", PressureState,
"pressure/" + armc + "_gripper_motor", rate,
r_finger_periph_pressure_processor)
self.perceptions["r_finger_periph_pressure"] = r_finger_periph_pressure_listener.read
if "r_finger_pad_pressure" in percept_mon_list:
r_finger_pad_pressure_processor = ft.partial(pressure_state_processor,
right_finger_tip=True, indicies=range(7,22))
r_finger_pad_pressure_listener = GenericListener("pressure_mon_node", PressureState,
"pressure/" + armc + "_gripper_motor", rate,
r_finger_pad_pressure_processor)
self.perceptions["r_finger_pad_pressure"] = r_finger_pad_pressure_listener.read
if "l_finger_periph_pressure" in percept_mon_list:
l_finger_periph_pressure_processor = ft.partial(pressure_state_processor,
right_finger_tip=False, indicies=range(1,7))
l_finger_periph_pressure_listener = GenericListener("pressure_mon_node", PressureState,
"pressure/" + armc + "_gripper_motor", rate,
l_finger_periph_pressure_processor)
self.perceptions["l_finger_periph_pressure"] = l_finger_periph_pressure_listener.read
if "l_finger_pad_pressure" in percept_mon_list:
l_finger_pad_pressure_processor = ft.partial(pressure_state_processor,
right_finger_tip=False, indicies=range(7,22))
l_finger_pad_pressure_listener = GenericListener("pressure_mon_node", PressureState,
"pressure/" + armc + "_gripper_motor", rate,
l_finger_pad_pressure_processor)
self.perceptions["l_finger_pad_pressure"] = l_finger_pad_pressure_listener.read
for k in self.perceptions:
self.perceptions[k] = ft.partial(self.perceptions[k], willing_to_wait=False,
quiet=True,
warn=False, allow_duplication=True)
if "gripper_pose" in percept_mon_list:
def gripper_pose_lookup():
lct = tf_listener.getLatestCommonTime("/torso_lift_link", "/" + armc + "_wrist_roll_link")
pos, quat = tf_listener.lookupTransform("/torso_lift_link", "/" + armc + "_wrist_roll_link", lct)
return (lct.to_nsec(), np.array(pos + quat))
self.perceptions["gripper_pose"] = gripper_pose_lookup
# all callbacks should return data in this format:
# (t, np.array([x1, x2, ...]))
# t is time in nanoseconds
self.clear_vars()
self.logger = RateCaller(self._gather_perception, self.rate)
log("Finished initialization")
def _gather_perception(self):
t1 = rospy.Time.now().to_sec()
for k in self.perceptions:
self.datasets[k][-1] += [self.perceptions[k]()]
t2 = rospy.Time.now().to_sec()
import random
if random.randint(0,100)==0:
print "Time:", t1-t2
##
# Initialize variables
def clear_vars(self):
self.datasets = {}
self.models = {}
for k in self.perceptions:
self.datasets[k] = []
self.models[k] = {"mean" : None, "variance" : None}
self.active = False
##
# Begin capturing peception data for all of the listeners
#
# @param duration If None, continue capturing until stop is called.
# Else, stop capturing after duration seconds have passed.
def start_training(self, duration=None):
if self.active:
log("Perception already active.")
return
self.active = True
for k in self.perceptions:
self.datasets[k] += [[]]
self.logger.run()
if not duration is None:
threading.Timer(self.stop_training, duration)
##
# Stop capturing perception data. Store output data in datasets list for
# later statistics.
def stop_training(self):
if not self.active:
log("Nothing to stop.")
return
self.logger.stop()
self.active = False
return len(self.datasets[self.datasets.keys()[0]][-1])
##
# Save training data as a pickle with given filename
#
# @param filename name of the pickle
def save(self, filename):
save_pickle((self.datasets, self.models), filename)
##
# Load training data as a pickle with given filename
#
# @param filename name of the pickle
def load(self, filename):
self.datasets, self.models = load_pickle(filename)
##
# Generates model functions of all the perceptions over several
# identical trajectories. Each of the parameters is a dictionary
# directing perceptions to their parameters.
#
# @param smooth_wind_dict the window size of the smoothing function
# @param var_wind_dict window size of the variance function
# @param var_smooth_wind_dict window size of the smoothing function on the variance
# @return mean function, variance function
# def generate_models(self, smooth_wind_dict=None, var_wind_dict=None):
# smooth_wind_default = 234
# var_wind_default = 400
# var_smooth_wind = 143
# for perception in self.perceptions:
# data_list = self.datasets[perception]
#
# if data_list is None:
# log("No data to generate model for")
# return None
# if self.active:
# log("Perception already active.")
# return None
# # get the minimum model length
# lens = [len(m) for m in data_list]
# max_len = np.max(lens)
# # dynamic finding of parameters
# if smooth_wind_dict is None or smooth_wind_dict[perception] is None:
# smooth_wind = smooth_wind_default
# else:
# smooth_wind = smooth_wind_dict[perception]
# ret_means, ret_vars, ret_mean_models, ret_noise_vars = [], [], [], []
# ret_times, noise_vars = [], []
# # find the number of coordinates from the first element
# num_coords = len(data_list[0][0][1])
# for coord in range(num_coords):
# mean_models, variance_models = [], []
# times = None
# for stream in data_list:
# # extract only the data stream for a single coordinate (all x values)
# stream_coord = np.array(zip(*zip(*stream)[1])[coord])
# cur_mean_model = signal_smooth(stream_coord, smooth_wind)
# mean_models += [cur_mean_model]
#
# # sum up the squared difference over the whole model
# noise_vars += [ ( sum([(x - y) ** 2 for x,y in zip(cur_mean_model,stream_coord)]) /
# len(cur_mean_model) ) ]
# # find the average case over the several runs
# avg_means_model = np.array([0.] * max_len)
# for i in range(max_len):
# n = 0
# for j in range(len(mean_models)):
# if i < len(mean_models[j]):
# avg_means_model[i] += mean_models[j][i]
# n += 1
# avg_means_model[i] /= n
# if var_wind_dict is None or var_wind_dict[perception] is None:
# var_wind = var_wind_default
# else:
# var_wind = var_wind_dict[perception]
# # find the variance of the signal but use var_wind points around the centers
# # to increase the sample size
# vars_model = signal_list_variance(mean_models, avg_means_model, var_wind)
# vars_model = signal_smooth(vars_model, var_smooth_wind)
# vars_model = signal_smooth(vars_model, var_smooth_wind + 23)
# ret_times += [times]
# ret_means += [avg_means_model]
# ret_vars += [vars_model]
# ret_mean_models += [mean_models]
# ret_noise_vars += [np.average(noise_vars)]
# # TODO deal with timestamp data in some way?
# # self.models[perception]["time"] = ret_times
# self.models[perception]["mean"] = np.array(zip(*ret_means))
# self.models[perception]["variance"] = np.array(zip(*ret_vars))
# a = ret_mean_models
# b = []
# for stream in range(len(a[0])):
# t1 = []
# for val in range(len(a[0][0])):
# t2 = []
# for coord in range(len(a)):
# if val < len(a[coord][stream]):
# t2 += [a[coord][stream][val]]
# t1 += [np.array(t2)]
# b += [t1]
# self.models[perception]["smoothed_signals"] = b
# self.models[perception]["noise_variance"] = np.array(ret_noise_vars)
# return self.models
def get_zeros(self, time=4.):
self._zeros = {}
for k in self.perceptions:
self._zeros[k] = None
self._n = 0
monitor = RateCaller(self._sum_values, self.rate)
monitor.run()
rospy.sleep(time)
monitor.stop()
for k in self.perceptions:
self._zeros[k] /= self._n
return self._zeros
def _sum_values(self):
for k in self.perceptions:
add_data = np.array(self.perceptions[k]()[1])
if self._zeros[k] is None:
self._zeros[k] = np.copy(add_data)
else:
self._zeros[k] += add_data
self._n += 1
##
# Sets up monitoring parameters
def setup_monitoring(self, models,
std_dev_dict=None, noise_dev_dict=None, duration=None,
std_dev_default=2.0, noise_dev_default=0.25,
tol_thresh_dict=None,
contingency=None, window_size=70, current_zeros=None,
sampling_rate = 1,
transform_dict=None, verbose=True, collide=True):
self.std_dev_default = std_dev_default
self.noise_dev_default = noise_dev_default
self.models = models
self.current_data = {}
self.std_dev_dict = std_dev_dict
self.noise_dev_dict = {}
self.contingency = contingency
self.window_size = window_size
self.current_zeros = {}
self.transform_dict = transform_dict
self.tol_thresh_dict = tol_thresh_dict
self.sampling_rate = sampling_rate
self.verbose = verbose
self.collide = collide
self.sum_data = {}
self.cur_pt = 0
self.failure = False
self.dur_timer = None
self.avg_list = {}
self.cum_avg = {}
self.c = {}
self.locks = {}
for k in self.perceptions:
self.current_data[k] = [None] * window_size
self.sum_data[k] = None
self.avg_list[k] = []
self.c[k] = None
self.locks[k] = threading.Lock()
self.create_max_min()
# Checks percept to see if the model indicates a collision with the current
# smoothed perception avg
# Returns index of perception and difference if collision, -1, 0 else
def create_max_min(self):
for k in self.models:
deviation = self.models[k]["variance"]
# noise_deviation = np.sqrt(self.models[k]["noise_variance"])
if self.std_dev_dict is not None and k in self.std_dev_dict:
std_dev = np.array(self.std_dev_dict[k])
else:
std_dev = self.std_dev_default
# if self.noise_dev_dict is not None and k in self.noise_dev_dict:
# noise_dev = np.array(self.noise_dev_dict[k])
# else:
# noise_dev = self.noise_dev_default
if self.tol_thresh_dict is not None and k in self.tol_thresh_dict:
tol_thresh = np.array(self.tol_thresh_dict[k])
else:
tol_thresh = 0.
self.models[k]["dev"] = (std_dev * deviation + tol_thresh)
# self.models[k]["dev"] = (std_dev * deviation + noise_dev * noise_deviation + tol_thresh)
# This is the monitoring equation
self.models[k]["max"] = self.models[k]["mean"] + self.models[k]["dev"]
self.models[k]["min"] = self.models[k]["mean"] - self.models[k]["dev"]
##
# Begin monitoring peception data to make sure it doesn't deviate from
# the model provided.
#
# TODO DOCS
# @param duration If None, continue capturing until stop is called.
# Else, stop capturing after duration seconds have passed.
def begin_monitoring(self, models=None, model_zeros=None,
std_dev_dict=None, noise_dev_dict=None, duration=None,
std_dev_default=2.0, noise_dev_default=0.25,
tol_thresh_dict=None,
contingency=None, window_size=70, current_zeros=None,
sampling_rate = 1,
only_pressure=False,
transform_dict=None, verbose=True, collide=True):
if self.active:
log("Perception already active.")
return
self.active = True
self.setup_monitoring(models,
std_dev_dict=std_dev_dict, noise_dev_dict=noise_dev_dict,
duration=duration, std_dev_default=std_dev_default,
noise_dev_default=noise_dev_default,
tol_thresh_dict=tol_thresh_dict,
contingency=contingency, window_size=window_size,
sampling_rate=sampling_rate,
current_zeros=current_zeros, transform_dict=transform_dict,
verbose=verbose, collide=collide)
# if models is not None:
# self.models = models
if model_zeros is not None:
self.model_zeros = model_zeros
self.cur_pt = 0
self.collision_times = {}
self.collision_sums = {}
self.cur_col_time = 0
self.current_zeros = {}
self.z_sum = {}
self.z_rsum = {}
self.z_list = {}
self.min_prob = 100000.0
self.cur_mals = {}
self.mals = None
self.only_pressure = only_pressure
self.monitor = RateCaller(self._monitor_data, self.rate * self.sampling_rate)
self.monitor.run()
# self.sumcalls = {}
# self.sumsave = {}
if not duration is None:
self.dur_timer = threading.Timer(self.end_monitoring, duration)
self.dur_timer.start()
def _stable_summer(self, percept, data):
# kahanSum
k = percept
# if percept not in self.sumcalls:
# self.sumcalls[percept] = 1
# self.sumsave[percept] = []
# else:
# self.sumcalls[percept] += 1
if self.c[k] is None:
self.c[k] = np.array([0.]*len(data))
if self.sum_data[k] is None:
self.sum_data[k] = np.copy(data)
else:
y = data - self.c[k]
t = self.sum_data[k] + y
self.c[k] = (t - self.sum_data[k]) - y
self.sum_data[k] = t
# self.sumsave[percept] += [self.sum_data[k]]
def _monitor_data(self):
avg_dict = {}
sttime = rospy.Time.now().to_sec()
for k in self.perceptions:
# update the running sum
add_data = self.perceptions[k]()[1]
# apply necessary transforms
# if self.transform_dict is not None:
# if k in self.transform_dict:
# add_data = self.transform_dict[k](add_data)
self._stable_summer(k, add_data)
# If we have enough data to monitor, we check to see if the values are in range
if self.cur_pt >= self.window_size: #self.current_data[k].full():
# self.prev_sum = copy.deepcopy(self.sum_data)
avg_dict[k] = self.sum_data[k] / self.window_size
if not k in self.current_zeros:
if not self.only_pressure:
mean = np.array(self.models[k]["mean"][self.cur_pt * self.sampling_rate])
else:
mean = np.array(self.models[k]["mean"][0])
self.current_zeros[k] = mean - avg_dict[k]
# self.current_zeros[k] = - avg_dict[k]
avg_dict[k] += self.current_zeros[k]
self.avg_list[k] += [avg_dict[k]] * self.sampling_rate
# if self.cur_pt == self.window_size:
# print self.avg_list[k]
# self.prev_avg = copy.deepcopy(avg)
# offset zeros into original perception frame
# if self.current_zeros is not None:
# if False and self.model_zeros is not None:
# avg_dict[k] += self.model_zeros[k] - self.current_zeros[k]
# else:
# # this is hacky, need to use zeros during training instead of first pt
# # print "NOOOOOOOOOOOO!\n"*10
# avg_dict[k] += np.array(self.models[k]["mean"][self.window_size]) - self.current_zeros[k]
# if collision_detected:
# log("Value %d of the perception %s failed with difference %f"
# % (index, k, diff))
# # if diff > 5. and k == "accelerometer":
# # print "avg_list", self.avg_list
# # print "avg", avg
# # for i in range(self.window_size+1):
# # d = self.current_data[k].get()
# # print d
# # self.current_data[k].put(d)
# self.failure = True
# self.contingency()
# self.monitor.stop()
rem_data = self.current_data[k][self.cur_pt % self.window_size]
self._stable_summer(k, -rem_data)
self.current_data[k][self.cur_pt % self.window_size] = add_data
if self.cur_pt >= self.window_size: #self.current_data[k].full():
collision_detected = self.collision_detect(avg_dict)
if self.collide and collision_detected:
print "collision reported"
self.failure = True
if not self.contingency is None:
self.contingency()
self.monitor.stop()
return
self.cur_pt += 1
if not self.only_pressure:
if self.cur_pt * self.sampling_rate >= 1.00 * len(self.models[self.models.keys()[0]]["mean"]):
print "ending early:", self.cur_pt * self.sampling_rate
self.end_monitoring()
endtime = rospy.Time.now().to_sec()
# if self.cur_pt % 10 == 0:
# print "dur:", sttime - endtime
##
# Stop capturing perception data. Store output data in datasets list for
# later statistics.
# TODO DOCS
def end_monitoring(self):
if not self.active:
log("Nothing to stop.")
return self.avg_list
print "-------------------------"
print "z averages:"
self.z_avg = {}
for k in self.z_sum:
self.z_avg[k] = self.z_sum[k] / self.cur_pt
print k, ":", self.z_avg[k]
print "-------------------------"
print "MINIMUM PROB"
print self.min_prob
print "-------------------------"
# print "Sum calls", self.sumcalls
# if self.sumcalls["r_finger_periph_pressure"] == 202:
# print self.sumsave
self.monitor.stop()
if self.dur_timer is not None:
self.dur_timer.cancel()
self.dur_timer = None
self.active = False
return self.avg_list
# Checks percept to see if the model indicates a collision with the current
# smoothed perception avg
# Returns index of perception and difference if collision, -1, 0 else
def collision_detect(self, avg_dict):
# is_outside_range_dict = {}
z = {}
mal_sum = 0.
for k in avg_dict:
# This is the monitoring equation
# is_outside_range_dict[k] = ((avg_dict[k] > self.models[k]["max"][self.cur_pt * self.sampling_rate]) +
# (avg_dict[k] < self.models[k]["min"][self.cur_pt * self.sampling_rate]))
# Uses both variance from various grasp tries and general noise variance
if not self.only_pressure:
mean = self.models[k]["mean"][self.cur_pt * self.sampling_rate]
dev = self.models[k]["dev"][self.cur_pt * self.sampling_rate]
else:
mean = self.models[k]["mean"][0]
dev = self.models[k]["dev"][0]
cur_mal = ((avg_dict[k] - mean) / dev) ** 2
self.cur_mals[k] = cur_mal
mal_sum += np.add.reduce( ( (avg_dict[k] - mean) / dev) ** 2 )
z[k] = np.fabs(avg_dict[k] - mean) / dev
if not k in self.z_sum:
self.z_sum[k] = np.copy(z[k])
else:
self.z_sum[k] += z[k]
# print "incoldet"
# collision_detected = self.collision_filtering(is_outside_range_dict)
# collision_detected = self.collision_filtering_mal(np.sqrt(mal_sum))
# return collision_detected
collision_detected = self.collision_filtering(z)
# print "coldete", collision_detected
return collision_detected
def collision_filtering_mal(self, mal):
prob = 1.
TIME_WINDOW = 4
if self.mals is None:
self.mals = np.array([0.] * TIME_WINDOW)
self.mals[self.cur_pt % TIME_WINDOW] = mal
if self.cur_pt < TIME_WINDOW:
return False
mal_avg = np.add.reduce(self.mals / TIME_WINDOW)
MAL_THRESH = 8.0
if mal_avg > MAL_THRESH:
print "Collision with mal dist:", mal_avg
for k in self.cur_mals:
print k, self.cur_mals[k]
return True
return False
def collision_filtering(self, z):
prob = 1.
TIME_WINDOW = 4
for k in z:
if not k in self.z_rsum:
self.z_rsum[k] = np.copy(z[k])
self.z_list[k] = [np.array([0.]*len(z[k]))] * TIME_WINDOW
else:
self.z_rsum[k] += z[k]
self.z_rsum[k] -= self.z_list[k][self.cur_pt % TIME_WINDOW]
self.z_list[k][self.cur_pt % TIME_WINDOW] = z[k]
# print z[k]
prob *= np.multiply.reduce(2 * stats.norm.cdf(-self.z_rsum[k] / TIME_WINDOW))
# print prob
if self.cur_pt < TIME_WINDOW:
return False
if prob < self.min_prob:
self.min_prob = prob
# CONFIDENCE = 1e-6
if not self.only_pressure:
# 4e-7 50/50
CONFIDENCE = 2.0e-6
else:
# pressure only confidence
CONFIDENCE = 1.e-5
if self.cur_pt % 20 == 0:
print "Current pt:", self.cur_pt, ", probability:", prob
if prob < CONFIDENCE:
print "probability:", prob
print "collision returned"
return True
# print "-------------------------"
# print num_percep_col
# for k in sig_counts:
# if sig_counts[k] >= PERCEPT_SIG_REQ[k]:
# print k, ":", sig_counts[k]
# print "-------------------------"
# return True
return False
# def collision_filtering(self, is_outside_range_dict):
# isord = is_outside_range_dict
# TIME_WINDOW = 10
# NUM_PERCEPT_COL_REQ = 2
# PERCEPT_SIG_REQ = { "accelerometer" : 2,
# "joint_angles" : 2,
# "joint_velocities" : 3,
# "joint_efforts" : 2,
# "r_finger_periph_pressure" : 2,
# "r_finger_pad_pressure" : 5,
# "l_finger_periph_pressure" : 2,
# "l_finger_pad_pressure" : 5 }
# num_percep_col = 0
# sig_counts = {}
# num_periph = 0
# for k in isord:
# # if any(isord[k]):
# # print k, isord
# if not k in self.collision_times:
# self.collision_times[k] = [np.array([0] * len(isord[k]))] * TIME_WINDOW
# self.collision_sums[k] = np.array([0] * len(isord[k]))
# # def queue_sum(q):
# # sum = None
# # for i in range(TIME_WINDOW):
# # val = q.get()
# # if sum is None:
# # sum = np.copy(val)
# # sum += val
# # q.put(val)
# # return sum
# # c_sum = queue_sum(self.collision_times[k])
# self.collision_sums[k] -= self.collision_times[k][self.cur_col_time]
# self.cur_col_time = (self.cur_col_time + 1) % TIME_WINDOW
# self.collision_times[k][self.cur_col_time] = np.int32(np.array(isord[k]))
# self.collision_sums[k] += self.collision_times[k][self.cur_col_time]
# def g0(x):
# if x > 0:
# return 1
# return 0
# sig_count = np.sum(map(g0, self.collision_sums[k]))
# sig_counts[k] = sig_count
# if sig_count >= PERCEPT_SIG_REQ[k]:
# # print "cols", k, isord[k]
# if k == "r_finger_periph_pressure" or k == "l_finger_periph_pressure":
# num_periph += 1
# num_percep_col += 1
# # num_periph != 1 eliminates side object collision possibilities
# if num_percep_col >= NUM_PERCEPT_COL_REQ and num_periph != 1:
# print "collision returned"
# print "-------------------------"
# print num_percep_col
# for k in sig_counts:
# if sig_counts[k] >= PERCEPT_SIG_REQ[k]:
# print k, ":", sig_counts[k]
# print "-------------------------"
# return True
# return False
# if self.collide and any(is_outside_range):
# # sensor has fallen outside acceptable range, trigger
# for i, x in enumerate(is_outside_range):
# if x:
# # print "Average:", avg
# # print "Last avg:", self.prev_avg
# # print "Prev sum:", self.prev_sum
# # print "MOD:", self.model_zeros[k]
# # print "MON:", self.current_zeros[k]
# return i, diff[i]
# return -1, 0.
# @TODO add sampling_rate stuff
def simulate_monitoring(self, monitor_data, models=None, model_zeros=None,
std_dev_dict=None, noise_dev_dict=None,
duration=None,
std_dev_default=2.0, noise_dev_default=0.25,
tol_thresh_dict=None,
contingency=None, window_size=70, current_zeros=None,
transform_dict=None, verbose=True, collide=True):
self.setup_monitoring(std_dev_dict=std_dev_dict, noise_dev_dict=noise_dev_dict,
duration=duration, std_dev_default=std_dev_default,
tol_thresh_dict=tol_thresh_dict,
noise_dev_default=noise_dev_default, contingency=contingency, window_size=window_size,
current_zeros=current_zeros, transform_dict=transform_dict,
verbose=verbose, collide=collide)
if models is not None:
self.models = models
if model_zeros is not None:
self.model_zeros = model_zeros
self.cur_pt = self.window_size
collision = None
# i is the number of samples in the monitor data
for i in range(len(monitor_data[monitor_data.keys()[0]])):
for k in monitor_data:
index, diff = self.collision_detect(k, monitor_data[k][i])
if index != -1:
collision = (k, index, diff)
self.cur_pt += 1
return collision
def resample_and_thin_data(self, monitor_data, sample_rate):
ret_data = {}
for k in monitor_data:
ret_data[k] = {}
ret_data[k]["mean"] = monitor_data[k]["mean"][::sample_rate]
ret_data[k]["variance"] = monitor_data[k]["variance"][::sample_rate]
return ret_data
def split_signals(datasets):
for perception in datasets:
data_list = datasets[perception]
# get the minimum model length
lens = [len(m) for m in data_list]
max_len = np.max(lens)
# dynamic finding of parameters
if smooth_wind_dict is None or smooth_wind_dict[perception] is None:
smooth_wind = smooth_wind_default
else:
smooth_wind = smooth_wind_dict[perception]
ret_means, ret_vars, ret_mean_models, ret_noise_vars = [], [], [], []
ret_times, noise_vars = [], []
# find the number of coordinates from the first element
num_coords = len(data_list[0][0][1])
for coord in range(num_coords):
mean_models, variance_models = [], []
times = None
for stream in data_list:
# extract only the data stream for a single coordinate (all x values)
stream_coord = np.array(zip(*zip(*stream)[1])[coord])
cur_mean_model = signal_smooth(stream_coord, smooth_wind)
mean_models += [cur_mean_model]
# sum up the squared difference over the whole model
noise_vars += [ ( sum([(x - y) ** 2 for x,y in zip(cur_mean_model,stream_coord)]) /
len(cur_mean_model) ) ]
# find the average case over the several runs
avg_means_model = np.array([0.] * max_len)
for i in range(max_len):
n = 0
for j in range(len(mean_models)):
if i < len(mean_models[j]):
avg_means_model[i] += mean_models[j][i]
n += 1
avg_means_model[i] /= n
if var_wind_dict is None or var_wind_dict[perception] is None:
var_wind = var_wind_default
else:
var_wind = var_wind_dict[perception]
# find the variance of the signal but use var_wind points around the centers
# to increase the sample size
vars_model = signal_list_variance(mean_models, avg_means_model, var_wind)
vars_model = signal_smooth(vars_model, var_smooth_wind)
vars_model = signal_smooth(vars_model, var_smooth_wind + 23)
ret_times += [times]
ret_means += [avg_means_model]
ret_vars += [vars_model]
ret_mean_models += [mean_models]
ret_noise_vars += [np.average(noise_vars)]
# TODO deal with timestamp data in some way?
# self.models[perception]["time"] = ret_times
self.models[perception]["mean"] = np.array(zip(*ret_means))
self.models[perception]["variance"] = np.array(zip(*ret_vars))
a = ret_mean_models
b = []
for stream in range(len(a[0])):
t1 = []
for val in range(len(a[0][0])):
t2 = []
for coord in range(len(a)):
if val < len(a[coord][stream]):
t2 += [a[coord][stream][val]]
t1 += [np.array(t2)]
b += [t1]
self.models[perception]["smoothed_signals"] = b
self.models[perception]["noise_variance"] = np.array(ret_noise_vars)
return self.models
##
# Generates model functions of all the perceptions over several
# identical trajectories. Each of the parameters is a dictionary
# directing perceptions to their parameters.
#
# @param smooth_wind_dict the window size of the smoothing function
# @param var_wind_dict window size of the variance function
# @param var_smooth_wind_dict window size of the smoothing function on the variance
# @return mean function, variance function
def generate_mean_grasp(datasets):
smooth_wind_default = 234
means = {}
for perception in datasets:
data_list = datasets[perception]
# get the minimum model length
lens = [len(m) for m in data_list]
max_len = np.max(lens)
ret_means = []
# find the number of coordinates from the first element
num_coords = len(data_list[0][0][1])
for coord in range(num_coords):
mean_models, variance_models = [], []
for stream in data_list:
# extract only the data stream for a single coordinate (all x values)
stream_coord = np.array(zip(*zip(*stream)[1])[coord])
cur_mean_model = signal_smooth(stream_coord, smooth_wind)
mean_models += [cur_mean_model]
# find the average case over the several runs
avg_means_model = np.array([0.] * max_len)
for i in range(max_len):
n = 0
for j in range(len(mean_models)):
if i < len(mean_models[j]):
avg_means_model[i] += mean_models[j][i]
n += 1
avg_means_model[i] /= n
ret_means += [avg_means_model]
means[perception] = np.array(zip(*ret_means))
return means
if __name__ == '__main__':
rospy.init_node(node_name, anonymous=True)
apm = ArmPerceptionMonitor(0, 0.001)
for x in range(3):
raw_input("Begin arm")
apm.start_training()
rospy.sleep(1.)
apm.stop_training()
rospy.sleep(0.1)
models = apm.generate_models()
apm.pickle_datasets("pickles//apmtest.pickle")
means = models["accelerometer"]["mean"]
vars = models["accelerometer"]["variance"]
xm, ym, zm = zip(*means)
xv, yv, zv = zip(*vars)
xv = map(np.sqrt, xv)
yv = map(np.sqrt, yv)
zv = map(np.sqrt, zv)
std_dev = 2.5
xmmax = [m + np.sqrt(v) * std_dev for m, v in zip(xm, xv)]
ymmax = [m + np.sqrt(v) * std_dev for m, v in zip(ym, yv)]
zmmax = [m + np.sqrt(v) * std_dev for m, v in zip(zm, zv)]
xmmin = [m - np.sqrt(v) * std_dev for m, v in zip(xm, xv)]
ymmin = [m - np.sqrt(v) * std_dev for m, v in zip(ym, yv)]
zmmin = [m - np.sqrt(v) * std_dev for m, v in zip(zm, zv)]
import matplotlib.pyplot as plt
plt.subplot(321)
plt.plot(xm)
plt.plot(xmmax)
plt.plot(xmmin)
#plt.axis([0, len(xm), 0., 15.])
plt.title("X mean")
plt.subplot(323)
plt.plot(ym)
plt.plot(ymmax)
plt.plot(ymmin)
plt.title("Y mean")
plt.subplot(325)
plt.plot(zm)
plt.plot(zmmax)
plt.plot(zmmin)
plt.title("Z mean")
plt.subplot(322)
plt.plot(xv)
plt.title("X variance")
plt.subplot(324)
plt.plot(yv)
plt.title("Y variance")
plt.subplot(326)
plt.plot(zv)
plt.title("Z variance")
plt.show()
| [
[
1,
0,
0.0023,
0.0008,
0,
0.66,
0,
954,
0,
2,
0,
0,
954,
0,
0
],
[
1,
0,
0.0031,
0.0008,
0,
0.66,
0.0323,
413,
0,
1,
0,
0,
413,
0,
0
],
[
1,
0,
0.0039,
0.0008,
0,
... | [
"import numpy as np, math",
"import scipy.stats as stats",
"from threading import RLock",
"import roslib; roslib.load_manifest('hrl_pr2_lib')",
"import roslib; roslib.load_manifest('hrl_pr2_lib')",
"import rospy",
"from hrl_lib.util import save_pickle, load_pickle",
"from hrl_lib.msg import FloatArray... |
#! /usr/bin/python
import numpy as np
import sys
import cPickle as pickle
import roslib
roslib.load_manifest('kelsey_sandbox')
roslib.load_manifest('hrl_generic_arms')
import rospy
import rosparam
import tf
import tf.transformations as tf_trans
from hrl_generic_arms.pose_converter import PoseConverter
#from umeyama_method import umeyama_method
def capture_data():
tf_list = tf.TransformListener()
opti_mat, robot_mat = [], []
print "Hit enter to collect a data sample"
i = 0
while not rospy.is_shutdown():
rospy.sleep(0.3)
#if raw_input(".") == 'q':
# break
now = rospy.Time(0.)
(opti_pos, opti_rot) = tf_list.lookupTransform("/pr2_antenna",
"/optitrak", now)
(robot_pos, robot_rot) = tf_list.lookupTransform("/wide_stereo_link",
"/base_footprint", now)
opti_mat.append(opti_pos)
opti_rot_foot = np.mat([[-0.17496687, 0.03719102, -0.98387165],
[-0.98098458, -0.09183928, 0.17098186],
[-0.08399907, 0.99507908, 0.05255265]]).T
opti_pos_foot = np.mat([[ 1.276 ],
[-0.81755],
[-0.06905]])
foot_B_opti = PoseConverter.to_homo_mat(opti_pos_foot, opti_rot_foot) ** -1
opti_B_ant = PoseConverter.to_homo_mat(opti_pos, opti_rot) ** -1
wide_B_foot = PoseConverter.to_homo_mat(robot_pos, robot_rot)
print wide_B_foot * foot_B_opti * opti_B_ant
offset_robot_pos = (wide_B_foot * foot_B_opti)[:3,3]
print offset_robot_pos, opti_pos
robot_mat.append(offset_robot_pos.T.A[0].tolist())
i += 1
if i % 10 == 0:
print i, "samples collected"
return opti_mat, robot_mat
def umeyama_method(A, B):
ux = np.mean(A, 1)
uy = np.mean(B, 1)
A_demean = A - ux
B_demean = B - uy
U, D, VT = np.linalg.svd(A_demean * B_demean.T)
R = VT.T * U.T
t = uy - R * ux
return t, R
def save_params(pos, rot, filename):
rot_homo = np.eye(4)
rot_homo[:3,:3] = rot
rot_quat = tf_trans.quaternion_from_matrix(rot_homo)
optitrak_params = { "position" : pos.T.A[0].tolist(),
"orientation" : rot_quat.tolist() }
print optitrak_params
rosparam.upload_params("optitrak_calibration", optitrak_params)
rospy.sleep(0.5)
rosparam.dump_params(filename, "optitrak_calibration")
def publish_transform():
optitrak_params = rosparam.get_param("optitrak_calibration")
remap_mat = PoseConverter.to_homo_mat(optitrak_params["position"],
optitrak_params["orientation"]) ** -1
tf_list = tf.TransformListener()
tf_broad = tf.TransformBroadcaster()
small_dur = rospy.Duration(0.001)
robot_mat = PoseConverter.to_homo_mat([0., 0., 0.], [0., 0., 0., 1.])
opti_mat = PoseConverter.to_homo_mat([0., 0., 0.], [0., 0., 0., 1.])
while not rospy.is_shutdown():
try:
now = rospy.Time(0.)
(opti_pos, opti_rot) = tf_list.lookupTransform("/optitrak",
"/pr2_antenna", now)
opti_mat = PoseConverter.to_homo_mat(opti_pos, opti_rot)
now = rospy.Time(0.)
(robot_pos, robot_rot) = tf_list.lookupTransform("/wide_stereo_link",
"/base_footprint", now)
robot_mat = PoseConverter.to_homo_mat(robot_pos, robot_rot)
odom_mat = opti_mat * remap_mat * robot_mat
odom_pos, odom_rot = PoseConverter.to_pos_quat(odom_mat)
tf_broad.sendTransform(odom_pos, odom_rot, rospy.Time.now(), "/base_footprint", "/optitrak")
rospy.sleep(0.001)
except Exception as e:
print e
def main():
rospy.init_node("optitrak_odom_remap")
from optparse import OptionParser
p = OptionParser()
p.add_option('-f', '--file', dest="filename", default="",
help="YAML file to save parameters in.")
p.add_option('-l', '--load', dest="is_load",
action="store_true", default=False,
help="Load parameters from file.")
p.add_option('-t', '--train', dest="is_train",
action="store_true", default=False,
help="Train by moving the head to different poses and capturing the relative positions.")
p.add_option('-p', '--publish', dest="is_pub",
action="store_true", default=False,
help="Publish the transformation from optitrak to base_footprint.")
(opts, args) = p.parse_args()
if opts.filename == "":
print "Bad command line parameters"
p.print_help()
return
if opts.is_load:
print "hi"
params = rosparam.load_file(opts.filename, "optitrak_calibration")[0][0]
rosparam.upload_params("optitrak_calibration", params)
rospy.sleep(0.1)
if opts.is_pub:
publish_transform()
return
if opts.is_train:
opti_mat, robot_mat = capture_data()
opti_mat = np.mat(opti_mat).T
robot_mat = np.mat(robot_mat).T
pos, rot = umeyama_method(opti_mat, robot_mat)
print np.linalg.norm(robot_mat - (rot * opti_mat + pos))
save_params(pos, rot, opts.filename)
return
if __name__ == "__main__":
main()
| [
[
1,
0,
0.0211,
0.007,
0,
0.66,
0,
954,
0,
1,
0,
0,
954,
0,
0
],
[
1,
0,
0.0282,
0.007,
0,
0.66,
0.0625,
509,
0,
1,
0,
0,
509,
0,
0
],
[
1,
0,
0.0352,
0.007,
0,
0.6... | [
"import numpy as np",
"import sys",
"import cPickle as pickle",
"import roslib",
"roslib.load_manifest('kelsey_sandbox')",
"roslib.load_manifest('hrl_generic_arms')",
"import rospy",
"import rosparam",
"import tf",
"import tf.transformations as tf_trans",
"from hrl_generic_arms.pose_converter im... |
#! /usr/bin/python
import numpy as np
from collections import deque
from threading import Lock
import roslib
roslib.load_manifest("hrl_pr2_arms")
import tf.transformations as tf_trans
import rospy
from hrl_pr2_arms.pr2_controller_switcher import ControllerSwitcher
from hrl_pr2_arms.pr2_arm import create_pr2_arm, PR2ArmJointTrajectory, PR2ArmCartesianPostureBase
from hrl_generic_arms.controllers import PIDController
rate = 100.
# controller gains
kp_proportional = 0.084
kp_integral = 0.35
kp_init_integral = 0.005
kp_constant = 0.002
kp_max_ctrl = 0.30
kr_proportional = 0.160
kr_integral = 0.200
kr_init_integral = 0.05
kr_constant = 0.020
kr_max_ctrl = 0.40
class PR2ArmCartVelocityController(object):
def __init__(self, arm, velocity_rot=None):
self.arm = arm
if velocity_rot is None:
self.velocity_rot = np.mat(np.eye(3))
else:
self.velocity_rot = velocity_rot
self._is_moving = False
self.lock = Lock()
def update_velocity_rot(self, velocity_rot):
with self.lock:
self.velocity_rot = np.mat(velocity_rot)
def move_velocity(self, velocity=0.015, is_translation=True, velocity_rot=None):
if velocity_rot is not None:
self.update_velocity_rot(velocity_rot)
pos_i_des, rot_i_des = self.arm.get_ep()
pos_i_act, rot_i_act = self.arm.get_end_effector_pose()
# this is the current residiual error in the controller at the start
pos_err = pos_i_act - pos_i_des
rot_err = rot_i_act.T * rot_i_des
if is_translation:
pos_vel_des = velocity
pid_ctrl = PIDController(rate=rate, k_p=kp_proportional, k_i=kp_integral,
i_max=None, init_integ=np.sign(pos_vel_des) * kp_init_integral,
saturation=kp_max_ctrl,
feed_forward=np.sign(pos_vel_des) * kp_constant,
name="arm_vel")
else:
rot_vel_des = velocity
pid_ctrl = PIDController(rate=rate, k_p=kr_proportional, k_i=kr_integral,
i_max=None, init_integ=np.sign(rot_vel_des) * kr_init_integral,
saturation=kr_max_ctrl,
feed_forward=np.sign(rot_vel_des) * kr_constant,
name="arm_vel")
vels = deque([np.array([0]*6)]*40)
r = rospy.Rate(rate)
self._is_moving = True
while not rospy.is_shutdown() and self._is_moving:
with self.lock:
vel_rot = self.velocity_rot.copy()
cur_pos, cur_rot = self.arm.get_end_effector_pose()
# hacky velocity filter
xd_act = self.arm.get_controller_state()['xd_act']
vels.append(xd_act)
vels.popleft()
vel_filt = np.mat(np.mean(vels, 0)).T
x_vel_filt = (vel_rot.T * vel_filt[:3,0])[0,0]
roll_vel_filt = (vel_rot.T * vel_filt[3:,0])[0,0]
if is_translation:
# PI velocity controller for position
pos_ctrl = pid_ctrl.update_state(pos_vel_des - x_vel_filt)
pos_des = vel_rot * (np.mat([pos_ctrl, 0, 0]).T +
np.mat(np.diag([1, 0, 0])) * vel_rot.T * (cur_pos - pos_err) +
np.mat(np.diag([0, 1, 1])) * vel_rot.T * pos_i_des)
rot_des = rot_i_des # don't change rotation
if not is_translation:
rot_des_vel_frame = np.mat(np.eye(4))
rot_des_vel_frame[:3,:3] = cur_rot * rot_err * vel_rot
roll_des_vel_frame, r2, r3 = tf_trans.euler_from_matrix(rot_des_vel_frame)
# PI velocity controller for rotation
rot_ctrl = pid_ctrl.update_state(rot_vel_des + roll_vel_filt)
print roll_vel_filt, rot_vel_des, rot_vel_des - roll_vel_filt
roll_ctrl_des = roll_des_vel_frame + rot_ctrl
r1, pitch_i_des, yaw_i_des = tf_trans.euler_from_matrix(rot_i_des * vel_rot)
rot_des = np.mat(tf_trans.euler_matrix(roll_ctrl_des, pitch_i_des, yaw_i_des)[:3,:3]) * vel_rot.T
pos_des = pos_i_des # don't change translation
self.arm.set_ep((pos_des, rot_des), 1)
r.sleep()
self.arm.set_ep(self.arm.get_ep(), 1)
def stop_moving(self):
self._is_moving = False
def main():
rospy.init_node("arm_cart_vel_control")
if True:
ctrl_switcher = ControllerSwitcher()
ctrl_switcher.carefree_switch('r', '%s_arm_controller',
'$(find hrl_pr2_arms)/params/joint_traj_params_electric.yaml')
rospy.sleep(0.5)
ctrl_switcher.carefree_switch('r', '%s_joint_controller_low',
'$(find hrl_pr2_arms)/params/joint_traj_params_electric_low.yaml')
r_arm_js = create_pr2_arm('r', PR2ArmJointTrajectory, controller_name='%s_joint_controller_low')
q = [-0.34781704, 0.27341079, -1.75392154, -2.08626393, -3.43756314, -1.82146607, -1.85187734]
r_arm_js.set_ep(q, 3)
rospy.sleep(6)
ctrl_switcher.carefree_switch('r', '%s_cart_low_rfh',
'$(find kelsey_sandbox)/params/j_transpose_low_rfh.yaml')
r_arm = create_pr2_arm('r', PR2ArmCartesianPostureBase)
r_arm.set_posture()
rospy.sleep(0.2)
vel_ctrl = PR2ArmCartVelocityController(r_arm)
#vel_frame = tf_trans.euler_matrix(0, -np.pi/2, 0)[:3,:3]
#vel_ctrl.move_velocity(velocity_rot=vel_frame, velocity=0.005, is_translation=False)
vel_frame = tf_trans.euler_matrix(0, 0, np.pi/2)[:3,:3]
vel_ctrl.move_velocity(velocity_rot=vel_frame, velocity=0.10, is_translation=False)
if __name__ == "__main__":
main()
| [
[
1,
0,
0.021,
0.007,
0,
0.66,
0,
954,
0,
1,
0,
0,
954,
0,
0
],
[
1,
0,
0.028,
0.007,
0,
0.66,
0.0435,
193,
0,
1,
0,
0,
193,
0,
0
],
[
1,
0,
0.035,
0.007,
0,
0.66,
... | [
"import numpy as np",
"from collections import deque",
"from threading import Lock",
"import roslib",
"roslib.load_manifest(\"hrl_pr2_arms\")",
"import tf.transformations as tf_trans",
"import rospy",
"from hrl_pr2_arms.pr2_controller_switcher import ControllerSwitcher",
"from hrl_pr2_arms.pr2_arm i... |
#!/usr/bin/python
import numpy as np
import functools
import roslib
roslib.load_manifest('hrl_pr2_arms')
roslib.load_manifest('smach_ros')
roslib.load_manifest('costmap_services')
import rospy
import smach
import smach_ros
from std_msgs.msg import Bool, Int8
from hrl_pr2_arms.pr2_arm import create_pr2_arm, PR2ArmJointTrajectory
from costmap_services.python_client import CostmapServices
from pr2_viz_servo import PR2VisualServoAR
outcomes_spa = ['succeeded','preempted','aborted']
#viz_servo_goals = {
# "r_pr2_ar_pose_marker" : [0.57226345, 0.32838129, -1.15480113],
# "l_pr2_ar_pose_marker" : [0.57903398, 0.44215034, -0.76362254]}
#"l_pr2_ar_pose_marker" : [0.59739709, 0.39469539, -0.7088098]}
class ServoStates:
BEGIN_FIND_TAG = 1
FOUND_TAG = 2
TIMEOUT_FIND_TAG = 3
BEGIN_SERVO = 4
SUCCESS_SERVO = 5
ARM_COLLISION = 6
LASER_COLLISION = 7
LOST_TAG = 8
USER_PREEMPT = 9
class ArmCollisionDetection(smach.State):
def __init__(self, min_l_torques=[-5.]*7, min_r_torques=[-5.]*7,
max_l_torques=[5.]*7, max_r_torques=[5.]*7):
smach.State.__init__(self, outcomes=['collision', 'preempted', 'aborted'])
self.min_l_tor = np.array(min_l_torques)
self.min_r_tor = np.array(min_r_torques)
self.max_l_tor = np.array(max_l_torques)
self.max_r_tor = np.array(max_r_torques)
self.l_arm = create_pr2_arm('l', PR2ArmJointTrajectory, timeout=0)
self.r_arm = create_pr2_arm('r', PR2ArmJointTrajectory, timeout=0)
def execute(self, userdata):
r = rospy.Rate(20)
while not rospy.is_shutdown():
l_tor = self.l_arm.get_joint_efforts()
r_tor = self.r_arm.get_joint_efforts()
if np.any(l_tor < self.min_l_tor):
print "Collision detected on left arm with torque:", l_tor
print "Minimum torques:", self.min_l_tor
return 'collision'
if np.any(l_tor > self.max_l_tor):
print "Collision detected on left arm with torque:", l_tor
print "Maximum torques:", self.max_l_tor
return 'collision'
if np.any(r_tor < self.min_r_tor):
print "Collision detected on right arm with torque:", r_tor
print "Minimum torques:", self.min_r_tor
return 'collision'
if np.any(r_tor > self.max_r_tor):
print "Collision detected on right arm with torque:", r_tor
print "Minimum torques:", self.max_r_tor
return 'collision'
if self.preempt_requested():
self.service_preempt()
return 'preempted'
r.sleep()
return 'aborted'
class LaserCollisionDetection(smach.State):
def __init__(self):
smach.State.__init__(self, outcomes=['collision', 'preempted', 'aborted'])
self.cs = CostmapServices(accum=3)
def execute(self, userdata):
r = rospy.Rate(20)
while not rospy.is_shutdown():
vx, vy, vtheta = 0., 0., 0. #TODO REMOVE
score = self.cs.scoreTraj_PosHyst(vx, vy, vtheta) # TODO
if score < 0:
print "Base laser detected a collision."
return 'collision'
if self.preempt_requested():
self.service_preempt()
return 'preempted'
r.sleep()
return 'aborted'
def build_cc_servoing(viz_servos):
def term_cb(outcome_map):
return True
def out_cb(outcome_map):
if outcome_map['ARM_COLLISION_DETECTION'] == 'collision':
return 'arm_collision'
if outcome_map['LASER_COLLISION_DETECTION'] == 'collision':
return 'laser_collision'
if outcome_map['USER_PREEMPT_DETECTION'] == 'true':
return 'user_preempted'
if outcome_map['USER_PREEMPT_DETECTION'] == 'false':
return 'aborted'
return outcome_map['SERVOING']
cc_servoing = smach.Concurrence(
outcomes=outcomes_spa+
['arm_collision', 'laser_collision', 'lost_tag', 'user_preempted'],
input_keys=['goal_ar_pose', 'initial_ar_pose', 'servo_topic'],
default_outcome='aborted',
child_termination_cb=term_cb,
outcome_cb=out_cb)
with cc_servoing:
smach.Concurrence.add('SERVOING',
ServoARTagState(viz_servos))
smach.Concurrence.add('ARM_COLLISION_DETECTION',
ArmCollisionDetection())
smach.Concurrence.add('LASER_COLLISION_DETECTION',
LaserCollisionDetection())
smach.Concurrence.add('USER_PREEMPT_DETECTION',
BoolTopicState("/pr2_ar_servo/preempt"))
return cc_servoing
class BoolTopicState(smach.State):
def __init__(self, topic, rate=20):
smach.State.__init__(self, outcomes=['true', 'false', 'preempted', 'aborted'])
self.rate = rate
self.ui_list = rospy.Subscriber(topic, Bool, self.ui_cb)
def ui_cb(self, msg):
self.bool_msg = msg.data
self.got_msg = True
def execute(self, userdata):
self.got_msg = False
r = rospy.Rate(self.rate)
while not rospy.is_shutdown():
if self.got_msg:
if self.bool_msg:
return 'true'
else:
return 'false'
if self.preempt_requested():
self.service_preempt()
return 'preempted'
r.sleep()
return 'aborted'
class PublishState(smach.State):
def __init__(self, topic, msg_type, msg):
smach.State.__init__(self, outcomes=['succeeded'])
self.pub = rospy.Publisher(topic, msg_type)
self.msg = msg
def execute(self, userdata):
self.pub.publish(self.msg)
return 'succeeded'
class FindARTagState(smach.State):
def __init__(self, viz_servos, viz_servo_goals, timeout=6.):
smach.State.__init__(self,
outcomes=['found_tag', 'timeout', 'preempted', 'aborted'],
output_keys=['initial_ar_pose', 'goal_ar_pose', 'servo_topic'])
self.viz_servos = viz_servos
self.viz_servo_goals = viz_servo_goals
self.timeout = timeout
def execute(self, userdata):
# This is just a mess.
# Figure this out and rewrite it...
def check_preempt(event):
if self.preempt_requested():
self.service_preempt()
for topic in self.viz_servos:
self.viz_servos[topic].request_preempt()
preempt_timer = rospy.Timer(rospy.Duration(0.1), check_preempt)
self.outcome_dict = {}
def call_find_ar_tag(te, viz_servo, fart_state, topic):
mean_ar, outcome = viz_servo.find_ar_tag(self.timeout)
self.outcome_dict[topic] = (mean_ar, outcome)
if outcome == "found_tag":
self.request_preempt()
for topic in self.viz_servos:
call_find_ar_tag_filled = functools.partial(call_find_ar_tag,
viz_servo=self.viz_servos[topic],
fart_state=self,
topic=topic)
rospy.Timer(rospy.Duration(0.01), call_find_ar_tag_filled, oneshot=True)
while not rospy.is_shutdown():
if self.preempt_requested() or len(self.outcome_dict) == len(self.viz_servos):
break
rospy.sleep(0.05)
outcome = "timeout"
for topic in self.outcome_dict:
if self.outcome_dict[topic][1] == "found_tag":
userdata['initial_ar_pose'] = self.outcome_dict[topic][0]
userdata['goal_ar_pose'] = self.viz_servo_goals[topic]
userdata['servo_topic'] = topic
outcome = "found_tag"
# FIXME I should be shot for these lines: FIXME
if topic == "r_pr2_ar_pose_marker":
rospy.set_param("/shaving_side", 'r')
else:
rospy.set_param("/shaving_side", 'l')
##################################################
break
preempt_timer.shutdown()
return outcome
class ServoARTagState(smach.State):
def __init__(self, viz_servos):
smach.State.__init__(self,
outcomes=['lost_tag'] + outcomes_spa,
input_keys=['goal_ar_pose', 'initial_ar_pose', 'servo_topic'])
self.viz_servos = viz_servos
def execute(self, userdata):
if 'initial_ar_pose' in userdata:
initial_ar_pose = userdata.initial_ar_pose
else:
rospy.logerr("Initial AR pose should be in userdata")
initial_ar_pose = None
servo_topic = userdata['servo_topic']
def check_preempt(event):
if self.preempt_requested():
self.service_preempt()
self.viz_servos[servo_topic].request_preempt()
preempt_timer = rospy.Timer(rospy.Duration(0.1), check_preempt)
self.viz_servos[servo_topic].preempt_requested = False
outcome = self.viz_servos[servo_topic].servo_to_tag(pose_goal=userdata.goal_ar_pose,
initial_ar_pose=initial_ar_pose)
preempt_timer.shutdown()
return outcome
def build_full_sm(viz_servo_goals):
find_tag_timeout = 6.
viz_servos = {}
for viz_servo_topic in viz_servo_goals:
viz_servos[viz_servo_topic] = PR2VisualServoAR(viz_servo_topic)
sm_pr2_servoing = smach.StateMachine(outcomes=outcomes_spa,
input_keys=['goal_ar_pose', 'initial_ar_pose'])
with sm_pr2_servoing:
smach.StateMachine.add('UI_FIND_TAG_WAIT',
BoolTopicState("/pr2_ar_servo/find_tag"),
transitions={'true' : 'BEGIN_FIND_TAG',
'false' : 'aborted'})
smach.StateMachine.add('BEGIN_FIND_TAG',
PublishState("/pr2_ar_servo/state_feedback",
Int8, Int8(ServoStates.BEGIN_FIND_TAG)),
transitions={'succeeded' : 'FIND_AR_TAG'})
smach.StateMachine.add('FIND_AR_TAG',
FindARTagState(viz_servos, viz_servo_goals, timeout=find_tag_timeout),
transitions={'found_tag' : 'FOUND_TAG',
'timeout' : 'TIMEOUT_FIND_TAG'})
smach.StateMachine.add('FOUND_TAG',
PublishState("/pr2_ar_servo/state_feedback",
Int8, Int8(ServoStates.FOUND_TAG)),
transitions={'succeeded' : 'UI_SERVO_WAIT'})
smach.StateMachine.add('TIMEOUT_FIND_TAG',
PublishState("/pr2_ar_servo/state_feedback",
Int8, Int8(ServoStates.TIMEOUT_FIND_TAG)),
transitions={'succeeded' : 'UI_FIND_TAG_WAIT'})
smach.StateMachine.add('UI_SERVO_WAIT',
BoolTopicState("/pr2_ar_servo/tag_confirm"),
transitions={'true' : 'BEGIN_SERVO',
'false' : 'UI_FIND_TAG_WAIT'})
smach.StateMachine.add('BEGIN_SERVO',
PublishState("/pr2_ar_servo/state_feedback",
Int8, Int8(ServoStates.BEGIN_SERVO)),
transitions={'succeeded' : 'CC_SERVOING'})
smach.StateMachine.add('CC_SERVOING',
build_cc_servoing(viz_servos),
transitions={'arm_collision' : 'ARM_COLLISION',
'laser_collision' : 'LASER_COLLISION',
'user_preempted' : 'USER_PREEMPT',
'lost_tag' : 'LOST_TAG',
'succeeded' : 'SUCCESS_SERVO'})
smach.StateMachine.add('SUCCESS_SERVO',
PublishState("/pr2_ar_servo/state_feedback",
Int8, Int8(ServoStates.SUCCESS_SERVO)),
transitions={'succeeded' : 'UI_FIND_TAG_WAIT'})
smach.StateMachine.add('ARM_COLLISION',
PublishState("/pr2_ar_servo/state_feedback",
Int8, Int8(ServoStates.ARM_COLLISION)),
transitions={'succeeded' : 'UI_FIND_TAG_WAIT'})
smach.StateMachine.add('LASER_COLLISION',
PublishState("/pr2_ar_servo/state_feedback",
Int8, Int8(ServoStates.LASER_COLLISION)),
transitions={'succeeded' : 'UI_FIND_TAG_WAIT'})
smach.StateMachine.add('LOST_TAG',
PublishState("/pr2_ar_servo/state_feedback",
Int8, Int8(ServoStates.LOST_TAG)),
transitions={'succeeded' : 'UI_FIND_TAG_WAIT'})
smach.StateMachine.add('USER_PREEMPT',
PublishState("/pr2_ar_servo/state_feedback",
Int8, Int8(ServoStates.USER_PREEMPT)),
transitions={'succeeded' : 'UI_FIND_TAG_WAIT'})
return sm_pr2_servoing
def build_test_sm():
viz_servo = PR2VisualServoAR("r_pr2_ar_pose_marker")
sm_only_servo = smach.StateMachine(outcomes=['lost_tag'] + outcomes_spa,
input_keys=['goal_ar_pose', 'initial_ar_pose'])
with sm_only_servo:
smach.StateMachine.add('ONLY_SERVO',
ServoARTagState(viz_servo))
return sm_only_servo
def main():
rospy.init_node("sm_pr2_servoing")
userdata = smach.user_data.UserData()
# old testing
#userdata['goal_ar_pose'] = [ 0.57160106, -0.4300153 , -1.70840111]
# both sides spot?
userdata['goal_ar_pose'] = [ 0.57226345, 0.32838129, -1.15480113]
viz_servo_goals = rospy.get_param("~ar_servo_poses", {})
print viz_servo_goals
if True:
sm_pr2_servoing = build_full_sm(viz_servo_goals)
sis = smach_ros.IntrospectionServer('pr2_servo', sm_pr2_servoing, 'UI_FIND_TAG_WAIT')
sis.start()
sm_pr2_servoing.execute(userdata)
sis.stop()
else:
sm_test = build_test_sm()
rospy.sleep(4)
sm_test.execute(userdata)
if __name__ == "__main__":
main()
| [
[
1,
0,
0.0083,
0.0028,
0,
0.66,
0,
954,
0,
1,
0,
0,
954,
0,
0
],
[
1,
0,
0.011,
0.0028,
0,
0.66,
0.04,
711,
0,
1,
0,
0,
711,
0,
0
],
[
1,
0,
0.0166,
0.0028,
0,
0.6... | [
"import numpy as np",
"import functools",
"import roslib",
"roslib.load_manifest('hrl_pr2_arms')",
"roslib.load_manifest('smach_ros')",
"roslib.load_manifest('costmap_services')",
"import rospy",
"import smach",
"import smach_ros",
"from std_msgs.msg import Bool, Int8",
"from hrl_pr2_arms.pr2_ar... |
#! /usr/bin/python
import sys
import numpy as np
import roslib; roslib.load_manifest("hrl_pr2_arms")
import rospy
import tf.transformations as tf_trans
from hrl_pr2_arms.pr2_arm import PR2Arm, create_pr2_arm
from hrl_pr2_arms.pr2_arm import PR2ArmJointTrajectory, PR2ArmJTranspose
from hrl_pr2_arms.pr2_arm import PR2ArmJInverse, PR2ArmJTransposeTask
from spheroid_space import SpheroidSpace
def main():
rospy.init_node("pr2_arm_test")
arm = sys.argv[1]
jnt_arm = create_pr2_arm(arm, arm_type=PR2ArmJointTrajectory)
kin = jnt_arm.kinematics
ellipse_rot = np.mat([[-1., 0., 0.], [0., -1., 0.], [0., 0., 1.]])
sspace = SpheroidSpace(0.15, np.mat([0.78, -0.18, 0.1]).T, ellipse_rot)
uvp = np.array([1.0, np.pi/2, 0.0])
uvp_delta = np.array([0.0, 0.6, 0.6])
pos, rot = sspace.spheroidal_to_pose(uvp + uvp_delta)
print pos, rot
#q_ik = kin.IK_search(pos, rot)
q_ik = kin.IK(pos, rot, jnt_arm.get_joint_angles())
if q_ik is not None:
jnt_arm.set_ep(q_ik, 5)
else:
print "IK failure"
if __name__ == "__main__":
main()
| [
[
1,
0,
0.0769,
0.0256,
0,
0.66,
0,
509,
0,
1,
0,
0,
509,
0,
0
],
[
1,
0,
0.1026,
0.0256,
0,
0.66,
0.0909,
954,
0,
1,
0,
0,
954,
0,
0
],
[
1,
0,
0.1538,
0.0256,
0,
... | [
"import sys",
"import numpy as np",
"import roslib; roslib.load_manifest(\"hrl_pr2_arms\")",
"import roslib; roslib.load_manifest(\"hrl_pr2_arms\")",
"import rospy",
"import tf.transformations as tf_trans",
"from hrl_pr2_arms.pr2_arm import PR2Arm, create_pr2_arm",
"from hrl_pr2_arms.pr2_arm import PR... |
#! /usr/bin/python
import numpy as np
import roslib
roslib.load_manifest("rospy")
roslib.load_manifest("std_msgs")
roslib.load_manifest("hrl_pr2_arms")
import rospy
from std_msgs.msg import String
import tf.transformations as tf_trans
from hrl_pr2_arms.pr2_arm import create_pr2_arm, PR2ArmJointTrajectory, PR2ArmCartesianPostureBase
from arm_cart_vel_control import PR2ArmCartVelocityController
from hrl_pr2_arms.pr2_controller_switcher import ControllerSwitcher
MOVE_BUTTONS = {'translate_up' : (True, tf_trans.euler_matrix(0, -np.pi/2, 0)[:3,:3]),
'translate_down' : (True, tf_trans.euler_matrix(0, np.pi/2, 0)[:3,:3]),
'translate_left' : (True, tf_trans.euler_matrix(0, 0, np.pi/2)[:3,:3]),
'translate_right' : (True, tf_trans.euler_matrix(0, 0, -np.pi/2)[:3,:3]),
'translate_in' : (True, tf_trans.euler_matrix(0, 0, np.pi)[:3,:3]),
'translate_out' : (True, tf_trans.euler_matrix(0, 0, 0)[:3,:3]),
'rotate_x_pos' : (False, tf_trans.euler_matrix(0, 0, 0)[:3,:3]),
'rotate_x_neg' : (False, tf_trans.euler_matrix(0, 0, np.pi)[:3,:3]),
'rotate_y_pos' : (False, tf_trans.euler_matrix(0, 0, np.pi/2)[:3,:3]),
'rotate_y_neg' : (False, tf_trans.euler_matrix(0, 0, -np.pi/2)[:3,:3]),
'rotate_z_pos' : (False, tf_trans.euler_matrix(0, -np.pi/2, 0)[:3,:3]),
'rotate_z_neg' : (False, tf_trans.euler_matrix(0, np.pi/2, 0)[:3,:3])}
MONITOR_RATE = 20.
MOVE_STATE_TOPIC = "/arm_control_gui/move_state"
LOAD_ARM_TOPIC = "/arm_control_gui/load_arm"
class ArmCartCtrlBackend(object):
def __init__(self, r_arm, l_arm, monitor_rate, misses_allowed=5):
self.misses_allowed = misses_allowed
self.is_move_connected = False
self.last_move_time = 0.
self.misses = 0
self.current_arm = "l"
self.arm_switch = False
self.topic_cmd = ""
self.active_cmd = ""
self.r_vel_ctrl = PR2ArmCartVelocityController(r_arm)
self.l_vel_ctrl = PR2ArmCartVelocityController(l_arm)
self.trans_vel = 0.01
self.rot_vel = 0.10
rospy.Subscriber(MOVE_STATE_TOPIC, String, self.move_state_cb)
rospy.Subscriber(LOAD_ARM_TOPIC, String, self.load_arm_cb)
def move_state_cb(self, msg):
self.is_move_connected = True
self.last_move_time = rospy.get_time()
self.misses = 0
self.topic_cmd = msg.data
def load_arm_cb(self, msg):
new_arm = msg.data
if self.current_arm != new_arm:
self.arm_switch = True
def check_arm_switched(self):
if self.arm_switch:
self.arm_switch = False
return True
return False
def check_move_state(self):
if rospy.get_time() - self.last_move_time > 1. / MONITOR_RATE:
self.misses += 1
if self.misses > self.misses_allowed:
self.is_move_connected = False
return self.is_move_connected
def backend_loop(self):
#vel_frame = tf_trans.euler_matrix(0, -np.pi/2, 0)[:3,:3]
#vel_ctrl.move_velocity(velocity_rot=vel_frame, velocity=0.005, is_translation=False)
vel_ctrl = self.r_vel_ctrl
r = rospy.Rate(MONITOR_RATE)
while not rospy.is_shutdown():
if self.check_move_state():
if self.topic_cmd != self.active_cmd and self.topic_cmd in MOVE_BUTTONS:
self.active_cmd = self.topic_cmd
is_translation, vel_frame = MOVE_BUTTONS[self.topic_cmd]
if is_translation:
vel_val = self.trans_vel
else:
vel_val = self.rot_vel
def move_vel_thread(te):
vel_ctrl.move_velocity(velocity_rot=vel_frame, velocity=vel_val,
is_translation=is_translation)
move_vel_timer = rospy.Timer(rospy.Duration(0.05), move_vel_thread, oneshot=True)
if self.topic_cmd == "":
self.active_cmd = ""
vel_ctrl.stop_moving()
else:
vel_ctrl.stop_moving()
r.sleep()
def main():
rospy.init_node("arm_cart_control_backend")
ctrl_switcher = ControllerSwitcher()
if False:
ctrl_switcher.carefree_switch('r', '%s_arm_controller',
'$(find hrl_pr2_arms)/params/joint_traj_params_electric.yaml')
rospy.sleep(0.5)
ctrl_switcher.carefree_switch('r', '%s_joint_controller_low',
'$(find hrl_pr2_arms)/params/joint_traj_params_electric_low.yaml')
r_arm_js = create_pr2_arm('r', PR2ArmJointTrajectory, controller_name='%s_joint_controller_low')
q = [-0.34781704, 0.27341079, -1.75392154, -2.08626393, -3.43756314, -1.82146607, -1.85187734]
r_arm_js.set_ep(q, 3)
rospy.sleep(6)
ctrl_switcher.carefree_switch('r', '%s_cart_low_rfh',
'$(find kelsey_sandbox)/params/j_transpose_low_rfh.yaml')
r_arm = create_pr2_arm('r', PR2ArmCartesianPostureBase, controller_name='%s_cart_low_rfh')
r_arm.set_posture()
rospy.sleep(0.2)
l_arm = None
#l_arm = create_pr2_arm('l', PR2ArmCartesianPostureBase)
#l_arm.set_posture()
rospy.sleep(0.2)
cart_ctrl = ArmCartCtrlBackend(r_arm, l_arm, MONITOR_RATE)
cart_ctrl.backend_loop()
if __name__ == "__main__":
main()
| [
[
1,
0,
0.0227,
0.0076,
0,
0.66,
0,
954,
0,
1,
0,
0,
954,
0,
0
],
[
1,
0,
0.0379,
0.0076,
0,
0.66,
0.0588,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0455,
0.0076,
0,
... | [
"import numpy as np",
"import roslib",
"roslib.load_manifest(\"rospy\")",
"roslib.load_manifest(\"std_msgs\")",
"roslib.load_manifest(\"hrl_pr2_arms\")",
"import rospy",
"from std_msgs.msg import String",
"import tf.transformations as tf_trans",
"from hrl_pr2_arms.pr2_arm import create_pr2_arm, PR2A... |
#! /usr/bin/python
import sys
import numpy as np
import roslib
roslib.load_manifest('hrl_pr2_arms')
roslib.load_manifest('smach_ros')
roslib.load_manifest('actionlib')
import rospy
import rosbag
import smach
from smach_ros import SimpleActionState, ServiceState, IntrospectionServer
import actionlib
import tf
import tf.transformations as tf_trans
from std_msgs.msg import Bool, Float32
from std_srvs.srv import Empty
from geometry_msgs.msg import PoseStamped, Vector3, Pose
from actionlib_msgs.msg import GoalStatus
from hrl_generic_arms.pose_converter import PoseConverter
from hrl_pr2_arms.pr2_arm import create_pr2_arm
from hrl_pr2_arms.pr2_arm_hybrid import PR2ArmHybridForce
def main():
rospy.init_node("cool_force_demo")
from optparse import OptionParser
p = OptionParser()
p.add_option('-f', '--force_mag', dest="force_mag", default=2,
help="Specify force magnitude.")
p.add_option('-x', '--max_force', dest="max_force", default=-1,
help="Specify max force magnitude.")
p.add_option('-c', '--compliance', dest="compliance", default=-1,
help="Compliance to maintain.")
p.add_option('-t', '--tip_frame', dest="tip_frame", default="/l_gripper_tool_frame",
help="Set tip to this frame.")
p.add_option('-z', '--zero_sensor', dest="zero_sensor", default=False,
action="store_true", help="Just zero the sensor.")
p.add_option('-l', '--force_line', dest="force_line", default=False,
action="store_true", help="Move in a line with zero force.")
p.add_option('-p', '--force_plane', dest="force_plane", default=False,
action="store_true", help="Move in a plane with zero force.")
p.add_option('-o', '--force_point', dest="force_point", default=False,
action="store_true", help="Move about a point with zero torque.")
p.add_option('-r', '--force_roll', dest="force_roll", default=False,
action="store_true", help="Move the wrist with zero torque.")
p.add_option('-a', '--force_all', dest="force_all", default=False,
action="store_true", help="All DOF are trying to set zero force.")
p.add_option('-n', '--force_none', dest="force_none", default=False,
action="store_true", help="Return to position control.")
p.add_option('-k', '--kill_controller', dest="kill_controller", default=False,
action="store_true", help="Render controller dead.")
(opts, args) = p.parse_args()
arm = create_pr2_arm('l', PR2ArmHybridForce)
rospy.sleep(1)
if opts.zero_sensor:
arm.zero_sensor()
# reset arm
arm.set_ep(arm.get_end_effector_pose(), 0)
arm.set_force(6 * [0])
fp_trans_major = 3
fp_trans_minor = 1
fp_rot = 0.1
fi_trans_major = 0.002
fi_trans_minor = 0.001
fi_max_trans_major = 10
fi_max_trans_minor = 5
fi_rot = 0
fi_max_rot = 0
pp_trans = 1000
pd_trans_major = 16
pd_trans_minor = 4
pp_rot = 120
pd_rot = 0
if opts.force_line:
arm.set_force_max([float(opts.max_force), -1, -1, -1, -1, -1])
arm.set_tip_frame(opts.tip_frame)
arm.set_force_gains(p_trans=[fp_trans_major, fp_trans_minor, fp_trans_minor],
p_rot=fp_rot, i_trans=[fi_trans_major, fi_trans_minor, fi_trans_minor],
i_max_trans=[fi_max_trans_major, fi_max_trans_minor, fi_max_trans_minor],
i_rot=fi_rot, i_max_rot=fi_max_rot)
arm.set_motion_gains(p_trans=[float(opts.compliance), pp_trans, pp_trans],
d_trans=[pd_trans_major, pd_trans_minor, pd_trans_minor],
p_rot=pp_rot, d_rot=pd_rot)
arm.set_force_directions(['x'])
arm.set_force([float(opts.force_mag), 0, 0, 0, 0, 0])
arm.update_gains()
return
if opts.force_plane:
arm.set_force_max([-1, float(opts.max_force), float(opts.max_force), -1, -1, -1, -1])
arm.set_tip_frame(opts.tip_frame)
arm.set_force_gains(p_trans=[fp_trans_minor, fp_trans_major, fp_trans_major],
p_rot=fp_rot, i_trans=[fi_trans_minor, fi_trans_major, fi_trans_major],
i_max_trans=[fi_max_trans_minor, fi_max_trans_major, fi_max_trans_major],
i_rot=fi_rot, i_max_rot=fi_max_rot)
arm.set_motion_gains(p_trans=[pp_trans, float(opts.compliance), float(opts.compliance)],
d_trans=[pd_trans_minor, pd_trans_major, pd_trans_major],
p_rot=pp_rot, d_rot=pd_rot)
arm.set_force_directions(['y', 'z'])
arm.set_force([0, float(opts.force_mag), float(opts.force_mag), 0, 0, 0])
arm.update_gains()
return
if opts.force_point:
arm.set_force_max([-1, -1, -1, -1, -1, -1, -1])
arm.set_tip_frame(opts.tip_frame)
arm.set_force_gains(p_trans=[fp_trans_minor, fp_trans_minor, fp_trans_minor],
p_rot=0.8, i_trans=[fi_trans_minor, fi_trans_minor, fi_trans_minor],
i_max_trans=[fi_max_trans_minor, fi_max_trans_minor, fi_max_trans_minor],
i_rot=fi_rot, i_max_rot=fi_max_rot)
arm.set_motion_gains(p_trans=[pp_trans, pp_trans, pp_trans],
d_trans=[pd_trans_minor, pd_trans_minor, pd_trans_minor],
p_rot=pp_rot, d_rot=pd_rot)
arm.set_force_directions([0, 0, 0, 1, 1, 1])
arm.set_force([0, 0, 0, float(opts.force_mag), float(opts.force_mag), float(opts.force_mag)])
arm.update_gains()
return
if opts.force_roll:
arm.set_force_max([-1, -1, -1, -1, -1, -1, -1])
arm.set_tip_frame(opts.tip_frame)
arm.set_force_gains(p_trans=[fp_trans_minor, fp_trans_minor, fp_trans_minor],
p_rot=1.8, i_trans=[fi_trans_minor, fi_trans_minor, fi_trans_minor],
i_max_trans=[fi_max_trans_minor, fi_max_trans_minor, fi_max_trans_minor],
i_rot=fi_rot, i_max_rot=fi_max_rot)
arm.set_motion_gains(p_trans=[pp_trans, pp_trans, pp_trans],
d_trans=[pd_trans_minor, pd_trans_minor, pd_trans_minor],
p_rot=pp_rot, d_rot=pd_rot)
arm.set_force_directions([0, 0, 0, 1, 0, 0])
arm.set_force([0, 0, 0, float(opts.force_mag), 0, 0])
arm.update_gains()
return
if opts.force_all:
arm.set_force_max([-1, -1, -1, -1, -1, -1, -1])
arm.set_tip_frame(opts.tip_frame)
arm.set_force_gains(p_trans=6,
p_rot=1.8, i_trans=[fi_trans_major, fi_trans_major, fi_trans_major],
i_max_trans=[fi_max_trans_major, fi_max_trans_major, fi_max_trans_major],
i_rot=fi_rot, i_max_rot=fi_max_rot)
arm.set_motion_gains(p_trans=[pp_trans, pp_trans, pp_trans],
d_trans=[pd_trans_major, pd_trans_major, pd_trans_major],
p_rot=pp_rot, d_rot=pd_rot)
arm.set_force_directions([1, 1, 1, 1, 1, 1])
arm.set_force([0, 0, 0, 0, 0, 0])
arm.update_gains()
return
if opts.force_none:
arm.set_force_max([-1, -1, -1, -1, -1, -1, -1])
arm.set_tip_frame(opts.tip_frame)
arm.set_force_gains(p_trans=[0, 0, 0],
p_rot=0, i_trans=[0, 0, 0],
i_max_trans=[0, 0, 0],
i_rot=0, i_max_rot=0)
arm.set_motion_gains(p_trans=[pp_trans, pp_trans, pp_trans],
d_trans=[pd_trans_minor, pd_trans_minor, pd_trans_minor],
p_rot=pp_rot, d_rot=pd_rot)
arm.set_force_directions([0, 0, 0, 0, 0, 0])
arm.set_force([0, 0, 0, 0, 0, 0])
arm.update_gains()
return
if opts.kill_controller:
arm.set_force_max([-1, -1, -1, -1, -1, -1, -1])
arm.set_tip_frame(opts.tip_frame)
arm.set_force_gains(p_trans=[0, 0, 0],
p_rot=0, i_trans=[0, 0, 0],
i_max_trans=[0, 0, 0],
i_rot=0, i_max_rot=0)
arm.set_motion_gains(p_trans=0,
d_trans=0,
p_rot=0, d_rot=0)
arm.set_force_directions([0, 0, 0, 0, 0, 0])
arm.set_force([0, 0, 0, 0, 0, 0])
arm.update_gains()
return
if __name__ == "__main__":
main()
| [
[
1,
0,
0.0159,
0.0053,
0,
0.66,
0,
509,
0,
1,
0,
0,
509,
0,
0
],
[
1,
0,
0.0212,
0.0053,
0,
0.66,
0.0476,
954,
0,
1,
0,
0,
954,
0,
0
],
[
1,
0,
0.0317,
0.0053,
0,
... | [
"import sys",
"import numpy as np",
"import roslib",
"roslib.load_manifest('hrl_pr2_arms')",
"roslib.load_manifest('smach_ros')",
"roslib.load_manifest('actionlib')",
"import rospy",
"import rosbag",
"import smach",
"from smach_ros import SimpleActionState, ServiceState, IntrospectionServer",
"i... |
import rospy
import hrl_lib
import yaml
import os
node_name = "overhead_grasping"
ARM = 0 # right arm
PRESSURE_LIST =["r_finger_periph_pressure",
"r_finger_pad_pressure",
"l_finger_periph_pressure",
"l_finger_pad_pressure"]
class FileOperations():
def __init__(self):
grep = os.popen("rospack find pr2_overhead_grasping|grep pr2_overhead_grasping")
self.package_loc = grep.readlines()[0].rstrip()
def load_pickle(self, fn):
return hrl_lib.util.load_pickle(self.package_loc + "//pickles//" + fn)
def save_pickle(self, p, fn):
hrl_lib.util.save_pickle(p, self.package_loc + "//pickles//" + fn)
def get_pickle_name(self, fn):
return self.package_loc + "//pickles//" + fn
def file_exists(self, fn):
return os.path.exists(self.package_loc + "//pickles//" + fn)
def get_plot_name(self, directory, gfn):
filename = (self.package_loc + "//plots//" + directory + "//" +
gfn.split(".")[0].split("//")[-1] + ".pdf")
return filename
def load_coll_times(self, loc):
ct_index_fn = (self.package_loc + "//pickles//" +
loc + "//collision_times.yaml")
stream = file(ct_index_fn, "r")
coll_times = yaml.load(stream)
return coll_times
def save_coll_times(self, coll_times, loc):
ct_index_fn = (self.package_loc + "//pickles//" +
loc + "//collision_times.yaml")
stream = file(ct_index_fn, "w")
yaml.dump(coll_times, stream)
def load_yaml_file(self, fn):
ct_index_fn = (self.package_loc + "//yaml//" + fn)
stream = file(ct_index_fn, "r")
coll_times = yaml.load(stream)
return coll_times
def make_directories(self, directory):
try:
os.mkdir(self.package_loc + "//plots")
except:
pass
try:
os.mkdir(self.package_loc + "//plots//" + directory)
except:
pass
try:
os.mkdir(self.package_loc + "//pickles")
except:
pass
try:
os.mkdir(self.package_loc + "//pickles//collision_data")
except:
pass
try:
os.mkdir(self.package_loc + "//pickles//collision_data//" + directory)
except:
pass
try:
os.mkdir(self.package_loc + "//arff_files")
except:
pass
try:
os.mkdir(self.package_loc + "//pickles//classifiers")
except:
pass
def log(*strs):
prstrs = ""
for s in strs:
prstrs += str(s) + " "
rospy.loginfo(node_name + ": " + prstrs)
def err(*strs):
prstrs = ""
for s in strs:
prstrs += str(s) + " "
rospy.logerr(node_name + ": " + prstrs)
def wait_for_key(ki, key='c'):
ch = None
while not rospy.is_shutdown() and ch != key:
ch = ki.getch()
rospy.sleep(0.1)
log("CONTINUING")
| [
[
1,
0,
0.0097,
0.0097,
0,
0.66,
0,
164,
0,
1,
0,
0,
164,
0,
0
],
[
1,
0,
0.0194,
0.0097,
0,
0.66,
0.1,
649,
0,
1,
0,
0,
649,
0,
0
],
[
1,
0,
0.0291,
0.0097,
0,
0.6... | [
"import rospy",
"import hrl_lib",
"import yaml",
"import os",
"node_name = \"overhead_grasping\"",
"ARM = 0 # right arm",
"PRESSURE_LIST =[\"r_finger_periph_pressure\", \n \"r_finger_pad_pressure\", \n \"l_finger_periph_pressure\",\n \"l_finger_pad_pressure\"... |
#! /usr/bin/python
#
# Copyright (c) 2009, Georgia Tech Research Corporation
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
# * Neither the name of the Georgia Tech Research Corporation nor the
# names of its contributors may be used to endorse or promote products
# derived from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY GEORGIA TECH RESEARCH CORPORATION ''AS IS'' AND
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL GEORGIA TECH BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
# OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
# OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
# \author Travis Deyle (Healthcare Robotics Lab, Georgia Tech.)
import roslib
roslib.load_manifest('pr2_overhead_grasping')
roslib.load_manifest('tf')
roslib.load_manifest('hrl_table_detect')
roslib.load_manifest('rfid_behaviors')
import rospy
import smach
from smach_ros import SimpleActionState, ServiceState, IntrospectionServer
import actionlib
import tf.transformations as tft
from rfid_behaviors.srv import HandoffSrv
from hrl_table_detect.srv import DetectTableInst, DetectTableInstRequest
from pr2_overhead_grasping.msg import OverheadGraspAction, OverheadGraspGoal
from pr2_overhead_grasping.msg import OverheadGraspSetupAction, OverheadGraspSetupGoal
from pr2_controllers_msgs.msg import SingleJointPositionAction, SingleJointPositionGoal
# Overhead grasping requres:
# run: hrl_pr2_gains/change_gains_grasp.py
# roslaunch pr2_overhead_grasping overhead_grasping_server.launch
class NTries(smach.State):
def __init__(self, n):
smach.State.__init__(self, outcomes=['succeeded', 'aborted'])
self.counter = 0
self.n = n
def execute(self, userdata):
self.counter += 1
if self.counter <= self.n:
rospy.logout( 'Executing NTries: On #%d of %d' % (self.counter, self.n))
return 'succeeded'
else:
return 'aborted'
def sm_grasp():
# Create a SMACH state machine
sm = smach.StateMachine(outcomes=['succeeded','aborted','preempted'])
with sm:
# Setup arm pose (out of way for perception)
tgoal = SingleJointPositionGoal()
tgoal.position = 0.190 # all the way up is 0.200
tgoal.min_duration = rospy.Duration( 2.0 )
tgoal.max_velocity = 1.0
smach.StateMachine.add(
'TORSO_SETUP',
SimpleActionState( 'torso_controller/position_joint_action',
SingleJointPositionAction,
goal = tgoal),
transitions = { 'succeeded': 'THREE_TRIES' })
# We will run the grasper at most 3 times.
smach.StateMachine.add(
'THREE_TRIES',
NTries( 3 ),
transitions = {'succeeded':'PERCEIVE_SETUP',
'aborted':'aborted'})
# get hand out of face
smach.StateMachine.add(
'PERCEIVE_SETUP',
ServiceState( '/rfid_handoff/grasp', HandoffSrv ),
transitions = { 'succeeded' : 'PERCEIVE_OBJECT' })
# Setment objects
smach.StateMachine.add(
'PERCEIVE_OBJECT',
ServiceState( '/obj_segment_inst',
DetectTableInst,
request = DetectTableInstRequest( 1.0 ),
response_slots = ['grasp_points']), # PoseArray
transitions = {'succeeded':'GRASP_SETUP'},
remapping = {'grasp_points':'object_poses'}) #output
# Setup arm pose (out of way for perception)
smach.StateMachine.add(
'GRASP_SETUP',
SimpleActionState( 'overhead_grasp_setup',
OverheadGraspSetupAction,
goal = OverheadGraspSetupGoal( True )), # disable new look
transitions = { 'succeeded': 'GRASP' })
# Actually perform grasp of some object in front of robot on table
def grasp_goal_cb( userdata, goal ):
# grasp_poses is PoseArray in base_link
mgp = userdata.grasp_poses.poses[0]
ggoal = OverheadGraspGoal()
ggoal.is_grasp = True
ggoal.grasp_type = OverheadGraspGoal.MANUAL_GRASP
ggoal.x = mgp.position.x + 0.05 # Converts base_link -> torso_lift_link (only for x,y)
ggoal.y = mgp.position.y
o = mgp.orientation
r,p,y = tft.euler_from_quaternion(( o.x, o.y, o.z, o.w ))
ggoal.rot = y
return ggoal
smach.StateMachine.add(
'GRASP',
SimpleActionState( 'overhead_grasp',
OverheadGraspAction,
goal_cb = grasp_goal_cb,
input_keys = ['grasp_poses']),
remapping = {'grasp_poses':'object_poses'},
transitions = { 'succeeded': 'succeeded',
'aborted':'THREE_TRIES' })
return sm
if __name__ == '__main__':
rospy.init_node('smach_sm_grasp')
sm = sm_grasp()
sis = IntrospectionServer('Grasping', sm, '/SM_GRASPING')
sis.start()
outcome = sm.execute()
sis.stop()
| [
[
1,
0,
0.1902,
0.0061,
0,
0.66,
0,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.1963,
0.0061,
0,
0.66,
0.0588,
630,
3,
1,
0,
0,
0,
0,
1
],
[
8,
0,
0.2025,
0.0061,
0,
0.... | [
"import roslib",
"roslib.load_manifest('pr2_overhead_grasping')",
"roslib.load_manifest('tf')",
"roslib.load_manifest('hrl_table_detect')",
"roslib.load_manifest('rfid_behaviors')",
"import rospy",
"import smach",
"from smach_ros import SimpleActionState, ServiceState, IntrospectionServer",
"import ... |
import svm
labels = [0, 1]
samples = [[0, 0], [0, 1]]
labels = [0, 1, 1, 2]
samples = [[0, 0], [0, 1], [1, 0], [1, 1]]
import svm
labels = [0, 0, 1, 1]
samples = [[1, 1], [1, -1], [-1, 1], [-1, -1]]
param = svm.svm_parameter('-c 1')
problem = svm.svm_problem(labels, samples)
model = svm.libsvm.svm_train(problem, param)
pmodel = svm.toPyModel(model)
pmodel.predict_values(samples[0])
for i in range(len(samples)):
print svm.libsvm.svm_predict(model, svm.gen_svm_nodearray(samples[i])[0])
r = (c_double*6)()
svm.libsvm.svm_predict_values(model, svm.gen_svm_nodearray(samples[0])[0], r)
| [
[
1,
0,
0.0357,
0.0357,
0,
0.66,
0,
75,
0,
1,
0,
0,
75,
0,
0
],
[
14,
0,
0.1429,
0.0357,
0,
0.66,
0.0667,
283,
0,
0,
0,
0,
0,
5,
0
],
[
14,
0,
0.1786,
0.0357,
0,
0.... | [
"import svm",
"labels = [0, 1]",
"samples = [[0, 0], [0, 1]]",
"labels = [0, 1, 1, 2]",
"samples = [[0, 0], [0, 1], [1, 0], [1, 1]]",
"import svm",
"labels = [0, 0, 1, 1]",
"samples = [[1, 1], [1, -1], [-1, 1], [-1, -1]]",
"param = svm.svm_parameter('-c 1')",
"problem = svm.svm_problem(labels, sam... |
#!/usr/bin/env python
import pdb
from svm import *
def svm_read_problem(data_file_name):
"""
svm_read_problem(data_file_name) -> [y, x]
Read LIBSVM-format data from data_file_name and return labels y
and data instances x.
"""
prob_y = []
prob_x = []
for line in open(data_file_name):
line = line.split(None, 1)
# In case an instance with all zero features
if len(line) == 1: line += ['']
label, features = line
xi = {}
for e in features.split():
ind, val = e.split(":")
xi[int(ind)] = float(val)
prob_y += [float(label)]
prob_x += [xi]
return (prob_y, prob_x)
def svm_load_model(model_file_name):
"""
svm_load_model(model_file_name) -> model
Load a LIBSVM model from model_file_name and return.
"""
model = libsvm.svm_load_model(model_file_name)
if not model:
print("can't open model file %s" % model_file_name)
return None
model = toPyModel(model)
return model
def svm_save_model(model_file_name, model):
"""
svm_save_model(model_file_name, model) -> None
Save a LIBSVM model to the file model_file_name.
"""
libsvm.svm_save_model(model_file_name, model)
def evaluations(ty, pv):
"""
evaluations(ty, pv) -> (ACC, MSE, SCC)
Calculate accuracy, mean squared error and squared correlation coefficient
using the true values (ty) and predicted values (pv).
"""
if len(ty) != len(pv):
raise ValueError("len(ty) must equal to len(pv)")
total_correct = total_error = 0
sumv = sumy = sumvv = sumyy = sumvy = 0
for v, y in zip(pv, ty):
if y == v:
total_correct += 1
total_error += (v-y)*(v-y)
sumv += v
sumy += y
sumvv += v*v
sumyy += y*y
sumvy += v*y
l = len(ty)
ACC = 100.0*total_correct/l
MSE = total_error/l
try:
SCC = ((l*sumvy-sumv*sumy)*(l*sumvy-sumv*sumy))/((l*sumvv-sumv*sumv)*(l*sumyy-sumy*sumy))
except:
SCC = float('nan')
return (ACC, MSE, SCC)
def svm_train(arg1, arg2=None, arg3=None):
"""
svm_train(y, x [, 'options']) -> model | ACC | MSE
svm_train(prob, [, 'options']) -> model | ACC | MSE
svm_train(prob, param) -> model | ACC| MSE
Train an SVM model from data (y, x) or an svm_problem prob using
'options' or an svm_parameter param.
If '-v' is specified in 'options' (i.e., cross validation)
either accuracy (ACC) or mean-squared error (MSE) is returned.
'options':
-s svm_type : set type of SVM (default 0)
0 -- C-SVC
1 -- nu-SVC
2 -- one-class SVM
3 -- epsilon-SVR
4 -- nu-SVR
-t kernel_type : set type of kernel function (default 2)
0 -- linear: u'*v
1 -- polynomial: (gamma*u'*v + coef0)^degree
2 -- radial basis function: exp(-gamma*|u-v|^2)
3 -- sigmoid: tanh(gamma*u'*v + coef0)
4 -- precomputed kernel (kernel values in training_set_file)
-d degree : set degree in kernel function (default 3)
-g gamma : set gamma in kernel function (default 1/num_features)
-r coef0 : set coef0 in kernel function (default 0)
-c cost : set the parameter C of C-SVC, epsilon-SVR, and nu-SVR (default 1)
-n nu : set the parameter nu of nu-SVC, one-class SVM, and nu-SVR (default 0.5)
-p epsilon : set the epsilon in loss function of epsilon-SVR (default 0.1)
-m cachesize : set cache memory size in MB (default 100)
-e epsilon : set tolerance of termination criterion (default 0.001)
-h shrinking : whether to use the shrinking heuristics, 0 or 1 (default 1)
-b probability_estimates : whether to train a SVC or SVR model for probability estimates, 0 or 1 (default 0)
-wi weight : set the parameter C of class i to weight*C, for C-SVC (default 1)
-v n: n-fold cross validation mode
-q : quiet mode (no outputs)
"""
prob, param = None, None
#pdb.set_trace()
if isinstance(arg1, (list, tuple)):
assert isinstance(arg2, (list, tuple))
y, x, options = arg1, arg2, arg3
prob = svm_problem(y, x)
param = svm_parameter(options)
elif isinstance(arg1, svm_problem):
prob = arg1
if isinstance(arg2, svm_parameter):
param = arg2
else:
param = svm_parameter(arg2)
if prob == None or param == None:
raise TypeError("Wrong types for the arguments")
if param.kernel_type == PRECOMPUTED:
for xi in prob.x_space:
idx, val = xi[0].index, xi[0].value
if xi[0].index != 0:
raise ValueError('Wrong input format: first column must be 0:sample_serial_number')
if val <= 0 or val > prob.n:
raise ValueError('Wrong input format: sample_serial_number out of range')
if param.gamma == 0 and prob.n > 0:
param.gamma = 1.0 / prob.n
libsvm.svm_set_print_string_function(param.print_func)
err_msg = libsvm.svm_check_parameter(prob, param)
if err_msg:
raise ValueError('Error: %s' % err_msg)
if param.cross_validation:
l, nr_fold = prob.l, param.nr_fold
target = (c_double * l)()
libsvm.svm_cross_validation(prob, param, nr_fold, target)
ACC, MSE, SCC = evaluations(prob.y[:l], target[:l])
if param.svm_type in [EPSILON_SVR, NU_SVR]:
print("Cross Validation Mean squared error = %g" % MSE)
print("Cross Validation Squared correlation coefficient = %g" % SCC)
return MSE
else:
print("Cross Validation Accuracy = %g%%" % ACC)
return ACC
else:
m = libsvm.svm_train(prob, param)
m = toPyModel(m)
# If prob is destroyed, data including SVs pointed by m can remain.
m.x_space = prob.x_space
return m
def svm_predict(y, x, m, options=""):
"""
svm_predict(y, x, m [, "options"]) -> (p_labels, p_acc, p_vals)
Predict data (y, x) with the SVM model m.
"options":
-b probability_estimates: whether to predict probability estimates,
0 or 1 (default 0); for one-class SVM only 0 is supported.
The return tuple contains
p_labels: a list of predicted labels
p_acc: a tuple including accuracy (for classification), mean-squared
error, and squared correlation coefficient (for regression).
p_vals: a list of decision values or probability estimates (if '-b 1'
is specified). If k is the number of classes, for decision values,
each element includes results of predicting k(k-1)/2 binary-class
SVMs. For probabilities, each element contains k values indicating
the probability that the testing instance is in each class.
Note that the order of classes here is the same as 'model.label'
field in the model structure.
"""
predict_probability = 0
argv = options.split()
i = 0
while i < len(argv):
if argv[i] == '-b':
i += 1
predict_probability = int(argv[i])
else:
raise ValueError("Wrong options")
i+=1
svm_type = m.get_svm_type()
is_prob_model = m.is_probability_model()
nr_class = m.get_nr_class()
pred_labels = []
pred_values = []
if predict_probability:
if not is_prob_model:
raise ValueError("Model does not support probabiliy estimates")
if svm_type in [NU_SVR, EPSILON_SVR]:
print("Prob. model for test data: target value = predicted value + z,\n"
"z: Laplace distribution e^(-|z|/sigma)/(2sigma),sigma=%g" % m.get_svr_probability());
nr_class = 0
prob_estimates = (c_double * nr_class)()
for xi in x:
xi, idx = gen_svm_nodearray(xi)
label = libsvm.svm_predict_probability(m, xi, prob_estimates)
values = prob_estimates[:nr_class]
pred_labels += [label]
pred_values += [values]
else:
if is_prob_model:
print("Model supports probability estimates, but disabled in predicton.")
if svm_type in (ONE_CLASS, EPSILON_SVR, NU_SVC):
nr_classifier = 1
else:
nr_classifier = nr_class*(nr_class-1)//2
dec_values = (c_double * nr_classifier)()
for xi in x:
#pdb.set_trace()
xi, idx = gen_svm_nodearray(xi)
label = libsvm.svm_predict_values(m, xi, dec_values)
values = dec_values[:nr_classifier]
pred_labels += [label]
pred_values += [values]
ACC, MSE, SCC = evaluations(y, pred_labels)
l = len(y)
if svm_type in [EPSILON_SVR, NU_SVR]:
print("Mean squared error = %g (regression)" % MSE)
print("Squared correlation coefficient = %g (regression)" % SCC)
else:
print("Accuracy = %g%% (%d/%d) (classification)" % (ACC, int(l*ACC/100), l))
return pred_labels, (ACC, MSE, SCC), pred_values
| [
[
1,
0,
0.0122,
0.0041,
0,
0.66,
0,
91,
0,
1,
0,
0,
91,
0,
0
],
[
1,
0,
0.0163,
0.0041,
0,
0.66,
0.1429,
75,
0,
1,
0,
0,
75,
0,
0
],
[
2,
0,
0.0653,
0.0857,
0,
0.66... | [
"import pdb",
"from svm import *",
"def svm_read_problem(data_file_name):\n\t\"\"\"\n\tsvm_read_problem(data_file_name) -> [y, x]\n\n\tRead LIBSVM-format data from data_file_name and return labels y\n\tand data instances x.\n\t\"\"\"\n\tprob_y = []",
"\t\"\"\"\n\tsvm_read_problem(data_file_name) -> [y, x]\n\n... |
#!/usr/bin/env python
from ctypes import *
from ctypes.util import find_library
import sys
import subprocess as sb
# For unix the prefix 'lib' is not considered.
if find_library('svm'):
libsvm = CDLL(find_library('svm'))
elif find_library('libsvm'):
libsvm = CDLL(find_library('libsvm'))
else:
if sys.platform == 'win32':
libsvm = CDLL('../windows/libsvm.dll')
else:
libsvm = CDLL(sb.Popen(['rospack', 'find', 'libsvm3'], stdout=sb.PIPE).communicate()[0].rstrip() + '/libsvm.so.2')
#libsvm = CDLL('../libsvm.so.2')
# Construct constants
SVM_TYPE = ['C_SVC', 'NU_SVC', 'ONE_CLASS', 'EPSILON_SVR', 'NU_SVR' ]
KERNEL_TYPE = ['LINEAR', 'POLY', 'RBF', 'SIGMOID', 'PRECOMPUTED']
for i, s in enumerate(SVM_TYPE): exec("%s = %d" % (s , i))
for i, s in enumerate(KERNEL_TYPE): exec("%s = %d" % (s , i))
PRINT_STRING_FUN = CFUNCTYPE(None, c_char_p)
def print_null(s):
return
def genFields(names, types):
return list(zip(names, types))
def fillprototype(f, restype, argtypes):
f.restype = restype
f.argtypes = argtypes
class svm_node(Structure):
_names = ["index", "value"]
_types = [c_int, c_double]
_fields_ = genFields(_names, _types)
def gen_svm_nodearray(xi, feature_max=None, issparse=None):
if isinstance(xi, dict):
index_range = xi.keys()
elif isinstance(xi, (list, tuple)):
index_range = range(len(xi))
else:
raise TypeError('xi should be a dictionary, list or tuple')
if feature_max:
assert(isinstance(feature_max, int))
index_range = filter(lambda j: j <= feature_max, index_range)
if issparse:
index_range = filter(lambda j:xi[j] != 0, index_range)
index_range = sorted(index_range)
ret = (svm_node * (len(index_range)+1))()
ret[-1].index = -1
for idx, j in enumerate(index_range):
ret[idx].index = j
ret[idx].value = xi[j]
max_idx = 0
if index_range:
max_idx = index_range[-1]
return ret, max_idx
class svm_problem(Structure):
_names = ["l", "y", "x"]
_types = [c_int, POINTER(c_double), POINTER(POINTER(svm_node))]
_fields_ = genFields(_names, _types)
def __init__(self, y, x):
if len(y) != len(x):
raise ValueError("len(y) != len(x)")
self.l = l = len(y)
max_idx = 0
x_space = self.x_space = []
for i, xi in enumerate(x):
tmp_xi, tmp_idx = gen_svm_nodearray(xi)
x_space += [tmp_xi]
max_idx = max(max_idx, tmp_idx)
self.n = max_idx
self.y = (c_double * l)()
for i, yi in enumerate(y): self.y[i] = yi
self.x = (POINTER(svm_node) * l)()
for i, xi in enumerate(self.x_space): self.x[i] = xi
class svm_parameter(Structure):
_names = ["svm_type", "kernel_type", "degree", "gamma", "coef0",
"cache_size", "eps", "C", "nr_weight", "weight_label", "weight",
"nu", "p", "shrinking", "probability"]
_types = [c_int, c_int, c_int, c_double, c_double,
c_double, c_double, c_double, c_int, POINTER(c_int), POINTER(c_double),
c_double, c_double, c_int, c_int]
_fields_ = genFields(_names, _types)
def __init__(self, options = None):
if options == None:
options = ''
self.parse_options(options)
def show(self):
attrs = svm_parameter._names + self.__dict__.keys()
values = map(lambda attr: getattr(self, attr), attrs)
for attr, val in zip(attrs, values):
print(' %s: %s' % (attr, val))
def set_to_default_values(self):
self.svm_type = C_SVC;
self.kernel_type = RBF
self.degree = 3
self.gamma = 0
self.coef0 = 0
self.nu = 0.5
self.cache_size = 100
self.C = 1
self.eps = 0.001
self.p = 0.1
self.shrinking = 1
self.probability = 0
self.nr_weight = 0
self.weight_label = (c_int*0)()
self.weight = (c_double*0)()
self.cross_validation = False
self.nr_fold = 0
self.print_func = None
def parse_options(self, options):
argv = options.split()
self.set_to_default_values()
self.print_func = cast(None, PRINT_STRING_FUN)
weight_label = []
weight = []
i = 0
while i < len(argv):
if argv[i] == "-s":
i = i + 1
self.svm_type = int(argv[i])
elif argv[i] == "-t":
i = i + 1
self.kernel_type = int(argv[i])
elif argv[i] == "-d":
i = i + 1
self.degree = int(argv[i])
elif argv[i] == "-g":
i = i + 1
self.gamma = float(argv[i])
elif argv[i] == "-r":
i = i + 1
self.coef0 = float(argv[i])
elif argv[i] == "-n":
i = i + 1
self.nu = float(argv[i])
elif argv[i] == "-m":
i = i + 1
self.cache_size = float(argv[i])
elif argv[i] == "-c":
i = i + 1
self.C = float(argv[i])
elif argv[i] == "-e":
i = i + 1
self.eps = float(argv[i])
elif argv[i] == "-p":
i = i + 1
self.p = float(argv[i])
elif argv[i] == "-h":
i = i + 1
self.shrinking = int(argv[i])
elif argv[i] == "-b":
i = i + 1
self.probability = int(argv[i])
elif argv[i] == "-q":
self.print_func = PRINT_STRING_FUN(print_null)
elif argv[i] == "-v":
i = i + 1
self.cross_validation = 1
self.nr_fold = int(argv[i])
if self.nr_fold < 2:
raise ValueError("n-fold cross validation: n must >= 2")
elif argv[i].startswith("-w"):
i = i + 1
self.nr_weight += 1
nr_weight = self.nr_weight
weight_label += [int(argv[i-1][2:])]
weight += [float(argv[i])]
else:
raise ValueError("Wrong options")
i += 1
libsvm.svm_set_print_string_function(self.print_func)
self.weight_label = (c_int*self.nr_weight)()
self.weight = (c_double*self.nr_weight)()
for i in range(self.nr_weight):
self.weight[i] = weight[i]
self.weight_label[i] = weight_label[i]
class svm_model(Structure):
#_names = ['param', 'nr_class', 'l', 'SV', 'sv_coef',
# 'rho', 'probA', 'probB', 'label', 'nSV', 'free_sv', 'SVidx', 'nx']
#_types = [POINTER(svm_parameter), c_int, c_int, POINTER(POINTER(svm_node)), POINTER(POINTER(c_double)),
# POINTER(c_double), POINTER(c_double), POINTER(c_double), POINTER(c_int), POINTER(c_int), c_int,
# POINTER(c_byte), c_int]
#_fields_ = genFields(_names, _types)
def __init__(self):
self.__createfrom__ = 'python'
def __del__(self):
# free memory created by C to avoid memory leak
if hasattr(self, '__createfrom__') and self.__createfrom__ == 'C':
libsvm.svm_free_and_destroy_model(pointer(self))
def get_svm_type(self):
return libsvm.svm_get_svm_type(self)
def get_nr_class(self):
return libsvm.svm_get_nr_class(self)
def get_svr_probability(self):
return libsvm.svm_get_svr_probability(self)
def get_labels(self):
nr_class = self.get_nr_class()
labels = (c_int * nr_class)()
libsvm.svm_get_labels(self, labels)
return labels[:nr_class]
def is_probability_model(self):
return (libsvm.svm_check_probability_model(self) == 1)
#def predict(self, sample):
# return libsvm.svm_predict(self, gen_svm_nodearray(sample)[0])
#def predict_values(self, sample):
# nc = self.get_nr_class()
# nvalues = (nc * (nc-1))/2
# dists = (c_double*nvalues)()
# p = libsvm.svm_predict_values(self, gen_svm_nodearray(sample)[0], dists)
# ddict = {}
# ii = 0
# for i in range(nc):
# for j in range(i+1, nc):
# ddict[(i,j)] = dists[ii]
# ii = ii+1
# nr_classifier = nc*(nc-1)//2
# dec_values = (c_double * nr_classifier)()
# xi = sample
# xi, idx = gen_svm_nodearray(xi)
# label = libsvm.svm_predict_values(self, xi, dec_values)
# values = dec_values[:nr_classifier]
# print 'got label', label
# return p, ddict
def get_support_vectors(self, samples_len):
svs = (c_int * samples_len)()
libsvm.svm_get_support_vectors(self, samples_len, svs)
return svs[:samples_len]
def toPyModel(model_ptr):
"""
toPyModel(model_ptr) -> svm_model
Convert a ctypes POINTER(svm_model) to a Python svm_model
"""
if bool(model_ptr) == False:
raise ValueError("Null pointer")
m = model_ptr.contents
m.__createfrom__ = 'C'
return m
fillprototype(libsvm.svm_train, POINTER(svm_model), [POINTER(svm_problem), POINTER(svm_parameter)])
fillprototype(libsvm.svm_cross_validation, None, [POINTER(svm_problem), POINTER(svm_parameter), c_int, POINTER(c_double)])
fillprototype(libsvm.svm_save_model, c_int, [c_char_p, POINTER(svm_model)])
fillprototype(libsvm.svm_load_model, POINTER(svm_model), [c_char_p])
fillprototype(libsvm.svm_get_svm_type, c_int, [POINTER(svm_model)])
fillprototype(libsvm.svm_get_nr_class, c_int, [POINTER(svm_model)])
fillprototype(libsvm.svm_get_labels, None, [POINTER(svm_model), POINTER(c_int)])
fillprototype(libsvm.svm_get_support_vectors, None, [POINTER(svm_model), c_int, POINTER(c_int)])
fillprototype(libsvm.svm_get_svr_probability, c_double, [POINTER(svm_model)])
fillprototype(libsvm.svm_predict_values, c_double, [POINTER(svm_model), POINTER(svm_node), POINTER(c_double)])
fillprototype(libsvm.svm_predict, c_double, [POINTER(svm_model), POINTER(svm_node)])
fillprototype(libsvm.svm_predict_probability, c_double, [POINTER(svm_model), POINTER(svm_node), POINTER(c_double)])
fillprototype(libsvm.svm_free_model_content, None, [POINTER(svm_model)])
fillprototype(libsvm.svm_free_and_destroy_model, None, [POINTER(POINTER(svm_model))])
fillprototype(libsvm.svm_destroy_param, None, [POINTER(svm_parameter)])
fillprototype(libsvm.svm_check_parameter, c_char_p, [POINTER(svm_problem), POINTER(svm_parameter)])
fillprototype(libsvm.svm_check_probability_model, c_int, [POINTER(svm_model)])
fillprototype(libsvm.svm_set_print_string_function, None, [PRINT_STRING_FUN])
| [
[
1,
0,
0.0099,
0.0033,
0,
0.66,
0,
182,
0,
1,
0,
0,
182,
0,
0
],
[
1,
0,
0.0132,
0.0033,
0,
0.66,
0.0278,
426,
0,
1,
0,
0,
426,
0,
0
],
[
1,
0,
0.0166,
0.0033,
0,
... | [
"from ctypes import *",
"from ctypes.util import find_library",
"import sys",
"import subprocess as sb",
"if find_library('svm'):\n\tlibsvm = CDLL(find_library('svm'))\nelif find_library('libsvm'):\n\tlibsvm = CDLL(find_library('libsvm'))\nelse:\n\tif sys.platform == 'win32':\n\t\tlibsvm = CDLL('../windows/... |
#!/usr/bin/env python
import sys
import os
from subprocess import *
if len(sys.argv) <= 1:
print('Usage: %s training_file [testing_file]' % sys.argv[0])
raise SystemExit
# svm, grid, and gnuplot executable files
is_win32 = (sys.platform == 'win32')
if not is_win32:
svmscale_exe = "../svm-scale"
svmtrain_exe = "../svm-train"
svmpredict_exe = "../svm-predict"
grid_py = "./grid.py"
gnuplot_exe = "/usr/bin/gnuplot"
else:
# example for windows
svmscale_exe = r"..\windows\svm-scale.exe"
svmtrain_exe = r"..\windows\svm-train.exe"
svmpredict_exe = r"..\windows\svm-predict.exe"
gnuplot_exe = r"c:\tmp\gnuplot\bin\pgnuplot.exe"
grid_py = r".\grid.py"
assert os.path.exists(svmscale_exe),"svm-scale executable not found"
assert os.path.exists(svmtrain_exe),"svm-train executable not found"
assert os.path.exists(svmpredict_exe),"svm-predict executable not found"
assert os.path.exists(gnuplot_exe),"gnuplot executable not found"
assert os.path.exists(grid_py),"grid.py not found"
train_pathname = sys.argv[1]
assert os.path.exists(train_pathname),"training file not found"
file_name = os.path.split(train_pathname)[1]
scaled_file = file_name + ".scale"
model_file = file_name + ".model"
range_file = file_name + ".range"
if len(sys.argv) > 2:
test_pathname = sys.argv[2]
file_name = os.path.split(test_pathname)[1]
assert os.path.exists(test_pathname),"testing file not found"
scaled_test_file = file_name + ".scale"
predict_test_file = file_name + ".predict"
cmd = '%s -s "%s" "%s" > "%s"' % (svmscale_exe, range_file, train_pathname, scaled_file)
print('Scaling training data...')
Popen(cmd, shell = True, stdout = PIPE).communicate()
cmd = '%s -svmtrain "%s" -gnuplot "%s" "%s"' % (grid_py, svmtrain_exe, gnuplot_exe, scaled_file)
print('Cross validation...')
f = Popen(cmd, shell = True, stdout = PIPE).stdout
line = ''
while True:
last_line = line
line = f.readline()
if not line: break
c,g,rate = map(float,last_line.split())
print('Best c=%s, g=%s CV rate=%s' % (c,g,rate))
cmd = '%s -c %s -g %s "%s" "%s"' % (svmtrain_exe,c,g,scaled_file,model_file)
print('Training...')
Popen(cmd, shell = True, stdout = PIPE).communicate()
print('Output model: %s' % model_file)
if len(sys.argv) > 2:
cmd = '%s -r "%s" "%s" > "%s"' % (svmscale_exe, range_file, test_pathname, scaled_test_file)
print('Scaling testing data...')
Popen(cmd, shell = True, stdout = PIPE).communicate()
cmd = '%s "%s" "%s" "%s"' % (svmpredict_exe, scaled_test_file, model_file, predict_test_file)
print('Testing...')
Popen(cmd, shell = True).communicate()
print('Output prediction: %s' % predict_test_file)
| [
[
1,
0,
0.038,
0.0127,
0,
0.66,
0,
509,
0,
1,
0,
0,
509,
0,
0
],
[
1,
0,
0.0506,
0.0127,
0,
0.66,
0.0385,
688,
0,
1,
0,
0,
688,
0,
0
],
[
1,
0,
0.0633,
0.0127,
0,
0... | [
"import sys",
"import os",
"from subprocess import *",
"if len(sys.argv) <= 1:\n\tprint('Usage: %s training_file [testing_file]' % sys.argv[0])\n\traise SystemExit",
"\tprint('Usage: %s training_file [testing_file]' % sys.argv[0])",
"is_win32 = (sys.platform == 'win32')",
"if not is_win32:\n\tsvmscale_e... |
#!/usr/bin/env python
import os, sys, traceback
import getpass
from threading import Thread
from subprocess import *
if(sys.hexversion < 0x03000000):
import Queue
else:
import queue as Queue
# svmtrain and gnuplot executable
is_win32 = (sys.platform == 'win32')
if not is_win32:
svmtrain_exe = "../svm-train"
gnuplot_exe = "/usr/bin/gnuplot"
else:
# example for windows
svmtrain_exe = r"..\windows\svm-train.exe"
gnuplot_exe = r"c:\tmp\gnuplot\bin\pgnuplot.exe"
# global parameters and their default values
fold = 5
c_begin, c_end, c_step = -5, 15, 2
g_begin, g_end, g_step = 3, -15, -2
global dataset_pathname, dataset_title, pass_through_string
global out_filename, png_filename
# experimental
telnet_workers = []
ssh_workers = []
nr_local_worker = 1
# process command line options, set global parameters
def process_options(argv=sys.argv):
global fold
global c_begin, c_end, c_step
global g_begin, g_end, g_step
global dataset_pathname, dataset_title, pass_through_string
global svmtrain_exe, gnuplot_exe, gnuplot, out_filename, png_filename
usage = """\
Usage: grid.py [-log2c begin,end,step] [-log2g begin,end,step] [-v fold]
[-svmtrain pathname] [-gnuplot pathname] [-out pathname] [-png pathname]
[additional parameters for svm-train] dataset"""
if len(argv) < 2:
print(usage)
sys.exit(1)
dataset_pathname = argv[-1]
dataset_title = os.path.split(dataset_pathname)[1]
out_filename = '%s.out' % dataset_title
png_filename = '%s.png' % dataset_title
pass_through_options = []
i = 1
while i < len(argv) - 1:
if argv[i] == "-log2c":
i = i + 1
(c_begin,c_end,c_step) = map(float,argv[i].split(","))
elif argv[i] == "-log2g":
i = i + 1
(g_begin,g_end,g_step) = map(float,argv[i].split(","))
elif argv[i] == "-v":
i = i + 1
fold = argv[i]
elif argv[i] in ('-c','-g'):
print("Option -c and -g are renamed.")
print(usage)
sys.exit(1)
elif argv[i] == '-svmtrain':
i = i + 1
svmtrain_exe = argv[i]
elif argv[i] == '-gnuplot':
i = i + 1
gnuplot_exe = argv[i]
elif argv[i] == '-out':
i = i + 1
out_filename = argv[i]
elif argv[i] == '-png':
i = i + 1
png_filename = argv[i]
else:
pass_through_options.append(argv[i])
i = i + 1
pass_through_string = " ".join(pass_through_options)
assert os.path.exists(svmtrain_exe),"svm-train executable not found"
assert os.path.exists(gnuplot_exe),"gnuplot executable not found"
assert os.path.exists(dataset_pathname),"dataset not found"
gnuplot = Popen(gnuplot_exe,stdin = PIPE).stdin
def range_f(begin,end,step):
# like range, but works on non-integer too
seq = []
while True:
if step > 0 and begin > end: break
if step < 0 and begin < end: break
seq.append(begin)
begin = begin + step
return seq
def permute_sequence(seq):
n = len(seq)
if n <= 1: return seq
mid = int(n/2)
left = permute_sequence(seq[:mid])
right = permute_sequence(seq[mid+1:])
ret = [seq[mid]]
while left or right:
if left: ret.append(left.pop(0))
if right: ret.append(right.pop(0))
return ret
def redraw(db,best_param,tofile=False):
if len(db) == 0: return
begin_level = round(max(x[2] for x in db)) - 3
step_size = 0.5
best_log2c,best_log2g,best_rate = best_param
if tofile:
gnuplot.write( "set term png transparent small\n".encode())
gnuplot.write( ("set output \"%s\"\n" % png_filename.replace('\\','\\\\')).encode())
#gnuplot.write("set term postscript color solid\n".encode())
#gnuplot.write(("set output \"%s.ps\"\n" % dataset_title).encode())
elif is_win32:
gnuplot.write("set term windows\n".encode())
else:
gnuplot.write( "set term x11\n".encode())
gnuplot.write("set xlabel \"log2(C)\"\n".encode())
gnuplot.write("set ylabel \"log2(gamma)\"\n".encode())
gnuplot.write(("set xrange [%s:%s]\n" % (c_begin,c_end)).encode())
gnuplot.write(("set yrange [%s:%s]\n" % (g_begin,g_end)).encode())
gnuplot.write("set contour\n".encode())
gnuplot.write(("set cntrparam levels incremental %s,%s,100\n" % (begin_level,step_size)).encode())
gnuplot.write("unset surface\n".encode())
gnuplot.write("unset ztics\n".encode())
gnuplot.write("set view 0,0\n".encode())
gnuplot.write(("set title \"%s\"\n" % dataset_title).encode())
gnuplot.write("unset label\n".encode())
gnuplot.write(("set label \"Best log2(C) = %s log2(gamma) = %s accuracy = %s%%\" \
at screen 0.5,0.85 center\n" % \
(best_log2c, best_log2g, best_rate)).encode())
gnuplot.write(("set label \"C = %s gamma = %s\""
" at screen 0.5,0.8 center\n" % (2**best_log2c, 2**best_log2g)).encode())
gnuplot.write("splot \"-\" with lines\n".encode())
db.sort(key = lambda x:(x[0], -x[1]))
prevc = db[0][0]
for line in db:
if prevc != line[0]:
gnuplot.write("\n".encode())
prevc = line[0]
gnuplot.write(("%s %s %s\n" % line).encode())
gnuplot.write("e\n".encode())
gnuplot.write("\n".encode()) # force gnuplot back to prompt when term set failure
gnuplot.flush()
def calculate_jobs():
c_seq = permute_sequence(range_f(c_begin,c_end,c_step))
g_seq = permute_sequence(range_f(g_begin,g_end,g_step))
nr_c = float(len(c_seq))
nr_g = float(len(g_seq))
i = 0
j = 0
jobs = []
while i < nr_c or j < nr_g:
if i/nr_c < j/nr_g:
# increase C resolution
line = []
for k in range(0,j):
line.append((c_seq[i],g_seq[k]))
i = i + 1
jobs.append(line)
else:
# increase g resolution
line = []
for k in range(0,i):
line.append((c_seq[k],g_seq[j]))
j = j + 1
jobs.append(line)
return jobs
class WorkerStopToken: # used to notify the worker to stop
pass
class Worker(Thread):
def __init__(self,name,job_queue,result_queue):
Thread.__init__(self)
self.name = name
self.job_queue = job_queue
self.result_queue = result_queue
def run(self):
while True:
(cexp,gexp) = self.job_queue.get()
if cexp is WorkerStopToken:
self.job_queue.put((cexp,gexp))
# print 'worker %s stop.' % self.name
break
try:
rate = self.run_one(2.0**cexp,2.0**gexp)
if rate is None: raise RuntimeError("get no rate")
except:
# we failed, let others do that and we just quit
traceback.print_exception(sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2])
self.job_queue.put((cexp,gexp))
print('worker %s quit.' % self.name)
break
else:
self.result_queue.put((self.name,cexp,gexp,rate))
class LocalWorker(Worker):
def run_one(self,c,g):
cmdline = '%s -c %s -g %s -v %s %s %s' % \
(svmtrain_exe,c,g,fold,pass_through_string,dataset_pathname)
result = Popen(cmdline,shell=True,stdout=PIPE).stdout
for line in result.readlines():
if str(line).find("Cross") != -1:
return float(line.split()[-1][0:-1])
class SSHWorker(Worker):
def __init__(self,name,job_queue,result_queue,host):
Worker.__init__(self,name,job_queue,result_queue)
self.host = host
self.cwd = os.getcwd()
def run_one(self,c,g):
cmdline = 'ssh -x %s "cd %s; %s -c %s -g %s -v %s %s %s"' % \
(self.host,self.cwd,
svmtrain_exe,c,g,fold,pass_through_string,dataset_pathname)
result = Popen(cmdline,shell=True,stdout=PIPE).stdout
for line in result.readlines():
if str(line).find("Cross") != -1:
return float(line.split()[-1][0:-1])
class TelnetWorker(Worker):
def __init__(self,name,job_queue,result_queue,host,username,password):
Worker.__init__(self,name,job_queue,result_queue)
self.host = host
self.username = username
self.password = password
def run(self):
import telnetlib
self.tn = tn = telnetlib.Telnet(self.host)
tn.read_until("login: ")
tn.write(self.username + "\n")
tn.read_until("Password: ")
tn.write(self.password + "\n")
# XXX: how to know whether login is successful?
tn.read_until(self.username)
#
print('login ok', self.host)
tn.write("cd "+os.getcwd()+"\n")
Worker.run(self)
tn.write("exit\n")
def run_one(self,c,g):
cmdline = '%s -c %s -g %s -v %s %s %s' % \
(svmtrain_exe,c,g,fold,pass_through_string,dataset_pathname)
result = self.tn.write(cmdline+'\n')
(idx,matchm,output) = self.tn.expect(['Cross.*\n'])
for line in output.split('\n'):
if str(line).find("Cross") != -1:
return float(line.split()[-1][0:-1])
def main():
# set parameters
process_options()
# put jobs in queue
jobs = calculate_jobs()
job_queue = Queue.Queue(0)
result_queue = Queue.Queue(0)
for line in jobs:
for (c,g) in line:
job_queue.put((c,g))
job_queue._put = job_queue.queue.appendleft
# fire telnet workers
if telnet_workers:
nr_telnet_worker = len(telnet_workers)
username = getpass.getuser()
password = getpass.getpass()
for host in telnet_workers:
TelnetWorker(host,job_queue,result_queue,
host,username,password).start()
# fire ssh workers
if ssh_workers:
for host in ssh_workers:
SSHWorker(host,job_queue,result_queue,host).start()
# fire local workers
for i in range(nr_local_worker):
LocalWorker('local',job_queue,result_queue).start()
# gather results
done_jobs = {}
result_file = open(out_filename, 'w')
db = []
best_rate = -1
best_c1,best_g1 = None,None
for line in jobs:
for (c,g) in line:
while (c, g) not in done_jobs:
(worker,c1,g1,rate) = result_queue.get()
done_jobs[(c1,g1)] = rate
result_file.write('%s %s %s\n' %(c1,g1,rate))
result_file.flush()
if (rate > best_rate) or (rate==best_rate and g1==best_g1 and c1<best_c1):
best_rate = rate
best_c1,best_g1=c1,g1
best_c = 2.0**c1
best_g = 2.0**g1
print("[%s] %s %s %s (best c=%s, g=%s, rate=%s)" % \
(worker,c1,g1,rate, best_c, best_g, best_rate))
db.append((c,g,done_jobs[(c,g)]))
redraw(db,[best_c1, best_g1, best_rate])
redraw(db,[best_c1, best_g1, best_rate],True)
job_queue.put((WorkerStopToken,None))
print("%s %s %s" % (best_c, best_g, best_rate))
main()
| [
[
1,
0,
0.0139,
0.0028,
0,
0.66,
0,
688,
0,
3,
0,
0,
688,
0,
0
],
[
1,
0,
0.0167,
0.0028,
0,
0.66,
0.0417,
784,
0,
1,
0,
0,
784,
0,
0
],
[
1,
0,
0.0195,
0.0028,
0,
... | [
"import os, sys, traceback",
"import getpass",
"from threading import Thread",
"from subprocess import *",
"if(sys.hexversion < 0x03000000):\n\timport Queue\nelse:\n\timport queue as Queue",
"\timport Queue",
"\timport queue as Queue",
"is_win32 = (sys.platform == 'win32')",
"if not is_win32:\n ... |
#!/usr/bin/env python
#
# A format checker for LIBSVM
#
#
# Copyright (c) 2007, Rong-En Fan
#
# All rights reserved.
#
# This program is distributed under the same license of the LIBSVM package.
#
from sys import argv, exit
import os.path
def err(line_no, msg):
print("line %d: %s" % (line_no, msg))
# works like float() but does not accept nan and inf
def my_float(x):
if x.lower().find("nan") != -1 or x.lower().find("inf") != -1:
raise ValueError
return float(x)
def main():
if len(argv) != 2:
print("Usage: %s dataset" % (argv[0]))
exit(1)
dataset = argv[1]
if not os.path.exists(dataset):
print("dataset %s not found" % (dataset))
exit(1)
line_no = 1
error_line_count = 0
for line in open(dataset, 'r'):
line_error = False
# each line must end with a newline character
if line[-1] != '\n':
err(line_no, "missing a newline character in the end")
line_error = True
nodes = line.split()
# check label
try:
label = nodes.pop(0)
if label.find(',') != -1:
# multi-label format
try:
for l in label.split(','):
l = my_float(l)
except:
err(line_no, "label %s is not a valid multi-label form" % label)
line_error = True
else:
try:
label = my_float(label)
except:
err(line_no, "label %s is not a number" % label)
line_error = True
except:
err(line_no, "missing label, perhaps an empty line?")
line_error = True
# check features
prev_index = -1
for i in range(len(nodes)):
try:
(index, value) = nodes[i].split(':')
index = int(index)
value = my_float(value)
# precomputed kernel's index starts from 0 and LIBSVM
# checks it. Hence, don't treat index 0 as an error.
if index < 0:
err(line_no, "feature index must be positive; wrong feature %s" % nodes[i])
line_error = True
elif index < prev_index:
err(line_no, "feature indices must be in an ascending order, previous/current features %s %s" % (nodes[i-1], nodes[i]))
line_error = True
prev_index = index
except:
err(line_no, "feature '%s' not an <index>:<value> pair, <index> integer, <value> real number " % nodes[i])
line_error = True
line_no += 1
if line_error:
error_line_count += 1
if error_line_count > 0:
print("Found %d lines with error." % (error_line_count))
return 1
else:
print("No error.")
return 0
if __name__ == "__main__":
exit(main())
| [
[
1,
0,
0.1389,
0.0093,
0,
0.66,
0,
509,
0,
2,
0,
0,
509,
0,
0
],
[
1,
0,
0.1481,
0.0093,
0,
0.66,
0.2,
79,
0,
1,
0,
0,
79,
0,
0
],
[
2,
0,
0.1713,
0.0185,
0,
0.66,... | [
"from sys import argv, exit",
"import os.path",
"def err(line_no, msg):\n\tprint(\"line %d: %s\" % (line_no, msg))",
"\tprint(\"line %d: %s\" % (line_no, msg))",
"def my_float(x):\n\tif x.lower().find(\"nan\") != -1 or x.lower().find(\"inf\") != -1:\n\t\traise ValueError\n\n\treturn float(x)",
"\tif x.low... |
#!/usr/bin/env python
from sys import argv, exit, stdout, stderr
from random import randint
method = 0
global n
global dataset_filename
subset_filename = ""
rest_filename = ""
def exit_with_help():
print("""\
Usage: %s [options] dataset number [output1] [output2]
This script selects a subset of the given dataset.
options:
-s method : method of selection (default 0)
0 -- stratified selection (classification only)
1 -- random selection
output1 : the subset (optional)
output2 : rest of the data (optional)
If output1 is omitted, the subset will be printed on the screen.""" % argv[0])
exit(1)
def process_options():
global method, n
global dataset_filename, subset_filename, rest_filename
argc = len(argv)
if argc < 3:
exit_with_help()
i = 1
while i < len(argv):
if argv[i][0] != "-":
break
if argv[i] == "-s":
i = i + 1
method = int(argv[i])
if method < 0 or method > 1:
print("Unknown selection method %d" % (method))
exit_with_help()
i = i + 1
dataset_filename = argv[i]
n = int(argv[i+1])
if i+2 < argc:
subset_filename = argv[i+2]
if i+3 < argc:
rest_filename = argv[i+3]
def main():
class Label:
def __init__(self, label, index, selected):
self.label = label
self.index = index
self.selected = selected
process_options()
# get labels
i = 0
labels = []
f = open(dataset_filename, 'r')
for line in f:
labels.append(Label(float((line.split())[0]), i, 0))
i = i + 1
f.close()
l = i
# determine where to output
if subset_filename != "":
file1 = open(subset_filename, 'w')
else:
file1 = stdout
split = 0
if rest_filename != "":
split = 1
file2 = open(rest_filename, 'w')
# select the subset
warning = 0
if method == 0: # stratified
labels.sort(key = lambda x: x.label)
label_end = labels[l-1].label + 1
labels.append(Label(label_end, l, 0))
begin = 0
label = labels[begin].label
for i in range(l+1):
new_label = labels[i].label
if new_label != label:
nr_class = i - begin
k = i*n//l - begin*n//l
# at least one instance per class
if k == 0:
k = 1
warning = warning + 1
for j in range(nr_class):
if randint(0, nr_class-j-1) < k:
labels[begin+j].selected = 1
k = k - 1
begin = i
label = new_label
elif method == 1: # random
k = n
for i in range(l):
if randint(0,l-i-1) < k:
labels[i].selected = 1
k = k - 1
i = i + 1
# output
i = 0
if method == 0:
labels.sort(key = lambda x: int(x.index))
f = open(dataset_filename, 'r')
for line in f:
if labels[i].selected == 1:
file1.write(line)
else:
if split == 1:
file2.write(line)
i = i + 1
if warning > 0:
stderr.write("""\
Warning:
1. You may have regression data. Please use -s 1.
2. Classification data unbalanced or too small. We select at least 1 per class.
The subset thus contains %d instances.
""" % (n+warning))
# cleanup
f.close()
file1.close()
if split == 1:
file2.close()
main()
| [
[
1,
0,
0.0137,
0.0068,
0,
0.66,
0,
509,
0,
4,
0,
0,
509,
0,
0
],
[
1,
0,
0.0205,
0.0068,
0,
0.66,
0.125,
715,
0,
1,
0,
0,
715,
0,
0
],
[
14,
0,
0.0342,
0.0068,
0,
... | [
"from sys import argv, exit, stdout, stderr",
"from random import randint",
"method = 0",
"subset_filename = \"\"",
"rest_filename = \"\"",
"def exit_with_help():\n\tprint(\"\"\"\\\nUsage: %s [options] dataset number [output1] [output2]\n\nThis script selects a subset of the given dataset.\n\noptions:\n-s... |
import numpy as np
import roslib
roslib.load_manifest('hrl_generic_arms')
import rospy
from equilibrium_point_control.ep_control import EPGenerator, EPC, EPStopConditions
##
# Returns a minimum jerk trajectory from x=0..1 given
# the number of samples in the trajectory. Assumes
# x_i = 0, x_f = 1, v_i = 0, v_f = 0.
def min_jerk_traj(n):
return [(10 * t**3 - 15 * t**4 + 6 * t**5)
for t in np.linspace(0, 1, n)]
##
# Implements a generic equilibirum point generator given a list
# of EPs and the arm object to execute them on.
class EPTrajectoryControl(EPGenerator):
def __init__(self, control_arm, trajectory, time_step=0.1):
self.control_arm = control_arm
self.trajectory = trajectory
self.time_step = time_step
self.t_i = 0
def generate_ep(self):
ep_new = self.trajectory[self.t_i]
self.t_i += 1
return EPStopConditions.CONTINUE, ep_new
def control_ep(self, ep):
self.control_arm.set_ep(ep, self.time_step)
def clamp_ep(self, ep):
return ep
def terminate_check(self):
if self.t_i == len(self.trajectory):
return EPStopConditions.SUCCESSFUL
return EPStopConditions.CONTINUE
##
# Equilbrium Point Control object used to execute a trajectory from
# the current EP to the end EP using a minimum jerk interpolation.
class EPArmController(EPC):
def __init__(self, arm, time_step=0.1, epc_name='epc_arm_controller'):
super(EPArmController, self).__init__(epc_name)
self.arm = arm
self.time_step = time_step
def execute_interpolated_ep(self, end_ep, duration, blocking=True):
num_samps = duration / self.time_step
joint_traj = self.arm.interpolate_ep(self.arm.get_ep(), end_ep, min_jerk_traj(num_samps))
ep_traj_control = EPTrajectoryControl(self.arm, joint_traj, self.time_step)
def exec_motion(event):
self.epc_motion(ep_traj_control, self.time_step)
if blocking:
exec_motion(None)
else:
rospy.Timer(rospy.Duration(0.01), exec_motion, oneshot=True)
| [
[
1,
0,
0.0323,
0.0161,
0,
0.66,
0,
954,
0,
1,
0,
0,
954,
0,
0
],
[
1,
0,
0.0645,
0.0161,
0,
0.66,
0.1429,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0806,
0.0161,
0,
... | [
"import numpy as np",
"import roslib",
"roslib.load_manifest('hrl_generic_arms')",
"import rospy",
"from equilibrium_point_control.ep_control import EPGenerator, EPC, EPStopConditions",
"def min_jerk_traj(n):\n return [(10 * t**3 - 15 * t**4 + 6 * t**5)\n for t in np.linspace(0, 1, n)]",
"... |
import numpy as np
import copy
import roslib; roslib.load_manifest('hrl_generic_arms')
import rospy
from std_msgs.msg import Header
from geometry_msgs.msg import PoseStamped, Pose, Point, Quaternion, PointStamped
from geometry_msgs.msg import Transform, TransformStamped, Vector3
from geometry_msgs.msg import Twist, TwistStamped
import tf.transformations as tf_trans
class PoseConverter:
@staticmethod
def _make_generic(args):
if type(args[0]) == str:
frame_id = args[0]
header, homo_mat, rot_quat, rot_euler = PoseConverter._make_generic(args[1:])
if header is None:
header = [0, rospy.Time.now(), '']
header[2] = frame_id
return header, homo_mat, rot_quat, rot_euler
if len(args) == 1:
if type(args[0]) is Pose:
homo_mat, rot_quat, rot_euler = PoseConverter._extract_pose_msg(args[0])
return None, homo_mat, rot_quat, rot_euler
elif type(args[0]) is PoseStamped:
homo_mat, rot_quat, rot_euler = PoseConverter._extract_pose_msg(args[0].pose)
seq = args[0].header.seq
stamp = args[0].header.stamp
frame_id = args[0].header.frame_id
return [seq, stamp, frame_id], homo_mat, rot_quat, rot_euler
elif type(args[0]) is Transform:
homo_mat, rot_quat, rot_euler = PoseConverter._extract_tf_msg(args[0])
return None, homo_mat, rot_quat, rot_euler
elif type(args[0]) is TransformStamped:
homo_mat, rot_quat, rot_euler = PoseConverter._extract_tf_msg(args[0].transform)
seq = args[0].header.seq
stamp = args[0].header.stamp
frame_id = args[0].header.frame_id
return [seq, stamp, frame_id], homo_mat, rot_quat, rot_euler
elif type(args[0]) is Twist:
homo_mat, rot_quat, rot_euler = PoseConverter._extract_twist_msg(args[0])
return None, homo_mat, rot_quat, rot_euler
elif type(args[0]) is TwistStamped:
homo_mat, rot_quat, rot_euler = PoseConverter._extract_twist_msg(args[0].twist)
seq = args[0].header.seq
stamp = args[0].header.stamp
frame_id = args[0].header.frame_id
return [seq, stamp, frame_id], homo_mat, rot_quat, rot_euler
elif isinstance(args[0], (np.matrix, np.ndarray)) and np.shape(args[0]) == (4, 4):
return (None, np.mat(args[0]), tf_trans.quaternion_from_matrix(args[0]).tolist(),
tf_trans.euler_from_matrix(args[0]))
elif isinstance(args[0], (tuple, list)) and len(args[0]) == 2:
pos_arg = np.mat(args[0][0])
rot_arg = np.mat(args[0][1])
if pos_arg.shape == (1, 3):
# matrix is row, convert to column
pos = pos_arg.T
elif pos_arg.shape == (3, 1):
pos = pos_arg
else:
return None, None, None, None
if rot_arg.shape == (3, 3):
# rotation matrix
homo_mat = np.mat(np.eye(4))
homo_mat[:3,:3] = rot_arg
quat = tf_trans.quaternion_from_matrix(homo_mat)
rot_euler = tf_trans.euler_from_matrix(homo_mat)
else:
if rot_arg.shape[1] == 1:
# make into row matrix
rot_arg = rot_arg.T
else:
rot_arg = rot_arg.tolist()[0]
if len(rot_arg) == 3:
# Euler angles rotation
homo_mat = np.mat(tf_trans.euler_matrix(*rot_arg))
quat = tf_trans.quaternion_from_euler(*rot_arg)
rot_euler = rot_arg
elif len(rot_arg) == 4:
# quaternion rotation
homo_mat = np.mat(tf_trans.quaternion_matrix(rot_arg))
quat = rot_arg
rot_euler = tf_trans.euler_from_quaternion(quat)
else:
return None, None, None, None
homo_mat[:3, 3] = pos
return None, homo_mat, np.array(quat), rot_euler
elif len(args) == 2:
header, homo_mat, rot_quat, rot_euler = PoseConverter._make_generic(
((args[0], args[1]),))
if homo_mat is not None:
return header, homo_mat, rot_quat, rot_euler
return None, None, None, None
@staticmethod
def _extract_pose_msg(pose):
px = pose.position.x; py = pose.position.y; pz = pose.position.z
ox = pose.orientation.x; oy = pose.orientation.y
oz = pose.orientation.z; ow = pose.orientation.w
quat = [ox, oy, oz, ow]
rot_euler = tf_trans.euler_from_quaternion(quat)
homo_mat = np.mat(tf_trans.quaternion_matrix(quat))
homo_mat[:3,3] = np.mat([[px, py, pz]]).T
return homo_mat, quat, rot_euler
@staticmethod
def _extract_tf_msg(tf_msg):
px = tf_msg.translation.x; py = tf_msg.translation.y; pz = tf_msg.translation.z
ox = tf_msg.rotation.x; oy = tf_msg.rotation.y
oz = tf_msg.rotation.z; ow = tf_msg.rotation.w
quat = [ox, oy, oz, ow]
rot_euler = tf_trans.euler_from_quaternion(quat)
homo_mat = np.mat(tf_trans.quaternion_matrix(quat))
homo_mat[:3,3] = np.mat([[px, py, pz]]).T
return homo_mat, quat, rot_euler
@staticmethod
def _extract_twist_msg(twist_msg):
pos = [twist_msg.linear.x, twist_msg.linear.y, twist_msg.linear.z]
rot_euler = [twist_msg.angular.x, twist_msg.angular.y, twist_msg.angular.z]
quat = tf_trans.quaternion_from_euler(*rot_euler, axes='sxyz')
homo_mat = np.mat(tf_trans.euler_matrix(*rot_euler))
homo_mat[:3,3] = np.mat([pos]).T
return homo_mat, quat, rot_euler
##
# @return geometry_msgs.Pose
@staticmethod
def to_pose_msg(*args):
header, homo_mat, quat_rot, _ = PoseConverter._make_generic(args)
if homo_mat is None:
rospy.logwarn("[pose_converter] Unknown pose type.")
return None, None, None, None
else:
return Pose(Point(*homo_mat[:3,3].T.A[0]), Quaternion(*quat_rot))
##
# @return geometry_msgs.PoseStamped
@staticmethod
def to_pose_stamped_msg(*args):
header, homo_mat, quat_rot, _ = PoseConverter._make_generic(args)
if homo_mat is None:
rospy.logwarn("[pose_converter] Unknown pose type.")
return None, None, None, None
ps = PoseStamped()
if header is None:
ps.header.stamp = rospy.Time.now()
else:
ps.header.seq = header[0]
ps.header.stamp = header[1]
ps.header.frame_id = header[2]
ps.pose = Pose(Point(*homo_mat[:3,3].T.A[0]), Quaternion(*quat_rot))
return ps
##
# @return geometry_msgs.Point
@staticmethod
def to_point_msg(*args):
header, homo_mat, quat_rot, _ = PoseConverter._make_generic(args)
if homo_mat is None:
rospy.logwarn("[pose_converter] Unknown pose type.")
return None, None, None, None
return Point(*homo_mat[:3,3].T.A[0])
##
# @return geometry_msgs.PointStamped
@staticmethod
def to_point_stamped_msg(*args):
header, homo_mat, quat_rot, _ = PoseConverter._make_generic(args)
if homo_mat is None:
rospy.logwarn("[pose_converter] Unknown pose type.")
return None, None, None, None
ps = PointStamped()
if header is None:
ps.header.stamp = rospy.Time.now()
else:
ps.header.seq = header[0]
ps.header.stamp = header[1]
ps.header.frame_id = header[2]
ps.point = Point(*homo_mat[:3,3].T.A[0])
return ps
##
# @return geometry_msgs.Transform
@staticmethod
def to_tf_msg(*args):
header, homo_mat, quat_rot, _ = PoseConverter._make_generic(args)
if homo_mat is None:
rospy.logwarn("[pose_converter] Unknown pose type.")
return None, None, None, None
else:
return Transform(Vector3(*homo_mat[:3,3].T.A[0]), Quaternion(*quat_rot))
##
# @return geometry_msgs.TransformStamped
@staticmethod
def to_tf_stamped_msg(*args):
header, homo_mat, quat_rot, _ = PoseConverter._make_generic(args)
if homo_mat is None:
rospy.logwarn("[pose_converter] Unknown pose type.")
return None, None, None, None
tf_stamped = TransformStamped()
if header is None:
tf_stamped.header.stamp = rospy.Time.now()
else:
tf_stamped.header.seq = header[0]
tf_stamped.header.stamp = header[1]
tf_stamped.header.frame_id = header[2]
tf_stamped.transform = Transform(Vector3(*homo_mat[:3,3].T.A[0]), Quaternion(*quat_rot))
return tf_stamped
##
# @return geometry_msgs.Twist
@staticmethod
def to_twist_msg(*args):
_, homo_mat, _, euler_rot = PoseConverter._make_generic(args)
if homo_mat is None:
rospy.logwarn("[pose_converter] Unknown pose type.")
return None, None, None, None
else:
return Twist(Vector3(*homo_mat[:3,3].T.A[0]), Vector3(*euler_rot))
##
# @return geometry_msgs.TwistStamped
@staticmethod
def to_twist_stamped_msg(*args):
header, homo_mat, _, euler_rot = PoseConverter._make_generic(args)
if homo_mat is None:
rospy.logwarn("[pose_converter] Unknown pose type.")
return None, None, None, None
twist_stamped = TwistStamped()
header_msg = Header()
if header is None:
header_msg.stamp = rospy.Time.now()
else:
header_msg.seq = header[0]
header_msg.stamp = header[1]
header_msg.frame_id = header[2]
return TwistStamped(header_msg, Twist(Vector3(*homo_mat[:3,3].T.A[0]), Vector3(*euler_rot)))
##
# @return 4x4 numpy mat
@staticmethod
def to_homo_mat(*args):
header, homo_mat, quat_rot, _ = PoseConverter._make_generic(args)
if homo_mat is None:
rospy.logwarn("[pose_converter] Unknown pose type.")
return None, None, None, None
else:
return homo_mat.copy()
##
# @return (3x1 numpy mat, 3x3 numpy mat)
@staticmethod
def to_pos_rot(*args):
header, homo_mat, quat_rot, _ = PoseConverter._make_generic(args)
if homo_mat is None:
rospy.logwarn("[pose_converter] Unknown pose type.")
return None, None, None, None
else:
return homo_mat[:3,3].copy(), homo_mat[:3,:3].copy()
##
# @return (3 list, 4 list)
@staticmethod
def to_pos_quat(*args):
header, homo_mat, quat_rot, _ = PoseConverter._make_generic(args)
if homo_mat is None:
rospy.logwarn("[pose_converter] Unknown pose type.")
return None, None, None, None
else:
return copy.copy(list(homo_mat[:3,3].T.A[0])), copy.copy(quat_rot)
##
# @return (3 list, 3 list)
@staticmethod
def to_pos_euler(*args):
header, homo_mat, quat_rot, euler_rot = PoseConverter._make_generic(args)
if homo_mat is None:
rospy.logwarn("[pose_converter] Unknown pose type.")
return None, None, None, None
else:
return copy.copy(list(homo_mat[:3,3].T.A[0])), copy.copy(euler_rot)
| [
[
1,
0,
0.0034,
0.0034,
0,
0.66,
0,
954,
0,
1,
0,
0,
954,
0,
0
],
[
1,
0,
0.0068,
0.0034,
0,
0.66,
0.1,
739,
0,
1,
0,
0,
739,
0,
0
],
[
1,
0,
0.0135,
0.0034,
0,
0.6... | [
"import numpy as np",
"import copy",
"import roslib; roslib.load_manifest('hrl_generic_arms')",
"import roslib; roslib.load_manifest('hrl_generic_arms')",
"import rospy",
"from std_msgs.msg import Header",
"from geometry_msgs.msg import PoseStamped, Pose, Point, Quaternion, PointStamped",
"from geomet... |
#
# Any robot that wants to use EPC should implement the functions
# sketched out in the HRLArm and HRLArmKinematics
#
# Standards:
# pos is a 3x1 numpy matrix representing a position
# rot is a 3x3 numpy matrix represetning a rotation
# All values are computed in the arm's reference frame (frame 0)
#
import numpy as np, math
import copy
from threading import RLock
##
# Abstract class which represents a basic structure for controlling
# an arm. An equilibrium point (ep) represents a commanded goal for the
# arm which is passed to the underlying controller. A basic assumption of
# equilibrium point control is that the underlying controller doesn't necessarily
# reach the arm commanded goal due to contact, gravity, low gains in the controller, etc.
# Thus we employ another layer of control which relocates the equilibrium point
# based on the task at hand.
class HRLArm(object):
def __init__(self, kinematics):
# object of class derived from HRLArmKinematics
self.kinematics = kinematics
self.ep = None # equilibrium point
self.q = None # angles
self.qdot = None # angular velocity
self.lock = RLock()
#----------------- abstract functions ---------------------
##
# Commands the arm to move to desired equilbrium point
def set_ep(self, *args):
raise RuntimeError('Unimplemented Function')
# publish different viz markers.
def publish_rviz_markers(self):
raise RuntimeError('Unimplemented Function')
##
# Resets the equilibrium point based on some estimate
def reset_ep(self):
raise RuntimeError('Unimplemented Function')
#----------------------------------------------------------
##
# Records the current joint angles. This must be updated regularly
# by the child class.
# @param q array-like of joint angles
def set_joint_angles(self, q):
with self.lock:
self.q = copy.copy(q)
##
# Returns the current joint angles of the arm
# @return array-like of joint angles
def get_joint_angles(self):
with self.lock:
return copy.copy(self.q)
##
# Returns the current equilibrium point
# @return equilibrium point
def get_ep(self):
with self.lock:
return copy.copy(self.ep)
##
# Returns the current pose of the tooltip
# @return (pos, rot)
def get_end_effector_pose(self):
q = self.get_joint_angles()
if q is None:
return None
else:
return self.kinematics.FK(q)
##
# Abstract class containing kinematics interfaces for an arm
class HRLArmKinematics(object):
##
# @param n_jts Number of joints of the arm
# @param tool_pos Postion offset of the tool from the last link in the kinematic chain
# @param tool_rot Rotation offset of the tool from the last link in the kinematic chain
def __init__(self, n_jts, arm_base_pos=np.matrix([0.]*3).T, arm_base_rot=np.matrix(np.eye(3)),
tool_pos=np.matrix([0.]*3).T, tool_rot=np.matrix(np.eye(3))):
self.n_jts = n_jts
self.set_arm_base(arm_base_pos, arm_base_rot)
self.set_tooltip(tool_pos, tool_rot)
#----------------- abstract functions ---------------------
##
# Returns FK for the last link in the kinematic chain.
# Must be implemented by child class.
# @param q Joint angles in radians
# @param link_number Link in the kinematic chain to return FK for
# 0 represents the ground frame, 1 returns the first link's frame, ...
# n_jts + 1 returns the tooltip's frame
# @return pos (3x1) np matrix, rot (3x3) np matrix
def FK_vanilla(self, q, link_number=None):
raise RuntimeError('Unimplemented Function')
##
# Computes IK for the last link in the kinematic chain.
# Must be implemented by child class.
# @param pos Desired link position (3x1 np matrix)
# @param rot Desired link rotation (3x3 np matrix)
# @param q_guess Estimate of the desired joint angles which seeds the IK solver
def IK_vanilla(self, pos, rot, q_guess=None):
raise RuntimeError('Unimplemented Function')
##
# Computes Jacobian in the arm's frame given joint angles at the specified position.
# Must be implemented by child class.
# @param q Joint angles for Jacobian
# @param pos Position at which the Jacobian is centered. If None, the tooltip
# location from FK is used.
# @return Jacobian 6xN np matrix
def jacobian_vanilla(self, q, pos=None):
raise RuntimeError('Unimplemented Function')
#----------------------------------------------------------
##
# Returns FK for the last link in the kinematic chain.
# Must be implemented by child class
# @param q Joint angles in radians
# @param link_number Link in the kinematic chain to return FK for
# 0 represents the ground frame, 1 returns the first link's frame, ...
# n_jts + 1 (and None) returns the tooltip's frame
# @return pos (3x1) np matrix, rot (3x3) np matrix
def FK(self, q, link_number=None):
if link_number == None or link_number > self.n_jts:
use_end_affector = True
link_number = None
else:
use_end_affector = False
pos, rot = self.FK_vanilla(q, link_number)
# offset arm base to FK end
pos = self.arm_base_pos + self.arm_base_rot * pos
rot = self.arm_base_rot * rot
if use_end_affector:
# offset end location to tooltip
tooltip_baseframe = rot * self.tooltip_pos
pos += tooltip_baseframe
rot = rot * self.tooltip_rot
return pos, rot
##
# Computes IK for the tooltip. The desired location is first transformed
# back into the last link's frame and IK is performed on that location.
# @param pos Desired link position (3x1 np matrix)
# @param rot Desired link rotation (3x3 np matrix)
# @param q_guess Estimate of the desired joint angles which seeds the IK solver
def IK(self, pos, rot, q_guess=None):
base_pos = self.arm_base_rot.T * pos - self.arm_base_rot.T * self.arm_base_pos
base_rot = self.arm_base_rot.T * rot
last_link_pos = base_pos - base_rot * self.tooltip_rot.T * self.tooltip_pos
last_link_rot = base_rot * self.tooltip_rot.T
return self.IK_vanilla(last_link_pos, last_link_rot, q_guess)
##
# Computes Jacobian in the arm's frame given joint angles at the specified position.
# @param q Joint angles for Jacobian
# @param pos Position at which the Jacobian is centered. If None, the tooltip
# location from FK is used.
# @return Jacobian 6xN np matrix
def jacobian(self, q, pos=None):
if pos is None:
pos = self.FK(q)
return self.jacobian_vanilla(q, pos)
##
# Sets the offset of the first link in the kinematic chain
# @param arm_base_pos Postion offset of the first link in the kinematic chain
# @param arm_base_rot Rotation offset of the first link in the kinematic chain
def set_arm_base(self, arm_base_pos, arm_base_rot=np.matrix(np.eye(3))):
self.arm_base_pos = arm_base_pos
self.arm_base_rot = arm_base_rot
##
# Sets the offset of the tool from the last link in the kinematic chain
# @param tool_pos Postion offset of the tool from the last link in the kinematic chain
# @param tool_rot Rotation offset of the tool from the last link in the kinematic chain
def set_tooltip(self, tool_pos, tool_rot=np.matrix(np.eye(3))):
self.tooltip_pos = tool_pos
self.tooltip_rot = tool_rot
| [
[
1,
0,
0.057,
0.0052,
0,
0.66,
0,
954,
0,
2,
0,
0,
954,
0,
0
],
[
1,
0,
0.0622,
0.0052,
0,
0.66,
0.25,
739,
0,
1,
0,
0,
739,
0,
0
],
[
1,
0,
0.0674,
0.0052,
0,
0.6... | [
"import numpy as np, math",
"import copy",
"from threading import RLock",
"class HRLArm(object):\n def __init__(self, kinematics):\n # object of class derived from HRLArmKinematics\n self.kinematics = kinematics\n self.ep = None # equilibrium point\n self.q = None # angles\n ... |
import numpy as np, math
import roslib; roslib.load_manifest('hrl_generic_arms')
import rospy
from std_msgs.msg import Float64, Float64MultiArray
##
# Classic PID controller with maximum integral thresholding to
# prevent windup.
class PIDController(object):
def __init__(self, rate=100., k_p=0., k_i=0., k_d=0., i_max=None, feed_forward=0.,
init_integ=0., saturation=None, name=None):
self.y = 0.
self.k_p = k_p
self.k_i = k_i
self.k_d = k_d
self.i_max = i_max
self.feed_forward = feed_forward
self.rate = rate
self.saturation = saturation
self.err_last = None
self.integral = init_integ
self.name = name
if self.name is not None:
self.err_pub = rospy.Publisher("/pid_controller/" + name + "_error", Float64)
self.out_pub = rospy.Publisher("/pid_controller/" + name + "_output", Float64)
self.diag_pub = rospy.Publisher("/pid_controller/" + name + "_diag", Float64MultiArray)
##
# Updates the controller state and returns the current output.
def update_state(self, err):
last_integral = self.integral
self.integral += err / self.rate
if self.i_max is not None:
self.integral = np.clip(self.integral, -self.i_max, self.i_max)
if self.err_last is None:
self.err_last = err
propr = self.k_p * err
integ = self.k_i * self.integral
deriv = self.k_d * (err - self.err_last) * self.rate
feedf = self.feed_forward
raw_y = propr + integ + deriv + feedf
self.err_last = err
if self.saturation is not None:
self.y = np.clip(raw_y, -self.saturation, self.saturation)
if self.y in [-self.saturation, self.saturation]:
self.integral = last_integral
if self.name is not None:
self.err_pub.publish(err)
self.out_pub.publish(self.y)
diag_msg = Float64MultiArray()
diag_msg.data = [self.y, propr, integ, deriv, feedf, raw_y, self.saturation]
self.diag_pub.publish(diag_msg)
return self.y
def reset_controller(self):
self.err_last = None
self.integral = 0
| [
[
1,
0,
0.0172,
0.0172,
0,
0.66,
0,
954,
0,
2,
0,
0,
954,
0,
0
],
[
1,
0,
0.0517,
0.0172,
0,
0.66,
0.2,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0517,
0.0172,
0,
0.6... | [
"import numpy as np, math",
"import roslib; roslib.load_manifest('hrl_generic_arms')",
"import roslib; roslib.load_manifest('hrl_generic_arms')",
"import rospy",
"from std_msgs.msg import Float64, Float64MultiArray",
"class PIDController(object):\n def __init__(self, rate=100., k_p=0., k_i=0., k_d=0., ... |
#
# Copyright (c) 2009, Georgia Tech Research Corporation
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
# * Neither the name of the Georgia Tech Research Corporation nor the
# names of its contributors may be used to endorse or promote products
# derived from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY GEORGIA TECH RESEARCH CORPORATION ''AS IS'' AND
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL GEORGIA TECH BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
# OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
# OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
# Author: Advait Jain
import math, numpy as np
import m3.rt_proxy as m3p
import m3.component_factory as m3f
import m3.toolbox as m3t
import m3.arm
THETA_GC = 5
THETA = 3
def safeop_things(proxy):
robot_name = 'm3humanoid_bimanual_mr1'
chain_names = ['m3arm_ma1', 'm3arm_ma2']
dynamatics_nms = ['m3dynamatics_ma1', 'm3dynamatics_ma2']
proxy.make_safe_operational(robot_name)
for c in chain_names:
proxy.make_safe_operational(c)
for d in dynamatics_nms:
proxy.make_safe_operational(d)
proxy = m3p.M3RtProxy()
proxy.start()
pwr_nm = 'm3pwr_pwr003'
pwr = m3f.create_component(pwr_nm)
proxy.publish_command(pwr)
joint_names = ['m3joint_ma1_j0', 'm3joint_ma1_j1', 'm3joint_ma1_j2', 'm3joint_ma1_j3', 'm3joint_ma1_j4', 'm3joint_ma1_j5', 'm3joint_ma1_j6']
comp_list = []
stiff_list = [0.2, 0.67, 1., 0.7, 0.75, 0.5, 0.5]
for i, c in enumerate(joint_names):
comp = m3f.create_component(c)
comp_list.append(comp)
proxy.publish_command(comp)
if i < 5:
comp.set_control_mode(THETA_GC)
else:
comp.set_control_mode(THETA)
comp.set_stiffness(stiff_list[i])
comp.set_slew_rate_proportion(1.)
# safeop_things must be after make_operational_all.
proxy.make_operational_all()
safeop_things(proxy)
#ma1 = m3.arm.M3Arm('m3arm_ma1')
#proxy.subscribe_status(ma1)
proxy.step()
proxy.step()
raw_input('Hit ENTER to power on')
pwr.set_motor_power_on()
proxy.step()
proxy.step()
raw_input('Hit ENTER to move the joint')
q = [0., 0., 0., 90., 0., 0., 0.]
q = np.radians(q)
for i, c in enumerate(comp_list):
c.set_theta_rad(q[i])
proxy.step()
proxy.step()
raw_input('Hit ENTER to stop')
proxy.stop()
#-------------- older code ---------------
##Force safe-op of robot, etc are present
#types=['m3humanoid','m3hand','m3gripper']
#for t in types:
# cc = proxy.get_available_components(t)
# for ccc in cc:
# print 'ccc:', ccc
# proxy.make_safe_operational(ccc)
#
#
##Force safe-op of chain so that gravity terms are computed
#chain=None
#if len(joint_names)>0:
# for j in joint_names:
# chain_name=m3t.get_joint_chain_name(j)
# print 'chain_name:', chain_name
# if chain_name!="":
# proxy.make_safe_operational(chain_name)
#
# #Force safe-op of chain so that gravity terms are computed
# dynamatics_name = m3t.get_chain_dynamatics_component_name(chain_name)
# print 'dynamatics_name:', dynamatics_name
# if dynamatics_name != "":
# proxy.make_safe_operational(dynamatics_name)
#
#
#
##Force safe-op of robot so that gravity terms are computed
#robot_name = m3t.get_robot_name()
#print 'robot_name:', robot_name
#if robot_name != "":
# proxy.make_safe_operational(robot_name)
| [
[
1,
0,
0.2109,
0.0068,
0,
0.66,
0,
526,
0,
2,
0,
0,
526,
0,
0
],
[
1,
0,
0.2177,
0.0068,
0,
0.66,
0.0312,
826,
0,
1,
0,
0,
826,
0,
0
],
[
1,
0,
0.2245,
0.0068,
0,
... | [
"import math, numpy as np",
"import m3.rt_proxy as m3p",
"import m3.component_factory as m3f",
"import m3.toolbox as m3t",
"import m3.arm",
"THETA_GC = 5",
"THETA = 3",
"def safeop_things(proxy):\n robot_name = 'm3humanoid_bimanual_mr1'\n chain_names = ['m3arm_ma1', 'm3arm_ma2']\n dynamatics_... |
#
# subscribe to thw joint angles and raw forces topics, and provide FK
# etc.
#
# Copyright (c) 2009, Georgia Tech Research Corporation
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
# * Neither the name of the Georgia Tech Research Corporation nor the
# names of its contributors may be used to endorse or promote products
# derived from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY GEORGIA TECH RESEARCH CORPORATION ''AS IS'' AND
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL GEORGIA TECH BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
# OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
# OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
# Author: Advait Jain
import math
import numpy as np
import copy
import sys
import roslib; roslib.load_manifest('hrl_cody_arms')
import rospy
from cody_arm_kinematics import CodyArmKinematics
from equilibrium_point_control.hrl_arm import HRLArm
import hrl_lib.viz as hv
from hrl_msgs.msg import FloatArray, FloatArrayBare
from std_msgs.msg import Header, Bool, Empty
from visualization_msgs.msg import Marker
# used in client and server.
def get_joint_name_list(arm):
if arm == 'r':
return ['m3joint_ma1_j%d'%i for i in range(7)]
else:
return ['m3joint_ma2_j%d'%i for i in range(7)]
class CodyArmClient(HRLArm):
# arm - 'r' or 'l'
def __init__(self, arm):
kinematics = CodyArmKinematics(arm)
HRLArm.__init__(self, kinematics)
#stiffness from .yaml file [1800., 1300., 350., 600., 60., 80., 60.] mN-meter/deg
self.nom_kp = [103, 74.5, 20.1, 4.4, 3.44] #N-m/rad
# NB: Original value for joint 4 was 34.4, changed to 4.4
# we don't use last two values becuase they are position controlled - 4.58, 3.44]
if arm == 'r':
#damping from .yaml file [100., 120., 10., 25., 1.25, 0.3, 0.25] mN-meter-sec/deg
self.nom_kd = [5.73, 6.88, 0.573, 1.43, 0.0716] #N-m-s/deg
# we don't use last two values becuase they are position controlled - 0.0172, 0.0143]
elif arm == 'l':
#damping from .yaml file [80., 60., 10., 15., 1.25, 0.3, 0.20] mN-meter-sec/deg
self.nom_kd = [4.58, 3.44, 0.573, 0.859, 0.0716] #N-m-s/deg
# we don't use last two values becuase they are position controlled - 0.0172, 0.0115
else:
rospy.logerr("You didn't give me a 'r' or 'l' for which arm ... Exiting")
assert(False)
self.alpha = None
self.torque = None
self.motor_temps = None
self.ft_val = None
self.pwr_state = False
self.fts_bias = {'force': np.matrix(np.zeros(3)).T,
'torque': np.matrix(np.zeros(3)).T}
self.joint_names_list = get_joint_name_list(arm)
self.jep_cmd_pub = rospy.Publisher('/'+arm+'_arm/command/jep', FloatArray)
self.alph_cmd_pub = rospy.Publisher('/'+arm+'_arm/command/joint_impedance_scale',
FloatArray)
self.stop_pub = rospy.Publisher('/arms/stop', Empty)
self.motors_off_pub = rospy.Publisher('/arms/command/motors_off', Empty)
self.marker_pub = rospy.Publisher('/'+arm+'_arm/viz/markers', Marker)
################## The following are for computing joint accelerations (added by Tapo, Jan 23-2013) ##################
self.q_r = None
self.q_l = None
self.q_rHOT = None
self.q_lHOT = None
self.q_rHHOT = None
self.q_lHHOT = None
self.time_stamp = None
######################################################################################################################
rospy.Subscriber('/'+arm+'_arm/jep', FloatArray, self.ep_cb)
rospy.Subscriber('/'+arm+'_arm/joint_impedance_scale', FloatArray, self.alpha_cb)
rospy.Subscriber('/'+arm+'_arm/q', FloatArray, self.q_cb)
rospy.Subscriber('/'+arm+'_arm/qdot', FloatArray, self.qdot_cb)
rospy.Subscriber('/'+arm+'_arm/force', FloatArray, self.force_cb)
rospy.Subscriber('/'+arm+'_arm/force_raw', FloatArray, self.raw_force_cb)
rospy.Subscriber('/'+arm+'_arm/joint_torque', FloatArray, self.torque_cb)
rospy.Subscriber('/'+arm+'_arm/joint_motor_temp', FloatArray, self.motor_temp_cb)
rospy.Subscriber('/arms/pwr_state', Bool, self.pwr_state_cb)
# Set desired joint angle - either through a delta from the current position, or as an absolute value.
rospy.Subscriber ("/haptic_mpc/q_des", FloatArrayBare, self.set_ep_callback)
rospy.Subscriber ("/haptic_mpc/delta_q_des", FloatArrayBare, self.set_delta_ep_callback)
try:
rospy.init_node(arm+'_arm_client', anonymous=False)
except rospy.ROSException:
pass
#---------- ROS callbacks -----------------
def pwr_state_cb(self, msg):
with self.lock:
self.pwr_state = msg.data
def ep_cb(self, msg):
with self.lock:
self.ep = copy.copy(msg.data)
def alpha_cb(self, msg):
with self.lock:
self.alpha = copy.copy(msg.data)
self.kp = (np.array(self.alpha)*np.array(self.nom_kp)).tolist()
self.kd = (np.array(self.alpha)*np.array(self.nom_kd)).tolist()
def torque_cb(self, msg):
with self.lock:
self.torque = copy.copy(msg.data)
def motor_temp_cb(self, msg):
with self.lock:
self.motor_temps = copy.copy(msg.data)
def q_cb(self, msg):
with self.lock:
self.q = copy.copy(msg.data)
def qdot_cb(self, msg):
with self.lock:
self.qdot = copy.copy(msg.data)
def force_cb(self, msg):
with self.lock:
self.ft_val = copy.copy(msg.data)
def raw_force_cb(self, msg):
with self.lock:
self.raw_force = copy.copy(msg.data)
#--------- functions to use -----------------
def publish_rviz_markers(self):
# publish the CEP marker.
o = np.matrix([0.,0.,0.,1.]).T
jep = self.get_ep()
cep, r = self.kinematics.FK(jep)
cep_marker = hv.single_marker(cep, o, 'sphere',
'/torso_lift_link', color=(0., 0., 1., 1.),
scale = (0.02, 0.02, 0.02), duration=0.,
m_id=1)
cep_marker.header.stamp = rospy.Time.now()
self.marker_pub.publish(cep_marker)
q = self.get_joint_angles()
ee, r = self.kinematics.FK(q)
ee_marker = hv.single_marker(ee, o, 'sphere',
'/torso_lift_link', color=(0., 1., 0., 1.),
scale = (0.02, 0.02, 0.02), duration=0.,
m_id=2)
ee_marker.header.stamp = rospy.Time.now()
self.marker_pub.publish(ee_marker)
def get_wrist_force(self, bias=True, base_frame=True,
filtered = True):
with self.lock:
if filtered:
f = copy.copy(self.ft_val)
else:
f = copy.copy(self.raw_force)
f_mat = np.matrix(f).T
f_mat = f_mat[0:3,:] # ignoring the torques.
if bias:
f_mat = f_mat - self.fts_bias['force'] #Tiffany added an 's' to 'ft'
if base_frame:
q = self.get_joint_angles()
rot = self.kinematics.FK(q)[1]
f_mat = rot*f_mat
return f_mat
def bias_wrist_ft(self):
f_list = []
t_list = []
rospy.loginfo('Starting biasing...')
for i in range(20):
f_list.append(self.get_wrist_force(bias=False,
base_frame=False))
rospy.sleep(0.02)
f_b = np.mean(np.column_stack(f_list), 1)
# torque is unimplemented.
t_b = self.get_wrist_torque(bias=False) #Tiffany Nov 8 2011 removed 'arm' arg
self.fts_bias['force'] = f_b
self.fts_bias['torque'] = t_b
rospy.loginfo('...done')
# @return array-like of floats b/w 0 and 1.
def get_impedance_scale(self):
with self.lock:
sc = copy.copy(self.alpha)
return sc
# @param s - list of floats b/w 0 and 1.
def set_impedance_scale(self, s):
time_stamp = rospy.Time.now()
h = Header()
h.stamp = time_stamp
self.alph_cmd_pub.publish(FloatArray(h, s))
def set_ep_callback(self, msg):
des_jep = msg.data
self.set_ep(des_jep)
def set_delta_ep_callback(self, msg):
delta_jep = msg.data
if self.ep == None:
self.ep = self.get_joint_angles()
des_jep = (np.array(self.ep) + np.array(delta_jep)).tolist()
self.set_ep(des_jep)
# @param duration - for compatibility with the PR2 class.
def set_ep(self, jep, duration=None):
time_stamp = rospy.Time.now()
h = Header()
h.stamp = time_stamp
self.jep_cmd_pub.publish(FloatArray(h, jep))
self.publish_rviz_markers()
def is_motor_power_on(self):
return self.pwr_state
def motors_off(self):
self.motors_off_pub.publish()
#-------- unimplemented functions -----------------
# leaving this unimplemented for now. Advait Nov 14, 2010.
# Implemented Now - Tapo, Jan 23 2013
def get_joint_accelerations(self, arm):
t_now = rospy.get_time()
q = self.get_joint_angles()
if arm == 'r':
if self.q_r != None and self.q_rHOT != None and self.q_rHHOT != None and self.time_stamp != None:
dt = t_now - self.time_stamp
qddot_r = (-np.array(q) + 4*np.array(self.q_r) - 5*np.array(self.q_rHOT) + 2*np.array(self.q_rHHOT)) / (dt*dt)
else:
qddot_r = np.zeros(7)
self.q_rHHOT = self.q_rHOT
self.q_rHOT = self.q_r
self.q_r = q
self.time_stamp = t_now
return qddot_r
elif arm == 'l':
if self.q_l != None and self.q_lHOT != None and self.q_lHHOT != None and self.time_stamp != None:
dt = t_now - self.time_stamp
qddot_l = (-np.array(q) + 4*np.array(self.q_l) - 5*np.array(self.q_lHOT) + 2*np.array(self.q_lHHOT)) / (dt*dt)
else:
qddot_l = np.zeros(7)
self.q_lHHOT = self.q_lHOT
self.q_lHOT = self.q_l
self.q_l = q
self.time_stamp = t_now
return qddot_l
# now implemented - marc Jul 2012
def get_joint_torques(self):
return self.torque
# added this as a safety measure since fabrice skin is not
# measuring real forces - marc Jul 2012
def get_joint_motor_temps(self):
return self.motor_temps
# leaving this unimplemented for now. Advait Nov 14, 2010.
def get_wrist_torque(self, bias=True): #Tiffany Nov 8 2011 removed 'arm' arg
pass
# these two classes are specifically for the model predictive
# controller that we developed for reaching in clutter with multiple
# contacts.
# We override the get_joint_impedance function to return values that
# the model predictive controller will use.
class CodyArmClient_7DOF(CodyArmClient):
def __init__(self, arm):
CodyArmClient.__init__(self, arm)
# dummy kp values for the wrist, kd still of length five
def get_joint_impedance(self):
with self.lock:
kp_t = [k for k in self.kp]
kp_t[-1] = 30.
kp_t.append(30.)
kp_t.append(30.)
return kp_t, copy.copy(self.kd)
class CodyArmClient_5DOF(CodyArmClient):
def __init__(self, arm):
CodyArmClient.__init__(self, arm)
def get_joint_impedance(self):
with self.lock:
return copy.copy(self.kp[0:5]), copy.copy(self.kd[0:5])
if __name__ == '__main__':
import m3.toolbox as m3t
import hrl_lib.transforms as tr
import optparse
p = optparse.OptionParser()
p.add_option('--arm_to_use', action='store', dest='arm',
type='string', help='which arm to use (l or r)',
default=None)
opt, args = p.parse_args()
if opt.arm == None:
print 'Please specify an arm_to_use'
print 'Exiting...'
sys.exit()
ac = CodyArmClient(opt.arm)
# print FT sensor readings.
if False:
ac.bias_wrist_ft()
while not rospy.is_shutdown():
f = ac.get_wrist_force()
print 'f:', f.A1
rospy.sleep(0.05)
# print joint angles.
if False:
while not rospy.is_shutdown():
#jep = ac.get_ep()
#print 'jep:', jep
q = ac.get_joint_angles()
print 'q:', np.degrees(q).tolist()[1]
rospy.sleep(0.05)
# publish end effector marker. useful to verify set_tooltip.
if False:
ac.kinematics.set_tooltip(np.matrix([0.,0.,-0.04]).T) # stub with mini45
while not rospy.is_shutdown():
ac.publish_rviz_markers()
rospy.sleep(0.05)
# print joint velocities
if False:
while not rospy.is_shutdown():
qdot = ac.get_joint_velocities()
print 'qdot:', np.degrees(qdot)
rospy.sleep(0.05)
# testing changing the impedance
if False:
rospy.sleep(1.)
isc = ac.get_impedance_scale()
print isc
isc[1] = 0.3
ac.set_impedance_scale(isc)
rospy.sleep(1.)
isc = ac.get_impedance_scale()
print isc
| [
[
1,
0,
0.0799,
0.0024,
0,
0.66,
0,
526,
0,
1,
0,
0,
526,
0,
0
],
[
1,
0,
0.0823,
0.0024,
0,
0.66,
0.0588,
954,
0,
1,
0,
0,
954,
0,
0
],
[
1,
0,
0.0847,
0.0024,
0,
... | [
"import math",
"import numpy as np",
"import copy",
"import sys",
"import roslib; roslib.load_manifest('hrl_cody_arms')",
"import roslib; roslib.load_manifest('hrl_cody_arms')",
"import rospy",
"from cody_arm_kinematics import CodyArmKinematics",
"from equilibrium_point_control.hrl_arm import HRLArm... |
#
# Copyright (c) 2009, Georgia Tech Research Corporation
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
# * Neither the name of the Georgia Tech Research Corporation nor the
# names of its contributors may be used to endorse or promote products
# derived from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY GEORGIA TECH RESEARCH CORPORATION ''AS IS'' AND
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL GEORGIA TECH BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
# OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
# OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
# Author: Advait Jain
import numpy as np, math
import copy
import hrl_lib.transforms as tr
# dictionary for transforming different coorsinate frames to global coord frame
# global is NOT the world or fixed frame, its just a convenient global frame
_globalT = {
'torso' : None,
'thok0' : None,
'utm0' : None,
'utmcam0': None,
'mecanum': None
}
def create_globalTDict():
""" call the create functions for all the coord frames
"""
createTorsoTransform()
createThok0Transform()
createUtm0Transform()
createMecanumTransform()
def createTorsoTransform():
''' torso frame -> global frame
'''
disp = np.matrix([0.,0.,0.]).T
rot = np.matrix(np.eye(3))
t = tr.composeHomogeneousTransform(rot,disp)
_globalT['torso'] = t
def createThok0Transform():
''' thok0 frame -> global frame
'''
disp = np.matrix([0.,0.,0.09]).T
rot = np.matrix(np.eye(3))
t = tr.composeHomogeneousTransform(rot,disp)
_globalT['thok0'] = t
def createUtm0Transform():
''' utm0 frame -> global frame
'''
disp = copy.copy(tr.getDispSubMat(_globalT['thok0']))
disp[2,0] += 0.055
rot = np.matrix(np.eye(3))
t = tr.composeHomogeneousTransform(rot,disp)
_globalT['utm0'] = t
def createMecanumTransform():
''' mecanum frame -> global frame (ignores the zenither)
'''
disp = np.matrix([-0.28,0.,0.0]).T
rot = np.matrix(np.eye(3))
t = tr.composeHomogeneousTransform(rot,disp)
_globalT['mecanum'] = t
create_globalTDict()
def globalTmecanum(p,floating_vector=False):
''' 3x1 vector from mecanum to global.
'''
p_hom = tr.xyzToHomogenous(p, floating_vector)
p_gl = _globalT['mecanum'] * p_hom
if floating_vector == False:
return p_gl[0:3]/p_gl[3]
else:
return p_gl[0:3]
def mecanumTglobal(p,floating_vector=False):
''' 3x1 vector from global to mecanum.
'''
p_hom = tr.xyzToHomogenous(p, floating_vector)
p_gl = tr.invertHomogeneousTransform(_globalT['mecanum']) * p_hom
if floating_vector == False:
return p_gl[0:3]/p_gl[3]
else:
return p_gl[0:3]
def globalTtorso(p,floating_vector=False):
''' 3x1 vector from torso to global.
'''
p_hom = tr.xyzToHomogenous(p, floating_vector)
p_gl = _globalT['torso'] * p_hom
if floating_vector == False:
return p_gl[0:3]/p_gl[3]
else:
return p_gl[0:3]
def torsoTglobal(p,floating_vector=False):
''' 3x1 vector from global to torso.
'''
p_hom = tr.xyzToHomogenous(p, floating_vector)
p_gl = tr.invertHomogeneousTransform(_globalT['torso']) * p_hom
if floating_vector == False:
return p_gl[0:3]/p_gl[3]
else:
return p_gl[0:3]
def globalTthok0(p,floating_vector=False):
''' 3x1 vector from thok0 to global.
'''
p_hom = tr.xyzToHomogenous(p, floating_vector)
p_gl = _globalT['thok0'] * p_hom
if floating_vector == False:
return p_gl[0:3]/p_gl[3]
else:
return p_gl[0:3]
def thok0Tglobal(p,floating_vector=False):
''' 3x1 vector from global to thok0.
'''
p_hom = tr.xyzToHomogenous(p, floating_vector)
p_gl = tr.invertHomogeneousTransform(_globalT['thok0']) * p_hom
if floating_vector == False:
return p_gl[0:3]/p_gl[3]
else:
return p_gl[0:3]
def globalTutm0(p,floating_vector=False):
''' 3x1 vector from utm0 to global.
'''
p_hom = tr.xyzToHomogenous(p, floating_vector)
p_gl = _globalT['utm0'] * p_hom
if floating_vector == False:
return p_gl[0:3]/p_gl[3]
else:
return p_gl[0:3]
def utm0Tglobal(p,floating_vector=False):
''' 3x1 vector from global to utm0.
'''
p_hom = tr.xyzToHomogenous(p, floating_vector)
p_gl = tr.invertHomogeneousTransform(_globalT['utm0']) * p_hom
if floating_vector == False:
return p_gl[0:3]/p_gl[3]
else:
return p_gl[0:3]
## transformation matrix to go from global to utmcam0 coord frame.
# @param ang - servo angle (in RADIANS)
# @return 4x4 transformation matrix.
def utmcam0Tglobal_mat(ang):
thok0Tglobal_mat = tr.invertHomogeneousTransform(_globalT['thok0'])
# servo angle.
disp = np.matrix([0.,0.,0.]).T
tmat = tr.composeHomogeneousTransform(tr.Ry(ang),disp)*thok0Tglobal_mat
# cameraTlaser from thok_cam_calib.py
x = 0.012
y = -0.056
z = 0.035
r1 = 0.
r2 = 0.
r3 = -0.7
disp = np.matrix([-x,-y,-z]).T
r = tr.Rz(math.radians(-90))*tr.Ry(math.radians(90.))
disp = r*disp
r = r*tr.Rx(math.radians(r1))
r = r*tr.Ry(math.radians(r2))
r = r*tr.Rz(math.radians(r3))
t = tr.composeHomogeneousTransform(r, disp)
tmat = t*tmat
return tmat
## global to utmcam0 coord frame.
# @param p - 3xN np matrix.
# @param ang - servo angle (in RADIANS)
# @param floating_vector - interpretation of p. False -> position vector. True -> floating vector (rotation only).
# @return 3xN np matrix in the new coord frame.
def utmcam0Tglobal(p,ang,floating_vector=False):
t = utmcam0Tglobal_mat(ang)
p_hom = tr.xyzToHomogenous(p, floating_vector)
p_c = t * p_hom
if floating_vector == False:
pt = p_c[0:3]/p_c[3]
else:
pt = p_c[0:3]
return pt
## utmcam0 coord frame to global
# @param p - 3xN np matrix.
# @param ang - servo angle (in RADIANS)
# @param floating_vector - interpretation of p. False -> position vector. True -> floating vector (rotation only).
# @return 3xN np matrix in the new coord frame.
def globalTutmcam0(p,ang,floating_vector=False):
t = utmcam0Tglobal_mat(ang)
t = tr.invertHomogeneousTransform(t)
p_hom = tr.xyzToHomogenous(p, floating_vector)
p_c = t * p_hom
if floating_vector == False:
pt = p_c[0:3]/p_c[3]
else:
pt = p_c[0:3]
return pt
| [
[
1,
0,
0.1354,
0.0044,
0,
0.66,
0,
954,
0,
2,
0,
0,
954,
0,
0
],
[
1,
0,
0.1397,
0.0044,
0,
0.66,
0.05,
739,
0,
1,
0,
0,
739,
0,
0
],
[
1,
0,
0.1441,
0.0044,
0,
0.... | [
"import numpy as np, math",
"import copy",
"import hrl_lib.transforms as tr",
"_globalT = {\n 'torso' : None,\n 'thok0' : None,\n 'utm0' : None,\n 'utmcam0': None,\n 'mecanum': None\n}",
"def create_globalTDict():\n \"\"\" call the create functions for all the coord frames\n \"\"\"\n ... |
#
# Copyright (c) 2009, Georgia Tech Research Corporation
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
# * Neither the name of the Georgia Tech Research Corporation nor the
# names of its contributors may be used to endorse or promote products
# derived from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY GEORGIA TECH RESEARCH CORPORATION ''AS IS'' AND
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL GEORGIA TECH BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
# OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
# OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
# Author: Advait Jain
import math, numpy as np
import arm_client as ac
import arms as ar
import roslib; roslib.load_manifest('hrl_cody_arms')
import rospy
import tf.broadcaster as tfb
import hrl_lib.transforms as tr
from hrl_msgs.msg import FloatArray
from std_msgs.msg import Header
from visualization_msgs.msg import Marker
def publish_cartesian_markers(arm, time_stamp, cep, rot, c1, c2, marker_id):
marker = Marker()
marker.header.frame_id = ar.link_tf_name(arm, 0)
marker.header.stamp = time_stamp
marker.ns = arm
marker.type = Marker.ARROW
marker.action = Marker.ADD
marker.pose.position.x = cep[0,0]
marker.pose.position.y = cep[1,0]
marker.pose.position.z = cep[2,0]
marker.scale.x = 0.1
marker.scale.y = 0.2
marker.scale.z = 0.2
marker.lifetime = rospy.Duration()
marker.id = marker_id*100 + 0
#rot1 = tr.Ry(math.radians(90.)) * rot.T
rot1 = rot * tr.rotY(math.pi/2)
quat = tr.matrix_to_quaternion(rot1)
marker.pose.orientation.x = quat[0]
marker.pose.orientation.y = quat[1]
marker.pose.orientation.z = quat[2]
marker.pose.orientation.w = quat[3]
marker.color.r = c1[0]
marker.color.g = c1[1]
marker.color.b = c1[2]
marker.color.a = 1.
marker_pub.publish(marker)
marker.id = marker_id*100 + 1
if arm == 'left_arm':
#rot2 = tr.Rz(math.radians(90.)) * rot.T
rot2 = rot * tr.rotZ(-math.pi/2)
else:
#rot2 = tr.Rz(math.radians(-90.)) * rot.T
rot2 = rot * tr.rotZ(math.pi/2)
quat = tr.matrix_to_quaternion(rot2)
marker.pose.orientation.x = quat[0]
marker.pose.orientation.y = quat[1]
marker.pose.orientation.z = quat[2]
marker.pose.orientation.w = quat[3]
marker.color.r = c2[0]
marker.color.g = c2[1]
marker.color.b = c2[2]
marker.color.a = 1.
marker_pub.publish(marker)
def publish_sphere_marker(color, size, frameid, time_stamp, ns,
marker_id):
marker = Marker()
marker.header.frame_id = frameid
marker.header.stamp = time_stamp
marker.ns = ns
marker.type = Marker.SPHERE
marker.action = Marker.ADD
marker.pose.position.x = 0.
marker.pose.position.y = 0.
marker.pose.position.z = 0.
marker.scale.x = size
marker.scale.y = size
marker.scale.z = size
marker.lifetime = rospy.Duration()
marker.id = marker_id
marker.pose.orientation.x = 0
marker.pose.orientation.y = 0
marker.pose.orientation.z = 0
marker.pose.orientation.w = 1
marker.color.r = color[0]
marker.color.g = color[1]
marker.color.b = color[2]
marker.color.a = 1.
marker_pub.publish(marker)
if __name__ == '__main__':
arms = ar.M3HrlRobot()
arm_client = ac.MekaArmClient(arms)
force_r_pub = rospy.Publisher('/r_arm/force_base', FloatArray)
force_l_pub = rospy.Publisher('/l_arm/force_base', FloatArray)
marker_pub = rospy.Publisher('/cody_arms/viz_marker', Marker)
rospy.logout('Sleeping ...')
rospy.sleep(1.0)
rospy.logout('... begin')
r_arm = 'right_arm'
l_arm = 'left_arm'
transform_bcast = tfb.TransformBroadcaster()
torso_link_name = ar.link_tf_name(r_arm, 0)
while not rospy.is_shutdown():
rospy.sleep(0.1)
f_r = arm_client.get_wrist_force(r_arm, base_frame=True)
f_l = arm_client.get_wrist_force(l_arm, base_frame=True)
time_stamp = rospy.Time.now()
h = Header()
h.stamp = time_stamp
force_r_pub.publish(FloatArray(h, f_r))
force_l_pub.publish(FloatArray(h, f_l))
publish_sphere_marker((0.5,0.5,0.5), 0.08, torso_link_name,
time_stamp, 'both_arms', 0)
for arm in [r_arm, l_arm]:
q = arm_client.get_joint_angles(arm)
links = [2, 3, 7]
for i in links:
p, rot = arms.FK_all(arm, q, i)
qaut = tr.matrix_to_quaternion(rot)
frameid = ar.link_tf_name(arm, i)
transform_bcast.sendTransform(p.A1.tolist(), qaut, time_stamp,
frameid, torso_link_name)
publish_sphere_marker((0.5,0.1,0.5), 0.05, frameid,
time_stamp, arm, i)
c1 = (0.5, 0.1, 0.5)
c2 = (0.5, 0.5, 0.1)
p, rot = arms.FK_all(arm, q)
publish_cartesian_markers(arm, time_stamp, p, rot, c1, c2,
marker_id=76)
c1 = (0.2, 0.2, 0.2)
c2 = (0.6, 0.6, 0.6)
jep = arm_client.get_jep(arm)
jep = arms.clamp_to_physical_joint_limits(arm, jep)
cep, rot = arms.FK_all(arm, jep)
publish_cartesian_markers(arm, time_stamp, cep, rot, c1, c2,
marker_id = 77)
| [
[
1,
0,
0.1694,
0.0055,
0,
0.66,
0,
526,
0,
2,
0,
0,
526,
0,
0
],
[
1,
0,
0.1803,
0.0055,
0,
0.66,
0.0769,
435,
0,
1,
0,
0,
435,
0,
0
],
[
1,
0,
0.1858,
0.0055,
0,
... | [
"import math, numpy as np",
"import arm_client as ac",
"import arms as ar",
"import roslib; roslib.load_manifest('hrl_cody_arms')",
"import roslib; roslib.load_manifest('hrl_cody_arms')",
"import rospy",
"import tf.broadcaster as tfb",
"import hrl_lib.transforms as tr",
"from hrl_msgs.msg import Flo... |
#
# Copyright (c) 2009, Georgia Tech Research Corporation
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
# * Neither the name of the Georgia Tech Research Corporation nor the
# names of its contributors may be used to endorse or promote products
# derived from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY GEORGIA TECH RESEARCH CORPORATION ''AS IS'' AND
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL GEORGIA TECH BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
# OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
# OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
# Author: Advait Jain
import math
import numpy as np
import copy
import sys, time, os
import PyKDL as kdl
import create_IK_guess_dict as cgd
import roslib; roslib.load_manifest('hrl_cody_arms')
import hrl_lib.transforms as tr
import hrl_lib.util as ut
import hrl_lib.kdl_utils as ku
#-------------- TF stuff ---------------
def link_tf_name(arm, link_number):
if arm == 'right_arm':
nm = 'r_arm'
else:
nm = 'l_arm'
if link_number == 0:
nm = 'torso_link'
elif link_number == 7:
nm = nm + '_ee'
else:
nm = nm + '_' + str(link_number)
return nm
class M3HrlRobot():
def __init__(self, end_effector_length):
# create joint limit dicts
self.joint_lim_dict = {}
self.joint_lim_dict['right_arm'] = {'max': np.radians([ 120.00, 122.15, 77.5, 144., 122., 45., 45.]),
'min': np.radians([ -47.61, -20., -77.5, 0., -80., -45., -45.])}
self.joint_lim_dict['left_arm'] = {'max': np.radians([ 120.00, 20., 77.5, 144., 80., 45., 45.]),
'min': np.radians([ -47.61, -122.15, -77.5, 0., -122., -45., -45.])}
end_effector_length += 0.0135 + 0.04318 # add wrist linkange and FT sensor lengths
self.setup_kdl_mekabot(end_effector_length)
q_guess_pkl_l = os.environ['HOME']+'/svn/gt-ros-pkg/hrl/hrl_arm_control/hrl_cody_arms/src/hrl_cody_arms/q_guess_left_dict.pkl'
q_guess_pkl_r = os.environ['HOME']+'/svn/gt-ros-pkg/hrl/hrl_arm_control/hrl_cody_arms/src/hrl_cody_arms/q_guess_right_dict.pkl'
self.q_guess_dict_left = ut.load_pickle(q_guess_pkl_l)
self.q_guess_dict_right = ut.load_pickle(q_guess_pkl_r)
# KDL joint array to meka joint list. (7->7)
# arm - 'left_arm' or 'right_arm'
def kdl_angles_to_meka(self, arm, q_jnt_arr):
if q_jnt_arr == None:
return None
q_rad = [0. for i in range(7)]
q_rad[0] = -q_jnt_arr[0]
q_rad[1] = -q_jnt_arr[1]
q_rad[2] = -q_jnt_arr[2]
q_rad[3] = -q_jnt_arr[3]
q_rad[4] = -q_jnt_arr[4]
q_rad[5] = -q_jnt_arr[5]
q_rad[6] = -q_jnt_arr[6]
return q_rad
# meka joint list to KDL joint array (7->7)
# arm - 'left_arm' or 'right_arm'
def meka_angles_to_kdl(self,arm,q_list):
if q_list == None:
return None
n_joints = len(q_list)
q = kdl.JntArray(n_joints)
q[0] = -q_list[0]
q[1] = -q_list[1]
q[2] = -q_list[2]
if n_joints > 3:
q[3] = -q_list[3]
if n_joints == 7:
q[4] = -q_list[4]
q[5] = -q_list[5]
q[6] = -q_list[6]
return q
def create_right_chain(self, end_effector_length):
ch = kdl.Chain()
ch.addSegment(kdl.Segment(kdl.Joint(kdl.Joint.RotY),kdl.Frame(kdl.Vector(0.,-0.18493,0.))))
ch.addSegment(kdl.Segment(kdl.Joint(kdl.Joint.RotX),kdl.Frame(kdl.Vector(0.,-0.03175,0.))))
ch.addSegment(kdl.Segment(kdl.Joint(kdl.Joint.RotZ),kdl.Frame(kdl.Vector(0.00635,0.,-0.27795))))
ch.addSegment(kdl.Segment(kdl.Joint(kdl.Joint.RotY),kdl.Frame(kdl.Vector(0.,0.,-0.27853))))
ch.addSegment(kdl.Segment(kdl.Joint(kdl.Joint.RotZ),kdl.Frame(kdl.Vector(0.,0.,0.))))
ch.addSegment(kdl.Segment(kdl.Joint(kdl.Joint.RotY),kdl.Frame(kdl.Vector(0.,0.,0.))))
ch.addSegment(kdl.Segment(kdl.Joint(kdl.Joint.RotX),kdl.Frame(kdl.Vector(0.,0.,-end_effector_length))))
return ch
def create_left_chain(self, end_effector_length):
ch = kdl.Chain()
ch.addSegment(kdl.Segment(kdl.Joint(kdl.Joint.RotY),kdl.Frame(kdl.Vector(0.,0.18493,0.))))
ch.addSegment(kdl.Segment(kdl.Joint(kdl.Joint.RotX),kdl.Frame(kdl.Vector(0.,0.03175,0.))))
ch.addSegment(kdl.Segment(kdl.Joint(kdl.Joint.RotZ),kdl.Frame(kdl.Vector(0.00635,0.,-0.27795))))
ch.addSegment(kdl.Segment(kdl.Joint(kdl.Joint.RotY),kdl.Frame(kdl.Vector(0.,0.,-0.27853))))
ch.addSegment(kdl.Segment(kdl.Joint(kdl.Joint.RotZ),kdl.Frame(kdl.Vector(0.,0.,0.))))
ch.addSegment(kdl.Segment(kdl.Joint(kdl.Joint.RotY),kdl.Frame(kdl.Vector(0.,0.,0.))))
ch.addSegment(kdl.Segment(kdl.Joint(kdl.Joint.RotX),kdl.Frame(kdl.Vector(0.,0.,-end_effector_length))))
return ch
def create_solvers(self, ch):
fk = kdl.ChainFkSolverPos_recursive(ch)
ik_v = kdl.ChainIkSolverVel_pinv(ch)
ik_p = kdl.ChainIkSolverPos_NR(ch, fk, ik_v)
jac = kdl.ChainJntToJacSolver(ch)
return fk, ik_v, ik_p, jac
def setup_kdl_mekabot(self, end_effector_length):
#right arm
ch = self.create_right_chain(end_effector_length)
fk, ik_v, ik_p, jac = self.create_solvers(ch)
kdl_rightarm = {}
kdl_rightarm['chain'] = ch
kdl_rightarm['nJnts'] = ch.getNrOfJoints()
kdl_rightarm['fk_p'] = fk
kdl_rightarm['ik_v'] = ik_v
kdl_rightarm['ik_p'] = ik_p
kdl_rightarm['jacobian_solver'] = jac
#left arm
kdl_leftarm = {}
ch = self.create_left_chain(end_effector_length)
fk, ik_v, ik_p, jac = self.create_solvers(ch)
kdl_leftarm['chain'] = ch
kdl_leftarm['nJnts'] = ch.getNrOfJoints()
kdl_leftarm['fk_p'] = fk
kdl_leftarm['ik_v'] = ik_v
kdl_leftarm['ik_p'] = ik_p
kdl_leftarm['jacobian_solver'] = jac
#Add both chains to dictionary
self.cody_kdl = {'right_arm':kdl_rightarm,'left_arm':kdl_leftarm}
def FK_kdl(self, arm, q, link_number):
fk_solver = self.cody_kdl[arm]['fk_p']
endeffec_frame = kdl.Frame()
kinematics_status = fk_solver.JntToCart(q, endeffec_frame,
link_number)
if kinematics_status >= 0:
# print 'End effector transformation matrix:', endeffec_frame
return endeffec_frame
else:
print 'Could not compute forward kinematics.'
return None
def Jac_kdl(self,arm,q):
''' returns the Jacobian, given the joint angles
'''
J_kdl = kdl.Jacobian(7)
self.cody_kdl[arm]['jacobian_solver'].JntToJac(q,J_kdl)
kdl_jac = np.matrix([
[J_kdl[0,0],J_kdl[0,1],J_kdl[0,2],J_kdl[0,3],J_kdl[0,4],J_kdl[0,5],J_kdl[0,6]],
[J_kdl[1,0],J_kdl[1,1],J_kdl[1,2],J_kdl[1,3],J_kdl[1,4],J_kdl[1,5],J_kdl[1,6]],
[J_kdl[2,0],J_kdl[2,1],J_kdl[2,2],J_kdl[2,3],J_kdl[2,4],J_kdl[2,5],J_kdl[2,6]],
[J_kdl[3,0],J_kdl[3,1],J_kdl[3,2],J_kdl[3,3],J_kdl[3,4],J_kdl[3,5],J_kdl[3,6]],
[J_kdl[4,0],J_kdl[4,1],J_kdl[4,2],J_kdl[4,3],J_kdl[4,4],J_kdl[4,5],J_kdl[4,6]],
[J_kdl[5,0],J_kdl[5,1],J_kdl[5,2],J_kdl[5,3],J_kdl[5,4],J_kdl[5,5],J_kdl[5,6]],
])
return kdl_jac
def IK_kdl(self,arm,frame, q_init):
''' IK, returns jointArray (None if impossible)
frame - desired frame of the end effector
q_init - initial guess for the joint angles. (JntArray)
'''
nJnts = self.cody_kdl[arm]['nJnts']
ik_solver = self.cody_kdl[arm]['ik_p']
q = kdl.JntArray(nJnts)
if ik_solver.CartToJnt(q_init,frame,q)>=0:
for i in range(nJnts):
q[i] = tr.angle_within_mod180(q[i])
return q
else:
if arm == 'right_arm':
ik_solver = self.cody_kdl[arm]['ik_p_nolim']
if ik_solver.CartToJnt(q_init,frame,q)>=0:
for i in range(nJnts):
q[i] = tr.angle_within_mod180(q[i])
return q
print 'Error: could not calculate inverse kinematics'
return None
def FK_rot(self, arm, q, link_number = 7):
pos, rot = self.FK_all(arm, q, link_number)
return rot
# @param arm - 'left_arm' or 'right_arm'
# @param q - list of 7 joint angles (RADIANs)
# @param link_number - perform FK up to this link. (1-7)
# @return 3x1 numpy matrix
def FK(self, arm, q, link_number = 7):
pos, rot = self.FK_all(arm, q, link_number)
return pos
def FK_all(self, arm, q, link_number = 7):
q = self.meka_angles_to_kdl(arm, q)
frame = self.FK_kdl(arm, q, link_number)
pos = frame.p
pos = ku.kdl_vec_to_np(pos)
m = frame.M
rot = ku.kdl_rot_to_np(m)
return pos, rot
def Jac(self,arm,q):
''' q - list of 7 joint angles (meka axes) in RADIANS.
arm - 'right_arm' or 'left_arm'
returns 6x7 numpy matrix.
'''
jntarr = self.meka_angles_to_kdl(arm,q)
kdl_jac = self.Jac_kdl(arm,jntarr)
meka_jac = -kdl_jac # the kdl jacobian is the negative of meka jacobian (see kdl_angles_to_meka)
return meka_jac
## compute Jacobian at point pos.
# p is in the torso_lift_link coord frame.
def Jacobian(self, arm, q, pos):
chain = self.cody_kdl[arm]['chain']
v_list = []
w_list = []
for i in range(self.n_joints):
p, rot = self.FK_all(arm, q, i)
r = pos - p
z_idx = chain.getSegment(i).getJoint().getType() - 1
z = rot[:, z_idx]
v_list.append(np.matrix(np.cross(z.A1, r.A1)).T)
w_list.append(z)
J = np.row_stack((np.column_stack(v_list), np.column_stack(w_list)))
#J = -J # the kdl jacobian is the negative of meka jacobian (see kdl_angles_to_meka)
J = self.Jac(arm, q)
return J
##
# Inverse Kinematics using KDL.
# @param p - 3X1 numpy matrix.
# @param rot - 3X3 numpy matrix. It transforms a vector in the
# end effector frame to the torso frame. (or it is the orientation
# of the end effector wrt the torso)
# @return list of 7 joint angles, or None if IK soln not found.
def IK(self,arm,p,rot,q_guess=None):
p_kdl = ku.np_vec_to_kdl(p)
rot_kdl = ku.np_rot_to_kdl(rot)
fr = kdl.Frame(rot_kdl,p_kdl)
if q_guess == None:
if arm == 'left_arm':
q_guess = cgd.find_good_config(p,self.q_guess_dict_left)
elif arm == 'right_arm':
q_guess = cgd.find_good_config(p,self.q_guess_dict_right)
q_guess = self.meka_angles_to_kdl(arm,q_guess)
q_res = self.IK_kdl(arm,fr,q_guess)
q_res = self.kdl_angles_to_meka(arm,q_res)
if self.within_joint_limits(arm,q_res):
if arm == 'right_arm':
if q_res[1]<0.:
q_res[1] = math.radians(10.)
qg = self.meka_angles_to_kdl(arm,q_res)
q_res = self.IK_kdl(arm,fr,qg)
q_res = self.kdl_angles_to_meka(arm,q_res)
if self.within_joint_limits(arm,q_res):
return q_res
else:
return None
else:
return q_res
else:
return None
## clamp joint angles to their physical limits.
# @param arm - 'left_arm' or 'right_arm'
# @param q - list of 7 joint angles.
# The joint limits for IK are larger that the physical limits.
def clamp_to_joint_limits(self, arm, q, delta_list=[0.,0.,0.,0.,0.,0.,0.]):
d = self.joint_lim_dict[arm]
max_arr = d['max']
min_arr = d['min']
q_arr = np.array(q)
d_arr = np.array(delta_list)
return np.clip(q_arr, min_arr-d_arr, max_arr+d_arr)
def within_joint_limits(self, arm, q, delta_list=[0.,0.,0.,0.,0.,0.,0.]):
d = self.joint_lim_dict[arm]
max_arr = d['max']
min_arr = d['min']
q_arr = np.array(q)
d_arr = np.array(delta_list)
return np.all((q_arr <= max_arr+d_arr, q_arr >= min_arr-d_arr))
if __name__ == '__main__':
import roslib; roslib.load_manifest('hrl_cody_arms')
import hrl_cody_arms.cody_arm_kinematics as cak
h = M3HrlRobot(0.16)
k = cak.CodyArmKinematics('r')
p = np.matrix([0., 0., -0.16]).T
k.set_tooltip(p)
J_old = h.Jacobian
| [
[
1,
0,
0.0891,
0.0029,
0,
0.66,
0,
526,
0,
1,
0,
0,
526,
0,
0
],
[
1,
0,
0.092,
0.0029,
0,
0.66,
0.0769,
954,
0,
1,
0,
0,
954,
0,
0
],
[
1,
0,
0.0948,
0.0029,
0,
0... | [
"import math",
"import numpy as np",
"import copy",
"import sys, time, os",
"import PyKDL as kdl",
"import create_IK_guess_dict as cgd",
"import roslib; roslib.load_manifest('hrl_cody_arms')",
"import roslib; roslib.load_manifest('hrl_cody_arms')",
"import hrl_lib.transforms as tr",
"import hrl_li... |
#
# subscribe to thw joint angles and raw forces topics, and provide FK
# etc.
#
# Copyright (c) 2009, Georgia Tech Research Corporation
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
# * Neither the name of the Georgia Tech Research Corporation nor the
# names of its contributors may be used to endorse or promote products
# derived from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY GEORGIA TECH RESEARCH CORPORATION ''AS IS'' AND
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL GEORGIA TECH BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
# OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
# OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
# Author: Advait Jain
import math
import numpy as np
import copy
import sys, time, os
from threading import RLock
import roslib; roslib.load_manifest('hrl_cody_arms')
import rospy
import hrl_lib.viz as hv
from hrl_msgs.msg import FloatArray
from std_msgs.msg import Header, Bool, Empty
from std_srvs.srv import Empty as Empty_srv
from visualization_msgs.msg import Marker
# used in client and server.
def get_joint_name_dict():
joint_names_list = {}
joint_names_list['right_arm'] = ['m3joint_ma1_j%d'%i for i in range(7)]
joint_names_list['left_arm'] = ['m3joint_ma2_j%d'%i for i in range(7)]
return joint_names_list
class MekaArmClient():
##
# @param arms: object of the ArmKinematics class.
def __init__(self, arms):
self.cb_lock = RLock()
self.r_arm_jep = None
self.l_arm_jep = None
self.r_arm_alpha = None
self.l_arm_alpha = None
self.r_arm_q = None
self.l_arm_q = None
self.r_arm_force = None
self.r_arm_raw_force = None
self.l_arm_force = None
self.l_arm_raw_force = None
self.pwr_state = False
self.left_arm_ft = {'force': np.matrix(np.zeros((3,1),dtype='float32')),
'torque': np.matrix(np.zeros((3,1),dtype='float32'))}
self.right_arm_ft = {'force': np.matrix(np.zeros((3,1),dtype='float32')),
'torque': np.matrix(np.zeros((3,1),dtype='float32'))}
self.fts_bias = {'left_arm': self.left_arm_ft, 'right_arm': self.right_arm_ft}
self.arms = arms
self.joint_names_list = get_joint_name_dict()
self.r_jep_cmd_pub = rospy.Publisher('/r_arm/command/jep', FloatArray)
self.l_jep_cmd_pub = rospy.Publisher('/l_arm/command/jep', FloatArray)
self.r_alph_cmd_pub = rospy.Publisher('/r_arm/command/joint_impedance_scale', FloatArray)
self.l_alph_cmd_pub = rospy.Publisher('/l_arm/command/joint_impedance_scale', FloatArray)
self.stop_pub = rospy.Publisher('/arms/stop', Empty)
self.motors_off_pub = rospy.Publisher('/arms/command/motors_off', Empty)
self.cep_marker_pub = rospy.Publisher('/arms/viz/cep', Marker)
rospy.Subscriber('/r_arm/jep', FloatArray, self.r_arm_jep_cb)
rospy.Subscriber('/l_arm/jep', FloatArray, self.l_arm_jep_cb)
rospy.Subscriber('/r_arm/joint_impedance_scale', FloatArray, self.r_arm_alpha_cb)
rospy.Subscriber('/l_arm/joint_impedance_scale', FloatArray, self.l_arm_alpha_cb)
rospy.Subscriber('/r_arm/q', FloatArray, self.r_arm_q_cb)
rospy.Subscriber('/l_arm/q', FloatArray, self.l_arm_q_cb)
rospy.Subscriber('/r_arm/force', FloatArray, self.r_arm_force_cb)
rospy.Subscriber('/l_arm/force', FloatArray, self.l_arm_force_cb)
rospy.Subscriber('/r_arm/force_raw', FloatArray, self.r_arm_raw_force_cb)
rospy.Subscriber('/l_arm/force_raw', FloatArray, self.l_arm_raw_force_cb)
rospy.Subscriber('/arms/pwr_state', Bool, self.pwr_state_cb)
rospy.wait_for_service('toggle_floating_arms')
self.toggle_floating_arms = rospy.ServiceProxy('toggle_floating_arms', Empty_srv)
try:
rospy.init_node('cody_arm_client', anonymous=True)
except rospy.ROSException:
pass
#---------- ROS callbacks -----------------
def pwr_state_cb(self, msg):
self.cb_lock.acquire()
self.pwr_state = msg.data
self.cb_lock.release()
def r_arm_jep_cb(self, msg):
self.cb_lock.acquire()
self.r_arm_jep = list(msg.data)
self.cb_lock.release()
# publish the CEP marker.
cep, r = self.arms.FK_all('right_arm', self.r_arm_jep)
o = np.matrix([0.,0.,0.,1.]).T
cep_marker = hv.single_marker(cep, o, 'sphere',
'/torso_lift_link', color=(0., 0., 1., 1.),
scale = (0.02, 0.02, 0.02), duration=0.)
cep_marker.header.stamp = msg.header.stamp
self.cep_marker_pub.publish(cep_marker)
def l_arm_jep_cb(self, msg):
self.cb_lock.acquire()
self.l_arm_jep = list(msg.data)
self.cb_lock.release()
def r_arm_alpha_cb(self, msg):
self.cb_lock.acquire()
self.r_arm_alpha = list(msg.data)
self.cb_lock.release()
def l_arm_alpha_cb(self, msg):
self.cb_lock.acquire()
self.l_arm_alpha = list(msg.data)
self.cb_lock.release()
def r_arm_q_cb(self, msg):
self.cb_lock.acquire()
self.r_arm_q = list(msg.data)
self.cb_lock.release()
def l_arm_q_cb(self, msg):
self.cb_lock.acquire()
self.l_arm_q = list(msg.data)
self.cb_lock.release()
def r_arm_force_cb(self, msg):
self.cb_lock.acquire()
self.r_arm_force = msg.data
self.cb_lock.release()
def l_arm_force_cb(self, msg):
self.cb_lock.acquire()
self.l_arm_force = msg.data
self.cb_lock.release()
def r_arm_raw_force_cb(self, msg):
self.cb_lock.acquire()
self.r_arm_raw_force = msg.data
self.cb_lock.release()
def l_arm_raw_force_cb(self, msg):
self.cb_lock.acquire()
self.l_arm_raw_force = msg.data
self.cb_lock.release()
#--------- functions to use -----------------
## Returns the current position, rotation of the arm.
# @param arm 0 for right, 1 for left
# @return position, rotation
def end_effector_pos(self, arm):
q = self.get_joint_angles(arm)
return self.arms.FK_all(arm, q)
##
# @return list of 7 joint angles.
def get_joint_angles(self, arm):
self.cb_lock.acquire()
if arm == 'right_arm':
q = copy.copy(self.r_arm_q)
elif arm == 'left_arm':
q = copy.copy(self.l_arm_q)
else:
self.cb_lock.release()
raise RuntimeError('Undefined arm: %s'%(arm))
self.cb_lock.release()
return q
def get_wrist_force(self, arm, bias=True, base_frame=False,
filtered = True):
self.cb_lock.acquire()
if arm == 'right_arm':
if filtered:
f = copy.copy(self.r_arm_force)
else:
f = copy.copy(self.r_arm_raw_force)
elif arm == 'left_arm':
if filtered:
f = copy.copy(self.l_arm_force)
else:
f = copy.copy(self.l_arm_raw_force)
else:
self.cb_lock.release()
raise RuntimeError('Undefined arm: %s'%(arm))
self.cb_lock.release()
f_mat = np.matrix(f).T
if bias:
f_mat = f_mat - self.fts_bias[arm]['force']
if base_frame:
q = self.get_joint_angles(arm)
rot = self.arms.FK_rot(arm, q)
f_mat = rot*f_mat
return f_mat
def bias_wrist_ft(self, arm):
f_list = []
t_list = []
print 'Starting biasing...'
for i in range(20):
f_list.append(self.get_wrist_force(arm, bias=False))
rospy.sleep(0.02)
f_b = np.mean(np.column_stack(f_list), 1)
# torque is unimplemented.
t_b = self.get_wrist_torque(arm, bias=False)
self.fts_bias[arm]['force'] = f_b
self.fts_bias[arm]['torque'] = t_b
print 'self.fts_bias[arm][\'force\']', self.fts_bias[arm]['force']
print 'arm:', arm
print '...done'
##
# @return list of floats b/w 0 and 1.
def get_impedance_scale(self, arm):
self.cb_lock.acquire()
if arm == 'right_arm':
sc = copy.copy(self.r_arm_alpha)
elif arm == 'left_arm':
sc = copy.copy(self.l_arm_alpha)
else:
self.cb_lock.release()
raise RuntimeError('Undefined arm: %s'%(arm))
self.cb_lock.release()
return sc
##
# @param s - list of floats b/w 0 and 1.
def set_impedance_scale(self, arm, s):
if arm == 'right_arm':
pub = self.r_alph_cmd_pub
elif arm == 'left_arm':
pub = self.l_alph_cmd_pub
else:
raise RuntimeError('Undefined arm: %s'%(arm))
time_stamp = rospy.Time.now()
h = Header()
h.stamp = time_stamp
pub.publish(FloatArray(h, s))
def get_jep(self, arm):
self.cb_lock.acquire()
if arm == 'right_arm':
jep = copy.copy(self.r_arm_jep)
elif arm == 'left_arm':
jep = copy.copy(self.l_arm_jep)
else:
self.cb_lock.release()
raise RuntimeError('Undefined arm: %s'%(arm))
self.cb_lock.release()
return jep
##
# @param q - list of 7 joint angles in RADIANS. according to meka's coordinate frames.
# @param duration - for compatibility with the PR2 class.
def set_jep(self, arm, q, duration=None):
if arm == 'right_arm':
pub = self.r_jep_cmd_pub
elif arm == 'left_arm':
pub = self.l_jep_cmd_pub
else:
raise RuntimeError('Undefined arm: %s'%(arm))
time_stamp = rospy.Time.now()
h = Header()
h.stamp = time_stamp
pub.publish(FloatArray(h, q))
##
#Function that commands the arm(s) to incrementally move to a jep
#@param speed the max angular speed (in radians per second)
#@return 'reach'
def go_jep(self, arm, q, stopping_function=None, speed=math.radians(30)):
if speed>math.radians(90.):
speed = math.radians(90.)
qs_list,qe_list,ns_list,qstep_list = [],[],[],[]
done_list = []
time_between_cmds = 0.025
#qs = np.matrix(self.get_joint_angles(arm))
qs = np.matrix(self.get_jep(arm))
qe = np.matrix(q)
max_change = np.max(np.abs(qe-qs))
total_time = max_change/speed
n_steps = int(total_time/time_between_cmds+0.5)
qstep = (qe-qs)/n_steps
if stopping_function != None:
done = stopping_function()
else:
done = False
step_number = 0
t0 = rospy.Time.now().to_time()
t_end = t0
while done==False:
t_end += time_between_cmds
t1 = rospy.Time.now().to_time()
if stopping_function != None:
done = stopping_function()
if step_number < n_steps and done == False:
q = (qs + step_number*qstep).A1.tolist()
self.set_jep(arm, q)
else:
done = True
while t1 < t_end:
if stopping_function != None:
done = done or stopping_function()
rospy.sleep(time_between_cmds/5)
t1 = rospy.Time.now().to_time()
step_number += 1
rospy.sleep(time_between_cmds)
return 'reach'
# Expect this to crash the program because sending a stop crashes
# the meka server
def stop(self):
self.stop_pub.publish()
def is_motor_power_on(self):
return self.pwr_state
def go_cep(self, arm, p, rot, speed = 0.10,
stopping_function = None, q_guess = None):
q = self.arms.IK(arm, p, rot, q_guess)
if q == None:
print 'IK soln NOT found.'
print 'trying to reach p= ', p
return 'fail'
else:
q_start = np.matrix(self.get_joint_angles(arm))
p_start = self.arms.FK(arm, q_start.A1.tolist())
q_end = np.matrix(q)
dist = np.linalg.norm(p-p_start)
total_time = dist/speed
max_change = np.max(np.abs(q_end-q_start))
ang_speed = max_change/total_time
return self.go_jep(arm, q, stopping_function, speed=ang_speed)
##
# linearly interpolates the commanded cep.
# @param arm - 'left_arm' or 'right_arm'
# @param p - 3x1 np matrix
# @param rot - rotation matrix
# @param speed - linear speed (m/s)
# @param stopping_function - returns True or False
# @return string (reason for stopping)
def go_cep_interpolate(self, arm, p, rot=None, speed=0.10,
stopping_function=None):
rot = None # Rotational interpolation not implemented right now.
time_between_cmds = 0.025
q_guess = self.get_jep(arm)
cep = self.arms.FK(arm, q_guess)
if rot == None:
rot = self.arms.FK_rot(arm, q_guess)
vec = p-cep
dist = np.linalg.norm(vec)
total_time = dist/speed
n_steps = int(total_time/time_between_cmds + 0.5)
vec = vec/dist
vec = vec * speed * time_between_cmds
pt = cep
all_done = False
i = 0
t0 = rospy.Time.now().to_time()
t_end = t0
while all_done==False:
t_end += time_between_cmds
t1 = rospy.Time.now().to_time()
pt = pt + vec
q = self.arms.IK(arm, pt, rot, q_guess)
if q == None:
all_done = True
stop = 'IK fail'
continue
self.set_jep(arm, q)
q_guess = q
while t1<t_end:
if stopping_function != None:
all_done = stopping_function()
if all_done:
stop = 'Stopping Condition'
break
rospy.sleep(time_between_cmds/5)
t1 = rospy.Time.now().to_time()
i+=1
if i == n_steps:
all_done = True
stop = ''
return stop
##
# @param vec - displacement vector (base frame)
# @param q_guess - previous JEP?
# @return string
def move_till_hit(self, arm, vec=np.matrix([0.3,0.,0.]).T, force_threshold=3.0,
speed=0.1, bias_FT=True):
unit_vec = vec/np.linalg.norm(vec)
def stopping_function():
force = self.get_wrist_force(arm, base_frame = True)
force_projection = force.T*unit_vec *-1 # projection in direction opposite to motion.
if force_projection>force_threshold:
return True
elif np.linalg.norm(force)>45.:
return True
else:
return False
jep = self.get_jep(arm)
cep, rot = self.arms.FK_all(arm, jep)
if bias_FT:
self.bias_wrist_ft(arm)
time.sleep(0.5)
p = cep + vec
return self.go_cep_interpolate(arm, p, rot, speed,
stopping_function)
def motors_off(self):
self.motors_off_pub.publish()
# def step(self):
# rospy.sleep(0.01)
#-------- unimplemented functions -----------------
# leaving this unimplemented for now. Advait Nov 14, 2010.
def get_joint_velocities(self, arm):
pass
# leaving this unimplemented for now. Advait Nov 14, 2010.
def get_joint_accelerations(self, arm):
pass
# leaving this unimplemented for now. Advait Nov 14, 2010.
def get_joint_torques(self, arm):
pass
# leaving this unimplemented for now. Advait Nov 14, 2010.
def get_wrist_torque(self, arm, bias=True):
pass
# leaving this unimplemented for now. Advait Nov 14, 2010.
def power_on(self):
pass
# leaving this unimplemented for now. Advait Nov 14, 2010.
# something to change and get arm_settings.
if __name__ == '__main__':
import arms as ar
import m3.toolbox as m3t
import hrl_lib.transforms as tr
r_arm = 'right_arm'
l_arm = 'left_arm'
arms = ar.M3HrlRobot(0.16)
ac = MekaArmClient(arms)
# print FT sensor readings.
if False:
ac.bias_wrist_ft(r_arm)
while not rospy.is_shutdown():
f = ac.get_wrist_force(r_arm)
print 'f:', f.A1
rospy.sleep(0.05)
# move the arms.
if False:
print 'hit a key to move the arms.'
k=m3t.get_keystroke()
rot_mat = tr.rotY(math.radians(-90))
p = np.matrix([0.3, -0.24, -0.3]).T
# q = arms.IK(l_arm, p, rot_mat)
# ac.go_jep(l_arm, q)
# ac.go_cep(l_arm, p, rot_mat)
ac.go_cep(r_arm, p, rot_mat)
# jep = ac.get_jep(r_arm)
# ac.go_jep(r_arm, jep)
rospy.sleep(0.5)
raw_input('Hit ENTER to print ee position')
q = ac.get_joint_angles(r_arm)
ee = ac.arms.FK(r_arm, q)
print 'ee:', ee.A1
print 'desired ee:', p.A1
if False:
print 'hit a key to float arms.'
k=m3t.get_keystroke()
ac.toggle_floating_arms()
print 'hit a key to UNfloat arms.'
k=m3t.get_keystroke()
ac.toggle_floating_arms()
#ac.move_till_hit(l_arm)
#ac.motors_off()
# ac.stop()
if False:
while not rospy.is_shutdown():
jep = ac.get_jep(r_arm)
print 'jep:', jep
rospy.sleep(0.05)
if True:
rospy.sleep(1.)
isc = ac.get_impedance_scale(r_arm)
print isc
isc[1] = 0.3
ac.set_impedance_scale(r_arm, isc)
rospy.sleep(1.)
isc = ac.get_impedance_scale(r_arm)
print isc
| [
[
1,
0,
0.0574,
0.0017,
0,
0.66,
0,
526,
0,
1,
0,
0,
526,
0,
0
],
[
1,
0,
0.0591,
0.0017,
0,
0.66,
0.0667,
954,
0,
1,
0,
0,
954,
0,
0
],
[
1,
0,
0.0609,
0.0017,
0,
... | [
"import math",
"import numpy as np",
"import copy",
"import sys, time, os",
"from threading import RLock",
"import roslib; roslib.load_manifest('hrl_cody_arms')",
"import roslib; roslib.load_manifest('hrl_cody_arms')",
"import rospy",
"import hrl_lib.viz as hv",
"from hrl_msgs.msg import FloatArra... |
#
# Copyright (c) 2009, Georgia Tech Research Corporation
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
# * Neither the name of the Georgia Tech Research Corporation nor the
# names of its contributors may be used to endorse or promote products
# derived from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY GEORGIA TECH RESEARCH CORPORATION ''AS IS'' AND
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL GEORGIA TECH BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
# OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
# OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
# Author: Advait Jain
import numpy as np, math
#np.set_printoptions(precision=4, linewidth=80)
import matplotlib.pyplot as pp
import roslib; roslib.load_manifest('hrl_cody_arms')
import PyKDL as kdl
from equilibrium_point_control.hrl_arm import HRLArmKinematics
import create_IK_guess_dict as cgd
import hrl_lib.transforms as tr
import hrl_lib.util as ut
import hrl_lib.kdl_utils as ku
class CodyArmKinematics(HRLArmKinematics):
# arm - 'r' or 'l'
def __init__(self, arm):
HRLArmKinematics.__init__(self, n_jts = 7)
# create joint limit dicts
if arm == 'r':
max_lim = np.radians([ 120.00, 122.15, 77.5, 144., 122., 45., 45.])
min_lim = np.radians([ -47.61, -20., -77.5, 0., -80., -45., -45.])
else:
max_lim = np.radians([ 120.00, 20., 77.5, 144., 80., 45., 45.])
min_lim = np.radians([ -47.61, -122.15, -77.5, 0., -122., -45., -45.])
self.joint_lim_dict = {}
self.joint_lim_dict['max'] = max_lim
self.joint_lim_dict['min'] = min_lim
wrist_stub_length = 0.0135 + 0.04318 # wrist linkange and FT sensor lengths
self.setup_kdl_chains(arm, wrist_stub_length)
if arm == 'r':
pkl_nm = 'q_guess_right_dict.pkl'
else:
pkl_nm = 'q_guess_left_dict.pkl'
# Seems to pre-load the seed start values for IK. Set to none for the moment.
pth = roslib.packages.get_pkg_dir('hrl_cody_arms') #roslib.rospack.rospackexec(['find', 'hrl_cody_arms'])
q_guess_pkl = pth + '/src/hrl_cody_arms/'+pkl_nm
self.q_guess_dict = None #ut.load_pickle(q_guess_pkl)
self.arm_type = 'real' # for epc_skin_math
#--------------- KDL stuff ----------------
# KDL joint array to meka joint list. (7->7)
def kdl_angles_to_meka(self, q_jnt_arr):
if q_jnt_arr == None:
return None
q_rad = [0. for i in range(7)]
q_rad[0] = -q_jnt_arr[0]
q_rad[1] = -q_jnt_arr[1]
q_rad[2] = -q_jnt_arr[2]
q_rad[3] = -q_jnt_arr[3]
q_rad[4] = -q_jnt_arr[4]
q_rad[5] = -q_jnt_arr[5]
q_rad[6] = -q_jnt_arr[6]
return q_rad
# meka joint list to KDL joint array (7->7)
def meka_angles_to_kdl(self, q_list):
if q_list == None:
return None
n_joints = len(q_list)
q = kdl.JntArray(n_joints)
q[0] = -q_list[0]
q[1] = -q_list[1]
q[2] = -q_list[2]
q[3] = -q_list[3]
q[4] = -q_list[4]
q[5] = -q_list[5]
q[6] = -q_list[6]
return q
def create_right_chain(self, end_effector_length):
ch = kdl.Chain()
ch.addSegment(kdl.Segment(kdl.Joint(kdl.Joint.RotY),kdl.Frame(kdl.Vector(0.,-0.18493,0.))))
ch.addSegment(kdl.Segment(kdl.Joint(kdl.Joint.RotX),kdl.Frame(kdl.Vector(0.,-0.03175,0.))))
ch.addSegment(kdl.Segment(kdl.Joint(kdl.Joint.RotZ),kdl.Frame(kdl.Vector(0.00635,0.,-0.27795))))
ch.addSegment(kdl.Segment(kdl.Joint(kdl.Joint.RotY),kdl.Frame(kdl.Vector(0.,0.,-0.27853))))
ch.addSegment(kdl.Segment(kdl.Joint(kdl.Joint.RotZ),kdl.Frame(kdl.Vector(0.,0.,0.))))
ch.addSegment(kdl.Segment(kdl.Joint(kdl.Joint.RotY),kdl.Frame(kdl.Vector(0.,0.,0.))))
ch.addSegment(kdl.Segment(kdl.Joint(kdl.Joint.RotX),kdl.Frame(kdl.Vector(0.,0.,-end_effector_length))))
return ch
def create_left_chain(self, end_effector_length):
ch = kdl.Chain()
ch.addSegment(kdl.Segment(kdl.Joint(kdl.Joint.RotY),kdl.Frame(kdl.Vector(0.,0.18493,0.))))
ch.addSegment(kdl.Segment(kdl.Joint(kdl.Joint.RotX),kdl.Frame(kdl.Vector(0.,0.03175,0.))))
ch.addSegment(kdl.Segment(kdl.Joint(kdl.Joint.RotZ),kdl.Frame(kdl.Vector(0.00635,0.,-0.27795))))
ch.addSegment(kdl.Segment(kdl.Joint(kdl.Joint.RotY),kdl.Frame(kdl.Vector(0.,0.,-0.27853))))
ch.addSegment(kdl.Segment(kdl.Joint(kdl.Joint.RotZ),kdl.Frame(kdl.Vector(0.,0.,0.))))
ch.addSegment(kdl.Segment(kdl.Joint(kdl.Joint.RotY),kdl.Frame(kdl.Vector(0.,0.,0.))))
ch.addSegment(kdl.Segment(kdl.Joint(kdl.Joint.RotX),kdl.Frame(kdl.Vector(0.,0.,-end_effector_length))))
return ch
def create_solvers(self, ch):
fk = kdl.ChainFkSolverPos_recursive(ch)
ik_v = kdl.ChainIkSolverVel_pinv(ch)
ik_p = kdl.ChainIkSolverPos_NR(ch, fk, ik_v)
jac = kdl.ChainJntToJacSolver(ch)
return fk, ik_v, ik_p, jac
def setup_kdl_chains(self, arm, end_effector_length):
if arm == 'r':
#right arm
ch = self.create_right_chain(end_effector_length)
fk, ik_v, ik_p, jac = self.create_solvers(ch)
else:
#left arm
ch = self.create_left_chain(end_effector_length)
fk, ik_v, ik_p, jac = self.create_solvers(ch)
kdl_chains = {}
kdl_chains['chain'] = ch
kdl_chains['nJnts'] = ch.getNrOfJoints()
kdl_chains['fk_p'] = fk
kdl_chains['ik_v'] = ik_v
kdl_chains['ik_p'] = ik_p
kdl_chains['jacobian_solver'] = jac
#Add both chains to dictionary
self.kdl_chains = kdl_chains
def FK_kdl(self, q, link_number):
fk_solver = self.kdl_chains['fk_p']
endeffec_frame = kdl.Frame()
kinematics_status = fk_solver.JntToCart(q, endeffec_frame,
link_number)
if kinematics_status >= 0:
# print 'End effector transformation matrix:', endeffec_frame
return endeffec_frame
else:
print 'Could not compute forward kinematics.'
return None
def IK_kdl(self,frame, q_init):
nJnts = self.kdl_chains['nJnts']
ik_solver = self.kdl_chains['ik_p']
q = kdl.JntArray(nJnts)
if ik_solver.CartToJnt(q_init,frame,q)>=0:
for i in range(nJnts):
q[i] = tr.angle_within_mod180(q[i])
return q
else:
return None
#-------------- implementation of HRLArmKinematics -----------
def FK_vanilla(self, q, link_number = 7):
q = self.meka_angles_to_kdl(q)
frame = self.FK_kdl(q, link_number)
pos = frame.p
pos = ku.kdl_vec_to_np(pos)
m = frame.M
rot = ku.kdl_rot_to_np(m)
return pos, rot
## compute Jacobian at point pos.
# p is in the ground coord frame.
# this is a wrapper to try and not
# break things after changes to PR2
# classes
def jacobian(self, q, pos=None):
return self.Jacobian(q, pos)
## compute Jacobian at point pos.
# p is in the ground coord frame.
def Jacobian(self, q, pos=None):
if pos == None:
pos = self.FK(q)[0]
ch = self.kdl_chains['chain']
v_list = []
w_list = []
for i in xrange(self.n_jts):
p, rot = self.FK_vanilla(q, i)
r = pos - p
z_idx = ch.getSegment(i).getJoint().getType() - 1
z = rot[:, z_idx]
# this is a nasty trick. The rotation matrix returned by
# FK_vanilla describes the orientation of a frame of the
# KDL chain in the base frame. It just so happens that the
# way Advait defined the KDL chain, the axis of rotation
# in KDL is the -ve of the axis of rotation on the real
# robot for every joint.
# Advait apologizes for this.
z = -z
v_list.append(np.matrix(np.cross(z.A1, r.A1)).T)
w_list.append(z)
J = np.row_stack((np.column_stack(v_list), np.column_stack(w_list)))
return J
def IK_vanilla(self, p, rot, q_guess=None):
p_kdl = ku.np_vec_to_kdl(p)
rot_kdl = ku.np_rot_to_kdl(rot)
fr = kdl.Frame(rot_kdl, p_kdl)
if q_guess == None:
q_guess = cgd.find_good_config(p, self.q_guess_dict)
q_guess = self.meka_angles_to_kdl(q_guess)
q_res = self.IK_kdl(arm, fr, q_guess)
q_res = self.kdl_angles_to_meka(arm, q_res)
return q_res
#----------- extra functions -----------------
## clamp joint angles to their physical limits.
# @param q - list of 7 joint angles.
# The joint limits for IK are larger that the physical limits.
def clamp_to_joint_limits(self, q, delta_list=[0.,0.,0.,0.,0.,0.,0.]):
min_arr, max_arr = self.get_joint_limits()
q_arr = np.array(q)
d_arr = np.array(delta_list)
return np.clip(q_arr, min_arr-d_arr, max_arr+d_arr)
def within_joint_limits(self, q, delta_list=[0.,0.,0.,0.,0.,0.,0.]):
min_arr, max_arr = self.get_joint_limits()
q_arr = np.array(q)
d_arr = np.array(delta_list)
return np.all((q_arr <= max_arr+d_arr, q_arr >= min_arr-d_arr))
def get_joint_limits(self):
return self.joint_lim_dict['min'], self.joint_lim_dict['max']
#------------ 2D functions ------------
# plot the arm using matplotlib.
def plot_arm(self, q, color='b', alpha=1.):
pts = [[0.,0.,0.]]
for i in range(len(q)):
p = self.FK(q, i+1)[0]
pts.append(p.A1.tolist())
pts_2d = np.array(pts)[:,0:2]
direc_list = (pts_2d[1:] - pts_2d[:-1]).tolist()
for i, d in enumerate(direc_list):
d_vec = np.matrix(d).T
d_vec = d_vec / np.linalg.norm(d_vec)
w = np.cross(d_vec.A1, np.array([0., 0., 1.])) * 0.03/2
x1 = pts_2d[i,0]
y1 = pts_2d[i,1]
x2 = pts_2d[i+1,0]
y2 = pts_2d[i+1,1]
x_data = [x1+w[0], x1-w[0], x2-w[0], x2+w[0], x1+w[0]]
y_data = [y1+w[1], y1-w[1], y2-w[1], y2+w[1], y1+w[1]]
l, = pp.plot(x_data, y_data, color+'-', alpha=alpha)
| [
[
1,
0,
0.1037,
0.0033,
0,
0.66,
0,
954,
0,
2,
0,
0,
954,
0,
0
],
[
1,
0,
0.1137,
0.0033,
0,
0.66,
0.1,
596,
0,
1,
0,
0,
596,
0,
0
],
[
1,
0,
0.1204,
0.0033,
0,
0.6... | [
"import numpy as np, math",
"import matplotlib.pyplot as pp",
"import roslib; roslib.load_manifest('hrl_cody_arms')",
"import roslib; roslib.load_manifest('hrl_cody_arms')",
"import PyKDL as kdl",
"from equilibrium_point_control.hrl_arm import HRLArmKinematics",
"import create_IK_guess_dict as cgd",
"... |
#!/usr/bin/python
#
# Copyright (c) 2009, Georgia Tech Research Corporation
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
# * Neither the name of the Georgia Tech Research Corporation nor the
# names of its contributors may be used to endorse or promote products
# derived from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY GEORGIA TECH RESEARCH CORPORATION ''AS IS'' AND
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL GEORGIA TECH BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
# OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
# OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
# Author: Advait Jain
# moved this to the top to get PyKDL from the ROS package for the Meka
# modules as well.
import roslib; roslib.load_manifest('hrl_cody_arms')
roslib.load_manifest('force_torque') # Advait hack on Oct 25, 2011
import force_torque.FTClient as ftc
import m3.rt_proxy as m3p
import m3.arm
import m3.toolbox as m3t
import m3.pwr as m3w
import m3.loadx6
import m3.component_factory as m3f
import cody_arm_client as ac
import numpy as np, math
import sys, time, os
import copy
from threading import RLock
import rospy
import hrl_lib.transforms as tr
from hrl_msgs.msg import FloatArray
from std_msgs.msg import Header, Bool, Empty
from sensor_msgs.msg import JointState
THETA_GC = 5
TORQUE_GC = 4
THETA = 3
OFF = 0 # in OFF mode also, the behavior is strange. Not the same as hitting the estop (Advait, Jan 1 2010)
## 1D kalman filter update.
def kalman_update(xhat, P, Q, R, z):
#time update
xhatminus = xhat
Pminus = P + Q
#measurement update
K = Pminus / (Pminus + R)
xhat = xhatminus + K * (z-xhatminus)
P = (1-K) * Pminus
return xhat, P
class MekaArmSettings():
def __init__(self, stiffness_list=[0.7,0.7,0.8,0.8,0.3],
control_mode='theta_gc'):
''' stiffness_list: list of 5 stiffness values for joints 0-4.
control_mode: 'theta_gc' or 'torque_gc'
'''
self.set_stiffness_scale(stiffness_list)
self.control_mode = control_mode
def set_stiffness_scale(self, l):
# for safety of wrist roll. Advait Jun 18, 2010.
# changed to 0.2 from 0.3 (Advait, Sept 19, 2010)
l[4] = min(l[4], 0.2)
self.stiffness_list = l
class MekaArmServer():
def __init__(self, right_arm_settings=None,
left_arm_settings=None, use_netft_r = False,
use_netft_l = False, enable_right_arm=True,
enable_left_arm=True):
self.arm_settings = {} # dict is set in set_arm_settings
self.left_arm_ft = {'force': np.matrix(np.zeros((3,1),dtype='float32')),
'torque': np.matrix(np.zeros((3,1),dtype='float32'))}
self.right_arm_ft = {'force': np.matrix(np.zeros((3,1),dtype='float32')),
'torque': np.matrix(np.zeros((3,1),dtype='float32'))}
# kalman filtering force vector. (self.step and bias_wrist_ft)
self.Q_force, self.R_force = {}, {}
self.xhat_force, self.P_force = {}, {}
self.Q_force['right_arm'] = [1e-3, 1e-3, 1e-3, 1e-3, 1e-3, 1e-3]
self.R_force['right_arm'] = [0.1**2, 0.1**2, 0.1**2, 0.05**2, 0.05**2, 0.05**2]
self.xhat_force['right_arm'] = [0., 0., 0., 0., 0., 0.]
self.P_force['right_arm'] = [1.0, 1.0, 1.0, 0., 0., 0.]
self.Q_force['left_arm'] = [1e-3, 1e-3, 1e-3, 1e-3, 1e-3, 1e-3]
self.R_force['left_arm'] = [0.1**2, 0.1**2, 0.1**2, 0.05**2, 0.05**2, 0.05**2]
self.xhat_force['left_arm'] = [0., 0., 0., 0., 0., 0.]
self.P_force['left_arm'] = [1.0, 1.0, 1.0, 0., 0., 0.]
self.enable_left_arm = enable_left_arm
self.enable_right_arm = enable_right_arm
if not enable_right_arm:
right_arm_settings = None
self.right_arm_ft = None
self.Q_force['right_arm'] = None
self.R_force['right_arm'] = None
self.P_force['right_arm'] = None
self.xhat_force['right_arm'] = None
if not enable_left_arm:
left_arm_settings = None
self.left_arm_ft = None
self.Q_force['left_arm'] = None
self.R_force['left_arm'] = None
self.P_force['left_arm'] = None
self.xhat_force['left_arm'] = None
self.initialize_joints(right_arm_settings, left_arm_settings)
#self.initialize_gripper()
#----- ROS interface ---------
rospy.init_node('arm_server', anonymous=False)
if use_netft_r:
self.ftclient_r = ftc.FTClient('force_torque_ft5', True)
self.ftclient_r.bias()
else:
self.ftclient_r = None
if use_netft_l:
self.ftclient_l = ftc.FTClient('force_torque_ft6', True)
self.ftclient_l.bias()
else:
self.ftclient_l = None
self.q_r_pub = rospy.Publisher('/r_arm/q', FloatArray)
self.q_l_pub = rospy.Publisher('/l_arm/q', FloatArray)
self.qdot_r_pub = rospy.Publisher('/r_arm/qdot', FloatArray)
self.qdot_l_pub = rospy.Publisher('/l_arm/qdot', FloatArray)
self.force_raw_r_pub = rospy.Publisher('/r_arm/force_raw', FloatArray)
self.force_raw_l_pub = rospy.Publisher('/l_arm/force_raw', FloatArray)
self.force_r_pub = rospy.Publisher('/r_arm/force', FloatArray)
self.force_l_pub = rospy.Publisher('/l_arm/force', FloatArray)
self.jep_r_pub = rospy.Publisher('/r_arm/jep', FloatArray)
self.jep_l_pub = rospy.Publisher('/l_arm/jep', FloatArray)
self.alph_r_pub = rospy.Publisher('/r_arm/joint_impedance_scale', FloatArray)
self.alph_l_pub = rospy.Publisher('/l_arm/joint_impedance_scale', FloatArray)
self.torque_r_pub = rospy.Publisher('/r_arm/joint_torque', FloatArray)
self.torque_l_pub = rospy.Publisher('/l_arm/joint_torque', FloatArray)
self.mot_temp_r_pub = rospy.Publisher('/r_arm/joint_motor_temp', FloatArray)
self.mot_temp_l_pub = rospy.Publisher('/l_arm/joint_motor_temp', FloatArray)
self.pwr_state_pub = rospy.Publisher('/arms/pwr_state', Bool)
self.joint_state_pub = rospy.Publisher('/joint_states', JointState)
rospy.Subscriber('/r_arm/command/jep', FloatArray, self.r_jep_cb)
rospy.Subscriber('/l_arm/command/jep', FloatArray, self.l_jep_cb)
rospy.Subscriber('/r_arm/command/joint_impedance_scale', FloatArray, self.r_alpha_cb)
rospy.Subscriber('/l_arm/command/joint_impedance_scale', FloatArray, self.l_alpha_cb)
# publishing to this message will stop the arms but also crash
# the server (since meka server crashes.) Advait Nov 14, 2010
rospy.Subscriber('/arms/stop', Empty, self.stop)
rospy.Subscriber('/arms/command/motors_off', Empty,
self.motors_off)
self.cb_lock = RLock()
self.r_jep = None # see set_jep
self.l_jep = None # see set_jep
self.q_r = None # using this to compute qdot
self.q_l = None # using this to compute qdot
self.q_rHOT = None # using this to compute qdot # added_by_tapo, Jan 23-2013
self.q_lHOT = None # using this to compute qdot # added_by_tapo, Jan 23-2013
self.time_stamp = None # using this to compute qdot
d = {}
d['right_arm'] = ac.get_joint_name_list('r')
d['left_arm'] = ac.get_joint_name_list('l')
self.joint_names_list = d
def set_arm_settings(self,right_arm_settings,left_arm_settings):
self.arm_settings['right_arm'] = right_arm_settings
self.arm_settings['left_arm'] = left_arm_settings
for arm,arm_settings in zip(['right_arm','left_arm'],[right_arm_settings,left_arm_settings]):
joint_component_list = self.joint_list_dict[arm]
# OFF mode doesn't seem to work. (Advait, Jan 1 2010)
if arm_settings == None:
if joint_component_list != None:
for c in joint_component_list:
c.set_control_mode(OFF)
continue
stiffness_list = arm_settings.stiffness_list
if arm_settings.control_mode == 'torque_gc':
print 'setting control mode to torque_gc'
for c in joint_component_list:
c.set_control_mode(TORQUE_GC)
c.set_torque_mNm(0.0)
elif arm_settings.control_mode == 'theta_gc':
print 'setting control mode to theta_gc'
for i in range(5):
joint_component_list[i].set_control_mode(THETA_GC)
joint_component_list[i].set_stiffness(stiffness_list[i])
joint_component_list[i].set_slew_rate_proportion(1.)
joint_component_list[5].set_control_mode(THETA)
joint_component_list[5].set_slew_rate_proportion(1.)
joint_component_list[6].set_control_mode(THETA)
joint_component_list[6].set_slew_rate_proportion(1.)
elif arm_settings.control_mode == 'wrist_theta_gc':
print 'setting control mode to theta_gc include wrist joints'
for i in range(7):
joint_component_list[i].set_control_mode(THETA_GC)
joint_component_list[i].set_stiffness(stiffness_list[i])
joint_component_list[i].set_slew_rate_proportion(1.)
else:
print 'hrl_robot.initialize_joints. unknown control mode for ', arm,':', arm_settings.control_mode
# put a few things into safeop so that individual joint
# components work.
def safeop_things(self):
robot_name = 'm3humanoid_bimanual_mr1'
chain_names = ['m3arm_ma1', 'm3arm_ma2']
dynamatics_nms = ['m3dynamatics_ma1', 'm3dynamatics_ma2']
self.proxy.make_safe_operational(robot_name)
for c in chain_names:
self.proxy.make_safe_operational(c)
for d in dynamatics_nms:
self.proxy.make_safe_operational(d)
def initialize_joints(self, right_arm_settings, left_arm_settings):
self.proxy = m3p.M3RtProxy()
self.proxy.start(True, True) # the second true enables ROS (needed for the skin patch)
l1 = ['m3pwr_pwr003']
if self.enable_right_arm:
l1.append('m3loadx6_ma1_l0')
l1.append('m3arm_ma1')
if left_arm_settings is not None:
l1.append('m3loadx6_ma2_l0')
l1.append('m3arm_ma2')
for c in l1:
if not self.proxy.is_component_available(c):
raise m3t.M3Exception('Component '+c+' is not available.')
self.joint_list_dict = {}
if self.enable_right_arm:
right_l = []
for c in ['m3joint_ma1_j0','m3joint_ma1_j1','m3joint_ma1_j2',
'm3joint_ma1_j3','m3joint_ma1_j4','m3joint_ma1_j5',
'm3joint_ma1_j6']:
if not self.proxy.is_component_available(c):
raise m3t.M3Exception('Component '+c+' is not available.')
right_l.append(m3f.create_component(c))
self.joint_list_dict['right_arm'] = right_l
else:
self.joint_list_dict['right_arm'] = None
if self.enable_left_arm:
left_l = []
for c in ['m3joint_ma2_j0','m3joint_ma2_j1','m3joint_ma2_j2',
'm3joint_ma2_j3','m3joint_ma2_j4','m3joint_ma2_j5',
'm3joint_ma2_j6']:
if not self.proxy.is_component_available(c):
raise m3t.M3Exception('Component '+c+' is not available.')
left_l.append(m3f.create_component(c))
self.joint_list_dict['left_arm'] = left_l
else:
self.joint_list_dict['left_arm'] = None
for arm,arm_settings in zip(['right_arm','left_arm'],[right_arm_settings,left_arm_settings]):
if arm_settings == None:
continue
for comp in self.joint_list_dict[arm]:
self.proxy.subscribe_status(comp)
self.proxy.publish_command(comp)
self.set_arm_settings(right_arm_settings,left_arm_settings)
self.pwr=m3f.create_component('m3pwr_pwr003')
self.proxy.subscribe_status(self.pwr)
self.proxy.publish_command(self.pwr)
self.arms = {}
if self.enable_right_arm:
right_fts=m3.loadx6.M3LoadX6('m3loadx6_ma1_l0')
self.proxy.subscribe_status(right_fts)
self.arms['right_arm']=m3.arm.M3Arm('m3arm_ma1')
self.proxy.subscribe_status(self.arms['right_arm'])
else:
right_fts = None
self.arms['right_arm'] = None
if self.enable_left_arm:
left_fts=m3.loadx6.M3LoadX6('m3loadx6_ma2_l0')
self.proxy.subscribe_status(left_fts)
self.arms['left_arm']=m3.arm.M3Arm('m3arm_ma2')
self.proxy.subscribe_status(self.arms['left_arm'])
else:
left_fts = None
self.arms['left_arm'] = None
self.fts = {'right_arm':right_fts,'left_arm':left_fts}
self.proxy.step()
self.proxy.step()
def initialize_gripper(self):
#self.right_gripper = m3h.M3Gripper('m3gripper_mg0')
self.right_gripper = m3h.M3Gripper('m3gripper_mg1')
self.proxy.publish_command(self.right_gripper)
self.proxy.subscribe_status(self.right_gripper)
def step(self):
self.proxy.step()
l = []
if self.enable_right_arm:
l.append('right_arm')
if self.enable_left_arm:
l.append('left_arm')
for arm in l:
z = self.get_wrist_force(arm).A1 # Force vector
#if arm == 'right_arm':
# z = self.get_wrist_force_nano().A1
for i in range(6):
xhat, p = kalman_update(self.xhat_force[arm][i],
self.P_force[arm][i],
self.Q_force[arm][i],
self.R_force[arm][i], z[i])
if abs(z[i] - self.xhat_force[arm][i]) > 3.:
xhat = z[i] # not filtering step changes.
self.xhat_force[arm][i] = xhat
self.P_force[arm][i] = p
def step_ros(self):
r_arm = 'right_arm'
l_arm = 'left_arm'
self.cb_lock.acquire()
if self.enable_left_arm:
l_jep = copy.copy(self.l_jep)
l_alpha = copy.copy(self.arm_settings['left_arm'].stiffness_list)
if self.enable_right_arm:
r_jep = copy.copy(self.r_jep)
r_alpha = copy.copy(self.arm_settings['right_arm'].stiffness_list)
self.cb_lock.release()
if self.enable_left_arm:
self.set_jep(l_arm, l_jep)
self.set_alpha(l_arm, l_alpha)
if self.enable_right_arm:
self.set_jep(r_arm, r_jep)
self.set_alpha(r_arm, r_alpha)
self.step()
motor_pwr_state = self.is_motor_power_on()
if not motor_pwr_state:
self.maintain_configuration()
if self.enable_right_arm:
q_r = self.get_joint_angles(r_arm)
tau_r = self.get_joint_torques(r_arm)
mot_temp_r = self.get_motor_temps(r_arm)
else:
q_r = None
tau_r = None
mot_temp_r = None
if self.enable_left_arm:
q_l = self.get_joint_angles(l_arm)
tau_l = self.get_joint_torques(l_arm)
mot_temp_l = self.get_motor_temps(l_arm)
else:
q_l = None
tau_l = None
mot_temp_l = None
# it seems like this estimate of joint velocity should really be filtered
# or at least a better estimate of the derivative (higher order difference equation)
# - marc Jul 13, 2012
# added one more term to achieve a better estimate of the derivative - tapo Jan 23, 2013
t_now = rospy.get_time()
if self.q_r != None and self.q_l != None and self.q_rHOT != None and self.q_lHOT != None and self.time_stamp != None:
dt = t_now - self.time_stamp
#qdot_r = (np.array(q_r) - np.array(self.q_r)) / dt
qdot_r = (-np.array(q_r) + 4*np.array(self.q_r) - 3*np.array(self.q_rHOT)) / (2*dt)
#qdot_l = (np.array(q_l) - np.array(self.q_l)) / dt
qdot_l = (-np.array(q_l) + 4*np.array(self.q_l) - 3*np.array(self.q_lHOT)) / (2*dt)
else:
qdot_r = np.zeros(7)
qdot_l = np.zeros(7)
self.q_rHOT = self.q_r
self.q_lHOT = self.q_l
self.q_r = q_r
self.q_l = q_l
self.time_stamp = t_now
if self.enable_right_arm:
f_raw_r = self.get_wrist_force(r_arm).A1.tolist()
f_r = self.xhat_force[r_arm]
if self.enable_left_arm:
f_raw_l = self.get_wrist_force(l_arm).A1.tolist()
f_l = self.xhat_force[l_arm]
# publish stuff over ROS.
time_stamp = rospy.Time.now()
h = Header()
h.stamp = time_stamp
h.frame_id = '/torso_lift_link'
pos = []
nms = []
if self.enable_right_arm:
self.q_r_pub.publish(FloatArray(h, q_r))
self.qdot_r_pub.publish(FloatArray(h, qdot_r))
self.jep_r_pub.publish(FloatArray(h, r_jep))
self.alph_r_pub.publish(FloatArray(h, r_alpha))
self.torque_r_pub.publish(FloatArray(h, tau_r))
self.mot_temp_r_pub.publish(FloatArray(h, mot_temp_r))
nms = nms + self.joint_names_list['right_arm']
pos = pos + q_r
h.frame_id = 'should_not_be_using_this'
self.force_raw_r_pub.publish(FloatArray(h, f_raw_r))
self.force_r_pub.publish(FloatArray(h, f_r))
if enable_left_arm:
self.q_l_pub.publish(FloatArray(h, q_l))
self.qdot_l_pub.publish(FloatArray(h, qdot_l))
self.jep_l_pub.publish(FloatArray(h, l_jep))
self.alph_l_pub.publish(FloatArray(h, l_alpha))
self.torque_l_pub.publish(FloatArray(h, tau_l))
self.mot_temp_l_pub.publish(FloatArray(h, mot_temp_l))
nms = nms + self.joint_names_list['left_arm']
pos = pos + q_l
h.frame_id = 'should_not_be_using_this'
self.force_raw_l_pub.publish(FloatArray(h, f_raw_l))
self.force_l_pub.publish(FloatArray(h, f_l))
self.joint_state_pub.publish(JointState(h, nms, pos,
[0.]*len(pos), [0.]*len(pos)))
self.pwr_state_pub.publish(Bool(motor_pwr_state))
def is_motor_power_on(self):
return self.pwr.is_motor_power_on(None)
# Advait, Aug 8, 2009
# two steps in motors_on and off because with simply one step
# pwr.is_motor_on does not get the correct value. (I think this is
# because at the clock edge when motor on command is sent, the power
# is still off and thus the status is not affected.)
def motors_off(self, msg=None):
self.pwr.set_motor_power_off()
def motors_on(self):
self.maintain_configuration()
self.pwr.set_motor_power_on()
self.step()
self.step()
def maintain_configuration(self):
l = []
if self.enable_left_arm:
l.append('left_arm')
if self.enable_right_arm:
l.append('right_arm')
for arm in l:
q = self.get_joint_angles(arm)
if self.arm_settings[arm] == None:
continue
if 'theta_gc' not in self.arm_settings[arm].control_mode:
raise RuntimeError('bad control mode: %s', self.arm_settings[arm].control_mode)
self.set_jep(arm, q)
self.cb_lock.acquire()
if arm == 'right_arm':
self.r_jep = q
else:
self.l_jep = q
self.cb_lock.release()
def power_on(self):
self.maintain_configuration()
self.proxy.make_operational_all()
self.safeop_things()
self.pwr.set_motor_power_on()
self.step()
self.step()
def stop(self, msg=None):
self.pwr.set_motor_power_off()
self.step()
self.proxy.stop()
##3X1 numpy matrix of forces measured by the wrist FT sensor.
#(This is the force that the environment is applying on the wrist)
# @param arm - 'left_arm' or 'right_arm'
# @return in SI units
#coord frame - tool tip coord frame (parallel to the base frame in the home position)
# 2010/2/5 Advait, Aaron King, Tiffany verified that coordinate frame
# from Meka is the left-hand coordinate frame.
def get_wrist_force(self, arm):
if arm == 'right_arm' and self.ftclient_r != None:
return self.get_wrist_force_netft('r')
if arm == 'left_arm' and self.ftclient_l != None:
return self.get_wrist_force_netft('l')
m = []
lc = self.fts[arm]
m.append(lc.get_Fx_mN()/1000.)
m.append(lc.get_Fy_mN()/1000.)
m.append(-lc.get_Fz_mN()/1000.)
m.append(lc.get_Tx_mNm()/1000.)
m.append(lc.get_Ty_mNm()/1000.)
m.append(-lc.get_Tz_mNm()/1000.)
m = np.matrix(m).T
r = tr.Rz(math.radians(-30.0))
m1 = r * m[0:3,:]
m1[1,0] = -m1[1,0]
m1[2,0] = -m1[2,0]
m2 = r * m[3:,:]
m2[1,0] = -m2[1,0]
m2[2,0] = -m2[2,0]
return np.row_stack((m1, m2))
def get_wrist_force_netft(self, arm):
if arm == 'r':
w = self.ftclient_r.read()
elif arm == 'l':
w = self.ftclient_l.read()
r = tr.Rz(math.radians(30.))
f = r * w[0:3]
t = r * w[0:3]
f[1,0] = f[1,0] * -1
t[1,0] = t[1,0] * -1
return np.row_stack((f,t))
def get_wrist_torque(self, arm):
m = []
lc = self.fts[arm]
m = tr.Rz(math.radians(-30.0))*np.matrix(m).T
m[1,0] = -m[1,0]
m[2,0] = -m[2,0]
return m
#-------------------- getting and setting joint angles ------------
##
# @param arm - 'left_arm' or 'right_arm'
# @return list of 7 joint accelerations in RADIANS/s^2.
# according to meka's coordinate frames.
def get_joint_accelerations(self, arm):
#return self.arms[arm].get_thetadotdot_rad().tolist()
raise RuntimeError('The meka joint accelerations are incorrect (Because the joint velocities are incorrect - Tapo, Jan 23, 2013). Computing my own joint accelerations.')
##
# @param arm - 'left_arm' or 'right_arm'
# @return list of 7 joint velocities in RADIANS/s.
# according to meka's coordinate frames.
def get_joint_velocities(self, arm):
#return self.arms[arm].get_thetadot_rad().tolist()
raise RuntimeError('The meka joint velocities seem incorrect. (Advait, July 6, 2011). Computing my own joint velocities.')
def get_joint_torques(self, arm):
''' returns list of 7 joint torques in mNm
'''
return self.arms[arm].get_torque_mNm().tolist()
def get_motor_temps(self, arm):
''' returns list of 7 motor temperatures in Celsius
'''
return self.arms[arm].get_motor_temp_C().tolist()
def get_joint_angles(self, arm):
''' returns list of 7 joint angles in RADIANS.
according to meka's coordinate frames.
'''
return self.arms[arm].get_theta_rad().tolist()
def l_jep_cb(self, msg):
self.cb_lock.acquire()
self.l_jep = msg.data
self.cb_lock.release()
def r_jep_cb(self, msg):
self.cb_lock.acquire()
self.r_jep = msg.data
self.cb_lock.release()
##
# @param q - list of 7 joint angles in RADIANS. according to meka's coordinate frames.
def set_jep(self, arm, q):
if self.arm_settings[arm] == None:
return
if self.arm_settings[arm].control_mode != 'theta_gc' and \
self.arm_settings[arm].control_mode != 'wrist_theta_gc':
raise RuntimeError('Bad control mode: %s'%(self.arm_settings[arm].control_mode))
for i,qi in enumerate(q):
## NOTE - meka's set_theta_deg takes angle in radians.
#self.joint_list_dict[arm][i].set_theta_deg(qi)
# Not anymore. (Advait Aug 27, 2009)
self.joint_list_dict[arm][i].set_theta_rad(qi)
self.cb_lock.acquire()
if arm == 'right_arm':
self.r_jep = q
else:
self.l_jep = q
self.cb_lock.release()
def r_alpha_cb(self, msg):
self.cb_lock.acquire()
self.arm_settings['right_arm'].set_stiffness_scale(list(msg.data))
self.cb_lock.release()
def l_alpha_cb(self, msg):
self.cb_lock.acquire()
self.arm_settings['left_arm'].set_stiffness_scale(list(msg.data))
self.cb_lock.release()
def set_alpha(self, arm, alpha):
jcl = self.joint_list_dict[arm]
for i,a in enumerate(alpha):
jcl[i].set_stiffness(a)
if __name__ == '__main__':
import optparse
p = optparse.OptionParser()
p.add_option('--enable_net_ft_r', action='store_true', dest='netft_r',
help='use net ft for the right arm')
p.add_option('--enable_net_ft_l', action='store_true', dest='netft_l',
help='use net ft for the left arm') #Tiffany 11/11/2011
p.add_option('--arm_to_use', action='store', dest='arm_to_use',
help='use only one arm (l or r)', type='string')
opt, args = p.parse_args()
try:
settings_r = MekaArmSettings(stiffness_list=[0.1939,0.6713,0.748,0.7272,0.75])
#settings_r = None
settings_l = MekaArmSettings(stiffness_list=[0.1939,0.6713,0.748,0.7272,0.75])
#settings_l = None
if opt.arm_to_use == 'l':
enable_left_arm = True
enable_right_arm = False
elif opt.arm_to_use == 'r':
enable_left_arm = False
enable_right_arm = True
elif opt.arm_to_use == 'b':
enable_right_arm = True
enable_left_arm = True
else:
raise RuntimeError('Unrecognized value for the arm_to_use command line argument')
cody_arms = MekaArmServer(settings_r, settings_l, opt.netft_r,
opt.netft_l, enable_right_arm,
enable_left_arm)
# print 'hit a key to power up the arms.'
# k=m3t.get_keystroke()
cody_arms.power_on()
while not rospy.is_shutdown():
cody_arms.step_ros()
rospy.sleep(0.005)
cody_arms.stop()
except m3t.M3Exception:
print '############################################################'
print 'In all likelihood the Meka server is not running.'
print '############################################################'
raise
except:
# only use cody_arms if it was successfully created.
if 'cody_arms' in locals():
cody_arms.stop()
raise
| [
[
1,
0,
0.0439,
0.0013,
0,
0.66,
0,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0439,
0.0013,
0,
0.66,
0.037,
630,
3,
1,
0,
0,
0,
0,
1
],
[
8,
0,
0.0452,
0.0013,
0,
0.6... | [
"import roslib; roslib.load_manifest('hrl_cody_arms')",
"import roslib; roslib.load_manifest('hrl_cody_arms')",
"roslib.load_manifest('force_torque') # Advait hack on Oct 25, 2011",
"import force_torque.FTClient as ftc",
"import m3.rt_proxy as m3p",
"import m3.arm",
"import m3.toolbox as m3t",
"import... |
#
# Copyright (c) 2009, Georgia Tech Research Corporation
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
# * Neither the name of the Georgia Tech Research Corporation nor the
# names of its contributors may be used to endorse or promote products
# derived from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY GEORGIA TECH RESEARCH CORPORATION ''AS IS'' AND
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL GEORGIA TECH BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
# OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
# OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
# Author: Advait Jain
import cody_arm_kinematics as cak
import math, numpy as np
import sys, optparse
import roslib; roslib.load_manifest('hrl_cody_arms')
import hrl_lib.transforms as tr
import hrl_lib.util as ut
def find_good_config(pt,dic):
''' finds a good configuration for the 3x1 pt.
'''
m = dic['cart_pts_mat']
min_idx = np.argmin(ut.norm(m-pt))
c = dic['good_configs_list'][min_idx]
# print 'good configuration:', [math.degrees(qi) for qi in c]
return c
def test_dict(fname):
dic = ut.load_pickle(fname)
firenze = cak.CodyArmKinematics('r')
rot = tr.rotY(math.radians(-90))
p = np.matrix([0.4,-0.42,-0.2]).T
c = find_good_config(p, dic)
res = firenze.IK(p, rot, q_guess=c)
print 'IK soln: ', [math.degrees(qi) for qi in res]
def create_dict(fname):
firenze = cak.CodyArmKinematics('r')
good_configs_list = ut.load_pickle(fname)
cartesian_points_list = []
for gc in good_configs_list:
cartesian_points_list.append(firenze.FK(gc).A1.tolist())
m = np.matrix(cartesian_points_list).T
print 'm.shape:', m.shape
dic = {'cart_pts_mat':m, 'good_configs_list':good_configs_list}
ut.save_pickle(dic,ut.formatted_time()+'_goodconf_dict.pkl')
def record_good_configs(use_left_arm):
import m3.toolbox as m3t
import cody_arm_client as cac
if use_left_arm:
arm = 'l'
else:
arm = 'r'
firenze = cac.CodyArmClient(arm)
print 'hit ENTER to start the recording process'
k=m3t.get_keystroke()
good_configs_list = []
while k == '\r':
print 'hit ENTER to record configuration, something else to exit'
k=m3t.get_keystroke()
q = firenze.get_joint_angles(arm)
good_configs_list.append(np.matrix(q).A1.tolist())
ut.save_pickle(good_configs_list,ut.formatted_time()+'_good_configs_list.pkl')
if __name__=='__main__':
p = optparse.OptionParser()
p.add_option('-r', action='store_true', dest='record',
help='put robot in GC and record good configurations.')
p.add_option('-c', action='store_true', dest='create',
help='create table to map points to good configs. (needs a good_configs pkl)')
p.add_option('-t', action='store_true', dest='test',
help='find a good config for a cartesian point. (needs a dict pkl)')
p.add_option('-f', action='store', type='string', dest='fname',
help='pkl file to use.', default='')
p.add_option('--ra', action='store_true', dest='right',
help='choose the right arm')
p.add_option('--la', action='store_true', dest='left',
help='choose the left arm')
opt, args = p.parse_args()
record = opt.record
create = opt.create
test = opt.test
fname = opt.fname
use_left_arm = opt.left
use_right_arm = opt.right
if test:
if fname == '':
print 'Specify a file name.'
sys.exit()
test_dict(fname)
elif create:
if fname == '':
print 'Specify a file name.'
sys.exit()
create_dict(fname)
elif record:
if use_right_arm == None and use_left_arm == None:
print 'Please specify either left or right arm. (--ra or --la)'
print 'Exiting...'
sys.exit()
record_good_configs(use_left_arm)
else:
print 'Please specify either record or create.'
| [
[
1,
0,
0.2222,
0.0074,
0,
0.66,
0,
201,
0,
1,
0,
0,
201,
0,
0
],
[
1,
0,
0.2296,
0.0074,
0,
0.66,
0.0909,
526,
0,
2,
0,
0,
526,
0,
0
],
[
1,
0,
0.237,
0.0074,
0,
0... | [
"import cody_arm_kinematics as cak",
"import math, numpy as np",
"import sys, optparse",
"import roslib; roslib.load_manifest('hrl_cody_arms')",
"import roslib; roslib.load_manifest('hrl_cody_arms')",
"import hrl_lib.transforms as tr",
"import hrl_lib.util as ut",
"def find_good_config(pt,dic):\n '... |
import numpy as np, math
import copy
import roslib; roslib.load_manifest('equilibrium_point_control')
import rospy
from std_msgs.msg import Bool
class EP_Generator():
# @param ep_gen_func: function that returns stop, ea where ea is the param to the control_function and stop: string which is '' for epc motion to continue
def __init__(self, ep_gen_func, control_function,
ep_clamp_func=None):
self.ep_gen_func = ep_gen_func
self.control_function = control_function
self.ep_clamp_func = ep_clamp_func
## Class defining the core EPC function and a few simple examples.
# More complex behaviors that use EPC should have their own ROS
# packages.
class EPC():
def __init__(self, robot, epc_name = 'epc'):
self.robot = robot
self.stop_epc = False
self.pause_epc = False
rospy.Subscriber('/'+epc_name+'/stop', Bool, self.stop_cb)
rospy.Subscriber('/'+epc_name+'/pause', Bool, self.pause_cb)
def stop_cb(self, msg):
self.stop_epc = msg.data
self.pause_epc = False # stop/start overrides pause.
def pause_cb(self, msg):
self.pause_epc = msg.data
##
# @param ep_gen - object of EP_Generator. can include any state that you want.
# @param time_step: time between successive calls to equi_pt_generator
# @param timeout - time after which the epc motion will stop.
# @return stop (the string which has the reason why the epc
# motion stopped.), ea (last commanded equilibrium angles)
def epc_motion(self, ep_gen, time_step, timeout=np.inf):
ep_gen_func = ep_gen.ep_gen_func
control_function = ep_gen.control_function
ep_clamp_func = ep_gen.ep_clamp_func
rt = rospy.Rate(1/time_step)
timeout_at = rospy.get_time() + timeout
stop = ''
ea = None
while stop == '':
if rospy.is_shutdown():
stop = 'rospy shutdown'
continue
if self.stop_epc:
stop = 'stop_command_over_ROS'
continue
if self.pause_epc:
rospy.sleep(0.1)
timeout_at += 0.101 # approximate.
continue
if timeout_at < rospy.get_time():
stop = 'timed out'
if stop == '':
stop, ea = ep_gen_func(ep_gen)
if stop == 'reset timing':
stop = ''
t_end = rospy.get_time()
if stop == '':
if ep_clamp_func != None:
ep = ea[0]
ea = list(ea)
ea[0] = ep_clamp_func(ep)
ea = tuple(ea)
control_function(*ea)
rt.sleep()
return stop, ea
##
# this function only makes sense for arms where we have Joint
# space Equilibrium Point Control.
def go_jep(self, goal_jep, speed=math.radians(20)):
start_jep = self.robot.get_ep()
diff_jep = np.array(goal_jep) - np.array(start_jep)
time_step = 0.02
max_ch = np.max(np.abs(diff_jep))
total_time = max_ch / speed
n_steps = max(np.round(total_time / time_step + 0.5), 1)
jep_step = diff_jep / n_steps
def eq_gen_func(ep_gen):
jep = ep_gen.jep
step_num = ep_gen.step_num
if step_num < n_steps:
q = list(np.array(jep) + jep_step)
stop = ''
else:
q = None
stop = 'Reached'
step_num += 1
ep_gen.jep = q
ep_gen.step_num = step_num
return stop, (q, time_step*1.2)
ep_gen = EP_Generator(eq_gen_func, self.robot.set_ep)
ep_gen.step_num = 0
ep_gen.jep = copy.copy(start_jep)
return self.epc_motion(ep_gen, time_step)
| [
[
1,
0,
0.0171,
0.0085,
0,
0.66,
0,
954,
0,
2,
0,
0,
954,
0,
0
],
[
1,
0,
0.0256,
0.0085,
0,
0.66,
0.1429,
739,
0,
1,
0,
0,
739,
0,
0
],
[
1,
0,
0.0342,
0.0085,
0,
... | [
"import numpy as np, math",
"import copy",
"import roslib; roslib.load_manifest('equilibrium_point_control')",
"import roslib; roslib.load_manifest('equilibrium_point_control')",
"import rospy",
"from std_msgs.msg import Bool",
"class EP_Generator():\n # @param ep_gen_func: function that returns stop... |
import numpy as np, math
import copy
import roslib; roslib.load_manifest('equilibrium_point_control')
import rospy
from std_msgs.msg import Bool
##
# Abstract class to be implemented when using equilibrium point control.
# If generate_ep produces equilibrium points which are used by control_ep
# to move the arm, this object can be passed into EPC.epc_motion to control
# the arm. Equilibrium points can be of any type so long as generate_ep,
# control_ep, and clamp_ep are all written with this type in mind.
class EPGenerator(object):
#----------------- abstract functions ---------------------
##
# Generates a new equilibrium point.
# @return (stop, ep)
# stop: EPStopConditions.CONTINUE or non-empty string to terminate
# ep: equilibrium point to be sent to control_function
def generate_ep(self):
raise RuntimeError('Unimplemented Function')
##
# Commands the arm to move towards the specified equilibrium point.
# @param ep equilibrium point to command the arm towards
def control_ep(self, ep):
raise RuntimeError('Unimplemented Function')
##
# Takes an equilibrium point and clamps it to reasonable control values.
# To be overwritten if needed by the child class.
# @param ep equilibrium point to clamp
# @return clamped equilibrium point
def clamp_ep(self, ep):
return ep
##
# Termination check for collision or goal reaching.
# To be overwritten if needed by the child class.
# @return EPStopConditions.CONTINUE or non-empty string to terminate
def terminate_check(self):
return EPStopConditions.CONTINUE
#----------------------------------------------------------
##
# Enumerated constants for EPC termination conditions
class EPStopConditions:
CONTINUE = ''
ROSPY_SHUTDOWN = 'rospy shutdown'
ROS_STOP = 'stop_command_over_ROS'
TIMEOUT = 'timed out'
RESET_TIMING = 'reset timing'
SUCCESSFUL = 'epc motion successful'
COLLISION = 'collision detected'
##
# Simple class containing the core EPC function: a control loop paradigm.
class EPC(object):
##
# Initializes variables and subscribers
def __init__(self, epc_name = 'epc'):
self.epc_name = epc_name
self.stop_epc = False
self.pause_epc = False
rospy.Subscriber('/'+epc_name+'/stop', Bool, self._stop_cb)
rospy.Subscriber('/'+epc_name+'/pause', Bool, self._pause_cb)
##
# Subscriber callback for stopping the arm's motion
def _stop_cb(self, msg):
self.stop_epc = msg.data
self.pause_epc = False # stop/start overrides pause.
##
# Subscriber callback for pausing the arm's motion
def _pause_cb(self, msg):
self.pause_epc = msg.data
##
# Control loop for equilibrium point control. For each time step, ep_gen
# provides 4 functions, a termination check, an ep generation step,
# a clamping step, and an ep control step. These functions are called in this
# order along with helper functionality for stopping and pausing control.
# @param ep_gen - Object of type EPGenerator.
# @param time_step: Time between successive calls to equi_pt_generator
# @param timeout - time after which the epc motion will stop.
# @return stop (the string which has the reason why the epc
# motion stopped.), ea (last commanded equilibrium angles)
def epc_motion(self, ep_gen, time_step, timeout=np.inf):
rospy.loginfo("[epc] epc_motion started")
timeout_at = rospy.get_time() + timeout
stop = EPStopConditions.CONTINUE
ea = None
while True:
# basic rospy shutdown termination
if rospy.is_shutdown():
stop = EPStopConditions.ROSPY_SHUTDOWN
break
# check to see if we should stop (stop_epc changed from another thread)
if self.stop_epc:
stop = EPStopConditions.ROS_STOP
break
# check to see if the generator thinks we should stop
stop = ep_gen.terminate_check()
if stop != EPStopConditions.CONTINUE:
break
# check to see if we're paused
if self.pause_epc:
rospy.sleep(0.1)
timeout_at += 0.101 # approximate.
continue
# timeout check
if timeout_at < rospy.get_time():
stop = EPStopConditions.TIMEOUT
break
# create a new ep
stop, ep = ep_gen.generate_ep()
if stop != EPStopConditions.CONTINUE:
break
# if a post-processing function exits, use it to process the ep
ep = ep_gen.clamp_ep(ep)
# command the arm to move to the ep
ep_gen.control_ep(ep)
rospy.sleep(time_step)
rospy.loginfo("[epc] epc_motion stopped with termination condition: %s" % stop)
return stop, ea
| [
[
1,
0,
0.0144,
0.0072,
0,
0.66,
0,
954,
0,
2,
0,
0,
954,
0,
0
],
[
1,
0,
0.0216,
0.0072,
0,
0.66,
0.125,
739,
0,
1,
0,
0,
739,
0,
0
],
[
1,
0,
0.0288,
0.0072,
0,
0... | [
"import numpy as np, math",
"import copy",
"import roslib; roslib.load_manifest('equilibrium_point_control')",
"import roslib; roslib.load_manifest('equilibrium_point_control')",
"import rospy",
"from std_msgs.msg import Bool",
"class EPGenerator(object):\n #----------------- abstract functions -----... |
#!/usr/bin/python
import roslib
roslib.load_manifest('room_explore')
import rospy
from geometry_msgs.msg import PoseWithCovarianceStamped
# header:
# seq: 7
# stamp:
# secs: 0
# nsecs: 0
# frame_id: /map
# pose:
# pose:
# position:
# x: -0.324687451124
# y: 0.183924600482
# z: 0.0
# orientation:
# x: 0.0
# y: 0.0
# z: -0.054315002133
# w: 0.998523850763
# covariance: [0.25, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.25, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.06853891945200942, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
if __name__ == '__main__':
rospy.init_node( 'pose_setter' )
pub = rospy.Publisher( '/initialpose', PoseWithCovarianceStamped )
rospy.sleep( 1.0 )
ps = PoseWithCovarianceStamped()
ps.header.stamp = rospy.Time(0)
ps.header.frame_id = '/base_link'
ps.pose.pose.orientation.w = 1.0
ps.pose.covariance = [0.01, 0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.01, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0, 0.0,
0.0, 0.005, 0.0, 0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0]
print ps
pub.publish( ps )
| [
[
1,
0,
0.0612,
0.0204,
0,
0.66,
0,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0816,
0.0204,
0,
0.66,
0.25,
630,
3,
1,
0,
0,
0,
0,
1
],
[
1,
0,
0.102,
0.0204,
0,
0.66,... | [
"import roslib",
"roslib.load_manifest('room_explore')",
"import rospy",
"from geometry_msgs.msg import PoseWithCovarianceStamped",
"if __name__ == '__main__':\n rospy.init_node( 'pose_setter' )\n\n pub = rospy.Publisher( '/initialpose', PoseWithCovarianceStamped )\n rospy.sleep( 1.0 )\n\n ps = ... |
__all__ = [
'room_explore'
]
| [
[
14,
0,
0.6667,
1,
0,
0.66,
0,
272,
0,
0,
0,
0,
0,
5,
0
]
] | [
"__all__ = [\n 'room_explore'\n ]"
] |
#!/usr/bin/python
import roslib
roslib.load_manifest('room_explore')
import rospy
import tf
from threading import Thread
import actionlib
from move_base_msgs.msg import MoveBaseGoal, MoveBaseAction
from visualization_msgs.msg import MarkerArray
from visualization_msgs.msg import Marker
from geometry_msgs.msg import Vector3, PoseStamped, Quaternion
from std_msgs.msg import ColorRGBA
from explore_hrl.msg import ExploreAction, ExploreResult, ExploreGoal
import yaml
import numpy as np, math
room = '/home/travis/svn/gt-ros-pkg/hrl/room_explore/rooms/rooms.yaml'
def retfalse():
return False
class TFthread( Thread ):
def __init__( self, df ):
Thread.__init__( self )
try:
rospy.init_node( 'TFthread' )
except:
pass # parent probably already initialized node.
self.df = df # yaml dictionary of rooms
self.bc = tf.TransformBroadcaster()
self.should_run = True
self.start()
def publish_transform( self ):
for room in self.df.keys():
self.bc.sendTransform( ( self.df[room]['position']['x'],
self.df[room]['position']['y'],
self.df[room]['position']['z'] ),
( self.df[room]['orientation']['x'],
self.df[room]['orientation']['y'],
self.df[room]['orientation']['z'],
self.df[room]['orientation']['w'] ),
rospy.Time.now(),
room,
'map' )
def run( self ):
rospy.logout( 'TFthread: Starting ' )
r = rospy.Rate( 10 )
while self.should_run and not rospy.is_shutdown():
self.publish_transform()
try:
r.sleep()
except:
pass # ROS exception.
rospy.logout( 'TFthread: Starting ')
def stop( self ):
# Kill off the poller thread.
self.should_run = False
self.join(5)
if (self.isAlive()):
raise RuntimeError('TFthread: Unable to stop thread ' )
# if __name__ == '__main__':
# f = open( room )
# dat = yaml.load( f )
# f.close()
# TFthread( dat )
# rospy.spin()
def standard_rad(t):
if t > 0:
return ((t + np.pi) % (np.pi * 2)) - np.pi
else:
return ((t - np.pi) % (np.pi * -2)) + np.pi
class RoomExplore( Thread ):
def __init__( self, df, room, start_rad = 1.5 ):
Thread.__init__( self )
try:
rospy.init_node( 'RoomExplore' )
except:
pass
self.should_run = True
self.frame = '/' + room
self.height = df[room]['height']
self.width = df[room]['width']
self.listener = tf.TransformListener()
self.listener.waitForTransform( '/base_link', '/map', rospy.Time(0), timeout = rospy.Duration(100))
self.setup_poses( radius = start_rad ) # also initializes radius
self.pub = rospy.Publisher( 'visarr', Marker )
self._as = actionlib.SimpleActionServer( '/explore', ExploreAction, execute_cb = self.action_request )
self._as.start()
rospy.logout('Action should be started.')
self.start()
def action_request( self, goal ):
rospy.logout( 'room_explore: action_request received for radius: \'%2.2f\'' % goal.radius )
def preempt_func():
# self._as should be in scope and bound @ function def. (I think for python...)
check = self._as.is_preempt_requested()
if check:
rospy.logout( 'room_explore: action_request preempted!' )
return check
rv = self.begin_explore( goal.radius, preempt_func = preempt_func )
rospy.logout( 'room_explore: action_request received result %d' % int(rv) )
if rv == True:
self._as.set_succeeded( ExploreResult() )
def begin_explore( self, radius, preempt_func = retfalse ):
client = actionlib.SimpleActionClient( 'move_base', MoveBaseAction )
rospy.logout( 'Waiting for move_base server' )
client.wait_for_server()
rospy.logout( 'room_explore: setting radius' )
all_goals = self.setup_poses( radius )
for goal in all_goals:
#print 'room_explore: sending goal ', goal
goal.target_pose.header.stamp = rospy.Time.now()
client.send_goal( goal )
time_last_moving = rospy.Time.now()
goal_time = rospy.Time.now()
new_pose = self.current_robot_position()
ref_pose = self.current_robot_position()
r = rospy.Rate( 5 )
while not rospy.is_shutdown():
state = client.get_state()
states = { 0: 'WAITING FOR GOAL ACK',
1: 'PENDING',
2: 'ACTIVE',
3: 'WAITING FOR RESULT',
4: 'WAITING FOR CANCEL ACK',
5: 'RECALLING',
6: 'PREEMPTING',
7: 'DONE' }
#print 'State: ', state, ' ', states[state]
#print 'Result: ', client.get_result()
#rospy.logout( 'room_explore: loop' )
if state == 7 or state == 3:
rospy.logout( 'room_explore: client no longer active' )
print 'State: ', state, ' ', states[state]
time_last_moving = rospy.Time.now()
break
if preempt_func():
rospy.logout( 'room_explore: preempted at a higher level.' )
time_last_moving = rospy.Time.now()
break
new_pose = self.current_robot_position()
dx = new_pose[0] - ref_pose[0]
dy = new_pose[1] - ref_pose[1]
da = new_pose[-1] - ref_pose[-1] # yaw
if dx*dx + dy*dy > 0.02 or da*da > math.radians( 5 ):
time_last_moving = rospy.Time.now()
ref_pose = self.current_robot_position()
rospy.logout('WE ARE MOVING')
if rospy.Time.now() - time_last_moving > rospy.Duration( 8 ):
rospy.logout( 'We do not appear to have moved. Aborting current goal.' )
client.cancel_all_goals() # Should force a break on GoalState
time_last_moving = rospy.Time.now()
break
if rospy.Time.now() - goal_time > rospy.Duration( 30 ):
rospy.logout( 'Goal not achieved after 30 seconds. Aborting.' )
client.cancel_all_goals() # Should force a break on GoalState
time_last_moving = rospy.Time.now()
break
r.sleep()
client.cancel_all_goals() # Just in case
if preempt_func(): # immediately exit if overall action preempted
break
return True
def current_robot_position( self ):
ps = PoseStamped()
ps.header.stamp = rospy.Time(0)
ps.header.frame_id = '/base_link'
ps.pose.orientation.w = 1.0
try:
ps_map = self.listener.transformPose( '/map', ps )
except:
rospy.logout( 'room_explore: Transform failed' )
ps_map = PoseStamped()
ps_map.header.stamp = rospy.Time.now()
ps_map.header.frame_id = '/map'
ps_map.pose.orientation = new_quat
roll, pitch, yaw = tf.transformations.euler_from_quaternion(( ps_map.pose.orientation.x,
ps_map.pose.orientation.y,
ps_map.pose.orientation.z,
ps_map.pose.orientation.w ))
rv = [ ps_map.pose.position.x,
ps_map.pose.position.y,
ps_map.pose.position.z,
roll,
pitch,
yaw ]
#print 'RV: ', rv
return rv
def setup_poses( self, radius ):
self.radius = radius
xdir = np.arange( self.radius / 2.0, self.height + self.radius / 2.0, self.radius )
ydir = np.arange( self.radius / 2.0, self.width + self.radius / 2.0, self.radius )
move_dir = 0.0
self.poses = []
mod = 0
for y in ydir:
if mod == 0:
xord = xdir
else:
xord = xdir[::-1]
for x in xord:
goal = MoveBaseGoal()
goal.target_pose.header.frame_id = self.frame
goal.target_pose.header.stamp = rospy.Time.now()
goal.target_pose.pose.position.x = x
goal.target_pose.pose.position.y = y
quat = tf.transformations.quaternion_from_euler( 0.0, 0.0, move_dir )
goal.target_pose.pose.orientation.x = quat[0]
goal.target_pose.pose.orientation.y = quat[1]
goal.target_pose.pose.orientation.z = quat[2]
goal.target_pose.pose.orientation.w = quat[3]
self.poses.append( goal )
move_dir = standard_rad( move_dir + np.pi )
mod = ( mod + 1 ) % 2
return self.poses
def run( self ):
rospy.logout( 'RoomExplore: Starting ' )
r = rospy.Rate( 2 )
while self.should_run and not rospy.is_shutdown():
self.publish_markers()
try:
r.sleep()
except:
pass # ROS exception.
rospy.logout( 'RoomExplore: Starting ' )
def stop( self ):
# Kill off the poller thread.
self.should_run = False
self.join(5)
if (self.isAlive()):
raise RuntimeError('RoomExplore: Unable to stop thread ' )
def publish_markers( self ):
for i,g in enumerate(self.poses):
m = Marker()
m.ns = 'sample_positions'
m.id = i
m.action = m.ADD
m.type = m.ARROW
m.header.frame_id = self.frame
m.header.stamp = rospy.Time.now()
m.scale = Vector3( 0.15, 1.0, 1.0 )
m.color = ColorRGBA( 0.2, 1.0, 0.2, 0.7 )
m.pose = g.target_pose.pose
self.pub.publish( m )
def goals( self ):
return self.poses
#self.explore_act = actionlib.SimpleActionClient('explore', explore_hrl.msg.ExploreAction)
if __name__ == '__main__':
f = open( room )
dat = yaml.load( f )
f.close()
TFthread( dat )
re = RoomExplore( dat, 'hrl', 0.8 )
#re.begin_explore( 0.8 )
# rosservice call /explore 0.8
# explore_act = actionlib.SimpleActionClient('explore', ExploreAction)
# rospy.logout( 'Waiting for explore.' )
# explore_act.wait_for_server()
# rospy.logout( 'Done waiting.' )
# goal = ExploreGoal( radius = 0.8 )
# explore_act.send_goal(goal)
# rospy.sleep( 0.5 )
# explore_act.wait_for_result()
rospy.spin()
| [
[
1,
0,
0.009,
0.003,
0,
0.66,
0,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0119,
0.003,
0,
0.66,
0.0526,
630,
3,
1,
0,
0,
0,
0,
1
],
[
1,
0,
0.0149,
0.003,
0,
0.66,
... | [
"import roslib",
"roslib.load_manifest('room_explore')",
"import rospy",
"import tf",
"from threading import Thread",
"import actionlib",
"from move_base_msgs.msg import MoveBaseGoal, MoveBaseAction",
"from visualization_msgs.msg import MarkerArray",
"from visualization_msgs.msg import Marker",
"f... |
#! /usr/bin/python
import roslib; roslib.load_manifest('pr2_omni_teleop')
import rospy
import hrl_camera.ros_camera as rc
import cv
import hrl_lib.rutils as ru
import hrl_lib.util as ut
import math
#TF
import tf
import hrl_lib.tf_utils as tfu
import tf.transformations as tr
if __name__ == '__main__':
import sys
base_name = sys.argv[1]
test = 'laser'
ls = ru.LaserScanner('point_cloud_srv')
prosilica = rc.Prosilica('prosilica', 'streaming')
tf_listener = tf.TransformListener()
rospy.loginfo( 'Getting laser scan.')
points = ls.scan(math.radians(180.), math.radians(-180.), 20.)
rospy.loginfo('Size of point cloud: %d' % len(points.points))
rospy.loginfo( 'Grabbing image.')
image = prosilica.get_frame()
rospy.loginfo( 'Grabbing transforms.')
#transform from tilt_laser => base_footprint (pointcloud is already in base_footprint)
#transform from base_footprint => (pose of head) prosilica
pro_T_bf = tfu.transform('/high_def_optical_frame', '/base_footprint', tf_listener)
#transform from base_footprint => map
map_T_bf = tfu.transform('/map', '/base_footprint', tf_listener)
#get camera's P matrix
rospy.loginfo('Waiting for camera_info.')
calibration = rc.ROSCameraCalibration('/prosilica/camera_info')
r = rospy.Rate(10)
while not rospy.is_shutdown() and calibration.has_msg == False:
r.sleep()
rospy.loginfo('Saving.')
pkl_name = '%s.pkl' % base_name
img_name = '%s.png' % base_name
ut.save_pickle({'points': points,
'pro_T_bf': pro_T_bf,
'map_T_bf': map_T_bf,
'camera_info': calibration}, pkl_name)
cv.SaveImage(img_name, image)
rospy.loginfo( 'Saved to %s and %s.' % (pkl_name, img_name))
| [
[
1,
0,
0.0357,
0.0179,
0,
0.66,
0,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0357,
0.0179,
0,
0.66,
0.0909,
630,
3,
1,
0,
0,
0,
0,
1
],
[
1,
0,
0.0536,
0.0179,
0,
0.... | [
"import roslib; roslib.load_manifest('pr2_omni_teleop')",
"import roslib; roslib.load_manifest('pr2_omni_teleop')",
"import rospy",
"import hrl_camera.ros_camera as rc",
"import cv",
"import hrl_lib.rutils as ru",
"import hrl_lib.util as ut",
"import math",
"import tf",
"import hrl_lib.tf_utils as... |
import numpy as np
coefficients = np.matrix([0.00957324711798050, -0.00204106308185305, -0.0217944712296340, -0.0386045234368094, -0.0240699173047884, 0.0411301337058247, 0.144943252298100, 0.242605833505432, 0.282695778236683, 0.242605833505432, 0.144943252298100, 0.0411301337058247, -0.0240699173047884, -0.0386045234368094, -0.0217944712296340, -0.00204106308185305, 0.00957324711798050]).reshape((17,1))
num = np.matrix([5.9476, 29.7379, 59.4758, 59.4758, 29.7379, 5.9476]).reshape((6,1))/1000.0
den = np.matrix([100.0000, -208.6232, 217.3800, -121.8451, 36.7561, -4.6356]).reshape((6,1))/100.0
| [
[
1,
0,
0.1667,
0.1667,
0,
0.66,
0,
954,
0,
1,
0,
0,
954,
0,
0
],
[
14,
0,
0.3333,
0.1667,
0,
0.66,
0.3333,
519,
3,
1,
0,
0,
276,
10,
2
],
[
14,
0,
0.6667,
0.1667,
0,
... | [
"import numpy as np",
"coefficients = np.matrix([0.00957324711798050, -0.00204106308185305, -0.0217944712296340, -0.0386045234368094, -0.0240699173047884, 0.0411301337058247, 0.144943252298100, 0.242605833505432, 0.282695778236683, 0.242605833505432, 0.144943252298100, 0.0411301337058247, -0.0240699173047884, -0.... |
#! /usr/bin/python
import numpy as np
import roslib; roslib.load_manifest('hrl_clickable_world')
import rospy
import std_msgs.msg
from hrl_clickable_world.srv import PerceiveButtons, ButtonAction, DisplayButtons
from hrl_clickable_world.srv import ButtonActionRequest
from hrl_clickable_world.srv import PerceiveButtonsResponse, ButtonActionResponse
from pixel_2_3d.srv import Pixel23d
NS_PREFIX = "/clickable_world/"
class BehaviorManager:
def __init__(self):
self.behavior_names = rospy.get_param(NS_PREFIX + "behavior_names")
self.robot_state = rospy.get_param(NS_PREFIX + "init_conditions")
self.srv_prefix = rospy.get_param(NS_PREFIX + "behavior_namespace")
self.percieve_buttons_sub = rospy.Subscriber(NS_PREFIX + "perceive_buttons",
std_msgs.msg.Bool,
self.perceive_buttons)
self.display_buttons_srv = rospy.ServiceProxy(NS_PREFIX + "display_buttons",
DisplayButtons)
self.button_action_srv = rospy.Service(NS_PREFIX + "button_action",
ButtonAction,
self.on_button_press)
self.pixel_2_3d_srv = rospy.ServiceProxy("/pixel_2_3d/pixel_2_3d",
Pixel23d)
self.behaviors = {}
self.perception_srvs = {}
self.action_srvs = {}
self.button_types = []
for name in self.behavior_names:
behavior = rospy.get_param(NS_PREFIX + name)
if behavior["perception_srv"] not in self.perception_srvs:
self.perception_srvs[behavior["perception_srv"]] = rospy.ServiceProxy(
self.srv_prefix + behavior["perception_srv"],
PerceiveButtons)
if behavior["action_srv"] not in self.action_srvs:
self.action_srvs[behavior["action_srv"]] = rospy.ServiceProxy(
self.srv_prefix + behavior["action_srv"],
ButtonAction)
self.behaviors[name] = behavior
def perceive_buttons(self, msg):
rospy.loginfo("Perceiving buttons")
self.button_types = []
cur_button_id = 1
displayed_buttons = []
for name in self.behavior_names:
# check to see if preconditions satisfied
preconds_satisfied = True
if "preconditions" in self.behaviors[name]:
for condition in self.behaviors[name]["preconditions"]:
if (self.behaviors[name]["preconditions"][condition] !=
self.robot_state[condition]):
preconds_satisfied = False
if preconds_satisfied:
# get the buttons for this perception
rospy.loginfo("Perceiving buttons for %s" % self.behaviors[name]["perception_srv"])
try:
resp = self.perception_srvs[self.behaviors[name]["perception_srv"]]()
except:
continue
cur_buttons = resp.buttons
for i, button in enumerate(cur_buttons):
self.button_types.append(name)
cur_buttons[i].id = cur_button_id
cur_buttons[i].ns = name
cur_button_id += 1
displayed_buttons.extend(cur_buttons)
# tell display to show buttons
self.display_buttons_srv(displayed_buttons)
def on_button_press(self, req):
if req.button_id == 0:
return
do_behav = self.behaviors[self.button_types[req.button_id-1]]
self.action_srvs[do_behav["action_srv"]](req)
action_success = True
# TODO use result from action srv
if action_success:
# update robot state
if "postconditions" in do_behav:
for condition in do_behav["postconditions"]:
self.robot_state[condition] = do_behav["postconditions"][condition]
rospy.loginfo("Current State: " + str(self.robot_state))
def main():
rospy.init_node('behavior_manager')
bm = BehaviorManager()
rospy.spin()
if __name__ == "__main__":
main()
| [
[
1,
0,
0.0306,
0.0102,
0,
0.66,
0,
954,
0,
1,
0,
0,
954,
0,
0
],
[
1,
0,
0.051,
0.0102,
0,
0.66,
0.0833,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.051,
0.0102,
0,
0.... | [
"import numpy as np",
"import roslib; roslib.load_manifest('hrl_clickable_world')",
"import roslib; roslib.load_manifest('hrl_clickable_world')",
"import rospy",
"import std_msgs.msg",
"from hrl_clickable_world.srv import PerceiveButtons, ButtonAction, DisplayButtons",
"from hrl_clickable_world.srv impo... |
import numpy as np
import roslib; roslib.load_manifest('pr2_grasp_behaviors')
import rospy
from std_msgs.msg import String, Bool
import std_srvs.srv
from tf.transformations import *
import object_manipulator.convert_functions as cf
from hrl_pr2_lib.hrl_controller_manager import HRLControllerManager as ControllerManager
from pr2_collision_monitor.srv import JointDetectionStart, ArmMovingWait
from pr2_grasp_behaviors.grasp_behavior_server import GraspStates
##
# Abstract class for a grasping behavior. Implements much of the framework for
# a generic behavior-based grasp and provides virtual template functions for specific
# behaviors to override.
class GraspBehavior(object):
def __init__(self, arm, use_coll_detection=False):
self.arm = arm
self.use_coll_detection = use_coll_detection
self.GRIPPER_POINT = np.array([0.23, 0.0, 0.0])
self.cm = ControllerManager(self.arm)
class CollisionState:
def __init__(self):
self.collided = False
def callback(self, msg):
if msg.data:
self.collided = True
self.coll_state = CollisionState()
if self.use_coll_detection:
rospy.loginfo("Waiting for start_detection")
rospy.wait_for_service(self.arm + '_joint_coll_detect/start_detection')
self.start_detection = rospy.ServiceProxy(self.arm + '_joint_coll_detect/start_detection', JointDetectionStart, persistent=True)
rospy.loginfo("Waiting for stop_detection")
rospy.wait_for_service(self.arm + '_joint_coll_detect/stop_detection')
self.stop_detection = rospy.ServiceProxy(self.arm + '_joint_coll_detect/stop_detection', std_srvs.srv.Empty, persistent=True)
self.stop_detection()
rospy.Subscriber(self.arm + "_joint_coll_detect/arm_collision_detected", Bool, self.coll_state.callback)
rospy.loginfo("Waiting for arm_moving_wait")
rospy.wait_for_service(self.arm + '_arm_moving_server/arm_moving_wait')
self.arm_moving_wait = rospy.ServiceProxy(self.arm + '_arm_moving_server/arm_moving_wait', ArmMovingWait, persistent=True)
rospy.loginfo("[grasp_manager] GraspBehavior loaded.")
################################################################################
# virtual functions to be implemented by specific grasp
##
# Move arm to preparatory pose
def grasp_preparation_move(self):
rospy.logerr("UNIMPLEMENTED!")
##
# Move arm to grasp setup, just before approach.
def grasp_setup_move(self, params):
rospy.logerr("UNIMPLEMENTED!")
##
# Execute the grasping arm motion
def execute_approach(self, block):
rospy.logerr("UNIMPLEMENTED!")
##
# Generate a random behavior parameterization for sampling
# the workspace of possible grasps
def random_generator(self):
rospy.logerr("UNIMPLEMENTED!")
##
# Attempt to slightly adjust grasp parameters to get a close configuration
# which will hopefully find an IK solution.
def jiggle_grasp_params(self, grasp_params):
return grasp_params
################################################################################
##
# Transforms the given position by the offset position in the given quaternion
# rotation frame
def transform_in_frame(self, pos, quat, off_point):
quatmat = np.mat(quaternion_matrix(quat))
quatmat[0:3,3] = np.mat(pos).T
trans = np.matrix([off_point[0],off_point[1],off_point[2],1.]).T
transpos = quatmat * trans
return transpos.T.A[0,0:3]
##
# Returns same gripper rotation normalized to [0, pi) range.
def normalize_rot(self, gripper_rot):
while gripper_rot >= np.pi:
gripper_rot -= np.pi
while gripper_rot < 0.:
gripper_rot += np.pi
return gripper_rot
##
# Creates a PoseStamped in the torso_lift_link frame
def create_goal_pose(self, x, y, z, gripper_pose):
point = [x, y, z]
point = self.transform_in_frame(point, gripper_pose, -self.GRIPPER_POINT).tolist()
pose = point + gripper_pose.tolist()
goal_pose = cf.create_pose_stamped(pose, "torso_lift_link")
goal_pose.header.stamp = rospy.Time.now()
return goal_pose
##
# Returns the position of the end effector
def get_end_effector_pos(self):
wrist_pose = self.cm.get_current_wrist_pose_stamped("torso_lift_link")
p = wrist_pose.pose.position
o = wrist_pose.pose.orientation
affector_pos = self.transform_in_frame([p.x, p.y, p.z],
[o.x, o.y, o.z, o.w], self.GRIPPER_POINT)
return affector_pos
##
# Takes special care to kill the arm's movement by canceling
# the action client and accounting for some edge cases.
def kill_arm_movement(self):
rospy.loginfo("Killing arm movement")
self.cm.joint_action_client.cancel_all_goals()
rospy.sleep(0.01)
# Needed for lag time in the case that the collision occurs
# before the action is dispatched and due to the fact that
# the arm doesn't necessarily respond the first time
while not self.cm.check_joint_trajectory_done():
self.cm.joint_action_client.cancel_all_goals()
rospy.sleep(0.01)
if rospy.is_shutdown():
self.cm.joint_action_client.cancel_all_goals()
##
# Readys arm for grasp motion.
def stage_grasp(self, grasp_params, open_gripper=True):
rospy.loginfo("Staging grasp motion")
self.grasp_setup_move(grasp_params)
if open_gripper:
# open gripper
rospy.loginfo("Opening gripper")
self.cm.command_gripper(1.00, -1.0, False)
self.cm.gripper_action_client.wait_for_result(rospy.Duration(2.0))
self.cm.wait_joint_trajectory_done()
##
# Performs motion where arm approaches object
def grasp_approach_motion(self, coll_detect=False, behavior_name="", sig_level=0.99):
# move arm down
rospy.loginfo("Moving arm down")
startt = rospy.Time.now().to_sec()
if coll_detect:
self.start_detection(behavior_name, sig_level)
result = self.execute_approach(False)
if result == "no solution":
# break without completing the grasp
#self.apm.end_collision_detection()
if coll_detect:
self.stop_detection()
return "no solution"
# grasp motion should be successful and moving now
# wait until the trajectory is complete.
# this loop will not exit until the arm has stopped moving
while not self.cm.check_joint_trajectory_done():
if rospy.is_shutdown():
self.kill_arm_movement()
return "shutdown"
if self.coll_state.collided:
self.kill_arm_movement()
break
rospy.sleep(0.005)
if coll_detect:
self.stop_detection()
if self.coll_state.collided and coll_detect:
grasp_result = "Collision"
else:
grasp_result = "No collision"
self.coll_state.collided = False
endt = rospy.Time.now().to_sec()
rospy.loginfo("Grasp duration: %f", endt - startt)
rospy.loginfo("Finished moving arm")
return grasp_result
##
# Gripper graping action
def grasping_action(self):
rospy.loginfo("Closing gripper")
self.cm.command_gripper(0.0, 30.0, True)
rospy.loginfo("Gripper closed")
##
# Gripper placing action
def placing_action(self):
rospy.loginfo("Opening gripper")
self.cm.command_gripper(1.00, -1.0, False)
rospy.sleep(0.5)
rospy.loginfo("Gripper opened")
##
# Performs full grasping behavior.
#
# @param grasp_params A tuple containing the parameters for the behavior.
# @param is_place If False, perform a grasp. If True, perform a place.
# @param collide Whether or not we should detect for collisions.
# @param data_collecting If True, only perform the approach motion and return after that.
# @param num_jiggle How many times the parameters should be jiggled before giving up
# @param publish_state Callback function which takes a string and publishes the current state
# @return grasp_result Result of grasp.
def perform_grasp(self, grasp_params, is_place=False, collide=True,
behavior_name="", sig_level=0.99,
data_collecting=False, num_jiggle=2,
publish_state=lambda x: x):
self.collide = collide
rospy.loginfo("Performing grasp with parameters: " + str(grasp_params))
iters = 0
while not rospy.is_shutdown():
# Move to grasp position
publish_state(GraspStates.GRASP_SETUP_MOVE)
self.stage_grasp(grasp_params, not is_place)
self.arm_moving_wait(True, 3.0) # Wait for the arm to stop moving
publish_state(GraspStates.EXECUTE_APPROACH)
approach_result = self.grasp_approach_motion(self.use_coll_detection and self.collide,
behavior_name=behavior_name,
sig_level=sig_level)
rospy.sleep(0.1)
if approach_result != "no solution":
break
else:
if num_jiggle == 0:
rospy.loginfo("Interpolated IK failed, cannot perform grasp for x = %1.2f, y = %1.2f, rot = %1.2f" % (x, y, gripper_rot))
return "IK failure"
rospy.loginfo("Interpolated IK failed, jiggling configuration for nearby trajectory")
# Jiggle it to see if it works
grasp_params = self.jiggle_grasp_params(grasp_params)
iters += 1
# Tried too many times
if iters >= num_jiggle:
rospy.loginfo("Cannot find IK solution")
return "IK failure"
else:
continue
if data_collecting:
return "Grasp motion success"
if approach_result == "Collision":
if not is_place:
publish_state(GraspStates.GRASP_OBJECT)
self.grasping_action()
else:
self.placing_action()
if not is_place:
rospy.loginfo("Picking object up")
else:
rospy.loginfo("Pulling arm away")
publish_state(GraspStates.EXECUTE_RETREAT)
self.execute_retreat()
################################################################################
# determine return result
self.arm_moving_wait(True, 3.0) # Wait for the arm to stop moving
if approach_result == "Collision":
if not is_place:
if self.is_obj_in_gripper():
grasp_result = "Object grasped"
else:
grasp_result = "Object missed"
else:
grasp_result = "Object placed"
else:
if not is_place:
grasp_result = "No collision for grasp"
else:
if self.is_obj_in_gripper():
grasp_result = "No collision for place"
else:
grasp_result = "Object dropped before place"
################################################################################
rospy.loginfo("Grasp result: %s" % grasp_result)
rospy.loginfo("Grasp complete!")
return grasp_result
##
# Checks to see if anything is in the gripper currently (gripper is not fully closed).
def is_obj_in_gripper(self):
last_opening = self.cm.get_current_gripper_opening()
while not rospy.is_shutdown():
rospy.sleep(0.2)
next_opening = self.cm.get_current_gripper_opening()
print next_opening
if abs(last_opening - next_opening) < 0.001:
break
last_opening = next_opening
return self.cm.get_current_gripper_opening() > 0.01
| [
[
1,
0,
0.0034,
0.0034,
0,
0.66,
0,
954,
0,
1,
0,
0,
954,
0,
0
],
[
1,
0,
0.0101,
0.0034,
0,
0.66,
0.0909,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0101,
0.0034,
0,
... | [
"import numpy as np",
"import roslib; roslib.load_manifest('pr2_grasp_behaviors')",
"import roslib; roslib.load_manifest('pr2_grasp_behaviors')",
"import rospy",
"from std_msgs.msg import String, Bool",
"import std_srvs.srv",
"from tf.transformations import *",
"import object_manipulator.convert_funct... |
#! /usr/bin/python
import numpy as np, math
import sys
import roslib; roslib.load_manifest('pr2_grasp_behaviors')
import rospy
import actionlib
from tf.transformations import *
from std_msgs.msg import String
from geometry_msgs.msg import PointStamped
import object_manipulator.convert_functions as cf
from object_manipulator.cluster_bounding_box_finder import ClusterBoundingBoxFinder
from tabletop_object_detector.srv import TabletopSegmentation
from pr2_controllers_msgs.msg import PointHeadAction, PointHeadGoal
from pr2_grasp_behaviors.msg import OverheadGraspAction, OverheadGraspResult
from pr2_grasp_behaviors.msg import OverheadGraspSetupAction, OverheadGraspSetupResult
from pr2_grasp_behaviors.msg import OverheadGraspFeedback
#from laser_interface.pkg import CURSOR_TOPIC, MOUSE_DOUBLE_CLICK_TOPIC, CURSOR_TOPIC, MOUSE_R_CLICK_TOPIC, MOUSE_R_DOUBLE_CLICK_TOPIC
class GraspStates:
ACTIONLIB_CALLED = 'Actionlib grasping goal called'
PERCEIVING_OBJECTS = 'Perceiving table objects'
GRASP_SETUP_MOVE = 'Moving to grasp setup'
EXECUTE_APPROACH = 'Executing grasp motion'
GRASP_OBJECT = 'Closing gripper on object'
EXECUTE_RETREAT = 'Retreating grasp motion'
ACTIONLIB_COMPLETE = 'Actionlib grasping goal completed'
class GraspBehaviorServer(object):
def __init__(self, arm, grasp_manager):
self.arm = arm
self.gman = grasp_manager
##
# Open gripper fully.
def open_gripper(self, blocking = False):
self.gman.cm.command_gripper(1.0, -1.0, False)
if blocking:
self.gman.cm.gripper_action_client.wait_for_result(rospy.Duration(4.0))
##
# Uses the object_detection service detect objects on the table. Returns a list
# of pairs [ [ x, y, z], rot ] which represent the centers and z orientation of
# each object detected on the table.
def detect_tabletop_objects(self):
DETECT_ERROR = 0.
cbbf = ClusterBoundingBoxFinder(tf_listener=self.gman.cm.tf_listener)
object_detector = rospy.ServiceProxy("/object_detection", TabletopSegmentation)
try:
detects = object_detector()
object_detector.close()
except ServiceException as se:
rospy.logerr("Tabletop segmentation crashed")
return []
if detects.result != 4:
rospy.logerr("Detection failed (err %d)" % (detects.result))
return []
table_z = detects.table.pose.pose.position.z
objects = []
for cluster in detects.clusters:
(object_points,
object_bounding_box_dims,
object_bounding_box,
object_to_base_link_frame,
object_to_cluster_frame) = cbbf.find_object_frame_and_bounding_box(cluster)
# rospy.loginfo("bounding box:", object_bounding_box)
(object_pos, object_quat) = cf.mat_to_pos_and_quat(object_to_cluster_frame)
angs = euler_from_quaternion(object_quat)
# position is half of height
object_pos[2] = table_z + object_bounding_box[1][2] / 2. + DETECT_ERROR
objects += [[object_pos, angs[2]]]
return objects
def get_grasp_loc(self, obj):
return obj[0][0], obj[0][1], obj[1], obj[0][2]
##
# Given an (x, y) location on a table, grasp the closest object detected.
# If repeat is True, will keep trying if the grasp fails.
def detect_closest_object(self, x, y, repeat=True, disable_head=False):
def dist(o):
return (o[0][0] - x) ** 2 + (o[0][1] - y) ** 2
grasped = False
num_tries = 0
if not disable_head:
self.point_head([x,y,-0.3])
while not grasped and num_tries < 4:
rospy.loginfo("Detect in")
rospy.sleep(0.6)
detect_tries = 0
objects = None
while (objects is None or len(objects) == 0):
objects = self.detect_tabletop_objects()
rospy.sleep(0.6)
detect_tries += 1
if detect_tries == 3 and (objects is None or len(objects) == 0):
rospy.logerr("Cannot detect any objects")
return None
rospy.loginfo("Detect out")
if len(objects) > 0:
try:
obj = min(objects, key=dist)
# Get better look
if not disable_head:
obj_pt = obj[0]
obj_pt[2] = -0.4
self.point_head(obj_pt)
rospy.sleep(0.2)
rospy.loginfo("Detect2 in")
objects = self.detect_tabletop_objects()
rospy.loginfo("Detect2 out")
obj = min(objects, key=dist)
except:
pass
return obj
else:
rospy.loginfo("No objects near point")
return None
return None
##
# Points head at given point in given frame.
def point_head(self, point, velocity = 0.6, frame="/torso_lift_link", block = True):
head_action_client = actionlib.SimpleActionClient("/head_traj_controller/point_head_action", PointHeadAction)
head_action_client.wait_for_server()
goal = PointHeadGoal()
goal.target = cf.create_point_stamped(point, frame)
goal.pointing_frame = "/openni_rgb_optical_frame"
goal.max_velocity = velocity
head_action_client.send_goal(goal)
if not block:
return 0
finished_within_time = head_action_client.wait_for_result(rospy.Duration(10))
if not finished_within_time:
head_action_client.cancel_goal()
rospy.logerr("timed out when asking the head to point to a new goal")
return 0
return 1
##
# Move the arm to a suitable setup position for moving to a grasp position
def setup_grasp(self, block = False, disable_head=False, open_gripper=False):
if open_gripper:
self.open_gripper(blocking=False)
if not disable_head:
self.point_head([0.3, 0.0, -0.3], block=False)
self.gman.grasp_preparation_move()
rospy.sleep(1.)
if block:
self.gman.arm_moving_wait(True, 8.0)
##
# Launch actionlib srv calls.
def start_grasping_server(self, grasp_server_name, setup_server_name):
self.grasping_server = actionlib.SimpleActionServer(grasp_server_name, OverheadGraspAction, self.execute_grasping_goal, False)
self.grasping_server.register_preempt_callback(self.gman.kill_arm_movement)
self.grasping_server.start()
self.setup_server = actionlib.SimpleActionServer(setup_server_name, OverheadGraspSetupAction, self.execute_grasping_setup, False)
self.setup_server.register_preempt_callback(self.gman.kill_arm_movement)
self.setup_server.start()
rospy.loginfo("Grasping server launched on %s, setup at %s",
grasp_server_name, setup_server_name)
##
# Wraps setup_grasp
def execute_grasping_setup(self, goal):
result = OverheadGraspSetupResult()
self.setup_grasp(block=True, disable_head=goal.disable_head, open_gripper=goal.open_gripper)
rospy.loginfo("Finished setup")
self.setup_server.set_succeeded(result)
##
# Executes grasping goal requested on actionlib srvs. Actions differ based
# on type of grasp requested.
def execute_grasping_goal(self, goal):
result = OverheadGraspResult()
feedback = OverheadGraspFeedback()
def publish_state(state):
feedback.state = state
self.grasping_server.publish_feedback(feedback)
publish_state(GraspStates.ACTIONLIB_CALLED)
# User specifies parameters
if goal.grasp_type == goal.MANUAL_GRASP:
grasp_params = (goal.x, goal.y, goal.roll, goal.pitch)
# Robot finds parameters
elif goal.grasp_type == goal.VISION_GRASP:
obj = self.detect_closest_object(goal.x,
goal.y,
disable_head=goal.disable_head)
publish_state(GraspStates.PERCEIVING_OBJECTS)
if obj is None:
rospy.loginfo("No objects detected")
result.grasp_result = "No objects detected"
self.grasping_server.set_aborted(result)
return
x, y, rot, z = self.get_grasp_loc(obj)
grasp_params = (x, y, rot, goal.pitch)
# execute a random grasp
elif goal.grasp_type == goal.RANDOM_GRASP:
grasp_params = self.random_generator()
else:
rospy.logerr("Bad grasp type")
self.grasping_server.set_aborted(result)
return
feedback.x, feedback.y = grasp_params[0], grasp_params[1]
feedback.roll, feedback.pitch = grasp_params[2], grasp_params[3]
grasp_result = self.gman.perform_grasp(grasp_params, collide=not goal.disable_coll,
behavior_name=goal.behavior_name,
sig_level=goal.sig_level,
is_place=not goal.is_grasp,
publish_state=publish_state)
result.grasp_result = grasp_result
if goal.is_grasp:
if grasp_result == "Object grasped":
self.grasping_server.set_succeeded(result)
else:
self.grasping_server.set_aborted(result)
else:
if grasp_result == "Object placed":
self.grasping_server.set_succeeded(result)
else:
self.grasping_server.set_aborted(result)
publish_state(GraspStates.ACTIONLIB_COMPLETE)
| [
[
1,
0,
0.0124,
0.0041,
0,
0.66,
0,
954,
0,
2,
0,
0,
954,
0,
0
],
[
1,
0,
0.0165,
0.0041,
0,
0.66,
0.0588,
509,
0,
1,
0,
0,
509,
0,
0
],
[
1,
0,
0.0248,
0.0041,
0,
... | [
"import numpy as np, math",
"import sys",
"import roslib; roslib.load_manifest('pr2_grasp_behaviors')",
"import roslib; roslib.load_manifest('pr2_grasp_behaviors')",
"import rospy",
"import actionlib",
"from tf.transformations import *",
"from std_msgs.msg import String",
"from geometry_msgs.msg imp... |
#! /usr/bin/python
import numpy as np, math
import random
import roslib; roslib.load_manifest('pr2_grasp_behaviors')
import rospy
from grasp_manager import GraspBehavior
class SidewaysGrasp(GraspBehavior):
def __init__(self, arm, use_coll_detection=False):
super(OverheadGrasp, self).__init__(arm, use_coll_detection)
self.SIDE_GRASP_DIST = 0.4
self.TABLE_Z = -0.2
self.JOINTS_BIAS = [0.0, 5.0, 0.0, -1.0, 4.0, -1.0, 0.0]
if arm == 'l':
for i in [0, 2, 4]:
self.JOINTS_BIAS[i] *= -1
self.BIAS_RADIUS = 0.012
self.INIT_ANGS = [-0.05, -0.3, -3.1, -1.9, 3.1, -1.5, 0.0]
self.GRASP_TIME = 2.0
self.SETUP_VELOCITY = 0.8
self.GRASP_VELOCITY = 0.4
def setup_move(self, params):
# object location (x, y), approach angle (r)
self.xyr = params
rospy.loginfo("Moving to grasp position (%1.2f, %1.2f, %1.2f)" % self.xyr)
grasp_pose = self.create_goal_pose(self.xyr[0], self.xyr[1], self.TABLE_Z,
quaternion_about_axis(self.xyr[2], (0, 0, 1)))
return self.cm.move_arm_pose_biased(grasp_pose, self.JOINTS_BIAS,
self.SETUP_VELOCITY, blocking = True,
init_angs=self.INIT_ANGS)
def execute_approach(self, block):
rospy.loginfo("Moving arm sideways")
goal_pose = self.create_goal_pose(
self.xyr[0] + self.SIDE_GRASP_DIST * np.cos(-self.xyr[2]),
self.xyr[1] - self.SIDE_GRASP_DIST * np.sin(-self.xyr[2]),
self.TABLE_Z,
quaternion_about_axis(self.xyr[2], (0, 0, 1)))
goal_pose.header.stamp = rospy.Time.now()
return self.cm.move_cartesian_ik(goal_pose, collision_aware = False,
blocking = block,
step_size = .005, pos_thres = .02, rot_thres = .1,
settling_time = rospy.Duration(self.GRASP_TIME),
joints_bias = self.JOINTS_BIAS, bias_radius = self.BIAS_RADIUS,
vel = self.GRASP_VELOCITY)
def execute_retreat(self):
rospy.logerr("Need to implement this!")
##
# Return random grasp configuration in entire space.
def random_generator(self):
x = random.uniform(0.45, 0.75)
y = random.uniform(-0.55, 0.10)
r = random.uniform(0., np.pi/2.)
return x, y, r
| [
[
1,
0,
0.0508,
0.0169,
0,
0.66,
0,
954,
0,
2,
0,
0,
954,
0,
0
],
[
1,
0,
0.0678,
0.0169,
0,
0.66,
0.1667,
715,
0,
1,
0,
0,
715,
0,
0
],
[
1,
0,
0.1017,
0.0169,
0,
... | [
"import numpy as np, math",
"import random",
"import roslib; roslib.load_manifest('pr2_grasp_behaviors')",
"import roslib; roslib.load_manifest('pr2_grasp_behaviors')",
"import rospy",
"from grasp_manager import GraspBehavior",
"class SidewaysGrasp(GraspBehavior):\n def __init__(self, arm, use_coll_d... |
#! /usr/bin/python
import roslib
roslib.load_manifest('pr2_approach_table')
import rospy
from geometry_msgs.msg import Twist
import actionlib
import costmap_services.python_client as costmap
from pr2_approach_table.srv import ApproachSrv
from pr2_approach_table.msg import ApproachAction, ApproachResult, ApproachGoal
import numpy as np, math
from collections import deque
import os
from threading import Lock
def ctime():
return rospy.Time.now().to_time()
def retfalse():
return False
class Approach( ):
def __init__( self, costmap_ns = '' ):
rospy.logout('approach_node: Initializing')
try:
rospy.init_node('approach_node')
except: # Node probably already initialized elsewhere
pass
# Create Costmap Services obj
self.cs = costmap.CostmapServices( accum = 3, ns = costmap_ns ) # be really conservative!
# Note: After moving, this will require accum * -1's before stopping.
# Publish move_base command
self._pub = rospy.Publisher( 'approach_cmd_vel', Twist )
# Alterative ways to call using ROS services / actionlib
self._service = rospy.Service( '/approach_table/move_forward_srv',
ApproachSrv,
self.service_request )
self._as = actionlib.SimpleActionServer( '/approach_table/move_forward_act',
ApproachAction,
execute_cb = self.action_request )
self._as.start()
rospy.logout( 'approach_node: Service ready and waiting' )
def service_request( self, req ):
return self.run( forward_vel = req.forward_vel,
forward_mult = req.forward_mult )
def action_request( self, goal ):
def preempt_func():
# self._as should be in scope and bound @ function def. (I think for python...)
check = self._as.is_preempt_requested()
if check:
rospy.logout( 'approach_node: action_request preempted!' )
return check
rv = self.run( preempt_func = preempt_func,
forward_vel = goal.forward_vel,
forward_mult = goal.forward_mult )
rospy.logout( 'approach_node: action_request received result %d' % int(rv) )
if preempt_func(): # this is a relatively new addition
rospy.logout('approach_node: returning actionlib state preempted.')
self._as.set_preempted()
elif rv == True:
self._as.set_succeeded( ApproachResult( int(rv) ))
def run( self, preempt_func = retfalse, forward_vel = 0.05, forward_mult = 1.0 ):
# preempt_func => returns true when a preempt request is received, else false
rospy.logout( 'approach_node: Run called for with values: \'%1.2f, %1.2f\'' % (forward_vel, forward_mult) )
rospy.logout('approach_node: Running')
r = rospy.Rate( 10 )
def check_func():
a = not rospy.is_shutdown()
# forward_mult is a hack to let us get closer at the current forward_vel
# without reducing the footprint.
b = self.cs.scoreTraj_PosHyst( forward_vel * forward_mult, 0.0, 0.0 ) != -1.0
c = not preempt_func()
return a and b and c
while check_func():
move_command = Twist()
move_command.linear.x = forward_vel
self._pub.publish( move_command )
# Don't do this too fast (avoid unwanted buffering / rate issues)
try:
r.sleep()
except rospy.ROSInterruptException: # rospy shutdown request received
pass
self._pub.publish( Twist() ) # Stop moving!
if preempt_func():
rospy.logout( 'approach_node: Preempt was requested. May not have finished.' )
rospy.logout( 'approach_node: Exiting' )
return False
else:
rospy.logout( 'approach_node: Exiting' )
return True
if __name__ == '__main__':
import optparse
p = optparse.OptionParser()
p.add_option('--ns', action='store', type='string', dest='ns',
help='Uses the namespace [ns] for services: /ns/approach_table/costmap_services/cs/...',
default = '')
opt, args = p.parse_args()
ap = Approach( costmap_ns = opt.ns )
# There are (at least) three ways to call this code.
# 1) Python:
# ap.run( forward_vel = 0.05, forward_mult = 0.5 )
# 2) ROS service:
# rosservice call /approach_table/move_forward_srv 0.05 0.5
# 3) ROS actionlib:
# try:
# client = actionlib.SimpleActionClient( '/approach_table/move_forward_act', ApproachAction )
# client.wait_for_server()
# client.send_goal( ActionGoal( 0.05, 0.5 ))
# client.wait_for_result()
# print client.get_result()
# except rospy.ROSInterruptException:
# print 'Program interrupted before completion'
rospy.spin()
| [
[
1,
0,
0.0134,
0.0067,
0,
0.66,
0,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0201,
0.0067,
0,
0.66,
0.0667,
630,
3,
1,
0,
0,
0,
0,
1
],
[
1,
0,
0.0268,
0.0067,
0,
0.... | [
"import roslib",
"roslib.load_manifest('pr2_approach_table')",
"import rospy",
"from geometry_msgs.msg import Twist",
"import actionlib",
"import costmap_services.python_client as costmap",
"from pr2_approach_table.srv import ApproachSrv",
"from pr2_approach_table.msg import ApproachAction, ApproachRe... |
#! /usr/bin/python
import roslib
roslib.load_manifest('pr2_approach_table')
roslib.load_manifest('rfid_behaviors')
import rospy
import tf
import tf.transformations as tft
import smach
from smach_ros import SimpleActionState, ServiceState, IntrospectionServer
import actionlib
from geometry_msgs.msg import PoseStamped, PoseArray, Pose, Quaternion
from move_base_msgs.msg import MoveBaseAction
from pr2_approach_table.srv import ApproachSrv
from pr2_approach_table.msg import ApproachAction, ApproachResult, ApproachGoal
from rfid_behaviors.srv import FloatFloat_Int32 as RotateBackupSrv
import numpy as np, math
class CheckHeading(smach.State):
def __init__(self, listener):
smach.State.__init__(self,
outcomes=['succeeded', 'preempted'],
input_keys = ['target_pose'], # PoseStamped
output_keys = ['angular_error']) # float
self.listener = listener
self.initialized = False
def execute(self, userdata):
ps_desired = userdata.target_pose
self.GLOBAL_FRAME = ps_desired.header.frame_id
if not self.initialized:
self.initialized = True
# self.listener = tf.TransformListener() # this is now passed in.
rospy.logout( 'CheckHeading (smach): Waiting on transforms from (%s -> %s)'
% ( self.GLOBAL_FRAME, '/base_link' ))
self.listener.waitForTransform( '/base_link',
self.GLOBAL_FRAME,
rospy.Time(0), timeout = rospy.Duration(30) )
rospy.logout( 'CheckHeading (smach): Ready.' )
try:
ps = PoseStamped()
ps.header.stamp = rospy.Time(0)
ps.header.frame_id = '/base_link'
ps.pose.orientation.w = 1.0
ps_global = self.listener.transformPose( self.GLOBAL_FRAME, ps )
efq = tft.euler_from_quaternion
r,p,yaw_curr = efq(( ps_global.pose.orientation.x,
ps_global.pose.orientation.y,
ps_global.pose.orientation.z,
ps_global.pose.orientation.w ))
r,p,yaw_des = efq(( ps_desired.pose.orientation.x,
ps_desired.pose.orientation.y,
ps_desired.pose.orientation.z,
ps_desired.pose.orientation.w ))
rospy.logout( 'CheckHeading (smach): Error was %3.2f (deg)' % math.degrees(yaw_des - yaw_curr))
userdata.angular_error = yaw_des - yaw_curr
except:
rospy.logout( 'CheckHeading (smach): TF failed. Returning ang error of 0.0' )
userdata.angular_error = 0.0
return 'succeeded'
class PoseSelection(smach.State):
def __init__(self, listener):
smach.State.__init__(self,
outcomes=['succeeded', 'aborted'],
input_keys=['candidate_poses'], # of type PoseArray!
output_keys=['selected_pose_global', # of type PoseStamped!
'movebase_pose_global' ]) # of type PoseStamped!
self.listener = listener
self.poses = []
self.initialized = False
self.ind = 0
#self.GLOBAL_FRAME = '/odom_combined'
self.GLOBAL_FRAME = '/map'
def execute(self, userdata):
rospy.logout( 'Executing POSE_SELECTION' )
poses_frame = userdata.candidate_poses.header.frame_id
#dist = userdata.approach_dist
dist = 0.80
if not self.initialized:
self.initialized = True
self.ind = 0
# self.listener = tf.TransformListener() # This is now passed in
rospy.logout( 'PoseSelector (smach): Waiting on transforms from (%s -> %s)'
% ( self.GLOBAL_FRAME, poses_frame ))
self.listener.waitForTransform( poses_frame,
self.GLOBAL_FRAME,
rospy.Time(0), timeout = rospy.Duration(30) )
rospy.logout( 'PoseSelector (smach): Ready.' )
# convert PoseArray to list of PoseStamped in global frame
frame_adjusted = [ self.frame_adjust(i,poses_frame,dist) for i in userdata.candidate_poses.poses ]
self.poses = [ i for i in frame_adjusted if i != None ] # in case the transforms fail.
if len( self.poses ) == 0 or self.ind >= len( self.poses ): # we've tried everything...
return 'aborted'
# print 'POSES:\n', self.poses
userdata.selected_pose_global = self.poses[ self.ind ][0]
userdata.movebase_pose_global = self.poses[ self.ind ][1]
# print 'SELECTED_POSE:\n', self.poses[ self.ind ]
self.ind += 1
return 'succeeded'
def frame_adjust( self, pose, poses_frame, dist, arm_offset = 0.0 ):
# Adjust all incoming candidate poses into a "Global" frame.
# Positive arm offset to move the approach point "right"
ps = PoseStamped()
ps.header.frame_id = poses_frame
ps.header.stamp = rospy.Time(0)
ps.pose = pose
# In some cases, we may want to move the pose right or left
# depending on which arm will be used for grasping.
efq = tft.euler_from_quaternion
r,p,y = efq(( pose.orientation.x,
pose.orientation.y,
pose.orientation.z,
pose.orientation.w ))
ps.pose.position.x = pose.position.x + arm_offset * np.cos( y + np.pi/2 )
ps.pose.position.y = pose.position.y + arm_offset * np.sin( y + np.pi/2 )
# print ps, '\nto\n', self.GLOBAL_FRAME, '\ntime:', rospy.Time.now()
try:
ps_global = self.listener.transformPose( self.GLOBAL_FRAME, ps )
ps_global.pose.position.z = 0.0
# print 'PS:\n', ps, '\nPS_GLOBAL:\n', ps_global
r,p,y = efq(( ps_global.pose.orientation.x,
ps_global.pose.orientation.y,
ps_global.pose.orientation.z,
ps_global.pose.orientation.w ))
# We want to move to a position that is 40-cm back from the tabletop using navstack
mps = PoseStamped()
mps.header.frame_id = ps_global.header.frame_id
mps.header.stamp = rospy.Time.now()
mps.pose.position.x = ps_global.pose.position.x + dist * np.cos( y )
mps.pose.position.y = ps_global.pose.position.y + dist * np.sin( y )
qfe = tft.quaternion_from_euler
mps.pose.orientation = Quaternion( *qfe( 0.0, 0.0, y - np.pi ))
# print 'MPS:\n', mps
# Return value: selected_pose_global, movebase_pose_global.
rv = [ ps_global, mps ]
except:
rospy.logout( 'PoseSelector (smach): TF failed. Ignoring pose.' )
rv = None
return rv # Return value: selected_pose_global (PoseStamped), movebase_pose_global (PoseStamped)
def sm_approach_table( listener = None ):
# for various states, you need a tf listener, but only one per thread supported.
if listener == None:
try:
rospy.init_node( 'sm_approach' )
except:
rospy.logout( 'sm_approach_table: Node already initialized elsewhere' )
listener = tf.TransformListener()
# Python only allows one listener per thread. This function has two (or more)
# classes that require the listener. You can pass in one from higher in the
# hierarchy if you prefer.
# Create a SMACH state machine
sm = smach.StateMachine( outcomes = ['succeeded','aborted','preempted'],
input_keys = ['table_edge_poses'], # type PoseArray
output_keys = ['movebase_pose_global', # type PoseStamped
'table_edge_global']) # type PoseStamped
# Open the container
with sm:
smach.StateMachine.add(
'POSE_SELECTION',
PoseSelection( listener = listener ),
transitions = { 'succeeded' : 'MOVE_BASE' },
remapping = {'candidate_poses':'table_edge_poses', # input (PoseArray)
'selected_pose_global':'table_edge_global', # output (PoseStamped)
'movebase_pose_global':'movebase_pose_global'}) # output (PoseStamped)
smach.StateMachine.add(
'MOVE_BASE',
SimpleActionState( '/move_base',
MoveBaseAction,
goal_slots = ['target_pose'], # PoseStamped
outcomes = ['succeeded','aborted','preempted']),
transitions = { 'succeeded' : 'CHECK_HEADING',
'aborted' : 'POSE_SELECTION' },
remapping = {'target_pose':'movebase_pose_global'}) # input (PoseStamped)
smach.StateMachine.add(
'CHECK_HEADING',
CheckHeading( listener = listener ),
transitions = { 'succeeded':'ADJUST_HEADING' },
remapping = { 'target_pose':'movebase_pose_global', # input (PoseStamped)
'angular_error':'angular_error' }) # output (float)
smach.StateMachine.add(
'ADJUST_HEADING',
ServiceState( '/rotate_backup',
RotateBackupSrv,
request_slots = ['rotate']), # float (displace = 0.0)
transitions = { 'succeeded':'MOVE_FORWARD' },
remapping = {'rotate':'angular_error'})
approach_goal = ApproachGoal()
approach_goal.forward_vel = 0.05
approach_goal.forward_mult = 0.50
smach.StateMachine.add(
'MOVE_FORWARD',
SimpleActionState( '/approach_table/move_forward_act',
ApproachAction,
goal = approach_goal ),
transitions = { 'succeeded' : 'succeeded' })
return sm
if __name__ == '__main__':
rospy.init_node('smach_example_state_machine')
# sm = sm_approach_table()
sm = smach.StateMachine(outcomes=['succeeded','aborted','preempted'],
input_keys = [ 'approach_poses' ])
p = Pose()
p.position.x = 0.3879
p.position.y = 0.79838
p.position.z = 0.0
p.orientation.z = -0.704
p.orientation.w = 0.709
pa = PoseArray()
pa.header.frame_id = '/map'
pa.poses = [ p ]
sm.userdata.table_edge_poses = pa
with sm:
sm_table = sm_approach_table()
smach.StateMachine.add(
'APPROACH_TABLE',
sm_table,
remapping = {'table_edge_poses':'table_edge_poses', # input
'movebase_pose_global':'movebase_pose_global', # output
'table_edge_global':'table_edge_global'}, # output
#transitions = {'succeeded':'MOVE_BACK'})
transitions = {'succeeded':'succeeded'})
# GRASP!
# smach.StateMachine.add(
# 'MOVE_BACK',
# SimpleActionState( '/move_base',
# MoveBaseAction,
# goal_slots = ['target_pose'], # PoseStamped
# outcomes = ['succeeded','aborted','preempted']),
# transitions = { 'succeeded' : 'succeeded'},
# remapping = {'target_pose':'intermediate_pose'}) # input
# GO DELIVER!
sis = IntrospectionServer('Approach_Table', sm, '/SM_APPROACH_TABLE')
sis.start()
rospy.sleep( 3.0 )
outcome = sm.execute()
sis.stop()
| [
[
1,
0,
0.0066,
0.0033,
0,
0.66,
0,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0099,
0.0033,
0,
0.66,
0.0556,
630,
3,
1,
0,
0,
0,
0,
1
],
[
8,
0,
0.0132,
0.0033,
0,
0.... | [
"import roslib",
"roslib.load_manifest('pr2_approach_table')",
"roslib.load_manifest('rfid_behaviors')",
"import rospy",
"import tf",
"import tf.transformations as tft",
"import smach",
"from smach_ros import SimpleActionState, ServiceState, IntrospectionServer",
"import actionlib",
"from geometry... |
#! /usr/bin/python
import numpy as np
import roslib; roslib.load_manifest('hrl_clickable_behaviors')
import rospy
import std_srvs.srv
import actionlib
import tf.transformations as tf_trans
from tf.listener import TransformListener
from geometry_msgs.msg import Quaternion
from hrl_clickable_world.srv import PerceiveButtons, ButtonAction, DisplayButtons
from hrl_clickable_world.srv import PerceiveButtonsResponse, ButtonActionResponse
from geometry_msgs.msg import Point, PoseStamped
from visualization_msgs.msg import Marker
from move_base_msgs.msg import MoveBaseAction, MoveBaseGoal
from hrl_move_floor_detect.srv import SegmentFloor
class MoveFloorButton:
def __init__(self):
self.tl = TransformListener()
self.perception_srv = rospy.Service("/clickable_world/detect_empty_floor",
PerceiveButtons,
self.do_perception)
self.percept_pub = rospy.Publisher("/clickable_world/floor_button_vis",
Marker)
self.goal_pub = rospy.Publisher("/clickable_world/move_floor_goal", PoseStamped)
self.action_srv = rospy.Service("/clickable_world/move_empty_floor",
ButtonAction,
self.do_action)
self.floor_seg_srv = rospy.ServiceProxy("/move_floor_detect",
SegmentFloor)
self.floor_move_client = actionlib.SimpleActionClient("move_base", MoveBaseAction)
rospy.loginfo("[move_floor_button] MoveFloorButton loaded.")
def do_perception(self, req):
# segment surfaces
rospy.loginfo("[move_floor_button] Segmenting floor")
self.surfaces = self.floor_seg_srv().surfaces
for i in range(len(self.surfaces)):
self.surfaces[i].color.r = 0
self.surfaces[i].color.g = 0
self.surfaces[i].color.b = 256
self.surfaces[i].color.a = 256
if len(self.surfaces) != 0:
self.percept_pub.publish(self.surfaces[0])
resp = PerceiveButtonsResponse()
resp.buttons = self.surfaces
return resp
def do_action(self, req):
rospy.loginfo("[move_floor_button] MoveFloorButton clicked!")
# put 3d pt in base frame
req.pixel3d.header.stamp = rospy.Time(0)
move_pt = self.tl.transformPoint("/base_link", req.pixel3d)
floor_move_goal = MoveBaseGoal()
floor_move_goal.target_pose.header.frame_id = move_pt.header.frame_id
floor_move_goal.target_pose.pose.position = move_pt.point
quat = tf_trans.quaternion_from_euler(0, 0, np.arctan2(move_pt.point.y, move_pt.point.x))
floor_move_goal.target_pose.pose.orientation = Quaternion(quat[0], quat[1], quat[2], quat[3])
floor_move_goal.target_pose.header.frame_id = "/base_link"
floor_move_goal.target_pose.header.stamp = rospy.Time.now()
try:
self.goal_pub.publish(floor_move_goal.target_pose)
self.floor_move_client.send_goal(floor_move_goal)
self.floor_move_client.wait_for_result()
cur_pose = self.floor_move_client.get_result()
except rospy.ROSInterruptException:
print "[move_floor_button] Move floor failed"
return ButtonActionResponse()
def main():
rospy.init_node('move_floor_button')
tb = MoveFloorButton()
rospy.spin()
if __name__ == "__main__":
main()
| [
[
1,
0,
0.0366,
0.0122,
0,
0.66,
0,
954,
0,
1,
0,
0,
954,
0,
0
],
[
1,
0,
0.061,
0.0122,
0,
0.66,
0.0588,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.061,
0.0122,
0,
0.... | [
"import numpy as np",
"import roslib; roslib.load_manifest('hrl_clickable_behaviors')",
"import roslib; roslib.load_manifest('hrl_clickable_behaviors')",
"import rospy",
"import std_srvs.srv",
"import actionlib",
"import tf.transformations as tf_trans",
"from tf.listener import TransformListener",
"... |
#! /usr/bin/python
import numpy as np
import roslib; roslib.load_manifest('hrl_clickable_behaviors')
import rospy
import std_srvs.srv
import actionlib
from tf.listener import TransformListener
from hrl_clickable_world.srv import PerceiveButtons, ButtonAction, DisplayButtons
from hrl_clickable_world.srv import PerceiveButtonsResponse, ButtonActionResponse
from geometry_msgs.msg import Point
from visualization_msgs.msg import Marker
from pr2_grasp_behaviors.msg import OverheadGraspSetupAction, OverheadGraspSetupGoal
from pr2_grasp_behaviors.msg import OverheadGraspAction, OverheadGraspGoal
from hrl_table_detect.srv import ObjectButtonDetect, SegmentSurfaces
class PlaceObject:
def __init__(self):
self.arm = rospy.get_param("arm", "r")
self.tl = TransformListener()
self.perception_srv = rospy.Service("/clickable_world/place_table_perceive",
PerceiveButtons,
self.do_perception)
self.action_srv = rospy.Service("/clickable_world/place_object",
ButtonAction,
self.do_action)
self.pc_capture_srv = rospy.ServiceProxy("/table_detection/surf_seg_capture_pc",
std_srvs.srv.Empty)
self.table_seg_srv = rospy.ServiceProxy("/table_detection/segment_surfaces",
SegmentSurfaces)
self.grasp_client = actionlib.SimpleActionClient(self.arm + '_overhead_grasp', OverheadGraspAction)
self.grasp_client.wait_for_server()
self.grasp_setup_client = actionlib.SimpleActionClient(self.arm + '_overhead_grasp_setup', OverheadGraspSetupAction)
self.grasp_setup_client.wait_for_server()
def do_perception(self, req):
rospy.loginfo("[place_object] Perceiving table...")
# capture a few clouds
rate = rospy.Rate(5)
for i in range(5):
self.pc_capture_srv()
rate.sleep()
# segment surfaces
self.surfaces = self.table_seg_srv().surfaces
for i in range(len(self.surfaces)):
self.surfaces[i].color.r = 256
self.surfaces[i].color.g = 0
self.surfaces[i].color.b = 256
self.surfaces[i].color.a = 256
resp = PerceiveButtonsResponse()
resp.buttons = self.surfaces
return resp
def do_action(self, req):
rospy.loginfo("[place_object] Table clicked, placing object...")
# put 3d pt in grasping frame
req.pixel3d.header.stamp = rospy.Time(0)
place_pt = self.tl.transformPoint("/torso_lift_link", req.pixel3d)
# move to place setup position
setup_goal = OverheadGraspSetupGoal()
setup_goal.disable_head = False
setup_goal.open_gripper = False
self.grasp_setup_client.send_goal(setup_goal)
self.grasp_setup_client.wait_for_result()
############################################################
# Creating place goal
grasp_goal = OverheadGraspGoal()
grasp_goal.is_grasp = False
grasp_goal.disable_head = False
grasp_goal.disable_coll = False
grasp_goal.grasp_type=OverheadGraspGoal.MANUAL_GRASP
grasp_goal.x = place_pt.point.x
grasp_goal.y = place_pt.point.y
grasp_goal.behavior_name = "overhead_grasp"
grasp_goal.sig_level = 0.999
############################################################
# place object
self.grasp_client.send_goal(grasp_goal)
self.grasp_client.wait_for_result()
result = self.grasp_client.get_result()
rospy.loginfo("[place_object] Place result: %s" % result)
obj_in_hand = result.grasp_result == "Object placed"
# go back to grasp setup
setup_goal.open_gripper = True
self.grasp_setup_client.send_goal(setup_goal)
self.grasp_setup_client.wait_for_result()
return ButtonActionResponse()
def main():
rospy.init_node('place_object')
po = PlaceObject()
rospy.spin()
if __name__ == "__main__":
main()
| [
[
1,
0,
0.0283,
0.0094,
0,
0.66,
0,
954,
0,
1,
0,
0,
954,
0,
0
],
[
1,
0,
0.0472,
0.0094,
0,
0.66,
0.0625,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0472,
0.0094,
0,
... | [
"import numpy as np",
"import roslib; roslib.load_manifest('hrl_clickable_behaviors')",
"import roslib; roslib.load_manifest('hrl_clickable_behaviors')",
"import rospy",
"import std_srvs.srv",
"import actionlib",
"from tf.listener import TransformListener",
"from hrl_clickable_world.srv import Perceiv... |
#! /usr/bin/python
import numpy as np
import roslib; roslib.load_manifest('hrl_clickable_behaviors')
import rospy
import std_srvs.srv
import actionlib
from hrl_clickable_world.srv import PerceiveButtons, ButtonAction, DisplayButtons
from hrl_clickable_world.srv import PerceiveButtonsResponse, ButtonActionResponse
from geometry_msgs.msg import Point
from visualization_msgs.msg import Marker
from hrl_table_detect.srv import SegmentSurfaces, GetTableApproaches
from hrl_table_detect.srv import GetTableApproachesRequest
from move_base_msgs.msg import MoveBaseAction, MoveBaseGoal
from pr2_approach_table.srv import ApproachSrv
class TableClickable:
def __init__(self):
self.perception_srv = rospy.Service("/clickable_world/table_perception",
PerceiveButtons,
self.do_perception)
self.percept_pub = rospy.Publisher("/clickable_world/table_button_vis",
Marker)
self.action_srv = rospy.Service("/clickable_world/table_approach_action",
ButtonAction,
self.do_action)
self.pc_capture_srv = rospy.ServiceProxy("/table_detection/surf_seg_capture_pc",
std_srvs.srv.Empty)
self.table_seg_srv = rospy.ServiceProxy("/table_detection/segment_surfaces",
SegmentSurfaces)
self.table_approach_detect_srv = rospy.ServiceProxy(
"/table_detection/detect_table_approaches",
GetTableApproaches)
self.table_move_client = actionlib.SimpleActionClient("move_base", MoveBaseAction)
self.approach_table_srv = rospy.ServiceProxy("/approach_table/move_forward_srv",
ApproachSrv)
def do_perception(self, req):
# capture a few clouds
rate = rospy.Rate(5)
for i in range(5):
self.pc_capture_srv()
rate.sleep()
# segment surfaces
self.surfaces = self.table_seg_srv().surfaces
for i in range(len(self.surfaces)):
self.surfaces[i].color.r = 0
self.surfaces[i].color.g = 256
self.surfaces[i].color.b = 0
self.surfaces[i].color.a = 256
self.percept_pub.publish(self.surfaces[0])
resp = PerceiveButtonsResponse()
resp.buttons = self.surfaces
return resp
def do_action(self, req):
rospy.loginfo("Table clicked!")
approach_req = GetTableApproachesRequest()
approach_req.table = self.surfaces[0]
approach_req.approach_pt = req.pixel3d
approach_poses = self.table_approach_detect_srv(approach_req).approach_poses
#return ButtonActionResponse()
table_move_goal = MoveBaseGoal()
for approach_pose in approach_poses.poses:
table_move_goal.target_pose.pose = approach_pose
table_move_goal.target_pose.header.frame_id = approach_poses.header.frame_id
table_move_goal.target_pose.header.stamp = rospy.Time.now()
try:
self.table_move_client.send_goal(table_move_goal)
self.table_move_client.wait_for_result()
cur_pose = self.table_move_client.get_result()
try:
self.approach_table_srv()
return ButtonActionResponse()
except rospy.ROSInterruptException:
print "Table approach failed"
except rospy.ROSInterruptException:
print "Table move failed"
return ButtonActionResponse()
def main():
rospy.init_node('table_clickable')
tc = TableClickable()
rospy.spin()
if __name__ == "__main__":
main()
| [
[
1,
0,
0.0323,
0.0108,
0,
0.66,
0,
954,
0,
1,
0,
0,
954,
0,
0
],
[
1,
0,
0.0538,
0.0108,
0,
0.66,
0.0625,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0538,
0.0108,
0,
... | [
"import numpy as np",
"import roslib; roslib.load_manifest('hrl_clickable_behaviors')",
"import roslib; roslib.load_manifest('hrl_clickable_behaviors')",
"import rospy",
"import std_srvs.srv",
"import actionlib",
"from hrl_clickable_world.srv import PerceiveButtons, ButtonAction, DisplayButtons",
"fro... |
#! /usr/bin/python
import numpy as np
import roslib; roslib.load_manifest('hrl_clickable_behaviors')
import rospy
import std_srvs.srv
import actionlib
from tf.listener import TransformListener
from hrl_clickable_world.srv import PerceiveButtons, ButtonAction, DisplayButtons
from hrl_clickable_world.srv import PerceiveButtonsResponse, ButtonActionResponse
from geometry_msgs.msg import Point
from visualization_msgs.msg import Marker
from pr2_grasp_behaviors.msg import OverheadGraspSetupAction, OverheadGraspSetupGoal
from pr2_grasp_behaviors.msg import OverheadGraspAction, OverheadGraspGoal
from hrl_table_detect.srv import ObjectButtonDetect
class GraspObjButton:
def __init__(self):
self.arm = rospy.get_param("arm", "r")
self.tl = TransformListener()
self.perception_srv = rospy.Service("/clickable_world/detect_objects",
PerceiveButtons,
self.do_perception)
self.action_srv = rospy.Service("/clickable_world/grasp_object",
ButtonAction,
self.do_action)
self.obj_seg_srv = rospy.ServiceProxy("/object_button_detect",
ObjectButtonDetect)
self.grasp_client = actionlib.SimpleActionClient(self.arm + '_overhead_grasp', OverheadGraspAction)
self.grasp_client.wait_for_server()
self.grasp_setup_client = actionlib.SimpleActionClient(self.arm + '_overhead_grasp_setup', OverheadGraspSetupAction)
self.grasp_setup_client.wait_for_server()
def do_perception(self, req):
rospy.loginfo("[grasp_obj_button] Perceiving object buttons...")
# perceive object on table
self.objects = self.obj_seg_srv().objects
for i in range(len(self.objects)):
self.objects[i].color.r = 256
self.objects[i].color.g = 0
self.objects[i].color.b = 0
self.objects[i].color.a = 256
# return object buttons
resp = PerceiveButtonsResponse()
resp.buttons = self.objects
return resp
def do_action(self, req):
rospy.loginfo("[grasp_obj_button] Table clicked, grasping object...")
# put 3d pt in grasping frame
req.pixel3d.header.stamp = rospy.Time(0)
grasp_pt = self.tl.transformPoint("/torso_lift_link", req.pixel3d)
# move to grasp setup position
setup_goal = OverheadGraspSetupGoal()
setup_goal.disable_head = False
setup_goal.open_gripper = True
self.grasp_setup_client.send_goal(setup_goal)
self.grasp_setup_client.wait_for_result()
############################################################
# Creating grasp goal
grasp_goal = OverheadGraspGoal()
grasp_goal.is_grasp = True
grasp_goal.disable_head = False
grasp_goal.disable_coll = False
grasp_goal.grasp_type=OverheadGraspGoal.VISION_GRASP
grasp_goal.x = grasp_pt.point.x
grasp_goal.y = grasp_pt.point.y
grasp_goal.behavior_name = "overhead_grasp"
grasp_goal.sig_level = 0.999
############################################################
# grasp object
self.grasp_client.send_goal(grasp_goal)
self.grasp_client.wait_for_result()
result = self.grasp_client.get_result()
rospy.loginfo("[grasp_obj_button] Grasp result: %s" % result)
obj_in_hand = result.grasp_result == "Object grasped"
# go back to grasp setup
setup_goal.open_gripper = False
self.grasp_setup_client.send_goal(setup_goal)
self.grasp_setup_client.wait_for_result()
return ButtonActionResponse()
def main():
rospy.init_node('grasp_obj_button')
gob = GraspObjButton()
rospy.spin()
if __name__ == "__main__":
main()
| [
[
1,
0,
0.0303,
0.0101,
0,
0.66,
0,
954,
0,
1,
0,
0,
954,
0,
0
],
[
1,
0,
0.0505,
0.0101,
0,
0.66,
0.0625,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0505,
0.0101,
0,
... | [
"import numpy as np",
"import roslib; roslib.load_manifest('hrl_clickable_behaviors')",
"import roslib; roslib.load_manifest('hrl_clickable_behaviors')",
"import rospy",
"import std_srvs.srv",
"import actionlib",
"from tf.listener import TransformListener",
"from hrl_clickable_world.srv import Perceiv... |
#!/usr/bin/python
import roslib
roslib.load_manifest('rfid_people_following')
import rospy
from std_msgs.msg import Float64
import tf
import time
import numpy as np, math
import functools
class tf_updater():
def __init__(self, name,
right_pan = '/robotis/servo_right_pan',
right_tilt = '/robotis/servo_right_tilt',
left_pan = '/robotis/servo_left_pan',
left_tilt = '/robotis/servo_left_tilt'):
try:
rospy.init_node( name )
except:
pass
# Right pan
rospy.Subscriber( right_pan, Float64,
functools.partial( self.rpan_cb, bc = tf.TransformBroadcaster() ))
# Right tilt
rospy.Subscriber( right_tilt, Float64,
functools.partial( self.rtilt_cb, bc = tf.TransformBroadcaster() ))
# Left pan
rospy.Subscriber( left_pan, Float64,
functools.partial( self.lpan_cb, bc = tf.TransformBroadcaster() ))
# Left tilt
rospy.Subscriber( left_tilt, Float64,
functools.partial( self.ltilt_cb, bc = tf.TransformBroadcaster() ))
def rpan_cb( self, ang_msg, bc ):
# bc is a specific TransformBroadcaster
bc.sendTransform( (-0.0655, -0.0510, 0.0675),
tf.transformations.quaternion_from_euler( 0.0, 0.0, ang_msg.data - math.radians( 60.0 ) ),
rospy.Time.now(),
'ear_pan_right',
'plate_right_base' )
def rtilt_cb( self, ang_msg, bc ):
# bc is a specific TransformBroadcaster
bc.sendTransform( (0.0673, 0.0, 0.0),
tf.transformations.quaternion_from_euler( 0.0, ang_msg.data, 0.0 ),
rospy.Time.now(),
'ear_tilt_right',
'ear_pan_right' )
def lpan_cb( self, ang_msg, bc ):
# bc is a specific TransformBroadcaster
bc.sendTransform( (-0.0655, +0.0510, 0.0675),
tf.transformations.quaternion_from_euler( 0.0, 0.0, ang_msg.data + math.radians( 60.0 ) ),
rospy.Time.now(),
'ear_pan_left',
'plate_left_base' )
def ltilt_cb( self, ang_msg, bc ):
# bc is a specific TransformBroadcaster
bc.sendTransform( (0.0673, 0.0, 0.0),
tf.transformations.quaternion_from_euler( 0.0, -1.0 * ang_msg.data, 0.0 ),
rospy.Time.now(),
'ear_tilt_left',
'ear_pan_left' )
if __name__ == '__main__':
tfs = tf_updater('servo_tf_updater')
rospy.spin()
| [
[
1,
0,
0.0366,
0.0122,
0,
0.66,
0,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0488,
0.0122,
0,
0.66,
0.1111,
630,
3,
1,
0,
0,
0,
0,
1
],
[
1,
0,
0.061,
0.0122,
0,
0.6... | [
"import roslib",
"roslib.load_manifest('rfid_people_following')",
"import rospy",
"from std_msgs.msg import Float64",
"import tf",
"import time",
"import numpy as np, math",
"import functools",
"class tf_updater():\n def __init__(self, name, \n right_pan = '/robotis/servo_right_pa... |
#!/usr/bin/python
import roslib
roslib.load_manifest( 'rfid_people_following' )
import rospy
from scipy.spatial import KDTree
import numpy as np, math
import pickle as pkl
import markers
import point_cloud_utils as pcu
import time
rospy.init_node( 'traj_pub' )
print 'Loading data'
f = open( 'trajectory_caps/resutls.pkl' , 'r' )
dset = pkl.load( f )
f.close()
captures = dset['captures']
def Linf_norm( arr ):
# arr is (2,)
rv = np.max( np.abs( arr - np.array([7.0, 3.0]) ))
#print 'arr: ', arr, ' rv: ', rv
return rv
def filt( dist_min, dist_max ):
# pts = 2xN array
pts = np.array([]).reshape([4,0])
for i in range(len(captures)):
lp = load_points( captures[i][3] )
if Linf_norm( lp[0:2,0] ) >= dist_min and Linf_norm( lp[0:2,0] ) <= dist_max:
pts = np.column_stack([ pts, lp ])
fpts_3d = np.row_stack([ pts[0], pts[1], np.zeros(pts.shape[1]) ])
print fpts_3d.shape
return np.matrix( fpts_3d )
def load_points( fname ):
print 'Loading %s' % fname
f = open( fname, 'r' )
d = pkl.load( f )
f.close()
return np.array(d).T # 4xN
# kd = KDTree( np.array([ [x,y] for x,y,ang,fname in captures ]))
#ind = kd.query_ball_point( np.array([ 3.0, 3.0 ]), r=0.5 )
#pts = np.column_stack([ load_points( captures[i][3] ) for i in ind ])
# pts = np.column_stack([ load_points( captures[i][3] ) for i in range(len(captures)) ])
if __name__ == '__main__':
import optparse
p = optparse.OptionParser()
p.add_option('-x', action='store', type='float', dest='dist_max', default='20.0', help='max distance')
p.add_option('-n', action='store', type='float', dest='dist_min', default='0.0', help='min distance')
opt, args = p.parse_args()
pub = rospy.Publisher( 'traj_pub_pts', pcu.PointCloud )
# ros_pts = pcu.np_points_to_ros( np.matrix(fpts_3d) )
ros_pts = pcu.np_points_to_ros( filt( opt.dist_min, opt.dist_max ))
ros_pts.header.frame_id = '/odom_combined'
rate = rospy.Rate( 2 )
print 'Publishing PointCloud'
while not rospy.is_shutdown():
ros_pts.header.stamp = rospy.Time.now()
pub.publish( ros_pts )
rate.sleep()
# arr = np.array( res ).T
# kd = KDTree( arr[0:2].T ) # xy-only.
# X,Y = np.meshgrid( range(0,11), range(0,7) )
# #xy = np.row_stack([ X.flatten(), Y.flatten() ])
# Z = np.zeros( X.shape )
# for i in xrange( X.shape[0] ):
# for j in xrange( X.shape[1] ):
# ind = kd.query_ball_point( np.array([ X[i,j], Y[i,j] ]), r=0.5 )
# if ind:
# Z[i,j] = np.mean( arr[3,ind] )
# else:
# #print i,j
# Z[i,j] = np.nan
| [
[
1,
0,
0.0312,
0.0104,
0,
0.66,
0,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0417,
0.0104,
0,
0.66,
0.0556,
630,
3,
1,
0,
0,
0,
0,
1
],
[
1,
0,
0.0521,
0.0104,
0,
0.... | [
"import roslib",
"roslib.load_manifest( 'rfid_people_following' )",
"import rospy",
"from scipy.spatial import KDTree",
"import numpy as np, math",
"import pickle as pkl",
"import markers",
"import point_cloud_utils as pcu",
"import time",
"rospy.init_node( 'traj_pub' )",
"print('Loading data')"... |
#! /usr/bin/python
import roslib;
roslib.load_manifest('hrl_pr2_kinematics_tutorials')
roslib.load_manifest('rfid_people_following')
roslib.load_manifest('std_srvs')
roslib.load_manifest('joy')
import rospy
from rfid_people_following.srv import StringInt32_Int32
from rfid_people_following.srv import String_Int32
from rfid_people_following.srv import Int32_Int32
from rfid_people_following.srv import String_StringArr
from rfid_people_following.srv import rfid_gui as gui_srv
from rfid_people_following.srv import HandoffSrv
from std_srvs.srv import Empty
from joy.msg import Joy
from cmd_process import CmdProcess
import numpy as np, math
import time
class DemoNode():
def __init__( self ):
rospy.init_node( 'rfid_demo', anonymous = True )
rospy.logout( 'demo_node: Initializing' )
rospy.logout( 'demo_node: Waiting for services' )
rospy.wait_for_service( '/rfid_servo/servo' )
rospy.wait_for_service( '/rfid_orient/orient' )
rospy.wait_for_service( '/rfid_orient/flap' )
rospy.wait_for_service( '/rfid_handoff/initialize' )
rospy.wait_for_service( '/rfid_handoff/handoff' )
rospy.wait_for_service( '/rfid_handoff/wave' )
#rospy.wait_for_service( '/rfid_gui/select' )
rospy.logout( 'demo_node: All services ready.' )
self.last_button = time.time()
self.run_demo = False
self.run_hoinit = False
self.run_handoff = False
self._joy_sub = rospy.Subscriber( 'joy', Joy, self.joy_process )
self._servo = rospy.ServiceProxy( '/rfid_servo/servo', StringInt32_Int32 )
self.follow1 = lambda : self._servo( 'person ', 1 ) # Stops at first obs
self.follow = lambda : self._servo( 'person ', 0 ) # Runs forever
self._servo_stop = rospy.ServiceProxy( '/rfid_servo/stop_next_obs', Int32_Int32 )
self.servo_toggle = lambda : self._servo_stop( 1 )
self._handoff = rospy.ServiceProxy( '/rfid_handoff/handoff', HandoffSrv )
self.handoff = lambda : self._handoff()
self._hoinit = rospy.ServiceProxy( '/rfid_handoff/initialize', HandoffSrv )
self.hoinit = lambda : self._hoinit()
self._howave = rospy.ServiceProxy( '/rfid_handoff/wave', HandoffSrv )
self.howave = lambda : self._howave()
self._flap = rospy.ServiceProxy( '/rfid_orient/flap', String_StringArr )
self.flap = lambda : self._flap( '' )
self._orient = rospy.ServiceProxy( '/rfid_orient/orient', String_Int32 )
self.orient = lambda tagid: self._orient( tagid )
#self._gui = rospy.ServiceProxy( '/rfid_gui/select', gui_srv )
#self.gui = lambda tags: self._gui( tags )
self._service = rospy.Service( '/rfid_demo/demo', Empty, self.demo )
self._service = rospy.Service( '/rfid_demo/gui', Empty, self.gui_test )
rospy.logout( 'demo_node: Demo service ready!' )
def joy_process( self, msg ):
if msg.buttons[11] == 1 and time.time() - self.last_button > 1.0:
if msg.buttons[12] == 1: # tri + R1
rospy.logout( 'demo_node: joy_process: Calling demo service' )
p = CmdProcess( ['rosservice', 'call', '/rfid_demo/demo'] )
p.run()
self.last_button = time.time()
elif msg.buttons[13] == 1: # circle + R1
rospy.logout( 'demo_node: joy_process: Calling handoff service' )
p = CmdProcess( ['rosservice', 'call', '/rfid_handoff/handoff'] )
p.run()
self.last_button = time.time()
elif msg.buttons[14] == 1: # X + R1
rospy.logout( 'demo_node: joy_process: Calling servo toggle service' )
p = CmdProcess( ['rosservice', 'call', '/rfid_servo/stop_next_obs', '1'] )
p.run()
self.last_button = time.time()
elif msg.buttons[15] == 1: # square + R1
rospy.logout( 'demo_node: joy_process: Calling handoff initialization service' )
p = CmdProcess( ['rosservice', 'call', '/rfid_handoff/initialize'] )
p.run()
self.last_button = time.time()
elif msg.buttons[9] == 1: # R2 + R1
rospy.logout( 'demo_node: joy_process: Calling handoff wave service' )
p = CmdProcess( ['rosservice', 'call', '/rfid_handoff/wave'] )
p.run()
self.last_button = time.time()
def gui_test( self, msg = None ):
tags = self.flap().value
gui_resp = self.gui( tags )
def demo( self, msg = None ):
tags = self.flap().value
#gui_resp = self.gui( tags )
#self.orient( gui_resp.selection )
self.orient( 'person ' )
#self.follow1()
self.follow()
self.handoff()
if __name__ == '__main__':
dn = DemoNode()
rospy.spin()
| [
[
1,
0,
0.0248,
0.0083,
0,
0.66,
0,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0331,
0.0083,
0,
0.66,
0.0556,
630,
3,
1,
0,
0,
0,
0,
1
],
[
8,
0,
0.0413,
0.0083,
0,
0.... | [
"import roslib;",
"roslib.load_manifest('hrl_pr2_kinematics_tutorials')",
"roslib.load_manifest('rfid_people_following')",
"roslib.load_manifest('std_srvs')",
"roslib.load_manifest('joy')",
"import rospy",
"from rfid_people_following.srv import StringInt32_Int32",
"from rfid_people_following.srv impor... |
#! /usr/bin/python
import time
import roslib
roslib.load_manifest('rospy')
roslib.load_manifest('tf')
roslib.load_manifest('geometry_msgs')
roslib.load_manifest('std_msgs')
roslib.load_manifest('hrl_rfid')
roslib.load_manifest('robotis')
roslib.load_manifest('rfid_people_following')
import rospy
import tf
import tf.transformations as tft
from geometry_msgs.msg import Twist
from geometry_msgs.msg import PointStamped
from geometry_msgs.msg import Point
from geometry_msgs.msg import PoseStamped
from geometry_msgs.msg import Quaternion
from geometry_msgs.msg import PoseWithCovarianceStamped
from std_msgs.msg import Float64
import hrl_rfid.ros_M5e_client as rmc
import robotis.ros_robotis as rr
from hrl_rfid.msg import RFIDreadArr
import rfid_people_following.rotate_backup_node as rb
from rfid_people_following.cmd_process import CmdProcess
from rfid_people_following.srv import String_Int32
from rfid_people_following.srv import String_Int32Response
from rfid_people_following.srv import String_StringArr
from rfid_people_following.srv import StringArr_Int32
import numpy as np, math
import time
from threading import Thread
from collections import deque
from functools import reduce
PAN_RATE = 30.0
#PAN_RATE = 10.0 # Used for datacapture.
#PAN_RATE = 3.0
def calculate_angle( pt1 ):
return np.arctan2( pt1.point.y, pt1.point.x )
def standard_rad(t):
if t > 0:
return ((t + np.pi) % (np.pi * 2)) - np.pi
else:
return ((t - np.pi) % (np.pi * -2)) + np.pi
class OrientNode( ):
def __init__( self ):
rospy.logout('orient_node: Initializing')
rospy.init_node('orient_node')
# After calling "flap ears", data will look something like this:
# { 'TagID1': [[ang,rssi], [ang,rssi], ...]
# 'TagID2': ... }
# * All angles are in /base_link and rssi's from both antennas
self.data = {}
# Will be transformed into base frame to determine best turn angle -- results in approximately 5-degrees (max) error for small angle assumption
self.tag_gt = { 'EleLeftEar': PointStamped(), 'EleRightEar': PointStamped() }
self.tag_gt[ 'EleLeftEar' ].header.frame_id = '/ear_antenna_left'
self.tag_gt[ 'EleLeftEar' ].header.stamp = rospy.Time.now()
self.tag_gt[ 'EleLeftEar' ].point.x = 10.0
self.tag_gt[ 'EleRightEar' ].header.frame_id = '/ear_antenna_right'
self.tag_gt[ 'EleRightEar' ].header.stamp = rospy.Time.now()
self.tag_gt[ 'EleRightEar' ].point.x = 10.0
self.listener = tf.TransformListener()
self.listener.waitForTransform('/base_link', '/ear_antenna_left',
rospy.Time(0), timeout = rospy.Duration(100) )
self.listener.waitForTransform('/base_link', '/ear_antenna_right',
rospy.Time(0), timeout = rospy.Duration(100) )
rospy.logout('orient_node: Transforms ready')
# For movement...
self.rotate_backup_client = rb.RotateBackupClient()
# "Ears" Setup
self.p_left = rr.ROS_Robotis_Client( 'left_pan' )
self.t_left = rr.ROS_Robotis_Client( 'left_tilt' )
self.p_right = rr.ROS_Robotis_Client( 'right_pan' )
self.t_right = rr.ROS_Robotis_Client( 'right_tilt' )
self.EX_1 = 1.350
self.EX_2 = 0.920
self.p_left.move_angle( self.EX_1, math.radians(10), blocking = False )
self.p_right.move_angle( -1.0 * self.EX_1, math.radians(10), blocking = True )
self.t_left.move_angle( 0.0, math.radians(10), blocking = False )
self.t_right.move_angle( 0.0, math.radians(10), blocking = True )
while self.p_left.is_moving() or self.p_right.is_moving():
time.sleep( 0.01 )
self.bag_pid = None
self.r = rmc.ROS_M5e_Client('ears')
self.__service_flap = rospy.Service( '/rfid_orient/flap',
String_StringArr,
self.flap_ears )
self.__service_bag = rospy.Service( '/rfid_orient/bag',
StringArr_Int32,
self.bag_cap )
self.__service_orient = rospy.Service( '/rfid_orient/orient',
String_Int32,
self.orient )
self.tag_arr_sub = rospy.Subscriber( '/rfid/ears_reader_arr',
RFIDreadArr,
self.add_tags )
rospy.logout( 'orient_node: Waiting for service calls.' )
def bag_cap( self, request ):
# request.data => String array
# sample args: ['rosbag', 'record', '/tf', '/rfid/ears_reader_arr', '-o', 'data/data']
if (request.data == [] or request.data[0] == 'kill'):
if self.bag_pid == None:
rospy.logout( 'orient_node: No open bag to kill.' )
else:
rospy.logout( 'orient_node: Killing open bag.' )
self.bag_pid.kill()
self.bag_pid = None
return int( True )
s = reduce( lambda x,y: x+' '+y, request.data )
rospy.logout( 'orient_node: Calling CmdProcess with args: %s' % s )
self.bag_pid = CmdProcess( request.data )
self.bag_pid.run()
return int( True )
def orient( self, request ):
tagid = request.data
if not self.data.has_key( tagid ):
rospy.logout( 'Tag id \'%s\' not found during last scan.' % tagid )
return String_Int32Response( int( False ))
arr = np.array( self.data[ tagid ]).T
arr = arr[:,np.argsort( arr[0] )]
h, bins = np.histogram( arr[0], 36, ( -np.pi, np.pi ))
ind = np.sum(arr[0][:, np.newaxis] > bins, axis = 1) - 1 # Gives indices for data into bins
bin_centers = (bins[:-1] + bins[1:]) / 2.0
best_dir = 0.0
best_rssi = 0.0
for i in np.unique( ind ):
avg_rssi = np.mean(arr[1,np.argwhere( ind == i )])
if avg_rssi > best_rssi:
best_rssi = avg_rssi
best_dir = bin_centers[i]
rospy.logout( 'orient_node: Best dir (deg): %2.2f with avg rssi: %2.1f' %
( math.degrees(best_dir), best_rssi ))
self.rotate_backup_client.rotate_backup( best_dir, 0.0 )
return String_Int32Response( int( True ))
def add_tags( self, msg ):
for read in msg.arr:
if read.rssi == -1:
return False
self.tag_gt[ read.antenna_name ].header.stamp = rospy.Time(0)
try:
pt = self.listener.transformPoint( '/base_link',
self.tag_gt[ read.antenna_name ])
except:
rospy.logout( 'orient_node: Transform failed' )
return False
if not self.data.has_key( read.tagID ):
self.data[ read.tagID ] = []
self.data[ read.tagID ].append([ calculate_angle( pt ), 1.0 * read.rssi ])
return True
def flap_ears( self, request ):
self.data = {}
tagid = request.data
if tagid == '':
rospy.logout( 'orient_node: capture for tagid: \'\' requested. Using QueryEnv.' )
self.r.query_mode( )
else:
rospy.logout( 'orient_node: capture for tagid: \'%s\' requested' % tagid )
self.r.track_mode( tagid )
forward = False
tilt_angs = [ math.radians( 0.0 ),
math.radians( 0.0 ) ]
for ta in tilt_angs:
# Tilt
self.t_left.move_angle( ta, math.radians( 30.0 ), blocking = False )
self.t_right.move_angle( -1.0 * ta, math.radians( 30.0 ), blocking = False )
while self.t_left.is_moving() or self.t_right.is_moving():
time.sleep(0.01)
# Pan
if forward:
self.p_left.move_angle( self.EX_1, math.radians( PAN_RATE ), blocking = False )
self.p_right.move_angle( -1.0 * self.EX_1, math.radians( PAN_RATE ), blocking = True )
forward = False
else:
self.p_left.move_angle( -1.0 * self.EX_2, math.radians( PAN_RATE ), blocking = False )
self.p_right.move_angle( self.EX_2, math.radians( PAN_RATE ), blocking = True )
forward = True
while self.p_left.is_moving() or self.p_right.is_moving():
time.sleep(0.01)
time.sleep(0.1)
self.r.stop()
print self.data.keys()
# Reset / Stow
self.p_left.move_angle( self.EX_1, math.radians(10), blocking = False )
self.t_left.move_angle( 0.0, math.radians(10), blocking = False )
self.p_right.move_angle( -1.0 * self.EX_1, math.radians(10), blocking = False )
self.t_right.move_angle( 0.0, math.radians(10), blocking = False )
rospy.logout( 'orient_node: capture completed' )
# print self.data
return [self.data.keys()]
if __name__ == '__main__':
on = OrientNode()
rospy.spin()
| [
[
1,
0,
0.0085,
0.0043,
0,
0.66,
0,
654,
0,
1,
0,
0,
654,
0,
0
],
[
1,
0,
0.0128,
0.0043,
0,
0.66,
0.027,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0171,
0.0043,
0,
0... | [
"import time",
"import roslib",
"roslib.load_manifest('rospy')",
"roslib.load_manifest('tf')",
"roslib.load_manifest('geometry_msgs')",
"roslib.load_manifest('std_msgs')",
"roslib.load_manifest('hrl_rfid')",
"roslib.load_manifest('robotis')",
"roslib.load_manifest('rfid_people_following')",
"impor... |
#! /usr/bin/python
import time
import roslib
roslib.load_manifest('rospy')
roslib.load_manifest('actionlib')
roslib.load_manifest( 'move_base_msgs' )
roslib.load_manifest('tf')
roslib.load_manifest('std_srvs')
roslib.load_manifest('geometry_msgs')
roslib.load_manifest('std_msgs')
roslib.load_manifest('hrl_rfid')
roslib.load_manifest('robotis')
roslib.load_manifest('rfid_people_following')
import rospy
import tf
import tf.transformations as tft
import actionlib
from move_base_msgs.msg import MoveBaseAction, MoveBaseGoal
from geometry_msgs.msg import Twist
from geometry_msgs.msg import PointStamped
from geometry_msgs.msg import Point
from geometry_msgs.msg import PoseStamped
from geometry_msgs.msg import Quaternion
from geometry_msgs.msg import PoseWithCovarianceStamped
from std_msgs.msg import Float64
from std_srvs.srv import Empty
from rfid_people_following.srv import *
import numpy as np, math
import os
import time
import pickle as pkl
from threading import Thread
from collections import deque
class BasePose( Thread ):
def __init__( self ):
self.should_run = True
Thread.__init__( self )
self.listener = tf.TransformListener()
self.listener.waitForTransform('/base_link', '/map',
rospy.Time(0), timeout = rospy.Duration(100) )
self.ps = PointStamped()
self.ps.header.frame_id = '/base_link'
self.pts = []
self.start()
def run( self ):
rate = rospy.Rate( 5 )
while self.should_run and not rospy.is_shutdown():
try:
self.ps.header.stamp = rospy.Time(0)
ps_map = self.listener.transformPoint( '/odom_combined', self.ps )
x = ps_map.point.x
y = ps_map.point.y
self.pts.append([ x, y ])
except:
rospy.logout( 'base_pose: Failed transform.' )
pass
rate.sleep()
def stop(self):
self.should_run = False
self.join(3)
if (self.isAlive()):
raise RuntimeError("ServoMode: unable to stop thread")
# sm = ServoMode( self.follow1 )
class ServoMode( Thread ):
def __init__( self, func ):
self.done = False
self.should_run = True
Thread.__init__( self )
self.func = func
self.start()
def run( self ):
self.func()
self.done = True
while self.should_run and not rospy.is_shutdown():
rospy.sleep(0.1)
def stop(self):
self.should_run = False
self.join(3)
if (self.isAlive()):
raise RuntimeError("ServoMode: unable to stop thread")
class SimCapture():
def __init__( self ):
try:
rospy.init_node( 'sim_capture' )
except:
pass
rospy.logout( 'sim_capture: Initializing' )
self.listener = tf.TransformListener()
self.listener.waitForTransform('/base_link', '/map',
rospy.Time(0), timeout = rospy.Duration(100) )
rospy.logout( 'sim_capture: Waiting for services' )
self._sh = rospy.Service( '/sim_capture/capture' , FloatFloatFloatFloat_Int32, self.capture )
rospy.wait_for_service( '/rfid_servo/servo' )
rospy.wait_for_service( '/rfid_servo/abort' )
rospy.wait_for_service( '/rotate_backup/navstack' )
self._servo = rospy.ServiceProxy( '/rfid_servo/servo', StringInt32_Int32 )
self.follow1 = lambda : self._servo( 'person ', 1 ) # Stops at first obs
self._abort = rospy.ServiceProxy( '/rfid_servo/abort', Empty )
self.abort = lambda : self._abort( ) # Kill current servoing
self._navstack = rospy.ServiceProxy( '/rotate_backup/navstack' , FloatFloatFloatFloat_Int32 )
self.navstack = lambda x,y,z,theta: self._navstack( x,y,z,theta )
rospy.logout( 'sim_capture: Services ready' )
def capture( self, request, fname = None ):
rospy.logout( 'sim_capture: New capture initiated @ %3.2f.' % rospy.Time.now().to_sec() )
rospy.logout( 'sim_capture: Moving to <%3.2f, %3.2f, %3.2f> %3.2f-deg' % ( request.x,
request.y,
request.z,
math.degrees( request.ang )))
self.navstack( request.x, request.y, request.z, request.ang )
rospy.logout( 'sim_capture: Arrived at location.' )
rospy.logout( 'sim_capture: Initializing recorder and servoing.' )
ps = PointStamped()
ps.header.frame_id = '/base_link'
ps2 = PointStamped()
ps2.header.frame_id = '/base_link'
ps2.point.x = 0.1
# Begin Servoing. Warning: Hack!
sm = ServoMode( self.follow1 )
#bp = BasePose( )
pts = []
t0 = rospy.Time.now().to_sec()
while sm.done == False:
if rospy.Time.now().to_sec() - t0 > 180:
rospy.logout( 'sim_capture: Time up. Aborting.' )
self.abort()
try:
ps.header.stamp = rospy.Time(0)
ps_map = self.listener.transformPoint( '/map', ps )
x = ps_map.point.x
y = ps_map.point.y
ps2.header.stamp = rospy.Time(0)
ps2_map = self.listener.transformPoint( '/map', ps2 )
pts.append([ x, y, ps2_map.point.x, ps2_map.point.y ])
inside = x > -0.5 and x < 10.5 and y > -0.5 and y < 6.5
if not inside:
self.abort()
except:
rospy.logout( 'sim_capture: Failed transform.' )
pass
rospy.sleep( 0.2 )
rospy.logout( 'sim_capture: Done servoing.' )
#pts = list( bp.pts )
sm.stop()
#bp.stop()
# Stop recorder and shuttle to disk.
if fname:
f = open( fname, 'w' )
else:
f = open( 'trajectory_caps/' + str(int(time.time())) + '_cap.pkl', 'w' )
pkl.dump( pts, f )
f.close()
rospy.logout( 'sim_capture: Capture complete' )
return int( True )
if __name__ == '__main__':
sc = SimCapture()
rospy.spin()
| [
[
1,
0,
0.01,
0.005,
0,
0.66,
0,
654,
0,
1,
0,
0,
654,
0,
0
],
[
1,
0,
0.0149,
0.005,
0,
0.66,
0.0286,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0199,
0.005,
0,
0.66,... | [
"import time",
"import roslib",
"roslib.load_manifest('rospy')",
"roslib.load_manifest('actionlib')",
"roslib.load_manifest( 'move_base_msgs' )",
"roslib.load_manifest('tf')",
"roslib.load_manifest('std_srvs')",
"roslib.load_manifest('geometry_msgs')",
"roslib.load_manifest('std_msgs')",
"roslib.l... |
#! /usr/bin/python
import time
import roslib
roslib.load_manifest('rospy')
roslib.load_manifest('actionlib')
roslib.load_manifest( 'move_base_msgs' )
roslib.load_manifest('tf')
roslib.load_manifest('geometry_msgs')
roslib.load_manifest('std_msgs')
roslib.load_manifest('hrl_rfid')
roslib.load_manifest('robotis')
roslib.load_manifest('rfid_people_following')
import rospy
import tf
import tf.transformations as tft
import actionlib
from move_base_msgs.msg import MoveBaseAction, MoveBaseGoal
from geometry_msgs.msg import Twist
from geometry_msgs.msg import PointStamped
from geometry_msgs.msg import Point
from geometry_msgs.msg import PoseStamped
from geometry_msgs.msg import Quaternion
from geometry_msgs.msg import PoseWithCovarianceStamped
from std_msgs.msg import Float64
from rfid_people_following.srv import FloatFloat_Int32
from rfid_people_following.srv import FloatFloat_Int32Response
from rfid_people_following.srv import FloatFloatFloatFloat_Int32
import numpy as np, math
import time
from threading import Thread
from collections import deque
def standard_rad(t):
if t > 0:
return ((t + np.pi) % (np.pi * 2)) - np.pi
else:
return ((t - np.pi) % (np.pi * -2)) + np.pi
class RotateBackup():
def __init__( self, service_name = '/rotate_backup' ):
try:
rospy.init_node( 'rotater' )
except:
pass
rospy.logout( 'rotate_backup: Initializing service: \'%s\'' % service_name )
self.pub = rospy.Publisher( '/move_base_simple/goal', PoseStamped )
self.pub_direct = rospy.Publisher( '/navigation/cmd_vel', Twist )
self.listener = tf.TransformListener()
self.listener.waitForTransform('/odom_combined', '/base_link',
rospy.Time(0), timeout = rospy.Duration(100) )
self._service_rb = rospy.Service( service_name, FloatFloat_Int32, self.move)
self._service_rb_navstack = rospy.Service( service_name+'/navstack', FloatFloatFloatFloat_Int32, self.navstack)
rospy.logout( 'rotate_backup: Service ready' )
def non_nav_rotate( self, r ):
success, pose, orient = self.get_pose() # orient = rx, ry, rz
if not success:
rospy.logout( 'rotate_backup: Rotate transform fail. Exiting.' )
return
t_rz = standard_rad( orient[-1] + r )
mov = Twist()
mov.linear.x = 0.05
mov.angular.z = 0.6 * np.sign( r )
rate = rospy.Rate( 10 )
while not np.allclose( [t_rz], [orient[-1]], atol=[0.08] ): # Not within 5deg of target
success, pose, orient = self.get_pose() # orient = rx, ry, rz
orient[-1] = standard_rad( orient[-1] )
if not success:
rospy.logout( 'rotate_backup: Rotate transform fail. Exiting.' )
return
self.pub_direct.publish( mov )
rate.sleep()
def non_nav_backup( self, d ):
# Hacky way to backup without relying on nav_stack's bizarre circling.
mov = Twist()
mov.linear.x = 0.1 * np.sign( d )
t0 = time.time()
rate = rospy.Rate( 10.0 )
while time.time() - t0 < np.abs(d) / 0.1:
self.pub_direct.publish( mov )
rate.sleep()
def get_pose( self ):
ps = PoseStamped()
ps.header.stamp = rospy.Time(0)
ps.header.frame_id = '/base_link'
#ps.pose.position.x = d
try:
ps_odom = self.listener.transformPose( '/odom_combined', ps )
except:
rospy.logout( 'rotate_backup: Failed transform #1.' )
time.sleep( 2.0 )
return False, [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]
orient = ps_odom.pose.orientation
rx, ry, rz = tft.euler_from_quaternion([ orient.x, orient.y, orient.z, orient.w ])
pose = [ ps_odom.pose.position.x, ps_odom.pose.position.y, ps_odom.pose.position.z ]
return True, pose, [rx, ry, rz]
# Hacky version not using actionlib
# def wait_for_stop( self, duration = 0.5 ):
# rospy.logout( 'rotate_backup: Waiting for movement to stop.' )
# t0 = time.time()
# rate = rospy.Rate( 10 )
# success, pose, orient = self.get_pose()
# if not success:
# rospy.logout( 'rotate_backup: Waiting 2 sec.' )
# time.sleep( 2.0 )
# return
# sp = np.array([ pose[0], pose[1], pose[2], orient[-1] ])
# while time.time() - t0 < duration:
# success, pose, orient = self.get_pose()
# if not success:
# rospy.logout( 'rotate_backup: Waiting 2 sec.' )
# time.sleep( 2.0 )
# return
# qp = np.array([ pose[0], pose[1], pose[2], orient[-1] ])
# if not np.allclose( sp, qp, atol=[0.01, 0.01, 0.01, 0.005] ):
# t0 = time.time()
# sp = qp
# rate.sleep()
# return
def move( self, request ):
r = request.rotate
d = request.displace
rospy.logout( 'rotate_backup: Asked to rotate: %3.2f (deg)' % math.degrees(r))
rospy.logout( 'rotate_backup: Asked to translate (forward-backward): %3.2f (m)' % d)
self.non_nav_backup( d )
self.non_nav_rotate( r )
# success, pose, orient = self.get_pose()
# if not success:
# return FloatFloat_Int32Response( int(False) )
# new_point = Point( pose[0], pose[1], pose[2] )
# old_rx, old_ry, old_rz = orient
# new_orient = tft.quaternion_from_euler( old_rx, old_ry, old_rz + r )
# new_quat = Quaternion( *new_orient )
# new_ps = PoseStamped()
# new_ps.header.stamp = rospy.Time(0)
# new_ps.header.frame_id = '/odom_combined'
# new_ps.pose.position = new_point
# new_ps.pose.orientation = new_quat
# self.pub.publish( new_ps )
# self.wait_for_stop()
# rospy.logout( 'rotate_backup: Done with call.' )
return FloatFloat_Int32Response( int(True) )
# Hacky version not using actionlib
# def navstack( self, request ):
# new_orient = tft.quaternion_from_euler( 0.0, 0.0, request.ang ) # rx, ry, rz
# new_quat = Quaternion( *new_orient )
# new_ps = PoseStamped()
# new_ps.header.stamp = rospy.Time(0)
# new_ps.header.frame_id = '/map'
# new_ps.pose.position.x = request.x
# new_ps.pose.position.y = request.y
# new_ps.pose.orientation = new_quat
# rospy.logout( 'rotate_backup: Requesting navstack move to <x,y,ang-deg> %3.3f %3.3f %3.3f.' % (request.x, request.y, math.degrees(request.ang)) )
# self.pub.publish( new_ps )
# rospy.logout( 'rotate_backup: Waiting for base to stop moving.' )
# self.wait_for_stop( 7.0 )
# return int( True )
def navstack( self, request ):
rospy.logout( 'rotate_backup: Requesting navstack move to <x,y,ang-deg> %3.3f %3.3f %3.3f.' % (request.x, request.y, math.degrees(request.ang)) )
client = actionlib.SimpleActionClient( 'move_base', MoveBaseAction )
client.wait_for_server()
ps = PoseStamped()
ps.header.frame_id = '/map'
ps.header.stamp = rospy.Time(0)
ps.pose.position.x = request.x
ps.pose.position.y = request.y
ps.pose.orientation = Quaternion( *tft.quaternion_from_euler( 0.0, 0.0, request.ang ))
goal = MoveBaseGoal( ps )
client.send_goal( goal )
rospy.logout( 'rotate_backup: Waiting for base to stop moving.' )
client.wait_for_result()
return int( True )
class RotateBackupClient():
def __init__( self, service_name = '/rotate_backup' ):
rospy.logout( 'rotate_backup_client: Waiting for service: \'%s\'' % service_name )
rospy.wait_for_service( service_name )
rospy.logout( 'rotate_backup_client: Service ready.' )
self._rb_service = rospy.ServiceProxy( service_name, FloatFloat_Int32 )
def rotate_backup( self, rotate, displace ):
return self._rb_service( rotate, displace )
if __name__ == '__main__':
rb = RotateBackup()
rospy.spin()
| [
[
1,
0,
0.0092,
0.0046,
0,
0.66,
0,
654,
0,
1,
0,
0,
654,
0,
0
],
[
1,
0,
0.0138,
0.0046,
0,
0.66,
0.0303,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0184,
0.0046,
0,
... | [
"import time",
"import roslib",
"roslib.load_manifest('rospy')",
"roslib.load_manifest('actionlib')",
"roslib.load_manifest( 'move_base_msgs' )",
"roslib.load_manifest('tf')",
"roslib.load_manifest('geometry_msgs')",
"roslib.load_manifest('std_msgs')",
"roslib.load_manifest('hrl_rfid')",
"roslib.l... |
db = {
'person ': { 'humanread': 'Person',
'img': 'person.jpg' },
'LightSwitch1': { 'humanread': 'Light Switch',
'img': 'LightSwitch1.jpg' }
}
| [
[
14,
0,
0.5833,
1,
0,
0.66,
0,
761,
0,
0,
0,
0,
0,
6,
0
]
] | [
"db = {\n 'person ': { 'humanread': 'Person',\n 'img': 'person.jpg' },\n 'LightSwitch1': { 'humanread': 'Light Switch',\n 'img': 'LightSwitch1.jpg' }\n}"
] |
import roslib
roslib.load_manifest( 'rfid_people_following' )
roslib.load_manifest( 'tf' )
roslib.load_manifest( 'geometry_msgs' )
roslib.load_manifest('hrl_rfid')
import rospy
from hrl_rfid.msg import RFIDread
from hrl_rfid.msg import RFIDreadArr
from hrl_rfid.srv import RfidSrv
import tf
from geometry_msgs.msg import PointStamped
import sys, serial, time, string
from threading import Thread
import friis
import pickle as pkl
import numpy as np, math
# A nice functional print function (Norvig)
def prin(x): print x
f = open( '/home/travis/svn/data_robot1/rfid_data/pan_captures/model_fit.pkl', 'r' )
d = pkl.load( f )
f.close()
def calculate_angle( pt1 ):
return np.arctan2( pt1.point.y, pt1.point.x )
class M5e:
"Interface to Mercury M5e and M5e-Compact"
def __init__(self, portSTR='/dev/robot/RFIDreader', baudrate=9600,
TXport=1, RXport=1, readPwr=2300, protocol='GEN2', compact=True, verbosity_func=prin):
# verbosity_func should alawys take string as an input. Lets us choose a selective
# print function (like rospy.logout) instead of built-in print.
self.TXport = TXport # Initialized transmit antenna
self.RXport = RXport # Initialized receive antenna
self.readPwr = readPwr # Initialized read TX power in centi-dBm
self.protocol = protocol # Initialized protocol
self.compact = compact
self.prin = verbosity_func
self.ser = None
try:
rospy.init_node( 'RFID_Simulator_Friis' )
except rospy.ROSException:
pass
self.prin( 'Initializing M5e (or M5e-Compact)' )
self.listener = tf.TransformListener()
rospy.logout('Simulated M5e: Waiting for odom_combined-antenna tf')
self.listener.waitForTransform('/ear_antenna_left', '/odom_combined',
rospy.Time(0), timeout = rospy.Duration(100) )
self.listener.waitForTransform('/ear_antenna_right', '/odom_combined',
rospy.Time(0), timeout = rospy.Duration(100) )
self.listener.waitForTransform('/left_rotation_center', '/odom_combined',
rospy.Time(0), timeout = rospy.Duration(100) )
self.listener.waitForTransform('/right_rotation_center', '/odom_combined',
rospy.Time(0), timeout = rospy.Duration(100) )
self.listener.waitForTransform('/base_link', '/odom_combined',
rospy.Time(0), timeout = rospy.Duration(100) )
self.listener.waitForTransform('/tag_gt', '/odom_combined',
rospy.Time(0), timeout = rospy.Duration(100) )
rospy.logout('Simulated M5e: Transforms ready')
self.prin( 'M5e Initialized' )
def ChangeAntennaPorts(self, TXport, RXport):
"Changes TX and RX ports"
self.TXport = TXport
self.RXport = RXport
# Currently Unimplemented!
def QueryEnvironment(self, timeout=50):
rospy.sleep( timeout * 0.001 )
return []
# Relies on a single tag whose coord frame is '/tag_gt'
# Lots of hardcoding... boo!
def TrackSingleTag(self, tagID, timeout=50):
rospy.sleep( timeout * 0.001 )
# 6DOF params -- Calculate these using tf
ant_zp = PointStamped()
ant_zp.header.stamp = rospy.Time(0)
tag_zp = PointStamped()
tag_zp.header.stamp = rospy.Time(0)
tag_zp.header.frame_id = '/tag_gt'
if self.TXport == 1 and self.RXport == 1: # 'EleLeftEar'
ear_frame = '/ear_antenna_left'
else: # 'EleRightEar'
ear_frame = '/ear_antenna_right'
ant_zp.header.frame_id = ear_frame
# should probably catch exceptions and throw big warnings...
tag_in_ant = self.listener.transformPoint( ear_frame, tag_zp )
ant_in_tag = self.listener.transformPoint( '/tag_gt', ant_zp )
tag_in_ant_sphere = np.array( friis.CartToSphere2( tag_in_ant.point.x,
tag_in_ant.point.y,
tag_in_ant.point.z ))
ant_in_tag_sphere = np.array( friis.CartToSphere2( ant_in_tag.point.x,
ant_in_tag.point.y,
ant_in_tag.point.z ))
# Determine Friis Powers
Ptag = friis.pwr_inc_tag( tag_in_ant_sphere[0], # radius
friis.patch.G, tag_in_ant_sphere[1], tag_in_ant_sphere[2],
friis.dipole.G, ant_in_tag_sphere[1], ant_in_tag_sphere[2] )
Prdr = friis.pwr_inc_rdr( tag_in_ant_sphere[0], # radius
friis.patch.G, tag_in_ant_sphere[1], tag_in_ant_sphere[2],
friis.dipole.G, ant_in_tag_sphere[1], ant_in_tag_sphere[2] )
Prdr_dBm = friis.WattsToDBm( Prdr )
# Calculate expectation (read/no-read and RSSI if applicable)
sim_read = Ptag > friis.DBmToWatts( -18.0 )
sim_rssi_ind = np.sum( Prdr_dBm > d['bins'][:-1] ) - 1
sim_rssi_ind = np.clip( sim_rssi_ind, 0, sim_rssi_ind ) # if less than 0 (power lower than in previous data)
sim_rssi = d['mean_rssi'][sim_rssi_ind]
if sim_read:
return int(sim_rssi) # be a little more accurate by returning int
else:
return -1
# Modeled off lib_M5e.M5e_Poller
class ROS_M5e( Thread ):
QUERY_MODE = 'query'
TRACK_MODE = 'track'
def __init__(self, name = 'reader1', readPwr = 2300,
portStr = '/dev/robot/RFIDreader',
antFuncs = [], callbacks = []):
Thread.__init__(self)
self.should_run = True
try:
rospy.init_node( 'rfid_m5e_' + name )
except rospy.ROSException:
pass
self.mode = ''
self.name = name + '_reader'
rospy.logout( 'ROS_M5e: Launching RFID Reader' )
rospy.logout( 'ROS_M5e: Please check out our related work @ http://www.hsi.gatech.edu/hrl/project_rfid.shtml' )
rospy.logout( 'ROS_M5e: '+self.name+' Building & Connecting to reader' )
def prin( x ): rospy.logout( 'ROS_M5e: lib_M5e: ' + x ) # use rospy.logout in underlying lib's output
self.reader = M5e(readPwr=readPwr, portSTR = portStr, verbosity_func = prin)
self.antFuncs = antFuncs
self.callbacks = callbacks + [self.broadcast]
rospy.logout( 'ROS_M5e: publishing RFID reader with type RFIDread to channel /rfid/'+name+'_reader' )
self.channel = rospy.Publisher('/rfid/'+name+'_reader', RFIDread)
self.pub_arr = rospy.Publisher('/rfid/'+name+'_reader_arr', RFIDreadArr)
self._mode_service_obj = rospy.Service('/rfid/'+name+'_mode',
RfidSrv, self._mode_service)
rospy.logout( 'ROS_M5e: '+self.name+' Inialized and awaiting instructions' )
self.start() # Thread: calls self.run()
def run( self ):
while self.should_run:
if self.mode == self.QUERY_MODE:
for aF in self.antFuncs:
antennaName = aF(self.reader) # let current antFunc make appropriate changes
results = self.reader.QueryEnvironment()
if len(results) == 0:
results = [[ '', -1 ]] # [[ tagid, rssi ], ...]
#datum = [antennaName, '', -1]
#[cF(datum) for cF in self.callbacks]
arr = []
t_now = rospy.Time.now()
for tagid, rssi in results:
rv = RFIDread( None, antennaName, tagid, rssi )
rv.header.stamp = t_now
arr.append( rv )
datum = [antennaName, tagid, rssi]
[cF(datum) for cF in self.callbacks]
rfid_arr = RFIDreadArr()
rfid_arr.header.stamp = t_now
rfid_arr.arr = arr
self.pub_arr.publish( rfid_arr )
elif self.mode == self.TRACK_MODE:
for aF in self.antFuncs:
antennaName = aF(self.reader) # let current antFunc make appropriate changes
tagid = self.tag_to_track
rssi = self.reader.TrackSingleTag(tagid, timeout=100)
t_now = rospy.Time.now()
rv = RFIDread( None, antennaName, tagid, rssi )
rv.header.stamp = t_now
rfid_arr = RFIDreadArr()
rfid_arr.header.stamp = t_now
rfid_arr.arr = [rv]
self.pub_arr.publish( rfid_arr )
#if rssi != -1:
datum = [antennaName, tagid, rssi]
[cF(datum) for cF in self.callbacks]
else:
time.sleep(0.005)
rospy.logout( 'ROS_M5e: '+self.name+' Shutting down reader' )
def stop( self ):
self.should_run = False
self.join(3)
if (self.isAlive()):
raise RuntimeError("ROS_M5e: unable to stop thread")
def broadcast(self, data):
antName, tagid, rssi = data
rv = RFIDread( None, antName, tagid, rssi )
rv.header.stamp = rospy.Time.now()
self.channel.publish( rv )
# For internal use only
def _mode_service(self, data):
val = data.data
if len(val) == 0:
rospy.logout( 'ROS_M5e: Mode Service called with invalid argument: ' + str(val) )
elif len(val) == 1:
if val[0] == self.QUERY_MODE:
rospy.logout( 'ROS_M5e: '+self.name+' Entering Query Mode' )
self.mode = self.QUERY_MODE
else:
rospy.logout( 'ROS_M5e: '+self.name+' Stopping Reader' )
self.mode = ''
elif len(val) == 2:
if val[0] == self.TRACK_MODE and len(val[1]) == 12:
rospy.logout( 'ROS_M5e: '+self.name+' Entering Track Mode: ' + str(val[1]) )
self.mode = self.TRACK_MODE
self.tag_to_track = val[1]
else:
rospy.logout( 'ROS_M5e: Mode Service called with invalid argument: ' + str(val) )
else:
rospy.logout( 'ROS_M5e: Mode Service called with invalid argument: ' + str(val) )
return True
# -----------------------------------------------
# Likely Callbacks: (various antennas)
# -----------------------------------------------
def EleLeftEar(M5e):
M5e.ChangeAntennaPorts(1,1)
rospy.sleep(0.010)
return 'EleLeftEar'
def EleRightEar(M5e):
M5e.ChangeAntennaPorts(2,2)
rospy.sleep(0.010)
return 'EleRightEar'
def Hand_Right_1(M5e):
# GPIO1 = 1, GPIO2 = 0
M5e.TransmitCommand('\x02\x96\x01\x01')
M5e.ReceiveResponse()
M5e.TransmitCommand('\x02\x96\x02\x00')
M5e.ReceiveResponse()
return 'Hand_Right_1'
def Hand_Right_2(M5e):
# GPIO1 = 1, GPIO2 = 1
M5e.TransmitCommand('\x02\x96\x01\x01')
M5e.ReceiveResponse()
M5e.TransmitCommand('\x02\x96\x02\x01')
M5e.ReceiveResponse()
return 'Hand_Right_2'
def Hand_Left_1(M5e):
# GPIO1 = 0, GPIO2 = 0
M5e.TransmitCommand('\x02\x96\x01\x00')
M5e.ReceiveResponse()
M5e.TransmitCommand('\x02\x96\x02\x00')
M5e.ReceiveResponse()
return 'Hand_Left_1'
def Hand_Left_2(M5e):
# GPIO1 = 0, GPIO2 = 1
M5e.TransmitCommand('\x02\x96\x01\x00')
M5e.ReceiveResponse()
M5e.TransmitCommand('\x02\x96\x02\x01')
M5e.ReceiveResponse()
return 'Hand_Left_2'
def PrintDatum(data):
ant, ids, rssi = data
print data
| [
[
1,
0,
0.0033,
0.0033,
0,
0.66,
0,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0066,
0.0033,
0,
0.66,
0.0357,
630,
3,
1,
0,
0,
0,
0,
1
],
[
8,
0,
0.0099,
0.0033,
0,
0.... | [
"import roslib",
"roslib.load_manifest( 'rfid_people_following' )",
"roslib.load_manifest( 'tf' )",
"roslib.load_manifest( 'geometry_msgs' )",
"roslib.load_manifest('hrl_rfid')",
"import rospy",
"from hrl_rfid.msg import RFIDread",
"from hrl_rfid.msg import RFIDreadArr",
"from hrl_rfid.srv import Rf... |
#!/usr/bin/python
import roslib
roslib.load_manifest( 'robotis' )
import rospy
import robotis.ros_robotis as rr
import time
import math
if __name__ == '__main__':
p_left = rr.ROS_Robotis_Client( 'left_pan' )
t_left = rr.ROS_Robotis_Client( 'left_tilt' )
p_left.move_angle( -1.370, math.radians(10), blocking = False )
t_left.move_angle( 0.0, math.radians(10), blocking = False )
p_right = rr.ROS_Robotis_Client( 'right_pan' )
t_right = rr.ROS_Robotis_Client( 'right_tilt' )
p_right.move_angle( 1.370, math.radians(10), blocking = False )
t_right.move_angle( 0.0, math.radians(10), blocking = False )
| [
[
1,
0,
0.125,
0.0417,
0,
0.66,
0,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.1667,
0.0417,
0,
0.66,
0.1667,
630,
3,
1,
0,
0,
0,
0,
1
],
[
1,
0,
0.2083,
0.0417,
0,
0.6... | [
"import roslib",
"roslib.load_manifest( 'robotis' )",
"import rospy",
"import robotis.ros_robotis as rr",
"import time",
"import math",
"if __name__ == '__main__':\n p_left = rr.ROS_Robotis_Client( 'left_pan' )\n t_left = rr.ROS_Robotis_Client( 'left_tilt' )\n \n p_left.move_angle( -1.370, m... |
#! /usr/bin/python
import roslib
roslib.load_manifest('rfid_people_following')
roslib.load_manifest('pr2_msgs')
roslib.load_manifest('std_msgs')
import rospy
from pr2_msgs.msg import PressureState
from std_msgs.msg import Float64
from rfid_people_following.srv import FloatFloat_Int32
import numpy as np, math
import time, string
def default_mag_func( x ):
return np.sum( np.abs( x ))
class TactileSensor( ):
def __init__( self, topic = '/pressure/r_gripper_motor',
mag_func = default_mag_func ):
rospy.logout( 'tactile_sensor: Initializing' )
try:
rospy.init_node( 'tactile_sensor' )
except:
pass
self.mag_func = mag_func
self.left = None
self.right = None
self.l_bias = None
self.r_bias = None
self.topic = topic
self.pub = rospy.Publisher( '/readings/' + string.replace(topic,'/','_') + '_mag', Float64 )
self.service = rospy.Service( '/readings/' + string.replace(topic,'/','_') + '_serv',
FloatFloat_Int32,
self.thresh_service )
self.reg_sensor( )
while self.left == None or self.right == None:
time.sleep( 0.1 )
self.unreg_sensor()
rospy.logout( 'tactile_sensor: Ready' )
def reg_sensor( self ):
self.sub = rospy.Subscriber( self.topic, PressureState, self.cb )
time.sleep( 0.3 )
def unreg_sensor( self ):
self.sub.unregister()
def cb( self, msg ):
self.left = np.array( list( msg.l_finger_tip ), dtype=float )
self.right = np.array( list( msg.r_finger_tip ), dtype=float )
if self.l_bias == None or self.r_bias == None:
self.l_bias = np.zeros( len( self.left ))
self.r_bias = np.zeros( len( self.right ))
self.l_read = np.copy( self.left - self.l_bias )
self.r_read = np.copy( self.right - self.r_bias )
self.mag = self.mag_func( np.append( self.l_read, self.r_read ))
#print np.append( self.l_read, self.r_read )
self.pub.publish( self.mag )
def bias( self ):
self.reg_sensor()
rospy.logout( 'tactile_sensor: Biasing' )
self.l_bias = np.copy( self.left )
self.r_bias = np.copy( self.right )
self.unreg_sensor()
return True
def read( self ):
return np.copy( self.l_read ), np.copy( self.r_read )
def thresh_service( self, request ):
self.thresh_detect( request.rotate, request.displace ) # yeah, jacked up names
return int( True )
def thresh_detect( self, threshold, timeout = 100.0 ):
rospy.logout( 'tactile_sensor: Threshold detector activated: %3.2f, timeout: %d' % (threshold, timeout))
self.bias()
self.reg_sensor()
t0 = time.time()
t_diff = time.time() - t0
lp = t0 # Printing status messages
while self.mag < threshold and t_diff < timeout:
if time.time() - lp > 1.0:
lp = time.time()
rospy.logout( 'tactile_sensor: Threshold still undetected' )
time.sleep( 0.05 )
t_diff = time.time() - t0
self.unreg_sensor()
rospy.logout( 'tactile_sensor: Detected (or timeout)' )
return self.mag
if __name__ == '__main__':
import optparse
p = optparse.OptionParser()
p.add_option('-r', '--right', action='store_true', dest='right', default=False,
help='Right finger')
p.add_option('-l', '--left', action='store_true', dest='left', default=False,
help='left finger')
opt, args = p.parse_args()
if opt.right:
r_tact = TactileSensor('/pressure/r_gripper_motor')
if opt.left:
l_tact = TactileSensor('/pressure/l_gripper_motor')
rospy.spin()
# print 'Reading: ', r_tact.read()
# raw_input('Hit [ENTER]')
# r_tact.bias()
# time.sleep(3.0)
# print 'Reading: ', r_tact.read()
# raw_input('Hit [ENTER]')
# print 'COMBINED:', np.append( *r_tact.read() )
# print 'ERR:', np.sum(np.abs( np.append( *r_tact.read() )))
# print 'Waiting for thresh'
# r_tact.thresh_detect( 5000 )
| [
[
1,
0,
0.0147,
0.0074,
0,
0.66,
0,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0221,
0.0074,
0,
0.66,
0.0833,
630,
3,
1,
0,
0,
0,
0,
1
],
[
8,
0,
0.0294,
0.0074,
0,
0.... | [
"import roslib",
"roslib.load_manifest('rfid_people_following')",
"roslib.load_manifest('pr2_msgs')",
"roslib.load_manifest('std_msgs')",
"import rospy",
"from pr2_msgs.msg import PressureState",
"from std_msgs.msg import Float64",
"from rfid_people_following.srv import FloatFloat_Int32",
"import nu... |
#! /usr/bin/python
import time
import roslib
roslib.load_manifest('rospy')
roslib.load_manifest('geometry_msgs')
roslib.load_manifest('hrl_rfid')
roslib.load_manifest('robotis')
import time
import rospy
from geometry_msgs.msg import Twist
import numpy as np, math
import hrl_rfid.ros_M5e_client as rmc
import robotis.ros_robotis as rr
from threading import Thread
class ServoNode( Thread ):
def __init__( self ):
Thread.__init__( self )
self.should_run = True
rospy.logout('servo_node: Initializing')
rospy.init_node('servo_node')
# Unfold "ears" to servo positions
p_left = rr.ROS_Robotis_Client( 'left_pan' )
t_left = rr.ROS_Robotis_Client( 'left_tilt' )
p_left.move_angle( math.radians(-40), math.radians(10), blocking = False )
t_left.move_angle( 0.0, math.radians(10), blocking = False )
p_right = rr.ROS_Robotis_Client( 'right_pan' )
t_right = rr.ROS_Robotis_Client( 'right_tilt' )
p_right.move_angle( math.radians(40), math.radians(10), blocking = False )
t_right.move_angle( 0.0, math.radians(10), blocking = False )
self.reader = rmc.ROS_M5e_Client('ears')
self.reader.track_mode('person ')
# Use assisted teleop as pseudo-callback to see if valid movement:
self.check_pub = rospy.Publisher( 'rfid_cmd_vel_check', Twist )
self.sub = rospy.Subscriber( "assisted_teleop_response", Twist, self.callback )
self.command_pub = rospy.Publisher( "rfid_cmd_vel", Twist )
self.moving = True
time.sleep(3.0) # give antennas time to settle
self.start()
def callback( self, msg ):
#print 'Hit callback: ', msg
self.response_received = True
self.response = msg
def sloppy_check( self, desired_movement, timeout = 5.0 ):
#print 'Checking: ', desired_movement
# Simple statemachine with self.callback. Checks to see if
# assisted teleop returns an unaltered command
self.response_received = False
self.response = Twist()
self.check_pub.publish( desired_movement )
t0 = time.time()
# wait for the callback to be received
while not self.response_received and time.time() - t0 < timeout and self.should_run and not rospy.is_shutdown():
time.sleep(0.01)
# Apply some hysteresis to starting & stopping conditions
if self.moving:
if self.response.linear.x > 0.04:
self.moving = True # As long as safe move is within 40%, keep moving
return self.response, True
else:
self.moving = False
return Twist(), False # Otherwise stop
else:
if self.response.linear.x > 0.075:
self.moving = True # Wait until it is within 75% to resume movement
return self.response, True
else:
self.moving = False
return Twist(), False # Otherwise remain stop
def run( self ):
rospy.logout('servo_node: Running')
filt_x = []
filt_z = []
while self.should_run and not rospy.is_shutdown():
left = self.reader.read('EleLeftEar')[-1]
if left == -1 or left < 75:
left = 75
right = self.reader.read('EleRightEar')[-1]
if right == -1 or right < 75:
right = 75
check = Twist()
check.linear.x = 0.1
check.angular.z = 0.07 * (left - right)/5.0
safe_move, continue_moving = self.sloppy_check( check )
if continue_moving:
filt_z.append( check.angular.z )
filt_x.append( check.linear.x )
else:
filt_z.append( 0.0 )
filt_x.append( 0.0 )
if len( filt_z ) < 5 or len( filt_x ) < 5: # let the 5-point averager fill up.
continue
filt_z = filt_z[1:]
filt_x = filt_x[1:]
filt_movement = Twist()
filt_movement.linear.x = np.average( filt_x )
filt_movement.angular.z = np.average( filt_z )
self.command_pub.publish( filt_movement )
time.sleep(0.01)
# Stop the RFID reader (conserve power and hardware)
try:
r.stop()
except:
# If servo_node is being run in the same launch file, stop is a
# race condition with service disappearing. Just ignore.
pass
self.command_pub.publish( Twist() ) # Halt the base (just in case)
rospy.logout('servo_node: Exiting')
def stop( self ):
self.should_run = False
self.join(3)
if (self.isAlive()):
raise RuntimeError("servo_node: unable to stop thread")
if __name__ == '__main__':
sn = ServoNode()
rospy.spin()
sn.stop()
| [
[
1,
0,
0.0132,
0.0066,
0,
0.66,
0,
654,
0,
1,
0,
0,
654,
0,
0
],
[
1,
0,
0.0199,
0.0066,
0,
0.66,
0.0714,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0265,
0.0066,
0,
... | [
"import time",
"import roslib",
"roslib.load_manifest('rospy')",
"roslib.load_manifest('geometry_msgs')",
"roslib.load_manifest('hrl_rfid')",
"roslib.load_manifest('robotis')",
"import time",
"import rospy",
"from geometry_msgs.msg import Twist",
"import numpy as np, math",
"import hrl_rfid.ros_... |
#!/usr/bin/python
# Merges functionality from ros_M5e in hrl_rfid package.
# if opt.device == 'ears':
# print 'Starting Ears RFID Services'
# ros_rfid = ROS_M5e( name = 'ears', readPwr = opt.power,
# portStr = '/dev/robot/RFIDreader',
# antFuncs = [EleLeftEar, EleRightEar],
# callbacks = [] )
# rospy.spin()
# ros_rfid.stop()
import roslib
roslib.load_manifest( 'robotis' )
roslib.load_manifest( 'hrl_rfid' )
roslib.load_manifest( 'rfid_people_following' )
import rospy
import time
from threading import Thread
# The Servers need to distinguish b/w real vs. simulated!
# They implement same services / functions. (Clients unaffected)
import os
if os.environ.has_key('ROBOT') and os.environ['ROBOT'] == 'sim':
import rfid_people_following.robotis_servo_sim as rr
import rfid_people_following.M5e_reader_sim as rM5e
else:
import robotis.ros_robotis as rr
import hrl_rfid.ros_M5e as rM5e
if __name__ == '__main__':
# p_right = rr.ROS_Robotis_Poller( '/dev/robot/servo1', [29,30], ['right_pan', 'right_tilt'] )
# p_left = rr.ROS_Robotis_Poller( '/dev/robot/servo0', [27,28], ['left_pan', 'left_tilt'] )
p_right = rr.ROS_Robotis_Poller( '/dev/robot/servo1', [29,30], ['right_pan', 'right_tilt'] )
p_left = rr.ROS_Robotis_Poller( '/dev/robot/servo0', [27,28], ['left_pan', 'left_tilt'] )
# p_right = rr.ROS_Robotis_Poller( '/dev/robot/servo0', [29,30], ['right_pan', 'right_tilt'] )
# p_left = rr.ROS_Robotis_Poller( '/dev/robot/servo1', [27,28], ['left_pan', 'left_tilt'] )
ros_rfid = rM5e.ROS_M5e( name = 'ears', readPwr = 3000,
portStr = '/dev/robot/RFIDreader',
antFuncs = [ rM5e.EleLeftEar, rM5e.EleRightEar ],
callbacks = [] )
rospy.spin()
ros_rfid.stop()
p_right.stop()
p_left.stop()
| [
[
1,
0,
0.2745,
0.0196,
0,
0.66,
0,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.2941,
0.0196,
0,
0.66,
0.1111,
630,
3,
1,
0,
0,
0,
0,
1
],
[
8,
0,
0.3137,
0.0196,
0,
0.... | [
"import roslib",
"roslib.load_manifest( 'robotis' )",
"roslib.load_manifest( 'hrl_rfid' )",
"roslib.load_manifest( 'rfid_people_following' )",
"import rospy",
"import time",
"from threading import Thread",
"import os",
"if os.environ.has_key('ROBOT') and os.environ['ROBOT'] == 'sim':\n import rfi... |
#!/usr/bin/python
import roslib
roslib.load_manifest('rfid_people_following')
roslib.load_manifest('geometry_msgs')
import rospy
import tf
from geometry_msgs.msg import PointStamped
import time
rospy.init_node('ground_truth_tag_pose')
listener = tf.TransformListener()
# listener.waitForTransform('/l_gripper_tool_frame', '/ear_antenna_left',
# rospy.Time(0), timeout = rospy.Duration(10) )
listener.waitForTransform('/l_gripper_tool_frame', '/map',
rospy.Time(0), timeout = rospy.Duration(10) )
rate = rospy.Rate(2)
while not rospy.is_shutdown():
p = PointStamped()
p.header.stamp = rospy.Time(0)
p.header.frame_id = '/l_gripper_tool_frame'
p.point.x = 0.015 # Frame is actually in middle of fingers. Move it out to tips
#p_earl = listener.transformPoint('/ear_antenna_left', p)
p_earl = listener.transformPoint('/map', p)
print '<x,y,z> = <%2.3f, %2.3f, %2.3f> ' % ( p_earl.point.x, p_earl.point.y, p_earl.point.z )
rate.sleep()
| [
[
1,
0,
0.0968,
0.0323,
0,
0.66,
0,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.129,
0.0323,
0,
0.66,
0.0909,
630,
3,
1,
0,
0,
0,
0,
1
],
[
8,
0,
0.1613,
0.0323,
0,
0.6... | [
"import roslib",
"roslib.load_manifest('rfid_people_following')",
"roslib.load_manifest('geometry_msgs')",
"import rospy",
"import tf",
"from geometry_msgs.msg import PointStamped",
"import time",
"rospy.init_node('ground_truth_tag_pose')",
"listener = tf.TransformListener()",
"listener.waitForTra... |
#!/usr/bin/python
import roslib
roslib.load_manifest( 'robotis' )
roslib.load_manifest( 'hrl_rfid' )
roslib.load_manifest( 'geometry_msgs' )
import rospy
import robotis.ros_robotis as rr
import hrl_rfid.ros_M5e_client as rmc
from geometry_msgs.msg import PointStamped
import time
import math
from threading import Thread
import optparse
class TagGroundTruth( Thread ):
def __init__( self, tag_x, tag_y, tag_z, baseframe = '/map', date = '' ):
Thread.__init__( self )
self.should_run = True
self.tag_gt = PointStamped()
self.tag_gt.header.stamp = rospy.Time(0)
self.tag_gt.header.frame_id = baseframe
self.tag_gt.point.x = tag_x
self.tag_gt.point.y = tag_y
self.tag_gt.point.z = tag_z
rospy.logout('Publishing tag groundtruth at <%4.3f, %4.3f, %4.3f> in frame %s' % ( tag_x, tag_y, tag_z, baseframe ))
self.pub = rospy.Publisher( 'tag_gt/' + date, PointStamped )
self.start()
def run( self ):
rate = rospy.Rate( 5 )
while self.should_run and not rospy.is_shutdown():
self.tag_gt.header.stamp = rospy.Time.now()
self.pub.publish( self.tag_gt )
rate.sleep()
def stop(self):
self.should_run = False
self.join(3)
if (self.isAlive()):
raise RuntimeError("Unable to stop thread")
if __name__ == '__main__':
p = optparse.OptionParser()
p.add_option('-x', action='store', type='float', dest='x', default=None,
help='tag groundtruth pose in x')
p.add_option('-y', action='store', type='float', dest='y', default=None,
help='tag groundtruth pose in y')
p.add_option('-z', action='store', type='float', dest='z', default=None,
help='tag groundtruth pose in z')
p.add_option('-d', action='store', type='string', dest='date', default=None,
help='date (yyyymmdd)')
opt, args = p.parse_args()
rospy.init_node( 'flapper' )
if opt.x == None or opt.y == None or opt.z == None or opt.date == None:
print 'Requires <x,y,z> and date arguments!'
exit()
p_left = rr.ROS_Robotis_Client( 'left_pan' )
t_left = rr.ROS_Robotis_Client( 'left_tilt' )
p_right = rr.ROS_Robotis_Client( 'right_pan' )
t_right = rr.ROS_Robotis_Client( 'right_tilt' )
EX_1 = 1.350
EX_2 = 0.520 # 30 deg.
# EX_2 = -1.000
tgt = TagGroundTruth( opt.x, opt.y, opt.z, '/map', opt.date )
p_left.move_angle( -1.0 * EX_1, math.radians(10), blocking = False )
t_left.move_angle( 0.0, math.radians(10), blocking = False )
p_right.move_angle( EX_1, math.radians(10), blocking = False )
t_right.move_angle( 0.0, math.radians(10), blocking = False )
forward = True
while not rospy.is_shutdown():
if not p_left.is_moving() and not p_right.is_moving():
if forward:
p_left.move_angle( -1.0 * EX_1, math.radians(30), blocking = False )
p_right.move_angle( EX_1, math.radians(30), blocking = False )
forward = False
else:
p_left.move_angle( EX_2, math.radians(30), blocking = False )
p_right.move_angle( -1.0 * EX_2, math.radians(30), blocking = False )
forward = True
time.sleep(0.1)
tgt.stop()
| [
[
1,
0,
0.0306,
0.0102,
0,
0.66,
0,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0408,
0.0102,
0,
0.66,
0.0769,
630,
3,
1,
0,
0,
0,
0,
1
],
[
8,
0,
0.051,
0.0102,
0,
0.6... | [
"import roslib",
"roslib.load_manifest( 'robotis' )",
"roslib.load_manifest( 'hrl_rfid' )",
"roslib.load_manifest( 'geometry_msgs' )",
"import rospy",
"import robotis.ros_robotis as rr",
"import hrl_rfid.ros_M5e_client as rmc",
"from geometry_msgs.msg import PointStamped",
"import time",
"import m... |
import time
import roslib
roslib.load_manifest('rospy')
roslib.load_manifest('actionlib')
roslib.load_manifest( 'move_base_msgs' )
roslib.load_manifest('tf')
roslib.load_manifest('std_srvs')
roslib.load_manifest('geometry_msgs')
roslib.load_manifest('std_msgs')
roslib.load_manifest('hrl_rfid')
roslib.load_manifest('robotis')
roslib.load_manifest('rfid_people_following')
import rospy
import tf
import tf.transformations as tft
import actionlib
from move_base_msgs.msg import MoveBaseAction, MoveBaseGoal
from geometry_msgs.msg import Twist
from geometry_msgs.msg import PointStamped
from geometry_msgs.msg import Point
from geometry_msgs.msg import PoseStamped
from geometry_msgs.msg import Quaternion
from geometry_msgs.msg import PoseWithCovarianceStamped
from std_msgs.msg import Float64
from std_srvs.srv import Empty
rospy.init_node( 'trial' )
import sim_capture
bp = sim_capture.BasePose()
# listener = tf.TransformListener()
# listener.waitForTransform('/base_link', '/odom_combined',
# rospy.Time(0), timeout = rospy.Duration(100) )
# ps = PointStamped()
# ps.header.frame_id = '/base_link'
# while True:
# ps.header.stamp = rospy.Time(0)
# ps_map = listener.transformPoint( '/odom_combined', ps )
# print ps_map.point.x, ps_map.point.y
# rospy.sleep( 0.2 )
# # try:
# # ps_map = self.listener.transformPoint( '/odom_combined', ps )
# # self.pts.append([ ps_map.point.x, ps.map.point.y ])
# # except:
# # rospy.logout( 'sim_capture: Failed transform.' )
# # pass
| [
[
1,
0,
0.0377,
0.0189,
0,
0.66,
0,
654,
0,
1,
0,
0,
654,
0,
0
],
[
1,
0,
0.0566,
0.0189,
0,
0.66,
0.037,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0755,
0.0189,
0,
0... | [
"import time",
"import roslib",
"roslib.load_manifest('rospy')",
"roslib.load_manifest('actionlib')",
"roslib.load_manifest( 'move_base_msgs' )",
"roslib.load_manifest('tf')",
"roslib.load_manifest('std_srvs')",
"roslib.load_manifest('geometry_msgs')",
"roslib.load_manifest('std_msgs')",
"roslib.l... |
#!/usr/bin/python
import roslib
roslib.load_manifest('rfid_people_following')
import rospy
import rfid_people_following.db_rfid as db_rfid
from rfid_people_following.srv import rfid_gui as gui_srv
import time
import string
import pygame
import pygame.display
import pygame.locals
import pygame.transform
import numpy as np, math
class ROS_UI_Robot():
def __init__(self, init=True):
if init:
try:
print 'Initializing RFID UI on Robot'
rospy.init_node('RFID_UI_Robot',anonymous=True)
except rospy.ROSException:
pass
self.tag_pub = rospy.Publisher('/hrl/ele/UI_Robot',RFID_Interface)
print 'RFID UI on Robot Running'
print 'Connecting to RFID UI on PC'
self.selected_tag = ''
self.selection = []
rospy.Subscriber('/hrl/ele/UI_PC_Selection', RFID_Interface, self.selection_cb, None, 1)
# def publish_tag_ids(self, tagIDs):
# ''' tagIDs is a list of strings '''
# for tag in tagIDs:
# rt = String()
# rt.data = tag
# self.tag_pub.publish( rt )
# time.sleep(0.2)
# rt.data = '-1'
# self.tag_pub.publish( rt )
# time.sleep(0.002)
def publish_tag_ids(self, tagIDs):
pub_msg = RFID_Interface()
pub_msg.tagIDs = tagIDs
pub_msg.humanread = []
pub_msg.actions = []
self.tag_pub.publish( pub_msg )
time.sleep(0.002)
# def selection_cb(self, pc_msg):
# self.selected_tag = pc_msg.data
# print 'Received tag selection from UI: ', self.selected_tag
# return self.selected_tag
def selection_cb(self, rfid_msg):
tagID = rfid_msg.tagIDs[0]
action = rfid_msg.actions[0]
humanread = rfid_msg.humanread[0]
self.selection = [tagID, humanread, action]
#print 'Received selection from UI: ', self.selection
def receive_response(self):
while self.selection == []:
time.sleep(0.02)
rv = self.selection
self.selection = []
return rv
# def receive_response(self):
# rt = String()
# rt = self.listener.read()
# return rt.data
class RFID_GUI():
def __init__(self, graphical=False, db = None):
try:
rospy.init_node('rfid_gui',anonymous=True)
except rospy.ROSException:
pass
rospy.logout( 'rfid_gui: Initializing' )
self.graphical = graphical
self.images_path = 'db_images/'
self.db = db
self._srv = rospy.Service( '/rfid_gui/select', gui_srv, self.gui_response )
rospy.logout( 'rfid_gui: Waiting for service calls.' )
def gui_response(self, request):
keys = request.keys
keys = [ k for k in keys if self.db.has_key( k ) ]
humanread = [ self.db[ k ]['humanread'] for k in keys ]
imgs = [ self.db[ k ]['img'] for k in keys ]
if len( keys ) == 0:
rospy.logout( 'rfid_gui: No items to select from. Fail.' )
return False, ''
# elif len( keys ) == 1:
# rospy.logout( 'rfid_gui: Only one to select from. Autoreturn: %s' % keys[0] )
# return True, keys[0]
# Get the selection (returned as RFID_Interface message)
if self.graphical:
success, selection = self.get_selection_graphical( keys, humanread, imgs )
else:
success, selection = self.get_selection_text( keys, humanread, imgs )
return int(success), selection
def get_selection_text( self, keys, humanread, imgs ):
# keys has at least one items.
ind = -1
while ind.__class__ != (1).__class__ or ind < 0 or ind > len( keys ) - 1:
print 'Make a selection:'
for i, hr in enumerate( humanread ):
print '\t(%d) %s' % (i, hr)
resp = raw_input()
try:
ind = string.atoi( resp )
except:
ind = ''
pass
rospy.logout( 'rfid_gui: Returning selection: %s' % humanread[ ind ] )
return True, keys[ ind ]
def smart_scale(self, image):
ims = np.array(image.get_size(),dtype='float')
scale = self.imheight / np.max(ims)
return pygame.transform.scale(image, tuple(ims*scale))
def calc_blit_loc(self, image, center_pos):
ims = np.array(image.get_size(), dtype='float')
horiz = center_pos[0] - self.imheight/2 + (self.imheight - ims[0]) / 2.
vert = center_pos[1] - self.imheight/2 + (self.imheight - ims[1]) / 2.
return (horiz, vert)
def get_selection_graphical( self, keys, humanread, imgs ):
# keys has at least one items.
pygame.init()
self.s_width = 600
self.s_height = 700
srf = pygame.display.set_mode((self.s_width,self.s_height))
fps = 100
loopFlag = True
clk = pygame.time.Clock()
obj = [srf, fps, clk]
self.imheight = 175.
w = self.s_width * 1.0
h = self.s_height * 1.0
blit_pos = [[ w/3-w/6, h/3-h/6],
[ w/3-w/6+w/3, h/3-h/6],
[ w/3-w/6+2*w/3, h/3-h/6],
[ w/3-w/6, h/3-h/6+h/3],
[ w/3-w/6+w/3, h/3-h/6+h/3],
[ w/3-w/6+2*w/3, h/3-h/6+h/3],
[ w/3-w/6, h/3-h/6+2*h/3],
[ w/3-w/6+w/3, h/3-h/6+2*h/3],
[ w/3-w/6+2*w/3, h/3-h/6+2*h/3]]
images = []
surfaces = []
blit_loc = []
for i, k in enumerate(keys):
rospy.logout( 'rfid_gui: Loading image: %s' % self.images_path + imgs[i] )
k_image = pygame.image.load(self.images_path + imgs[i]).convert()
k_image = self.smart_scale(k_image)
images.append( k_image )
blit_loc.append( blit_pos[i] )
#pygame.display.set_mode(tag_images[i].get_size())
#tag_surfaces.append(pygame.display.get_surface())
srf.blit(k_image, self.calc_blit_loc(k_image,blit_loc[i]))
ind = self.get_selection( obj, images, humanread, blit_loc )
rospy.logout( 'rfid_gui: Returning selection: %s' % humanread[ ind ] )
return True, keys[ ind ]
def put_bottom_text( self, srf, text ):
font = pygame.font.Font(None, 25)
box = font.render(text, 1,(10, 10, 10, 0))
ts = box.get_size()
horiz = self.s_width / 2.0 - ts[0]/2.0
vt = self.s_height - 50.0 - ts[1]/2.0
srf.blit(box, (horiz, vt))
return True
def draw_rect(self, srf, blit_loc):
width = self.imheight * 1.10
height = self.imheight *1.10
horiz = blit_loc[0] - width / 2.0
vert = blit_loc[1] - height / 2.0
pygame.draw.rect(srf, (255, 0, 0), (horiz, vert, width, height))
width = self.imheight * 1.01
height = self.imheight *1.01
horiz = blit_loc[0] - width / 2.0
vert = blit_loc[1] - height / 2.0
pygame.draw.rect(srf, (255, 255, 255), (horiz, vert, width, height))
return True
def get_selection( self, obj, images, humanread, blit_loc ):
[srf, fps, clk] = obj
loopFlag = True
ind = 0
pos = (0,0)
while loopFlag:
# Clear the screen
srf.fill((255,255,255))
diffs = np.array(blit_loc) - np.array(pos)
ind = np.argmin( np.sum( np.power( diffs, 2.0 ), axis = 1 ) )
self.put_bottom_text( srf, humanread[ind] )
self.draw_rect(srf, blit_loc[ind])
for i, image in enumerate(images):
srf.blit(image, self.calc_blit_loc(image,blit_loc[i]))
#print 'going'
pygame.display.flip()
events = pygame.event.get()
for e in events:
if e.type==pygame.locals.QUIT:
loopFlag=False
if e.type==pygame.locals.KEYDOWN:
if e.key == 27: # Esc
loopFlag=False
if e.type == pygame.locals.MOUSEMOTION:
pos = e.pos
if e.type==pygame.locals.MOUSEBUTTONDOWN:
if e.button == 1:
# left button
pos = e.pos
diffs = np.array(blit_loc) - np.array(pos)
ind = np.argmin( np.sum( np.power( diffs, 2.0 ), axis = 1 ) )
loopFlag = False
clk.tick(fps)
srf.fill((255,255,255))
pygame.display.flip()
clk.tick(fps)
return ind
# pc = ROS_UI_PC(init = False, graphical = True)
# pc.get_selection_graphical(['LightSwitch1','LightSwitch1'],
# ['lightswitch','LightSwitch1'],
# [['on','off'],['on','off']])
if __name__ == '__main__':
import optparse
p = optparse.OptionParser()
p.add_option('-d', action='store_true', dest='graphical',
help='Use a graphical display.', default=False)
opt, args = p.parse_args()
gui = RFID_GUI( graphical = opt.graphical, db = db_rfid.db )
rospy.spin()
# while True:
# print 'Waiting for robot action(s)...\n'
# pc.publish_selected_id()
# pc.ids = []
# pc.ids_done = False
# On the Robot's side:
# ro = ROS_UI_Robot()
# ro.publish_tag_ids(['one','two','hello'])
# ro.receive_response()
| [
[
1,
0,
0.0107,
0.0036,
0,
0.66,
0,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0143,
0.0036,
0,
0.66,
0.0714,
630,
3,
1,
0,
0,
0,
0,
1
],
[
1,
0,
0.0179,
0.0036,
0,
0.... | [
"import roslib",
"roslib.load_manifest('rfid_people_following')",
"import rospy",
"import rfid_people_following.db_rfid as db_rfid",
"from rfid_people_following.srv import rfid_gui as gui_srv",
"import time",
"import string",
"import pygame",
"import pygame.display",
"import pygame.locals",
"imp... |
import subprocess as sb
import os
class CmdProcess:
def __init__(self, cmd_list):
self.cmd_list= cmd_list
self.process = None
def run(self):
self.process = sb.Popen(self.cmd_list)
def kill(self):
os.system('kill -2 %d' % self.process.pid)
| [
[
1,
0,
0.0714,
0.0714,
0,
0.66,
0,
394,
0,
1,
0,
0,
394,
0,
0
],
[
1,
0,
0.1429,
0.0714,
0,
0.66,
0.5,
688,
0,
1,
0,
0,
688,
0,
0
],
[
3,
0,
0.6429,
0.7857,
0,
0.6... | [
"import subprocess as sb",
"import os",
"class CmdProcess:\n \n def __init__(self, cmd_list):\n self.cmd_list= cmd_list\n self.process = None\n\n def run(self):\n self.process = sb.Popen(self.cmd_list)",
" def __init__(self, cmd_list):\n self.cmd_list= cmd_list\n ... |
#! /usr/bin/python
# Taken from Tiffany & Kelsey and readapted to my needs.
import roslib
roslib.load_manifest('hrl_pr2_lib')
roslib.load_manifest('ar_pose')
roslib.load_manifest('rfid_people_following')
import rospy
import tf
import actionlib
from actionlib_msgs.msg import GoalStatus
from pr2_controllers_msgs.msg import PointHeadAction, PointHeadGoal
from geometry_msgs.msg import PointStamped
from rfid_people_following.srv import FloatFloatFloatFloat_Int32 as arm_srv
from ar_pose.msg import ARMarkers
import time
from threading import Thread
import numpy as np, math
def ctime():
return rospy.Time.now().to_time()
def goal( frame, pos, d ):
g = PointHeadGoal()
g.target.header.frame_id = frame
g.target.point.x = pos[0]
g.target.point.y = pos[1]
g.target.point.z = pos[2]
g.min_duration = rospy.Duration( d )
# Note, looking @ head action source, it seems pointing_frame unimplemented...
# Just account with a static offset (for now) where desired.
return g
class ARtagDetect():
def __init__( self ):
try:
rospy.init_node('ar_detect_tracker')
except: # Parent already initialized
pass
self.found_tag = False
self.settling = False
self.last_pos = [ 0.54, 0.0, 0.35 ]
self.last_logout = ctime()
self.hc = actionlib.SimpleActionClient('/head_traj_controller/point_head_action', PointHeadAction) # headclient
self.hc.wait_for_server()
self.listener = tf.TransformListener()
self.listener.waitForTransform('/torso_lift_link', '/openni_rgb_optical_frame',
rospy.Time(0), timeout = rospy.Duration(100) )
self.artag_sub = rospy.Subscriber( '/artag_marker_handoff',
ARMarkers,
self.processARtag )
self.abort = False
rospy.logout('ARtagDetect: Ready and Running.')
def processARtag( self, msg ):
if msg.markers != []:
frame = msg.markers[0].header.frame_id
p = msg.markers[0].pose.pose.position
pt = PointStamped()
pt.header.frame_id = frame
pt.point.x = p.x
pt.point.y = p.y
pt.point.z = p.z
pt.header.stamp = rospy.Time(0)
try:
pt_bl = self.listener.transformPoint( '/torso_lift_link', pt )
pbl = pt_bl.point
# pointing_frame manual offset (should actually be on p.y,
# but this is a good approximation with less noise in robot frame).
pbl.z = pbl.z - 0.2
self.last_pos = [ pbl.x, pbl.y, pbl.z ]
if not self.found_tag:
self.hc.cancel_all_goals() # stop searching
self.found_tag = True
except:
print pt
rospy.logout( 'ARtagDetect: Transform failed' )
return False
else:
if not self.found_tag and ctime() - self.last_logout > 3.0:
rospy.logout( 'ARtag still undetected...' )
self.last_logout = ctime()
def scan( self ):
rate = rospy.Rate(10)
self.hc.send_goal( goal( 'torso_lift_link', [0.54, 0.2, 0.25], 2.0 ))
self.hc.wait_for_result()
rospy.logout('ARtagDetect: starting sweep')
cmds = [ [0.54, -0.2, 0.25],
[0.54, 0.2, -0.10],
[0.54, -0.2, 0.0],
[0.54, 0.2, 0.20],
[0.54, -0.2, 0.30],
[0.54, 0.0, 0.35] ]
q_rate = rospy.Rate(30)
for cmd in cmds:
self.hc.send_goal( goal( 'torso_lift_link', cmd, 6.0 ))
self.hc.wait_for_result( rospy.Duration( 6.0 ))
if self.found_tag or self.abort:
break
if not self.found_tag or self.abort:
self.hc.cancel_all_goals() # just in case
self.hc.send_goal( goal( 'torso_lift_link', [0.54, 0.0, 0.35], 2.0 ))
self.hc.wait_for_result()
return (False, 'torso_lift_link', self.last_pos)
self.hc.cancel_all_goals() # just in case
rate.sleep()
rospy.logout('ARtagDetect: Tag detected!')
self.settling = True
settle = ctime()
pos = list( self.last_pos )
#while not rospy.is_shutdown():
while ctime() - settle < 1.5 and not self.abort:
self.hc.send_goal( goal( 'torso_lift_link', self.last_pos, 1.0 ))
self.hc.stop_tracking_goal()
if not np.allclose( pos, self.last_pos, rtol=0.15 ): # not settled within 5cm per axis?
print 'Pos: ', pos, ' LastPos: ', self.last_pos
settle = ctime() # reset counter
pos = list( self.last_pos ) # reset basis pose
rate.sleep()
self.hc.cancel_all_goals() # just in case
rate.sleep()
# return (success, link, pose)
rospy.logout( 'Tag found!' )
self.settling = False
return (True, 'torso_lift_link', pos)
class ARthread( Thread ):
def __init__( self ):
Thread.__init__( self )
self.should_run = True
self.d = ARtagDetect()
self.should_scan = False
self.res = False, 'linkname', [1.0, 1.0, 1.0]
self.success = False
self.logtime = ctime()
self.logtime1 = ctime()
self.start()
def run( self ):
r = rospy.Rate( 10 )
while self.should_run and not rospy.is_shutdown():
if self.should_scan and not self.success:
self.d.abort = False
self.d.found_tag = False
self.d.settling = False
self.res = self.d.scan()
self.success, link, pos = self.res
r.sleep()
def scan( self ):
if ctime() - self.logtime > 3.0:
self.logtime = ctime()
rospy.logout('ARthread: started scanning')
#self.res = False, 'linkname', [1.0, 1.0, 1.0]
self.should_scan = True
def found_tag( self ):
return self.d.found_tag
def settling( self ):
return self.d.settling
def abort( self ):
if ctime() - self.logtime1 > 3.0:
self.logtime1 = ctime()
rospy.logout('ARthread: scanning aborted.')
self.should_scan = False
self.d.abort = True
def stop( self ):
self.should_run = False
self.join(10)
if (self.isAlive()):
raise RuntimeError("ARNode: unable to stop thread")
if __name__ == '__main__':
ar = ARthread()
print 'Starting scann'
ar.scan()
print 'Sleeping 10 sec.'
time.sleep( 10.0 )
ar.abort()
print 'Aborted...'
print 'Result: ', ar.res
ar.stop()
# if __name__ == '__main__':
# detector = ARtagDetect( )
# print 'done'
# rospy.wait_for_service( '/rfid_handoff/handoff_pos' )
# print 'done1'
# _hopos = rospy.ServiceProxy( '/rfid_handoff/handoff_pos', arm_srv )
# hopos = lambda x,y,z,a: _hopos( x,y,z,a )
# success, link, pos = detector.scan()
# print 'Pos: ', pos
# x,y,z = pos
# ang = 0.0
# if success == True:
# # hacky! Pull the handoff point (wrist) 36cm closer to robot in xy-plane
# r = np.sqrt( x ** 2.0 + y ** 2.0 )
# theta = np.arctan2( y, x )
# r = r - 0.36
# x_new = r * np.cos( theta )
# print 'x_new: ', x_new
# y_new = r * np.sin( theta )
# hopos( x_new, y_new, z + 0.20, ang )
| [
[
1,
0,
0.0175,
0.0044,
0,
0.66,
0,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0218,
0.0044,
0,
0.66,
0.0526,
630,
3,
1,
0,
0,
0,
0,
1
],
[
8,
0,
0.0262,
0.0044,
0,
0.... | [
"import roslib",
"roslib.load_manifest('hrl_pr2_lib')",
"roslib.load_manifest('ar_pose')",
"roslib.load_manifest('rfid_people_following')",
"import rospy",
"import tf",
"import actionlib",
"from actionlib_msgs.msg import GoalStatus",
"from pr2_controllers_msgs.msg import PointHeadAction, PointHeadGo... |
#! /usr/bin/python
# Directly stolen from Tiffany. Thanks! ;-)
import roslib
roslib.load_manifest('hrl_pr2_lib')
import rospy
import actionlib
from actionlib_msgs.msg import *
from pr2_controllers_msgs.msg import *
from geometry_msgs.msg import *
import numpy as np
import dynamic_reconfigure.client #to turn on/off projector
try:
rospy.init_node('tmp_headmove')
except:
pass
class Head():
def __init__(self ):
# rospy.init_node('move_the_head', anonymous=True)
self.client = actionlib.SimpleActionClient('/head_traj_controller/point_head_action', PointHeadAction)
self.client.wait_for_server()
self.goal = PointHeadGoal()
def set_pose(self, pos):
self.goal.target.header.frame_id = 'torso_lift_link'
self.goal.target.point.x = pos[0]
self.goal.target.point.y = pos[1]
self.goal.target.point.z = pos[2]
self.goal.min_duration = rospy.Duration(1.0)
self.client.send_goal(self.goal)
self.client.wait_for_result()
if self.client.get_state() == GoalStatus.SUCCEEDED:
print "Succeeded"
else:
print "Failed"
#Borrowed from Kelsey's hrl_pr2_lib/simple_grasp_learner.py
def change_projector_mode(self, on):
client = dynamic_reconfigure.client.Client("camera_synchronizer_node")
node_config = client.get_configuration()
node_config["projector_mode"] = 2
if on:
node_config["narrow_stereo_trig_mode"] = 3
else:
node_config["narrow_stereo_trig_mode"] = 4
client.update_configuration(node_config)
if __name__ == '__main__':
head = Head()
pos = np.matrix([.54, 0.0, 0.9]).T
head.set_pose(pos)
#rospy.sleep(5.0)
#rospy.logout('Moved the head, done pausing.')
head.change_projector_mode(False)
| [
[
1,
0,
0.069,
0.0172,
0,
0.66,
0,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0862,
0.0172,
0,
0.66,
0.0909,
630,
3,
1,
0,
0,
0,
0,
1
],
[
1,
0,
0.1034,
0.0172,
0,
0.6... | [
"import roslib",
"roslib.load_manifest('hrl_pr2_lib')",
"import rospy",
"import actionlib",
"from actionlib_msgs.msg import *",
"from pr2_controllers_msgs.msg import *",
"from geometry_msgs.msg import *",
"import numpy as np",
"import dynamic_reconfigure.client \t#to turn on/off projector",
"try:\... |
#! /usr/bin/python
import time
import roslib
roslib.load_manifest('rospy')
roslib.load_manifest('geometry_msgs')
roslib.load_manifest('std_msgs')
roslib.load_manifest('hrl_rfid')
roslib.load_manifest('robotis')
roslib.load_manifest('rfid_people_following')
import time
import rospy
from geometry_msgs.msg import Twist
from std_msgs.msg import Float64
from rfid_people_following.srv import StringInt32_Int32
from rfid_people_following.srv import Int32_Int32
from rfid_people_following.srv import StringInt32_Int32Response
from std_srvs.srv import Empty
import numpy as np, math
import os
import hrl_rfid.ros_M5e_client as rmc
import robotis.ros_robotis as rr
from threading import Thread
from collections import deque
SCORE_BUFFER_LEN = 5
SCORE_BUFFER_MOVE = 3 # number of checked buffer elements that must not be -1.
ANGLE_FILTER_LEN = 5
ANGLE_SLEW = math.radians( 10 )
def ctime():
return rospy.Time.now().to_time()
class ServoNode( ):
def __init__( self ):
rospy.logout('servo_node: Initializing')
try:
rospy.init_node('servo_node')
except:
pass
# Unfold "ears" to servo positions
self.p_left = rr.ROS_Robotis_Client( 'left_pan' )
self.t_left = rr.ROS_Robotis_Client( 'left_tilt' )
self.p_right = rr.ROS_Robotis_Client( 'right_pan' )
self.t_right = rr.ROS_Robotis_Client( 'right_tilt' )
# Use assisted teleop as pseudo-callback to see if valid movement:
self.scores = deque()
self.og_pub = rospy.Publisher( 'assisted_teleop_check', Twist )
self.og_sub = rospy.Subscriber( 'assisted_teleop_score', Float64, self.og_score_cb )
self.command_pub = rospy.Publisher( 'rfid_cmd_vel', Twist )
self._service_servo = rospy.Service('/rfid_servo/servo',
StringInt32_Int32,
self.run )
self._service_stop = rospy.Service('/rfid_servo/stop', Empty, self.servo_stop )
self._service_stop = rospy.Service('/rfid_servo/abort', Empty, self.servo_abort )
self._service_stop_next_obs = rospy.Service('/rfid_servo/stop_next_obs', Int32_Int32, self.stop_request )
self.stop_next_obs = False # run forever
self.should_run = True
self.abort = False
rospy.logout( 'servo_node: Service ready and waiting' )
def stop_request( self, msg = None ):
#self.stop_next_obs = bool( msg.data )
self.stop_next_obs = not self.stop_next_obs
rospy.logout( 'servo_node: Stop after next obstacle flag set to %s' % str( self.stop_next_obs ))
return True
def servo_stop( self, msg = None ):
# Note... should now be called "toggle"
self.should_run = not self.should_run
rospy.logout( 'servo_node: Toggled should_run to %s' % str( self.should_run ))
def servo_abort( self, msg = None ):
# Note... should now be called "toggle"
self.abort = True
rospy.logout( 'servo_node: Aborting!' )
def og_score_cb( self, msg ):
self.scores.append( msg.data )
if len( self.scores ) > SCORE_BUFFER_LEN:
self.scores.popleft()
def run( self, request ):
rospy.logout( 'servo_node: Called for tagid: \'%s\', continous: %d' % (request.data, request.cont) )
# Move Antennas into Servo mode
self.t_left.move_angle( 0.0, math.radians(30), blocking = False )
self.t_right.move_angle( 0.0, math.radians(30), blocking = False )
self.p_left.move_angle( math.radians(-40), math.radians(30), blocking = False )
self.p_right.move_angle( math.radians(40), math.radians(30), blocking = True )
while self.p_left.is_moving() or self.p_right.is_moving():
#time.sleep( 0.01 ) # Not such a good idea when doing simulation.
rospy.sleep( 0.05 )
self.stop_next_obs = bool( request.cont )
self.should_run = True
self.abort = False
# Startup RFID reads
self.rp = rfid_poller( request.data )
rospy.logout('servo_node: Running')
rate = rospy.Rate( 15.0 )
zed = deque([ 0.0 ])
last_zed = 0.0
#self.scores = deque()
last_print = ctime()
while self.should_run and not rospy.is_shutdown():
rate.sleep()
left, right = self.rp.values
#zed.append( 0.07 * (left - right)/5.0 )
zed.append( 0.10 * (left - right)/5.0 )
if len( zed ) > ANGLE_FILTER_LEN:
zed.popleft()
target_zed = np.mean( zed )
new_zed = last_zed + np.clip( target_zed - last_zed, -1.0 * ANGLE_SLEW, ANGLE_SLEW )
last_zed = new_zed
check = Twist()
check.linear.x = 0.1
check.angular.z = new_zed
self.og_pub.publish( check )
move_command = Twist()
if self.abort:
self.should_run = False
elif len( self.scores ) < SCORE_BUFFER_LEN:
rospy.logout( 'servo_node: Score buffer filling: %d of %d' % (len(self.scores), SCORE_BUFFER_LEN) )
elif sum([ i != -1 for i in self.scores]) < SCORE_BUFFER_MOVE:
# Check for tag detected!
if ctime() - last_print > 1.0:
rospy.logout( 'servo_node: Obstacle detected' )
last_print = ctime()
if self.stop_next_obs: # Stop after next obstacle detected
self.should_run = False
elif len( zed ) < ANGLE_FILTER_LEN:
rospy.logout( 'servo_node: Angle buffer filling' )
else:
move_command.linear.x = check.linear.x
move_command.angular.z = check.angular.z
self.command_pub.publish( move_command )
# When servo node shuts down...
self.command_pub.publish( Twist() ) # Halt the base
self.rp.stop() # Stop the reader
# Return servos to home position
self.t_left.move_angle( 0.0, math.radians(10), blocking = False )
self.t_right.move_angle( 0.0, math.radians(10), blocking = False )
self.p_left.move_angle( -1.350, math.radians(10), blocking = False )
if not (os.environ.has_key('ROBOT') and os.environ['ROBOT'] == 'sim'):
self.p_right.move_angle( 1.350, math.radians(10), blocking = False )
else:
self.p_right.move_angle( 1.350, math.radians(10), blocking = True )
rospy.logout('servo_node: Returning')
return StringInt32_Int32Response( int( True ))
class ServoNodeClient():
def __init__( self, service_name = '/rfid_servo/servo' ):
rospy.logout( 'servo_node_client: Waiting for service: \'%s\'' % service_name )
rospy.wait_for_service( service_name )
rospy.logout( 'servo_node_client: Service ready.' )
self._servo_service = rospy.ServiceProxy( service_name, StringInt32_Int32 )
def servo( self, tagid, continuous_operation = True ):
return self._servo_service( tagid, int( continuous_operation ))
class rfid_poller( Thread ):
def __init__( self, tagid ):
Thread.__init__( self )
self.reader = rmc.ROS_M5e_Client('ears')
self.reader.track_mode( tagid )
self.should_run = True
self.values = [75.0, 75.0]
self.start()
def stop( self ):
self.should_run = False
self.join(3)
if (self.isAlive()):
raise RuntimeError("rfid_poller: Unable to stop thread")
def run( self ):
rospy.logout( 'rfid_poller: Starting' )
while self.should_run and not rospy.is_shutdown():
left = np.clip( self.reader.read('EleLeftEar')[-1], 75.0, 110.0 )
right = np.clip( self.reader.read('EleRightEar')[-1], 75.0, 110.0 )
self.values = [left, right]
try: # Shut it down to conserve power. Something of a race condition (exception)
self.reader.stop()
except:
pass
rospy.logout( 'rfid_poller: Exiting' )
if __name__ == '__main__':
sn = ServoNode()
rospy.spin()
| [
[
1,
0,
0.0091,
0.0046,
0,
0.66,
0,
654,
0,
1,
0,
0,
654,
0,
0
],
[
1,
0,
0.0137,
0.0046,
0,
0.66,
0.0333,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0183,
0.0046,
0,
... | [
"import time",
"import roslib",
"roslib.load_manifest('rospy')",
"roslib.load_manifest('geometry_msgs')",
"roslib.load_manifest('std_msgs')",
"roslib.load_manifest('hrl_rfid')",
"roslib.load_manifest('robotis')",
"roslib.load_manifest('rfid_people_following')",
"import time",
"import rospy",
"fr... |
# ROS imports
import roslib
roslib.load_manifest('rfid_people_following')
roslib.load_manifest('robotis')
import rospy
from std_msgs.msg import Float64
from robotis.srv import None_Float
from robotis.srv import None_FloatResponse
from robotis.srv import MoveAng
from robotis.srv import MoveAngResponse
from robotis.srv import None_Int32
from robotis.srv import None_Int32Response
import time
import numpy as np, math
from threading import Thread
def standard_rad(t):
if t > 0:
return ((t + np.pi) % (np.pi * 2)) - np.pi
else:
return ((t - np.pi) % (np.pi * -2)) + np.pi
class USB2Dynamixel_Device():
''' Class that manages serial port contention between servos on same bus
'''
def __init__( self, dev_name = '/dev/ttyUSB0', baudrate = 57600 ):
self.dev_name = dev_name
class Robotis_Servo( Thread ):
''' Class to use a robotis RX-28 or RX-64 servo.
'''
def __init__(self, USB2Dynamixel, servo_id ):
''' USB2Dynamixel - USB2Dynamixel_Device object to handle serial port.
Handles threadsafe operation for multiple servos
servo_id - servo ids connected to USB2Dynamixel 1,2,3,4 ... (1 to 253)
[0 is broadcast if memory serves]
'''
Thread.__init__( self )
try:
rospy.init_node( 'RobotisServo_'+str(servo_id) )
except rospy.ROSException:
pass
self.should_run = True
self.is_moving_flag = False
self.curr_angle = 0.0
self.rate = 0.0
self.des_angle = 0.0
self.max_speed = math.radians( 50 )
self.dyn = USB2Dynamixel
# ID exists on bus?
self.servo_id = servo_id
self.start()
def is_moving(self):
''' returns True if servo is moving.
'''
return self.is_moving_flag
def write_address(self, address, data):
''' writes data at the address.
data = [n1,n2 ...] list of numbers.
return [n1,n2 ...] (list of return parameters)
'''
return
def read_angle(self):
''' returns the current servo angle (radians)
'''
return self.curr_angle
def move_angle(self, ang, angvel=None, blocking=True):
''' move to angle (radians)
'''
self.rate = angvel
self.des_angle = ang
rospy.sleep( 0.05 )
while blocking and self.is_moving_flag:
rospy.sleep( 0.05 )
return
def run( self ):
#last_time = time.time()
last_time = rospy.Time.now().to_nsec() * 10**-9
while self.should_run and not rospy.is_shutdown():
rospy.sleep( 1.0 / 30.0 )
new_time = rospy.Time.now().to_nsec() * 10**-9
curr = self.curr_angle
des = self.des_angle
if curr == des:
self.is_moving_flag = False
else:
ang_diff = standard_rad( des - curr )
move_mag = np.sign( ang_diff ) * (new_time - last_time) * self.rate
new_ang = curr + move_mag
if np.abs( ang_diff ) < np.abs( move_mag ):
self.curr_angle = des
self.is_moving_flag = False
else:
self.is_moving_flag = True
self.curr_angle = new_ang
last_time = new_time
class ROS_Robotis_Server():
# This class provides ROS services for a select few lib_robotis functions
def __init__(self, servo = None, name = '' ):
if servo == None:
raise RuntimeError( 'ROS_Robotis_Servo: No servo specified for server.\n' )
self.servo = servo
self.name = name
try:
rospy.init_node( 'robotis_servo_' + self.name )
except rospy.ROSException:
pass
#self.servo.disable_torque()
rospy.logout( 'ROS_Robotis_Servo: Starting Server /robotis/servo_' + self.name )
self.channel = rospy.Publisher('/robotis/servo_' + self.name, Float64)
self.__service_ang = rospy.Service('/robotis/servo_' + name + '_readangle',
None_Float, self.__cb_readangle)
self.__service_ismove = rospy.Service('/robotis/servo_' + name + '_ismoving',
None_Int32, self.__cb_ismoving)
self.__service_moveang = rospy.Service('/robotis/servo_' + name + '_moveangle',
MoveAng, self.__cb_moveangle)
def __cb_readangle( self, request ):
ang = self.update_server()
return None_FloatResponse( ang )
def __cb_ismoving( self, request ):
status = self.servo.is_moving()
return None_Int32Response( int(status) )
def __cb_moveangle( self, request ):
rospy.logout( 'RobotisServo: Move %s to angle %3.2f' % (self.name, math.degrees( request.angle )))
ang = request.angle
angvel = request.angvel
blocking = bool( request.blocking )
self.servo.move_angle( ang, angvel, blocking )
rospy.logout( 'RobotisServo: Move %s Done' % (self.name))
return MoveAngResponse()
def update_server(self):
ang = self.servo.read_angle()
self.channel.publish( Float64(ang) )
return ang
class ROS_Robotis_Poller( Thread ):
# A utility class that will setup and poll a number of ROS_Robotis_Servos on one USB2Dynamixel
def __init__( self, dev_name, ids, names ):
Thread.__init__(self)
self.should_run = True
self.dev_name = dev_name
self.ids = ids
self.names = names
for n in self.names:
rospy.logout( 'ROS_Robotis_Servo: Starting Up /robotis/servo_' + n + ' on ' + self.dev_name )
self.dyn = USB2Dynamixel_Device( self.dev_name )
self.servos = [ Robotis_Servo( self.dyn, i ) for i in self.ids ]
self.ros_servers = [ ROS_Robotis_Server( s, n ) for s,n in zip( self.servos, self.names ) ]
rospy.logout( 'ROS_Robotis_Servo: Setup Complete on ' + self.dev_name )
self.start()
def run( self ):
while self.should_run:
[ s.update_server() for s in self.ros_servers ]
rospy.sleep(0.001)
for n in self.names:
rospy.logout( 'ROS_Robotis_Servo: Shutting Down /robotis/servo_' + n + ' on ' + self.dev_name )
def stop(self):
self.should_run = False
self.join(3)
if (self.isAlive()):
raise RuntimeError("ROS_Robotis_Servo: unable to stop thread")
# Client should come from robotis package. All services defined.
| [
[
1,
0,
0.0145,
0.0048,
0,
0.66,
0,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0193,
0.0048,
0,
0.66,
0.0556,
630,
3,
1,
0,
0,
0,
0,
1
],
[
8,
0,
0.0242,
0.0048,
0,
0.... | [
"import roslib",
"roslib.load_manifest('rfid_people_following')",
"roslib.load_manifest('robotis')",
"import rospy",
"from std_msgs.msg import Float64",
"from robotis.srv import None_Float",
"from robotis.srv import None_FloatResponse",
"from robotis.srv import MoveAng",
"from robotis.srv import Mov... |
#! /usr/bin/python
import roslib;
roslib.load_manifest('hrl_pr2_kinematics_tutorials')
roslib.load_manifest('rfid_people_following')
roslib.load_manifest('hrl_lib')
roslib.load_manifest('std_srvs')
import rospy
import hrl_pr2_kinematics_tutorials.hrl_pr2 as hrl_pr2
import hrl_lib.transforms as tr
import rfid_people_following.tactile_sensors as tsen
from rfid_people_following.srv import FloatFloatFloatFloat_Int32 as arm_srv
from rfid_people_following.srv import HandoffSrv
import numpy as np, math
import os
import time
class HandoffNode():
def __init__( self ):
rospy.init_node( 'handoff', anonymous = True )
rospy.logout( 'handoff_node: Have run hrl_pr2_gains/change_gains.sh yet?' )
self.robot = hrl_pr2.HRL_PR2()
if not (os.environ.has_key('ROBOT') and os.environ['ROBOT'] == 'sim'):
self.ts = tsen.TactileSensor()
self.arm = 'right_arm'
self.start_ja = [0.040304940763152608, 1.2398003444166741, -1.2204088251845415, -1.9324078526157087, -31.197472992401149, -1.7430222641585842, -1.5358378047038517]
#self.target_ja = [0.35891507126604916, 0.13778228113494312, -0.01277662779292843, -1.4992538841561938, -28.605807802842136, -0.96590944225972863, -3.0950669743130161]
self.target_ja = [0.0818, 0.377, -0.860, -2.144, -3.975, -1.479, 3.907]
self._sh = rospy.Service( '/rfid_handoff/handoff' , HandoffSrv, self.handoff )
self._si = rospy.Service( '/rfid_handoff/initialize' , HandoffSrv, self.initialize )
self._sj = rospy.Service( '/rfid_handoff/handoff_pos' , arm_srv, self.handoff_pos )
self._swave = rospy.Service( '/rfid_handoff/wave' , HandoffSrv, self.wave )
# self.initialize() # Prefer to do this manually... (rosservice call /rfid_handoff/initialize)
rospy.logout( 'handoff_node: Waiting for service calls.' )
def initialize( self, msg = None ):
rospy.logout( 'handoff_node: Initializing. Hand me an object!' )
# Put into handoff position, ready to accept object
self.robot.set_jointangles( self.arm, self.target_ja, 3.0 )
rospy.sleep( rospy.Duration( 3.0 ))
self.robot.open_gripper( self.arm )
rospy.sleep( rospy.Duration( 2.0 ))
self.stow()
return True
def wave( self, msg = None ):
wave_a = [0.0131, 0.325, -0.832, -1.762,-6.511, -0.191, 0.162]
wave_b = [-0.180, 0.034, 0.108, -1.295, -6.224, -0.383, 0.119]
self.robot.set_jointangles( self.arm, wave_a, 2.0 )
rospy.sleep( rospy.Duration( 2.0 ))
self.robot.set_jointangles( self.arm, wave_b, 1.0 )
rospy.sleep( rospy.Duration( 1.0 ))
self.robot.set_jointangles( self.arm, wave_a, 1.0 )
rospy.sleep( rospy.Duration( 1.0 ))
self.robot.set_jointangles( self.arm, wave_b, 1.0 )
rospy.sleep( rospy.Duration( 1.0 ))
self.robot.set_jointangles( self.arm, wave_a, 1.0 )
rospy.sleep( rospy.Duration( 1.0 ))
self.robot.set_jointangles( self.arm, self.start_ja, 3.0 )
rospy.sleep( rospy.Duration( 3.0 ))
return True
def stow( self ):
# Grab object
self.robot.close_gripper( self.arm )
rospy.sleep( rospy.Duration( 2.0 ))
# Stow
self.robot.set_jointangles( self.arm, self.start_ja, 3.0 )
rospy.sleep( rospy.Duration( 3.0 ))
def open( self ):
self.robot.open_gripper( self.arm )
rospy.sleep( rospy.Duration( 2.0 ))
def close( self ):
self.robot.close_gripper( self.arm )
rospy.sleep( rospy.Duration( 2.0 ))
def handoff( self, msg = None ):
# Put into handoff position.
self.robot.set_jointangles( self.arm, self.target_ja, 3.0 )
rospy.sleep( rospy.Duration( 3.0 ))
# Tactile Sensor detector
rospy.sleep( rospy.Duration( 0.5 ))
self.ts.thresh_detect( 3000 )
# Release object
self.robot.open_gripper( self.arm )
rospy.sleep( rospy.Duration( 2.0 ))
# Stow
self.robot.set_jointangles( self.arm, self.start_ja, 3.0 )
rospy.sleep( rospy.Duration( 3.0 ))
return True
def handoff_pos( self, msg ):
#pos = np.matrix([0.6977, -0.03622, 0.2015]).T
#ang = tr.Rx(math.radians(0.))
print msg
pos = np.matrix([ msg.x, msg.y, msg.z ]).T
ang = tr.Rx( msg.ang )
q = [0, 0, 0, 0, 0, 0, 0]
j = self.robot.IK('right_arm', pos, ang, self.target_ja)
#j = self.robot.IK('right_arm', pos, ang, q)
self.robot.set_jointangles( 'right_arm', j, 3.0 )
# Tactile Sensor detector
rospy.sleep( rospy.Duration( 0.5 ))
self.ts.thresh_detect( 3000 )
# Release object
self.robot.open_gripper( self.arm )
rospy.sleep( rospy.Duration( 2.0 ))
# Stow
self.robot.set_jointangles( self.arm, self.start_ja, 3.0 )
rospy.sleep( rospy.Duration( 3.0 ))
return True
if __name__ == '__main__':
hon = HandoffNode()
#hon.handoff_pos()
rospy.spin()
#ho.handoff()
| [
[
1,
0,
0.0207,
0.0069,
0,
0.66,
0,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0276,
0.0069,
0,
0.66,
0.0667,
630,
3,
1,
0,
0,
0,
0,
1
],
[
8,
0,
0.0345,
0.0069,
0,
0.... | [
"import roslib;",
"roslib.load_manifest('hrl_pr2_kinematics_tutorials')",
"roslib.load_manifest('rfid_people_following')",
"roslib.load_manifest('hrl_lib')",
"roslib.load_manifest('std_srvs')",
"import rospy",
"import hrl_pr2_kinematics_tutorials.hrl_pr2 as hrl_pr2",
"import hrl_lib.transforms as tr",... |
import numpy as np,math
import sim_capture
import glob
import pickle as pkl
import time
class request():
def __init__( self, x, y, ang ):
self.x = x
self.y = y
self.z = 0
self.ang = ang
def has_item( lst, item ):
try:
lst.index( item )
return True
except:
return False
X,Y = np.meshgrid( range(0,11), range(0,7) )
xy = np.column_stack([ X.flatten(), Y.flatten() ]).tolist()
xy.remove( [7,3] )
xy.remove( [6,3] )
d_func = lambda lst: ( lst[0] - 7 )**2 + ( lst[1] - 3 )**2
cmp_func = lambda x,y : cmp(d_func(x),d_func(y))
xy.sort( cmp=cmp_func )
xya = []
for ang in [ math.radians(p) for p in [0.0, 90.0, 180.0, 270.0]]:
for x,y in xy:
xya.append( [x,y,ang] )
if not glob.glob( 'trajectory_caps/resutls.pkl' ):
print 'Creating pickle file'
d = { 'desired_pts': xya,
'capture_pts': [],
'captures': []
}
f = open( 'trajectory_caps/resutls.pkl', 'w' )
pkl.dump( d, f )
f.close()
f = open( 'trajectory_caps/resutls.pkl', 'r' )
d = pkl.load( f )
f.close()
remaining = [ x for x in d['desired_pts'] if not has_item( d['capture_pts'], x )]
print 'Remaining to capture: %d' % len( remaining )
sc = sim_capture.SimCapture()
for x,y,ang in remaining:
fname = 'trajectory_caps/' + str(int(time.time())) + '_cap.pkl'
sc.capture( request( x, y, ang ), fname )
d[ 'capture_pts' ].append( [x,y,ang] )
d[ 'captures' ].append( [x,y,ang,fname] )
f = open( 'trajectory_caps/resutls.pkl', 'w' )
pkl.dump( d, f )
f.close()
| [
[
1,
0,
0.0149,
0.0149,
0,
0.66,
0,
954,
0,
2,
0,
0,
954,
0,
0
],
[
1,
0,
0.0299,
0.0149,
0,
0.66,
0.0435,
365,
0,
1,
0,
0,
365,
0,
0
],
[
1,
0,
0.0448,
0.0149,
0,
... | [
"import numpy as np,math",
"import sim_capture",
"import glob",
"import pickle as pkl",
"import time",
"class request():\n def __init__( self, x, y, ang ):\n self.x = x\n self.y = y\n self.z = 0\n self.ang = ang",
" def __init__( self, x, y, ang ):\n self.x = x\n... |
#! /usr/bin/python
import time
import roslib
roslib.load_manifest('hrl_rfid')
roslib.load_manifest('sound_play')
import rospy
import time
import numpy as np, math
import hrl_rfid.ros_M5e_client as rmc
import sound_play.libsoundplay as lsp
r = rmc.ROS_M5e_Client('ears')
r.query_mode()
speaker = lsp.SoundClient()
i = 0
reads_dict = {}
while not rospy.is_shutdown():
if i % 2 == 0:
read = r.read('EleLeftEar')
else:
read = r.read('EleRightEar')
i = i + 1
print 'read:', read
if read[-1] > 92:
if not reads_dict.has_key( read[-2] ):
reads_dict[ read[-2] ] = time.time() - 3.5
if time.time() - reads_dict[ read[-2] ] > 3.0:
reads_dict[ read[-2] ] = time.time()
print read
speaker.say( read[-2] )
r.stop()
| [
[
1,
0,
0.0476,
0.0238,
0,
0.66,
0,
654,
0,
1,
0,
0,
654,
0,
0
],
[
1,
0,
0.0714,
0.0238,
0,
0.66,
0.0667,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0952,
0.0238,
0,
... | [
"import time",
"import roslib",
"roslib.load_manifest('hrl_rfid')",
"roslib.load_manifest('sound_play')",
"import rospy",
"import time",
"import numpy as np, math",
"import hrl_rfid.ros_M5e_client as rmc",
"import sound_play.libsoundplay as lsp",
"r = rmc.ROS_M5e_Client('ears')",
"r.query_mode()... |
#!/usr/bin/python
import roslib
roslib.load_manifest('room_explore')
import rospy
import tf
from nav_msgs.srv import GetPlan, GetPlanRequest
from geometry_msgs.msg import PoseStamped
import util as ut
import time
#srv_name = '/move_base_node/NavfnROS/make_plan'
srv_name = '/move_base_node/make_plan'
rospy.init_node('trial_explore')
listener = tf.TransformListener()
listener.waitForTransform('/base_link', '/map',
rospy.Time(0), timeout = rospy.Duration(100) )
get_plan = rospy.ServiceProxy( srv_name, GetPlan )
rospy.get_param('/move_base_node/global_costmap/raytrace_range')
rospy.get_param('/move_base_node/TrajectoryPlannerROS/xy_goal_tolerance')
req = GetPlanRequest()
req.tolerance = 0.5
req.start = ut.robot_in_map( listener )
req.goal.header.stamp = rospy.Time(0)
req.goal.header.frame_id = '/map'
req.goal.pose.position.x = 0.85
#req.goal.pose.position.y = 0.85
req.goal.pose.orientation.w = 1.0
res = get_plan( req )
found = bool( res.plan.poses != [] )
print res
print 'Found Path: ', found
for i in xrange( 100 ):
t0 = time.time()
res = get_plan( req )
t1 = time.time()
print 'Rate: ', 1.0 / (t1 - t0)
| [
[
1,
0,
0.0612,
0.0204,
0,
0.66,
0,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0816,
0.0204,
0,
0.66,
0.0385,
630,
3,
1,
0,
0,
0,
0,
1
],
[
1,
0,
0.102,
0.0204,
0,
0.6... | [
"import roslib",
"roslib.load_manifest('room_explore')",
"import rospy",
"import tf",
"from nav_msgs.srv import GetPlan, GetPlanRequest",
"from geometry_msgs.msg import PoseStamped",
"import util as ut",
"import time",
"srv_name = '/move_base_node/make_plan'",
"rospy.init_node('trial_explore')",
... |
#!/usr/bin/python
import roslib
roslib.load_manifest('rfid_explore_room')
roslib.load_manifest('explore_hrl')
import rospy
import tf
import tf.transformations as tft
import actionlib
import rfid_explore_room.util as ut
from actionlib.simple_action_client import SimpleGoalState
from move_base_msgs.msg import MoveBaseGoal, MoveBaseAction
from geometry_msgs.msg import PoseStamped, Quaternion
from nav_msgs.srv import GetPlan, GetPlanRequest
from rfid_explore_room.srv import ExploreRoomSrv, ExploreRoomSrvResponse
from explore_hrl.msg import ExploreAction, ExploreResult, ExploreGoal
import yaml
import numpy as np, math
import string
import os
def retfalse():
return False
class SnakingExplore( ):
def __init__( self, df, room, start_rad = 1.5, markers_update = lambda x: True ):
try:
rospy.init_node( 'SnakingExplore' )
except:
pass
self.frame = '/' + room
self.markers_update = markers_update
self.length = df[room]['length']
self.width = df[room]['width']
rospy.logout( 'snaking_explore: Initializing' )
self.listener = tf.TransformListener()
self.listener.waitForTransform( '/base_link', '/map', rospy.Time(0), timeout = rospy.Duration(100))
self.listener.waitForTransform( self.frame, '/map', rospy.Time(0), timeout = rospy.Duration(100))
self.setup_poses( radius = start_rad )
self.client = actionlib.SimpleActionClient( 'move_base', MoveBaseAction )
self.client.wait_for_server()
self._service = rospy.Service( '/explore/explore' , ExploreRoomSrv, self.service_request )
self._as = actionlib.SimpleActionServer( '/explore', ExploreAction, execute_cb = self.action_request )
self._as.start()
rospy.logout( 'snaking_explore: Ready and waiting.' )
def service_request( self, req ):
res = self.begin_explore( req.radius )
rospy.logout( 'snaking_explore: Returning result \'%s\'' % res )
return res
def action_request( self, goal ):
rospy.logout( 'snaking_explore: action_request received for radius: \'%2.2f\'' % goal.radius )
def preempt_func():
# self._as should be in scope and bound @ function def. (I think for python...)
check = self._as.is_preempt_requested()
if check:
rospy.logout( 'snaking_explore: action_request preempted!' )
return check
rv = self.begin_explore( goal.radius, preempt_func = preempt_func )
rospy.logout( 'snaking_explore: action_request received result %d' % int(rv) )
if rv == 'succeeded':
rospy.logout( 'snaking_explore: returning \'succeeded\'' )
self._as.set_succeeded( ExploreResult() )
elif rv == 'preempted':
rospy.logout( 'snaking_explore: returning \'preempted\'' )
self._as.set_preempted( )
else: # rv == 'aborted'
rospy.logout( 'snaking_explore: returning \'aborted\'' )
self._as.set_aborted()
def robot_in_map( self ):
ps_base = PoseStamped()
ps_base.header.frame_id = '/base_link'
ps_base.header.stamp = rospy.Time(0)
ps_base.pose.orientation.w = 1.0
return self.ps_in_map( ps_base )
def ps_in_map( self, ps ):
# ps is pose_stamped
try:
ps_map = self.listener.transformPose( '/map', ps )
except:
rospy.logout( 'snaking_explore: %s -> map Transform failed.' % ps.header.frame_id )
ps_map = None
return ps_map
def range_to_waypoint( self, r, w ):
# r => robot in map, w => waypoint in map
return np.sqrt( (r.pose.position.x - w.pose.position.x)**2.0 +
(r.pose.position.y - w.pose.position.y)**2.0 )
def begin_explore( self, radius, preempt_func = retfalse ):
rospy.logout( 'snaking_explore: setting radius' )
waypoints = self.setup_poses( radius ) # PoseStamped in self.frame
local_planner = rospy.get_param('/move_base_node/base_local_planner') # : dwa_local_planner/DWAPlannerROS
local_planner = local_planner[string.find(local_planner,'/')+1:]
obs_range = rospy.get_param('/move_base_node/global_costmap/obstacle_range')
move_tol = rospy.get_param('/move_base_node/'+local_planner+'/xy_goal_tolerance')
no_progress = rospy.get_param( rospy.get_name() + '/no_progress_move', 5)
unreached_time = rospy.get_param( rospy.get_name() + '/not_reached_move', 30)
# I'm not entirely sure which service to use. I do know that
# non-NavfnROS make_plan sometimes fails for an unknown
# reason... and thus NavfnROS/make_plan is more robust.
# srv_name = '/move_base_node/make_plan'
srv_name = '/move_base_node/NavfnROS/make_plan'
get_plan = rospy.ServiceProxy( srv_name, GetPlan )
# Clear costmap...? Do this here or in smach...?
if preempt_func(): # immediately exit if overall action preempted
return 'preempted'
for i,w in enumerate( waypoints ):
if preempt_func(): # immediately exit if overall action preempted
return 'preempted'
rospy.logout( 'snaking_explore: Seeking waypoint %d of %d' % (i+1,len(waypoints)))
# rospy.logout( 'snaking_explore: %2.2f %2.2f in frame %s' % (w.pose.position.x, w.pose.position.y, w.header.frame_id))
rim = self.robot_in_map()
w.header.stamp = rospy.Time(0) # transform it _now_
wim = self.ps_in_map( w ) # waypoint in map
if not rim or not wim: # if transforms failed
rospy.logout( 'snaking_explore: Bad transforms. Aborting explore' )
return 'aborted'
if self.range_to_waypoint( rim, wim ) < 0.9 * obs_range:
# We're nearby the waypoint, so we'll just trust that the planner
# has a good view of its surroundings to determine reachability.
req = GetPlanRequest()
req.tolerance = 0.1
req.start = rim
req.goal = wim
resp = get_plan( req )
found_plan = bool( resp.plan.poses != [] )
if not found_plan:
rospy.logout( 'snaking_explore: No plan to nearby waypoint. Proceeding to next waypoint' )
# Perhaps its worth pulling the waypoint closer until a path _is_ found?
continue
# We now know that a path exists. Send the waypoint to the client.
rospy.logout( 'snaking_explore: Near by with good plan. Calling move_base action.' )
else:
# Any nav plan at beyond obstacle range will require the
# nav stack to get a better vantage. Send the waypoint to
# the client.
rospy.logout( 'snaking_explore: Far away. Calling move_base action.' )
# If we made it this far, it's time to call move_base action.
# Cancel any previous goals
self.client.cancel_goals_at_and_before_time( rospy.Time.now() )
if os.environ.has_key('ROBOT') and os.environ['ROBOT'] == 'sim':
rospy.logout( 'running in sim: give the system a little time to respond' )
rospy.sleep( 1 )
# Send our new goal
rospy.logout( 'snaking_explore: sending movebase action goal.' )
move_goal = MoveBaseGoal()
move_goal.target_pose = wim
self.client.send_goal( move_goal )
if os.environ.has_key('ROBOT') and os.environ['ROBOT'] == 'sim':
rospy.logout( 'running in sim: give the system a little time to respond' )
rospy.sleep( 1 )
# We'll monitor the state ourselves, and allow ourselves
# the opportunity to cancel the goal for various reasons
# (eg. if we haven't moved for a while or if new plans
# aren't found after getting within obstacle distance)
# When this loop is broken, we'll go to the next goal. We
# don't need to cancel the goals here -- they will be
# cancelled before a new one is sent.
r = rospy.Rate( 10 )
xytt_old = None # Checks for movement
stime = rospy.Time.now().to_sec()
while True:
if self.client.simple_state == SimpleGoalState.DONE:
res = self.client.get_result()
rospy.logout('snaking_explore: Movebase actionlib completed with result. Proceeding to next waypoint')
break
rim = self.robot_in_map()
w.header.stamp = rospy.Time( 0 )
wim = self.ps_in_map( w )
# Proceed when close enough to goal (within two tolerance factors)
if rim and wim: # only do this check if transform succeeds
if self.range_to_waypoint( rim, wim ) < move_tol * 2.0:
rospy.logout( 'snaking_explore: Close enough to waypoint. Proceeding to next waypoint' )
break # We're near the waypoint, so let's must move on to next
# Proceed when there has been no movement (x,y, or theta) for X sec.
if rim: # only do this check if transform succeeds
xytt = self.xythetatime( rim )
if not xytt_old:
xytt_old = xytt
if np.abs( xytt[0] - xytt_old[0] ) > 0.05 or \
np.abs( xytt[1] - xytt_old[1] ) > 0.05 or \
np.abs( xytt[2] - xytt_old[2] ) > math.radians(10):
xytt_old = xytt
if xytt[3] - xytt_old[3] > no_progress:
rospy.logout( 'snaking_explore: No movement in %2.1f seconds. Proceeding to next waypoint' % no_progress )
break
if rospy.Time.now().to_sec() - stime > unreached_time:
rospy.logout( 'snaking_explore: Goal unreached in %2.1f seconds. Proceeding to next waypoint' % unreached_time )
break
r.sleep()
self.client.cancel_all_goals()
rospy.logout( 'snaking_explore: Finished with exploration.' )
return 'succeeded'
def xythetatime( self, ps ):
o = ps.pose.orientation
r,p,y = tft.euler_from_quaternion(( o.x, o.y, o.z, o.w ))
return ps.pose.position.x, ps.pose.position.y, y, rospy.Time.now().to_sec()
def setup_poses( self, radius ):
# poses = self.setup_poses_xonly( radius )
poses = self.setup_poses_snaking( radius )
self.markers_update( poses )
return poses
def setup_poses_snaking( self, radius ):
# tt are the min's and maxes of the snake along x-axis
cycles = np.ceil( self.length / radius )
tt = np.linspace( 0.0, self.length, 2 * cycles + 1 )
# Determine waypoints at crest and valleys (lengthwise)
crests = []
atmin = False
for xx in tt:
atmin = not atmin # alternate between ys = 0 and ys = width
yy = float( atmin ) * self.width
crests.append( (xx, yy) )
# Determine intermediate waypoints (widthwise)
xyinter = []
inter = np.ceil( self.width / radius )
x_next, y_next = 0.0, 0.0
for i in xrange( len(crests) - 1 ):
x_prev = crests[i][0]
y_prev = crests[i][1]
x_next = crests[i+1][0]
y_next = crests[i+1][1]
x_inter = np.linspace( x_prev, x_next, inter * 2, endpoint = False )
y_inter = np.linspace( y_prev, y_next, inter * 2, endpoint = False )
xyinter += zip( x_inter, y_inter )
xyinter += [ (x_next, y_next) ]
# Determine headings (in self.frame)
xytheta = []
def add_xytheta( x, y, t ):
ps = PoseStamped()
ps.header.frame_id = self.frame
ps.header.stamp = rospy.Time(0)
ps.pose.position.x = x
ps.pose.position.y = y
ps.pose.orientation = Quaternion( *tft.quaternion_from_euler( 0.0, 0.0, t ))
xytheta.append( ps )
theta = 0.0
for i in xrange( len(xyinter) - 1 ):
theta = np.arctan2( xyinter[i+1][1] - xyinter[i][1],
xyinter[i+1][0] - xyinter[i][0] )
add_xytheta( xyinter[i][0], xyinter[i][1], theta )
add_xytheta( xyinter[-1][0], xyinter[-1][1], theta )
return xytheta
def setup_poses_xonly( self, radius ):
poses = []
xpos = 0.0
def ps_x( x ):
ps = PoseStamped()
ps.header.frame_id = self.frame
ps.pose.position.x = x
ps.pose.orientation.w = 1.0
return ps
for i in xrange(3):
poses.append( ps_x( xpos ))
xpos += 0.5
xpos += 3.0
for i in xrange(3):
poses.append( ps_x( xpos ))
xpos += 0.5
return poses
if __name__ == '__main__':
import optparse
p = optparse.OptionParser()
p.add_option('--yaml', action='store', type='string', dest='yaml',
help='Room definition file (required)', default='')
p.add_option('--room', action='store', type='string', dest='room',
help='Specific room [default \'hrl\']', default='hrl')
opt, args = p.parse_args()
if opt.yaml == '':
print 'room_explore: YAML FILE REQUIRED.'
else:
print 'Using YAML file: ', opt.yaml
f = open( opt.yaml )
dat = yaml.load( f )
f.close()
room_transforms = ut.TFthread( dat )
pm = ut.PosesMarkers()
re = SnakingExplore( df = dat,
room = opt.room,
start_rad = 1.5,
markers_update = pm.update_poses )
# rospy.sleep( 4 )
# re.publish_markers()
rospy.spin()
# r = rospy.Rate( 2 )
# while not rospy.is_shutdown():
# re.publish_markers()
# r.sleep()
#re.begin_explore( 0.8 )
# rosservice call /explore 0.8
# explore_act = actionlib.SimpleActionClient('explore', ExploreAction)
# rospy.logout( 'Waiting for explore.' )
# explore_act.wait_for_server()
# rospy.logout( 'Done waiting.' )
# goal = ExploreGoal( radius = 0.8 )
# explore_act.send_goal(goal)
# rospy.sleep( 0.5 )
# explore_act.wait_for_result()
| [
[
1,
0,
0.0079,
0.0026,
0,
0.66,
0,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0105,
0.0026,
0,
0.66,
0.05,
630,
3,
1,
0,
0,
0,
0,
1
],
[
8,
0,
0.0132,
0.0026,
0,
0.66... | [
"import roslib",
"roslib.load_manifest('rfid_explore_room')",
"roslib.load_manifest('explore_hrl')",
"import rospy",
"import tf",
"import tf.transformations as tft",
"import actionlib",
"import rfid_explore_room.util as ut",
"from actionlib.simple_action_client import SimpleGoalState",
"from move_... |
#!/usr/bin/python
import roslib
roslib.load_manifest('room_explore')
import rospy
import tf
from geometry_msgs.msg import PoseStamped
from visualization_msgs.msg import Marker, MarkerArray
from geometry_msgs.msg import Vector3, PoseStamped, Quaternion
from std_msgs.msg import ColorRGBA
from threading import Thread
import numpy as np, math
class TFthread( Thread ):
def __init__( self, df ):
Thread.__init__( self )
try:
rospy.init_node( 'TFthread' )
except:
pass # parent probably already initialized node.
self.df = df # yaml dictionary of rooms
self.bc = tf.TransformBroadcaster()
self.should_run = True
self.start()
def publish_transform( self ):
for room in self.df.keys():
self.bc.sendTransform( ( self.df[room]['position']['x'],
self.df[room]['position']['y'],
self.df[room]['position']['z'] ),
( self.df[room]['orientation']['x'],
self.df[room]['orientation']['y'],
self.df[room]['orientation']['z'],
self.df[room]['orientation']['w'] ),
rospy.Time.now(),
room,
'map' )
def run( self ):
rospy.logout( 'TFthread: Starting ' )
r = rospy.Rate( 10 )
while self.should_run and not rospy.is_shutdown():
self.publish_transform()
try:
r.sleep()
except:
pass # ROS exception.
rospy.logout( 'TFthread: Starting ')
def stop( self ):
# Kill off the poller thread.
self.should_run = False
self.join(5)
if (self.isAlive()):
raise RuntimeError('TFthread: Unable to stop thread ' )
class PosesMarkers( Thread ):
def __init__( self ):
Thread.__init__( self )
try:
rospy.init_node( 'snaking_room_posesmarkers' )
except:
pass # parent probably already initialized node.
self.poses = []
self.markers = []
self.mid = 0
self.new_poses = False
self.should_run = True
self.pub = rospy.Publisher( 'visarr', Marker )
self.start()
def update_poses( self, poses ):
self.poses = list( poses )
self.new_poses = True
def run( self ):
rospy.logout( 'PosesMarkers: Starting ' )
r = rospy.Rate( 5 )
while self.should_run and not rospy.is_shutdown():
if self.new_poses == True:
self.new_poses = False
# Delete old markers
for old_m in self.markers:
old_m.action = old_m.DELETE
self.pub.publish( old_m )
# Create new markers
self.markers = []
for p in self.poses:
self.mid += 1
m = Marker()
m.ns = 'explore_poses'
m.id = self.mid
m.action = m.ADD
m.type = m.ARROW
m.header.frame_id = p.header.frame_id
m.header.stamp = rospy.Time.now()
m.scale = Vector3( 0.15, 0.75, 0.75 )
m.color = ColorRGBA( 0.2, 0.2, 1.0, 0.9 )
m.pose = p.pose
self.markers.append( m )
# Publish markers.
for m in self.markers:
m.header.stamp = rospy.Time.now()
self.pub.publish( m )
r.sleep()
# Delete old markers
for old_m in self.markers:
old_m.action = old_m.DELETE
self.pub.publish( old_m )
rospy.logout( 'PoseMarkers: Stopping. ')
def stop( self ):
# Kill off the poller thread.
self.should_run = False
self.join(5)
if (self.isAlive()):
raise RuntimeError('TFthread: Unable to stop thread ' )
def standard_rad(t):
if t > 0:
return ((t + np.pi) % (np.pi * 2)) - np.pi
else:
return ((t - np.pi) % (np.pi * -2)) + np.pi
def robot_in_map( l, fail_msg = '' ):
# l is tf listener
ps = PoseStamped()
ps.header.frame_id = '/base_link'
ps.pose.orientation.w = 1.0
try:
ps_map = l.transformPose( '/map', ps )
except:
rospy.logout( fail_msg + 'Transform failed.' )
ps_map = None
return ps_map
| [
[
1,
0,
0.0197,
0.0066,
0,
0.66,
0,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0263,
0.0066,
0,
0.66,
0.0769,
630,
3,
1,
0,
0,
0,
0,
1
],
[
1,
0,
0.0329,
0.0066,
0,
0.... | [
"import roslib",
"roslib.load_manifest('room_explore')",
"import rospy",
"import tf",
"from geometry_msgs.msg import PoseStamped",
"from visualization_msgs.msg import Marker, MarkerArray",
"from geometry_msgs.msg import Vector3, PoseStamped, Quaternion",
"from std_msgs.msg import ColorRGBA",
"from t... |
__all__ = [
'snaking_room_explore'
]
| [
[
14,
0,
0.6667,
1,
0,
0.66,
0,
272,
0,
0,
0,
0,
0,
5,
0
]
] | [
"__all__ = [\n 'snaking_room_explore'\n ]"
] |
#!/usr/bin/python
import roslib
roslib.load_manifest('rfid_explore_room')
import rospy
import tf
from threading import Thread
import actionlib
from move_base_msgs.msg import MoveBaseGoal, MoveBaseAction
from visualization_msgs.msg import MarkerArray
from visualization_msgs.msg import Marker
from geometry_msgs.msg import Vector3, PoseStamped, Quaternion
from std_msgs.msg import ColorRGBA
from explore_hrl.msg import ExploreAction, ExploreResult, ExploreGoal
import yaml
import numpy as np, math
def retfalse():
return False
class TFthread( Thread ):
def __init__( self, df ):
Thread.__init__( self )
try:
rospy.init_node( 'TFthread' )
except:
pass # parent probably already initialized node.
self.df = df # yaml dictionary of rooms
self.bc = tf.TransformBroadcaster()
self.should_run = True
self.start()
def publish_transform( self ):
for room in self.df.keys():
self.bc.sendTransform( ( self.df[room]['position']['x'],
self.df[room]['position']['y'],
self.df[room]['position']['z'] ),
( self.df[room]['orientation']['x'],
self.df[room]['orientation']['y'],
self.df[room]['orientation']['z'],
self.df[room]['orientation']['w'] ),
rospy.Time.now(),
room,
'map' )
def run( self ):
rospy.logout( 'TFthread: Starting ' )
r = rospy.Rate( 10 )
while self.should_run and not rospy.is_shutdown():
self.publish_transform()
try:
r.sleep()
except:
pass # ROS exception.
rospy.logout( 'TFthread: Starting ')
def stop( self ):
# Kill off the poller thread.
self.should_run = False
self.join(5)
if (self.isAlive()):
raise RuntimeError('TFthread: Unable to stop thread ' )
# if __name__ == '__main__':
# f = open( room )
# dat = yaml.load( f )
# f.close()
# TFthread( dat )
# rospy.spin()
def standard_rad(t):
if t > 0:
return ((t + np.pi) % (np.pi * 2)) - np.pi
else:
return ((t - np.pi) % (np.pi * -2)) + np.pi
class RoomExplore( ):
def __init__( self, df, room, start_rad = 1.5 ):
try:
rospy.init_node( 'RoomExplore' )
except:
pass
self.should_run = True
self.frame = '/' + room
self.old_markers = []
self.mid = 1
self.height = df[room]['height']
self.width = df[room]['width']
self.listener = tf.TransformListener()
self.listener.waitForTransform( '/base_link', '/map', rospy.Time(0), timeout = rospy.Duration(100))
self.pub = rospy.Publisher( 'visarr', Marker )
self.setup_poses( radius = start_rad ) # also initializes radius
print 'Len: ', len(self.poses), ' Publishing.'
self.publish_markers()
self._as = actionlib.SimpleActionServer( '/explore', ExploreAction, execute_cb = self.action_request )
self._as.start()
self.publish_markers()
rospy.logout('Action should be started.')
def action_request( self, goal ):
rospy.logout( 'room_explore: action_request received for radius: \'%2.2f\'' % goal.radius )
def preempt_func():
# self._as should be in scope and bound @ function def. (I think for python...)
check = self._as.is_preempt_requested()
if check:
rospy.logout( 'room_explore: action_request preempted!' )
return check
rv = self.begin_explore( goal.radius, preempt_func = preempt_func )
rospy.logout( 'room_explore: action_request received result %d' % int(rv) )
if rv == True:
self._as.set_succeeded( ExploreResult() )
def begin_explore( self, radius, preempt_func = retfalse ):
client = actionlib.SimpleActionClient( 'move_base', MoveBaseAction )
rospy.logout( 'Waiting for move_base server' )
client.wait_for_server()
rospy.logout( 'room_explore: setting radius' )
all_goals = self.setup_poses( radius )
self.publish_markers()
for goal in all_goals:
#print 'room_explore: sending goal ', goal
goal.target_pose.header.stamp = rospy.Time.now()
client.send_goal( goal )
time_last_moving = rospy.Time.now()
goal_time = rospy.Time.now()
new_pose = self.current_robot_position()
ref_pose = self.current_robot_position()
r = rospy.Rate( 5 )
while not rospy.is_shutdown():
state = client.get_state()
states = { 0: 'WAITING FOR GOAL ACK',
1: 'PENDING',
2: 'ACTIVE',
3: 'WAITING FOR RESULT',
4: 'WAITING FOR CANCEL ACK',
5: 'RECALLING',
6: 'PREEMPTING',
7: 'DONE' }
#print 'State: ', state, ' ', states[state]
#print 'Result: ', client.get_result()
#rospy.logout( 'room_explore: loop' )
if state == 7 or state == 3:
rospy.logout( 'room_explore: client no longer active' )
print 'State: ', state, ' ', states[state]
time_last_moving = rospy.Time.now()
break
if preempt_func():
rospy.logout( 'room_explore: preempted at a higher level.' )
time_last_moving = rospy.Time.now()
break
new_pose = self.current_robot_position()
dx = new_pose[0] - ref_pose[0]
dy = new_pose[1] - ref_pose[1]
da = new_pose[-1] - ref_pose[-1] # yaw
if dx*dx + dy*dy > 0.02 or da*da > math.radians( 5 ):
time_last_moving = rospy.Time.now()
ref_pose = self.current_robot_position()
rospy.logout('WE ARE MOVING')
if rospy.Time.now() - time_last_moving > rospy.Duration( 8 ):
rospy.logout( 'We do not appear to have moved. Aborting current goal.' )
client.cancel_all_goals() # Should force a break on GoalState
time_last_moving = rospy.Time.now()
break
if rospy.Time.now() - goal_time > rospy.Duration( 30 ):
rospy.logout( 'Goal not achieved after 30 seconds. Aborting.' )
client.cancel_all_goals() # Should force a break on GoalState
time_last_moving = rospy.Time.now()
break
r.sleep()
client.cancel_all_goals() # Just in case
if preempt_func(): # immediately exit if overall action preempted
break
return True
def current_robot_position( self ):
ps = PoseStamped()
ps.header.stamp = rospy.Time(0)
ps.header.frame_id = '/base_link'
ps.pose.orientation.w = 1.0
try:
ps_map = self.listener.transformPose( '/map', ps )
except:
rospy.logout( 'room_explore: Transform failed' )
ps_map = PoseStamped()
ps_map.header.stamp = rospy.Time.now()
ps_map.header.frame_id = '/map'
ps_map.pose.orientation = new_quat
roll, pitch, yaw = tf.transformations.euler_from_quaternion(( ps_map.pose.orientation.x,
ps_map.pose.orientation.y,
ps_map.pose.orientation.z,
ps_map.pose.orientation.w ))
rv = [ ps_map.pose.position.x,
ps_map.pose.position.y,
ps_map.pose.position.z,
roll,
pitch,
yaw ]
#print 'RV: ', rv
return rv
def setup_poses( self, radius ):
self.radius = radius
xdir = np.arange( self.radius / 2.0, self.height + self.radius / 2.0, self.radius )
ydir = np.arange( self.radius / 2.0, self.width + self.radius / 2.0, self.radius )
move_dir = 0.0
self.poses = []
mod = 0
for y in ydir:
if mod == 0:
xord = xdir
else:
xord = xdir[::-1]
for x in xord:
goal = MoveBaseGoal()
goal.target_pose.header.frame_id = self.frame
goal.target_pose.header.stamp = rospy.Time.now()
goal.target_pose.pose.position.x = x
goal.target_pose.pose.position.y = y
quat = tf.transformations.quaternion_from_euler( 0.0, 0.0, move_dir )
goal.target_pose.pose.orientation.x = quat[0]
goal.target_pose.pose.orientation.y = quat[1]
goal.target_pose.pose.orientation.z = quat[2]
goal.target_pose.pose.orientation.w = quat[3]
self.poses.append( goal )
move_dir = standard_rad( move_dir + np.pi )
mod = ( mod + 1 ) % 2
return self.poses
def destroy_old_markers( self ):
for m in self.old_markers:
m.action = m.DELETE
self.pub.publish( m )
self.old_markers = []
def publish_markers( self ):
self.destroy_old_markers()
for i,g in enumerate(self.poses):
self.mid += 1
m = Marker()
m.ns = 'explore_poses'
m.id = self.mid
m.action = m.ADD
m.type = m.ARROW
m.header.frame_id = self.frame
m.header.stamp = rospy.Time.now()
m.scale = Vector3( 0.15, 1.0, 1.0 )
m.color = ColorRGBA( 0.2, 1.0, 0.2, 0.7 )
m.pose = g.target_pose.pose
self.old_markers.append( m )
self.pub.publish( m )
def goals( self ):
return self.poses
#self.explore_act = actionlib.SimpleActionClient('explore', explore_hrl.msg.ExploreAction)
if __name__ == '__main__':
import optparse
p = optparse.OptionParser()
p.add_option('--yaml', action='store', type='string', dest='yaml',
help='Room definition file (required)', default='')
p.add_option('--room', action='store', type='string', dest='room',
help='Specific room [default \'hrl\']', default='hrl')
opt, args = p.parse_args()
if opt.yaml == '':
print 'room_explore: YAML FILE REQUIRED.'
else:
print 'Using YAML file: ', opt.yaml
f = open( opt.yaml )
dat = yaml.load( f )
f.close()
TFthread( dat )
re = RoomExplore( dat, opt.room, 1.5 )
rospy.sleep( 4 )
re.publish_markers()
rospy.spin()
# r = rospy.Rate( 2 )
# while not rospy.is_shutdown():
# re.publish_markers()
# r.sleep()
#re.begin_explore( 0.8 )
# rosservice call /explore 0.8
# explore_act = actionlib.SimpleActionClient('explore', ExploreAction)
# rospy.logout( 'Waiting for explore.' )
# explore_act.wait_for_server()
# rospy.logout( 'Done waiting.' )
# goal = ExploreGoal( radius = 0.8 )
# explore_act.send_goal(goal)
# rospy.sleep( 0.5 )
# explore_act.wait_for_result()
| [
[
1,
0,
0.0087,
0.0029,
0,
0.66,
0,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0116,
0.0029,
0,
0.66,
0.0556,
630,
3,
1,
0,
0,
0,
0,
1
],
[
1,
0,
0.0145,
0.0029,
0,
0.... | [
"import roslib",
"roslib.load_manifest('rfid_explore_room')",
"import rospy",
"import tf",
"from threading import Thread",
"import actionlib",
"from move_base_msgs.msg import MoveBaseGoal, MoveBaseAction",
"from visualization_msgs.msg import MarkerArray",
"from visualization_msgs.msg import Marker",... |
#! /usr/bin/python
# Without the in-hand RFID reader, use ARToolKit instead for upclose
# (nearfield) validation
import roslib
roslib.load_manifest('rfid_artoolkit')
import rospy
import rfid_servoing.servo as servo
import costmap_services.python_client as costmap
import artoolkit_detector as artag
import actionlib
from rfid_artoolkit.srv import ARServoSrv, ARServoSrvResponse
from rfid_artoolkit.msg import UpCloseAction, UpCloseResult, UpCloseGoal
class ARservoScan():
# Uses ARtagScan along with costmap functionality (ie. in rfid_servoing) to
# determine when to preempt the ARtagScan and continue servoing.
# This class is used to keep the artoolkit_detector somewhat decoupled from all this other jazz.
def __init__( self ):
try:
rospy.init_node('artag_superclass')
except: # Parent already initialized
pass
rospy.logout( 'ARservoScan: Initializing' )
self.scanner = artag.ARtagScan()
# Create Costmap Services obj
self.cs = costmap.CostmapServices( accum = 15 )
self._service = rospy.Service( '/rfid_artoolkit/upclose', ARServoSrv, self.service_request )
self._as = actionlib.SimpleActionServer( '/rfid_artoolkit/upclose_act',
UpCloseAction, execute_cb = self.action_request )
self._as.start()
# Note: After moving, this will require accum * -1's before stopping.
rospy.logout( 'ARservoScan: Ready and Running.' )
def service_request( self, req ):
success, found_tag, pos, frame = self.scan( req.tagid )
rv = ARServoSrvResponse()
rv.success = success and found_tag # not preempted & found tag
if success and found_tag:
rv.ps.header.frame_id = frame
rv.ps.header.stamp = rospy.Time.now()
rv.ps.point.x = pos[0]
rv.ps.point.y = pos[1]
rv.ps.point.z = pos[2]
return rv
def action_request( self, goal ):
rospy.logout( 'ARservoScan: action_request received for tagid: \'%s\'' % goal.tagid )
zc = servo.ZedCalc( filt_len = 5, tag_id = goal.tagid )
def free_to_move_preempt():
# Note: I believe the variables are scoped at time of func def
zed_next = zc.next_pub() # Where does RFID want to go?
costmap_rv = self.cs.scoreTraj_NegHyst( 0.1, 0.0, zed_next )
#print zed_next
#print costmap_rv
if costmap_rv == -1.0:
#rospy.logout( 'Obstacle still present.' )
return False # Still keep scaning
else:
rospy.logout( 'ARservoScan: Obstacle Gone... PREEMPT!' )
return True # Whatever was in way is gone. Should go back to servoing.
def actionlib_preempt():
check = self._as.is_preempt_requested()
if check:
rospy.logout( 'ARservoScan: actionlib Preempt requested. PREEMPT!' )
return check
def preempt_func():
return free_to_move_preempt() or actionlib_preempt()
success, found_tag, pos, frame = self.scanner.scan( preempt_func = preempt_func )
# Success will be false if it was preempted (eg. preempt_func returns True)
zc.stop() # Stop the RFID reader...
if success and found_tag:
found_tag, pos, frame = self.scanner.settle( pos, frame )
if success: # Weren't preempted
if found_tag:
status = 'SUCCEEDED'
else:
status = 'FAILED'
else:
if actionlib_preempt(): # preempt caused by actionlib
status = 'PREEMPTED'
else: # obstacle is clear
status = 'RESERVO'
rospy.logout( 'ARservoScan: Scan completed.' )
rv = UpCloseResult()
rv.success = success and found_tag # not preempted & found tag
rv.status = status
if success and found_tag:
rv.ps.header.frame_id = frame
rv.ps.header.stamp = rospy.Time.now()
rv.ps.point.x = pos[0]
rv.ps.point.y = pos[1]
rv.ps.point.z = pos[2]
self._as.set_succeeded( rv )
def scan( self, tag_id ):
# Note: action_request does pretty much the same thing, but with preemption.
rospy.logout( 'ARservoScan: Scan requested for tagid \'%s\'' % tag_id )
# Subscribe to RFID reader to figure out where it wants to go.
zc = servo.ZedCalc( filt_len = 5, tag_id = tag_id )
def preempt_func():
# Note: I believe the variables are scoped at time of func def
zed_next = zc.next_pub() # Where does RFID want to go?
costmap_rv = self.cs.scoreTraj_NegHyst( 0.1, 0.0, zed_next )
#print zed_next
#print costmap_rv
if costmap_rv == -1.0:
#rospy.logout( 'Obstacle still present.' )
return False # Still keep scaning
else:
rospy.logout( 'ARservoScan: Obstacle Gone... PREEMPT!' )
return True # Whatever was in way is gone. Should go back to servoing.
success, found_tag, pos, frame = self.scanner.scan( preempt_func = preempt_func )
# Success will be false if it was preempted (eg. preempt_func returns True)
zc.stop() # Stop the RFID reader...
if success and found_tag:
found_tag, pos, frame = self.scanner.settle( pos, frame )
rospy.logout( 'ARservoScan: Scan completed.' )
#print 'scan result: ', success, found_tag, pos, frame
return ( success, found_tag, pos, frame )
def testScan():
rospy.init_node( 'testScan' )
servoScan = ARservoScan()
success, found_tag, pos, frame = servoScan.scan( 'person ' )
print 'results: ', success, found_tag, pos, frame
if __name__ == '__main__':
ss = ARservoScan()
rospy.spin()
# There are (at least) three ways to call this code.
# 1) Python:
# testScan()
# 2) ROS service:
# rosservice call /rfid_artoolkit/upclose "'person '"
# 3) ROS actionlib:
# try:
# client = actionlib.SimpleActionClient( '/rfid_artoolkit/upclose_act', UpCloseAction )
# client.wait_for_server()
# client.send_goal( UpCloseGoal( 'person ' ))
# # Test Preempt
# # rospy.sleep( 10 )
# # client.cancel_all_goals()
# client.wait_for_result()
# print client.get_result()
# except rospy.ROSInterruptException:
# print 'Program interrupted before completion'
# rospy.spin()
| [
[
1,
0,
0.0311,
0.0052,
0,
0.66,
0,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0363,
0.0052,
0,
0.66,
0.0909,
630,
3,
1,
0,
0,
0,
0,
1
],
[
1,
0,
0.0415,
0.0052,
0,
0.... | [
"import roslib",
"roslib.load_manifest('rfid_artoolkit')",
"import rospy",
"import rfid_servoing.servo as servo",
"import costmap_services.python_client as costmap",
"import artoolkit_detector as artag",
"import actionlib",
"from rfid_artoolkit.srv import ARServoSrv, ARServoSrvResponse",
"from rfid_... |
#! /usr/bin/python
import roslib
roslib.load_manifest('rfid_artoolkit')
import rospy
import tf
import actionlib
from actionlib_msgs.msg import GoalStatus
from pr2_controllers_msgs.msg import PointHeadAction, PointHeadGoal
from geometry_msgs.msg import PointStamped
from ar_pose.msg import ARMarkers
import time
from threading import Thread, Lock
import numpy as np, math
from collections import deque
def ctime():
return rospy.Time.now().to_time()
def retfalse():
return False
def goal( frame, pos, d ):
g = PointHeadGoal()
g.target.header.frame_id = frame
g.target.point.x = pos[0]
g.target.point.y = pos[1]
g.target.point.z = pos[2]
g.min_duration = rospy.Duration( d )
# Note, looking @ head action source, it seems pointing_frame unimplemented...
# Just account with a static offset (for now) where desired.
return g
class ARtagDetect():
def __init__( self ):
try:
rospy.init_node('ar_detect_tracker')
except: # Parent already initialized
pass
rospy.logout('ARtagDetect: Initializing.')
self.lock = Lock() # for last_pos & found_tag
self.found_tag = False
self.init_pos = [ 0.54, 0.0, 0.35 ]
self.last_pos = [ 0.54, 0.0, 0.35 ]
self.listener = tf.TransformListener()
self.listener.waitForTransform('/torso_lift_link', '/openni_rgb_optical_frame',
rospy.Time(0), timeout = rospy.Duration(100) )
self.artag_sub = rospy.Subscriber( '/artag_marker_handoff',
ARMarkers,
self.processARtag )
rospy.logout('ARtagDetect: Ready and Running.')
def processARtag( self, msg ):
if msg.markers != []:
frame = msg.markers[0].header.frame_id
p = msg.markers[0].pose.pose.position
pt = PointStamped()
pt.header.frame_id = frame
pt.point.x = p.x
pt.point.y = p.y
pt.point.z = p.z
pt.header.stamp = rospy.Time(0)
try:
pt_bl = self.listener.transformPoint( '/torso_lift_link', pt )
pbl = pt_bl.point
# pointing_frame manual offset (should actually be on p.y,
# but this is a good approximation with less noise in robot frame).
pbl.z = pbl.z - 0.2
self.lock.acquire()
self.last_pos = [ pbl.x, pbl.y, pbl.z ]
self.found_tag = True
self.lock.release()
except:
rospy.logout( 'ARtagDetect: Transform failed' )
def init_new_detection( self ):
self.lock.acquire()
self.last_pos = self.init_pos
self.found_tag = False
self.lock.release()
def found_new_tag( self ):
self.lock.acquire()
rv = ( self.found_tag, self.last_pos, '/torso_lift_link' )
self.lock.release()
return rv
class ARtagScan():
def __init__( self ):
try:
rospy.init_node('artag_scanner')
except: # Parent already initialized
pass
rospy.logout( 'ARtagScan: Initializing' )
self.detector = ARtagDetect()
self.hc = actionlib.SimpleActionClient('/head_traj_controller/point_head_action', PointHeadAction) # headclient
self.hc.wait_for_server()
rospy.logout( 'ARtagScan: Ready and Running.' )
def scan( self, preempt_func = retfalse ):
# self.hc.send_goal( goal( 'torso_lift_link', [0.54, 0.2, 0.25], 2.0 ))
# self.hc.wait_for_result( rospy.Duration( 2.0 ))
rospy.logout('ARtagScan: starting sweep')
cmds = [ [0.54, -0.2, 0.25],
[0.54, 0.2, -0.10],
[0.54, -0.2, 0.0],
[0.54, 0.2, 0.20],
[0.54, -0.2, 0.30],
[0.54, 0.0, 0.35] ]
self.detector.init_new_detection()
found_tag, pos, frame = self.detector.found_new_tag()
for cmd in cmds:
if not rospy.is_shutdown() and not found_tag and not preempt_func():
self.hc.send_goal( goal( 'torso_lift_link', cmd, 6.0 ))
found_tag, pos, frame = self.detector.found_new_tag()
goal_done = False
while not rospy.is_shutdown() and not goal_done and not found_tag and not preempt_func():
found_tag, pos, frame = self.detector.found_new_tag()
goal_done = self.hc.wait_for_result( rospy.Duration( 0.05 )) # ~20Hz
self.hc.cancel_all_goals() # just in case
if preempt_func():
rospy.logout( 'ARtagScan: Preempt was requested. May not have finished.' )
rospy.logout( 'ARtagScan: Exiting' )
return ( False, found_tag, pos, frame )
else:
rospy.logout( 'ARtagScan: Exiting' )
return ( True, found_tag, pos, frame )
def settle( self, init_pos, init_frame, preempt_func = retfalse ):
rospy.logout('ARtagScan: Starting settle. Looking at detection')
# Look in direction of initial read
self.hc.send_goal( goal( init_frame, init_pos, 2.0 ))
self.hc.wait_for_result( rospy.Duration( 2.0 ))
buff = deque()
buff.append( init_pos )
rospy.sleep( 0.3 )
settle = 5.0
stime = ctime()
rospy.logout('ARtagScan: Averaging scans')
# Refine the estimate
found_tag = False
self.detector.init_new_detection()
self.hc.send_goal( goal( init_frame, init_pos, 0.5 ))
goal_reached = False
r = rospy.Rate( 20 )
while not rospy.is_shutdown() and ctime() - stime < settle:
#print 'Times: ', ctime(), stime
found_tag, pos, frame = self.detector.found_new_tag()
if found_tag:
buff.append( pos )
found_tag = False
self.detector.init_new_detection()
goal_reached = self.hc.wait_for_result( rospy.Duration( 0.02 ))
if goal_reached:
mean_pos = np.mean( buff, axis = 0 )
self.hc.send_goal( goal( init_frame, mean_pos, 0.5 ))
r.sleep()
self.hc.wait_for_result( rospy.Duration( 2.0 ))
mean_pos = np.mean( buff, axis = 0 )
return ( True, mean_pos, init_frame )
def testDetect():
rospy.init_node( 'testDetect' )
rate = rospy.Rate( 1.0 )
detector = ARtagDetect()
detector.init_new_detection()
found_tag, pos, frame = detector.found_new_tag()
while not rospy.is_shutdown():
found_tag, pos, frame = detector.found_new_tag()
print found_tag, pos, frame
rate.sleep()
def testScan():
rospy.init_node( 'testScan' )
rate = rospy.Rate( 1.0 )
scanner = ARtagScan()
rv = scanner.scan()
print 'scanner res: ', rv
success, found_tag, pos, frame = rv
rv = scanner.settle( pos, frame )
print 'settle res: ', rv
if __name__ == '__main__':
#testDetect()
testScan()
| [
[
1,
0,
0.0136,
0.0045,
0,
0.66,
0,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0181,
0.0045,
0,
0.66,
0.05,
630,
3,
1,
0,
0,
0,
0,
1
],
[
1,
0,
0.0226,
0.0045,
0,
0.66... | [
"import roslib",
"roslib.load_manifest('rfid_artoolkit')",
"import rospy",
"import tf",
"import actionlib",
"from actionlib_msgs.msg import GoalStatus",
"from pr2_controllers_msgs.msg import PointHeadAction, PointHeadGoal",
"from geometry_msgs.msg import PointStamped",
"from ar_pose.msg import ARMar... |
#! /usr/bin/python
import roslib
roslib.load_manifest('rfid_servoing')
import rospy
import hrl_rfid.ros_M5e_client as rmc
from hrl_rfid.msg import RFIDread
import robotis.ros_robotis as rr
import costmap_services.python_client as costmap
from geometry_msgs.msg import Twist
import actionlib
from rfid_servoing.srv import ServoSrv
from rfid_servoing.msg import ServoAction, ServoResult, ServoGoal
import numpy as np, math
from collections import deque
import os
from threading import Lock
def ctime():
return rospy.Time.now().to_time()
def retfalse():
return False
class ServoNode( ):
def __init__( self ):
rospy.logout('servo_node: Initializing')
try:
rospy.init_node('servo_node')
except: # Node probably already initialized elsewhere
pass
# Create servos.
self.p_left = rr.ROS_Robotis_Client( 'left_pan' )
self.t_left = rr.ROS_Robotis_Client( 'left_tilt' )
self.p_right = rr.ROS_Robotis_Client( 'right_pan' )
self.t_right = rr.ROS_Robotis_Client( 'right_tilt' )
# Create Costmap Services obj
self.cs = costmap.CostmapServices( accum = 3 )
# Note: After moving, this will require accum * -1's before stopping.
# Publish move_base command
self._pub = rospy.Publisher( 'rfid_cmd_vel', Twist )
# Alterative ways to call servoing using ROS services / actionlib
self._service_servo = rospy.Service( '/rfid_servo/servo', ServoSrv, self.service_request )
self._as = actionlib.SimpleActionServer( '/rfid_servo/servo_act',
ServoAction, execute_cb = self.action_request )
self._as.start()
rospy.logout( 'servo_node: Service ready and waiting' )
def service_request( self, req ):
return self.run( req.tagid )
def action_request( self, goal ):
rospy.logout( 'servo_node: action_request received for tagid: \'%s\'' % goal.tagid )
def preempt_func():
# self._as should be in scope and bound @ function def. (I think for python...)
check = self._as.is_preempt_requested()
if check:
rospy.logout( 'servo_node: action_request preempted!' )
return check
rv = self.run( goal.tagid, preempt_func = preempt_func )
rospy.logout( 'servo_node: action_request received result %d' % int(rv) )
if preempt_func(): # this is a relatively new addition
rospy.logout('servo_node: returning actionlib state preempted.')
self._as.set_preempted()
elif rv == True:
self._as.set_succeeded( ServoResult( int(rv) ))
def run( self, tag_id, preempt_func = retfalse ):
# tag_id => 12-character tag id
# preempt_func => returns true when a preempt request is received, else false
rospy.logout( 'servo_node: Run called for tagid: \'%s\'' % tag_id )
# Ears out.
self.robotis_init()
# Startup RFID reads
zc = ZedCalc( filt_len = 5, tag_id = tag_id )
rospy.logout('servo_node: Running')
zed_next = zc.next_pub()
r = rospy.Rate( 10 )
while not rospy.is_shutdown() and self.cs.scoreTraj_PosHyst( 0.1, 0.0, zed_next ) != -1.0 and not preempt_func():
move_command = Twist()
move_command.linear.x = 0.1
move_command.angular.z = zed_next
self._pub.publish( move_command )
zc.update_last_pub( zed_next )
zed_next = zc.next_pub()
# Don't do this too fast (avoid unwanted buffering / rate issues)
try:
r.sleep()
except rospy.ROSInterruptException: # rospy shutdown request received
pass
self._pub.publish( Twist() ) # Stop moving.
# Tuck ears
# self.robotis_end()
zc.stop() # Stop the RFID reader...
if preempt_func():
rospy.logout( 'servo_node: Preempt was requested. May not have finished.' )
rospy.logout( 'servo_node: Exiting' )
return False
else:
rospy.logout( 'servo_node: Exiting' )
return True
def robotis_init( self ):
# Move Antennas into Servo mode
self.t_left.move_angle( 0.0, math.radians(30), blocking = False )
self.t_right.move_angle( 0.0, math.radians(30), blocking = False )
self.p_left.move_angle( math.radians(40), math.radians(30), blocking = False )
self.p_right.move_angle( math.radians(-40), math.radians(30), blocking = True )
while self.p_left.is_moving() or self.p_right.is_moving():
rospy.sleep( 0.05 )
def robotis_end( self ):
# Return servos to home position
self.t_left.move_angle( 0.0, math.radians(10), blocking = False )
self.t_right.move_angle( 0.0, math.radians(10), blocking = False )
self.p_left.move_angle( 1.350, math.radians(10), blocking = False )
if not (os.environ.has_key('ROBOT') and os.environ['ROBOT'] == 'sim'):
self.p_right.move_angle( -1.350, math.radians(10), blocking = False )
else:
self.p_right.move_angle( -1.350, math.radians(10), blocking = True )
class ZedCalc( ):
### WARNING: Do not instantiate in init's. This object queries the RFID reader!
def __init__( self, tag_id, sub_name = '/rfid/ears_reader', filt_len = 5 ):
rospy.logout( 'ZedCalc: Initializing' )
# We will process the reads ourself
self.values = { 'EleLeftEar': 75.0,
'EleRightEar': 75.0 }
self.lock = Lock()
self.buff_len = filt_len * 2 # two antennas' worth
self.zed_buff = deque( np.zeros( self.buff_len )) # Angle filter length
self.last_zed = 0.0 # last published command
self.new_zed = 0.0 # projected new command
self._sub = rospy.Subscriber( sub_name, RFIDread, self.callback)
self.reader = rmc.ROS_M5e_Client('ears')
self.reader.track_mode( tag_id )
rospy.logout( 'ZedCalc: Ready.' )
def stop( self ):
rospy.logout( 'ZedCalc: Stopping RFID reader' )
self.reader.stop() # Stop RFID reads
def callback( self, msg ):
self.values[ msg.antenna_name ] = np.clip( msg.rssi, 75.0, 110.0 )
left = self.values[ 'EleLeftEar' ]
right = self.values[ 'EleRightEar' ]
self.lock.acquire() # lock on buff
self.zed_buff.append( 0.10 * (left - right)/5.0 )
if len( self.zed_buff ) > self.buff_len:
self.zed_buff.popleft()
self.lock.release()
def next_pub( self, angle_slew = math.radians( 10 )):
self.lock.acquire() # lock on buff
target = np.mean( self.zed_buff )
self.lock.release()
lz = self.last_zed
return lz + np.clip( target - lz, -1.0 * angle_slew, angle_slew )
def update_last_pub( self, pub_val ):
self.last_zed = pub_val
if __name__ == '__main__':
sn = ServoNode()
rospy.spin()
# There are (at least) three ways to call this code.
# 1) Python:
# print sn.run( 'person ' )
# rospy.spin()
# 2) ROS service:
# rosservice call /rfid_servo/servo "'person '"
# 3) ROS actionlib:
# try:
# client = actionlib.SimpleActionClient( '/rfid_servo/servo_act', ServoAction )
# client.wait_for_server()
# client.send_goal( ServoGoal( 'person ' ))
# client.wait_for_result()
# print client.get_result()
# except rospy.ROSInterruptException:
# print 'Program interrupted before completion'
# rospy.spin()
| [
[
1,
0,
0.0088,
0.0044,
0,
0.66,
0,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0132,
0.0044,
0,
0.66,
0.0526,
630,
3,
1,
0,
0,
0,
0,
1
],
[
1,
0,
0.0175,
0.0044,
0,
0.... | [
"import roslib",
"roslib.load_manifest('rfid_servoing')",
"import rospy",
"import hrl_rfid.ros_M5e_client as rmc",
"from hrl_rfid.msg import RFIDread",
"import robotis.ros_robotis as rr",
"import costmap_services.python_client as costmap",
"from geometry_msgs.msg import Twist",
"import actionlib",
... |
#! /usr/bin/python
import roslib
roslib.load_manifest('rfid_servoing')
import rospy
from geometry_msgs.msg import Twist
from std_msgs.msg import Float64
from rfid_people_following.srv import StringInt32_Int32
from rfid_people_following.srv import Int32_Int32
from rfid_people_following.srv import StringInt32_Int32Response
from std_srvs.srv import Empty
import numpy as np, math
import os
import hrl_rfid.ros_M5e_client as rmc
import robotis.ros_robotis as rr
from threading import Thread
from collections import deque
SCORE_BUFFER_LEN = 5
SCORE_BUFFER_MOVE = 3 # number of checked buffer elements that must not be -1.
ANGLE_FILTER_LEN = 5
ANGLE_SLEW = math.radians( 10 )
def ctime():
return rospy.Time.now().to_time()
class ServoNode( ):
def __init__( self ):
rospy.logout('servo_node: Initializing')
try:
rospy.init_node('servo_node')
except:
pass
# Unfold "ears" to servo positions
self.p_left = rr.ROS_Robotis_Client( 'left_pan' )
self.t_left = rr.ROS_Robotis_Client( 'left_tilt' )
self.p_right = rr.ROS_Robotis_Client( 'right_pan' )
self.t_right = rr.ROS_Robotis_Client( 'right_tilt' )
# Use assisted teleop as pseudo-callback to see if valid movement:
self.scores = deque()
self.og_pub = rospy.Publisher( 'assisted_teleop_check', Twist )
self.og_sub = rospy.Subscriber( 'assisted_teleop_score', Float64, self.og_score_cb )
self.command_pub = rospy.Publisher( 'rfid_cmd_vel', Twist )
self._service_servo = rospy.Service('/rfid_servo/servo',
StringInt32_Int32,
self.run )
self._service_stop = rospy.Service('/rfid_servo/stop', Empty, self.servo_stop )
self._service_stop = rospy.Service('/rfid_servo/abort', Empty, self.servo_abort )
self._service_stop_next_obs = rospy.Service('/rfid_servo/stop_next_obs', Int32_Int32, self.stop_request )
self.stop_next_obs = False # run forever
self.should_run = True
self.abort = False
rospy.logout( 'servo_node: Service ready and waiting' )
def stop_request( self, msg = None ):
#self.stop_next_obs = bool( msg.data )
self.stop_next_obs = not self.stop_next_obs
rospy.logout( 'servo_node: Stop after next obstacle flag set to %s' % str( self.stop_next_obs ))
return True
def servo_stop( self, msg = None ):
# Note... should now be called "toggle"
self.should_run = not self.should_run
rospy.logout( 'servo_node: Toggled should_run to %s' % str( self.should_run ))
def servo_abort( self, msg = None ):
# Note... should now be called "toggle"
self.abort = True
rospy.logout( 'servo_node: Aborting!' )
def og_score_cb( self, msg ):
self.scores.append( msg.data )
if len( self.scores ) > SCORE_BUFFER_LEN:
self.scores.popleft()
def run( self, request ):
rospy.logout( 'servo_node: Called for tagid: \'%s\', continous: %d' % (request.data, request.cont) )
# Move Antennas into Servo mode
self.t_left.move_angle( 0.0, math.radians(30), blocking = False )
self.t_right.move_angle( 0.0, math.radians(30), blocking = False )
self.p_left.move_angle( math.radians(-40), math.radians(30), blocking = False )
self.p_right.move_angle( math.radians(40), math.radians(30), blocking = True )
while self.p_left.is_moving() or self.p_right.is_moving():
#time.sleep( 0.01 ) # Not such a good idea when doing simulation.
rospy.sleep( 0.05 )
self.stop_next_obs = bool( request.cont )
self.should_run = True
self.abort = False
# Startup RFID reads
self.rp = rfid_poller( request.data )
rospy.logout('servo_node: Running')
rate = rospy.Rate( 15.0 )
zed = deque([ 0.0 ])
last_zed = 0.0
#self.scores = deque()
last_print = ctime()
while self.should_run and not rospy.is_shutdown():
rate.sleep()
left, right = self.rp.values
#zed.append( 0.07 * (left - right)/5.0 )
zed.append( 0.10 * (left - right)/5.0 )
if len( zed ) > ANGLE_FILTER_LEN:
zed.popleft()
target_zed = np.mean( zed )
new_zed = last_zed + np.clip( target_zed - last_zed, -1.0 * ANGLE_SLEW, ANGLE_SLEW )
last_zed = new_zed
check = Twist()
check.linear.x = 0.1
check.angular.z = new_zed
self.og_pub.publish( check )
move_command = Twist()
if self.abort:
self.should_run = False
elif len( self.scores ) < SCORE_BUFFER_LEN:
rospy.logout( 'servo_node: Score buffer filling: %d of %d' % (len(self.scores), SCORE_BUFFER_LEN) )
elif sum([ i != -1 for i in self.scores]) < SCORE_BUFFER_MOVE:
# Check for tag detected!
if ctime() - last_print > 1.0:
rospy.logout( 'servo_node: Obstacle detected' )
last_print = ctime()
if self.stop_next_obs: # Stop after next obstacle detected
self.should_run = False
elif len( zed ) < ANGLE_FILTER_LEN:
rospy.logout( 'servo_node: Angle buffer filling' )
else:
move_command.linear.x = check.linear.x
move_command.angular.z = check.angular.z
self.command_pub.publish( move_command )
# When servo node shuts down...
self.command_pub.publish( Twist() ) # Halt the base
self.rp.stop() # Stop the reader
# Return servos to home position
self.t_left.move_angle( 0.0, math.radians(10), blocking = False )
self.t_right.move_angle( 0.0, math.radians(10), blocking = False )
self.p_left.move_angle( -1.350, math.radians(10), blocking = False )
if not (os.environ.has_key('ROBOT') and os.environ['ROBOT'] == 'sim'):
self.p_right.move_angle( 1.350, math.radians(10), blocking = False )
else:
self.p_right.move_angle( 1.350, math.radians(10), blocking = True )
rospy.logout('servo_node: Returning')
return StringInt32_Int32Response( int( True ))
class ServoNodeClient():
def __init__( self, service_name = '/rfid_servo/servo' ):
rospy.logout( 'servo_node_client: Waiting for service: \'%s\'' % service_name )
rospy.wait_for_service( service_name )
rospy.logout( 'servo_node_client: Service ready.' )
self._servo_service = rospy.ServiceProxy( service_name, StringInt32_Int32 )
def servo( self, tagid, continuous_operation = True ):
return self._servo_service( tagid, int( continuous_operation ))
class rfid_poller( Thread ):
def __init__( self, tagid ):
Thread.__init__( self )
self.reader = rmc.ROS_M5e_Client('ears')
self.reader.track_mode( tagid )
self.should_run = True
self.values = [75.0, 75.0]
self.start()
def stop( self ):
self.should_run = False
self.join(3)
if (self.isAlive()):
raise RuntimeError("rfid_poller: Unable to stop thread")
def run( self ):
rospy.logout( 'rfid_poller: Starting' )
while self.should_run and not rospy.is_shutdown():
left = np.clip( self.reader.read('EleLeftEar')[-1], 75.0, 110.0 )
right = np.clip( self.reader.read('EleRightEar')[-1], 75.0, 110.0 )
self.values = [left, right]
try: # Shut it down to conserve power. Something of a race condition (exception)
self.reader.stop()
except:
pass
rospy.logout( 'rfid_poller: Exiting' )
if __name__ == '__main__':
sn = ServoNode()
rospy.spin()
| [
[
1,
0,
0.0094,
0.0047,
0,
0.66,
0,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0142,
0.0047,
0,
0.66,
0.0435,
630,
3,
1,
0,
0,
0,
0,
1
],
[
1,
0,
0.0189,
0.0047,
0,
0.... | [
"import roslib",
"roslib.load_manifest('rfid_servoing')",
"import rospy",
"from geometry_msgs.msg import Twist",
"from std_msgs.msg import Float64",
"from rfid_people_following.srv import StringInt32_Int32",
"from rfid_people_following.srv import Int32_Int32",
"from rfid_people_following.srv import St... |
__all__ = [
'servo'
]
| [
[
14,
0,
0.6667,
1,
0,
0.66,
0,
272,
0,
0,
0,
0,
0,
5,
0
]
] | [
"__all__ = [\n 'servo'\n ]"
] |
#! /usr/bin/python
import roslib
roslib.load_manifest('rfid_demos')
roslib.load_manifest('rfid_behaviors')
roslib.load_manifest('pr2_grasp_behaviors')
roslib.load_manifest('hrl_trajectory_playback')
roslib.load_manifest('pr2_controllers_msgs')
roslib.load_manifest('robotis')
import rospy
import smach
import actionlib
from smach_ros import SimpleActionState, ServiceState, IntrospectionServer
from geometry_msgs.msg import PoseStamped, PoseWithCovarianceStamped
from move_base_msgs.msg import MoveBaseAction, MoveBaseGoal
from rfid_behaviors.srv import NextBestVantage
from rfid_behaviors.srv import HandoffSrv, HandoffSrvRequest
from rfid_behaviors.srv import FloatFloat_Int32Request as RotateBackupSrvRequest
from rfid_behaviors.srv import FloatFloat_Int32 as RotateBackupSrv
from pr2_controllers_msgs.msg import PointHeadAction, PointHeadGoal
from pr2_controllers_msgs.msg import SingleJointPositionAction, SingleJointPositionGoal
from robotis.srv import MoveAng, MoveAngRequest
from hrl_trajectory_playback.srv import TrajPlaybackSrv, TrajPlaybackSrvRequest
import sm_rfid_delivery
#from sm_next_best_vantage import BestVantage
# import sm_fetch
# import sm_rfid_explore
class PrintStr(smach.State):
def __init__(self, ins = 'Hand me an object [ENTER]'):
smach.State.__init__(self, outcomes=['succeeded', 'aborted', 'preempted'])
self.ins = ins
def execute(self, userdata):
rospy.logout( 'Executing PrintStr: %s' % self.ins )
raw_input()
return 'succeeded'
class InitLocalization(smach.State):
def __init__(self, init_pose = None):
smach.State.__init__(self, outcomes=['succeeded', 'aborted'])
self.init_pose = init_pose
def execute(self, userdata):
rospy.logout( 'Initializing Localization' )
pub = rospy.Publisher( '/initialpose', PoseWithCovarianceStamped )
rospy.sleep( 0.5 )
if not self.init_pose:
msg = PoseWithCovarianceStamped()
msg.header.frame_id = '\map'
msg.pose.pose.position.x = -1.565
msg.pose.pose.position.y = 0.807
msg.pose.pose.position.z = 0.000
msg.pose.pose.orientation.w = 1.000
msg.pose.covariance = [0.25, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.25,
0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0,
0.0, 0.068, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0]
print 'RUNNING: ', msg
raw_input( 'Drive the robot to the initial location (in kitchen by default). Hit [ENTER] when done.' )
msg.header.stamp = rospy.Time(0)
pub.publish( msg )
# for i in xrange( 5 ):
# msg.header.stamp = rospy.Time(0)
# pub.publish( msg )
# rospy.sleep( 0.05 )
return 'succeeded'
def init_local_test():
sm = smach.StateMachine( outcomes=['succeeded','aborted'] )
with sm:
smach.StateMachine.add(
'INIT_LOCALIZATION',
InitLocalization(),
transitions = { 'succeeded':'succeeded' })
return sm
def cousins_demo():
# Create a SMACH state machine
sm = smach.StateMachine(outcomes=['succeeded','aborted','preempted'],
input_keys = [ 'person_id' ])
with sm:
smach.StateMachine.add(
'ROTATE_BEFORE_MOVE',
ServiceState( '/rotate_backup',
RotateBackupSrv,
request = RotateBackupSrvRequest( 3.14, 0.0)), # Full 180-deg spin.
transitions = { 'succeeded':'MOVE_SHOW_OFF_POSE' })
gd = MoveBaseGoal()
gd.target_pose.header.frame_id = '/map'
gd.target_pose.header.stamp = rospy.Time(0)
gd.target_pose.pose.position.x = 2.956
gd.target_pose.pose.position.y = 3.047
gd.target_pose.pose.orientation.z = 0.349
gd.target_pose.pose.orientation.w = 0.937
smach.StateMachine.add(
'MOVE_SHOW_OFF_POSE',
SimpleActionState( '/move_base',
MoveBaseAction,
goal = gd ),
# transitions = {'succeeded':'READY_RETURN_HALLWAY'})
transitions = {'succeeded':'succeeded'})
# smach.StateMachine.add(
# 'READY_RETURN_HALLWAY',
# PrintStr('Ready to return to hallway [ENTER]'),
# transitions = { 'succeeded':'MOVE_HALLWAY' })
# go = MoveBaseGoal()
# go.target_pose.header.frame_id = '/map'
# go.target_pose.header.stamp = rospy.Time(0)
# go.target_pose.pose.position.x = -5.07
# go.target_pose.pose.position.y = 8.725
# go.target_pose.pose.orientation.z = 0.926
# go.target_pose.pose.orientation.w = 0.377
# smach.StateMachine.add(
# 'MOVE_HALLWAY',
# SimpleActionState( '/move_base',
# MoveBaseAction,
# goal = go ), # Back down the hallway
# transitions = {'succeeded':'succeeded'})
return sm
if False:
rospy.init_node('localization_trial')
sm = smach.StateMachine( outcomes=['succeeded','aborted','preempted'] )
with sm:
# Just a precation
tgoal = SingleJointPositionGoal()
tgoal.position = 0.040 # all the way up is 0.200
tgoal.min_duration = rospy.Duration( 2.0 )
tgoal.max_velocity = 1.0
smach.StateMachine.add(
'TORSO_SETUP',
SimpleActionState( 'torso_controller/position_joint_action',
SingleJointPositionAction,
goal = tgoal),
transitions = { 'succeeded': 'succeeded' })
sm.execute()
if __name__ == '__main__':
# if False:
rospy.init_node('smach_aware_home')
sm = cousins_demo()
sis = IntrospectionServer('sm_aware_home', sm, '/SM_AWARE_HOME')
sis.start()
rospy.logout( 'READY TO RUN AWARE_HOME DEMO' )
sm.userdata.person_id = 'person '
# sm.userdata.explore_radius = 1.5
# sm.userdata.explore_rfid_reads = []
outcome = sm.execute()
# rospy.spin()
sis.stop()
| [
[
1,
0,
0.0104,
0.0052,
0,
0.66,
0,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0156,
0.0052,
0,
0.66,
0.037,
630,
3,
1,
0,
0,
0,
0,
1
],
[
8,
0,
0.0208,
0.0052,
0,
0.6... | [
"import roslib",
"roslib.load_manifest('rfid_demos')",
"roslib.load_manifest('rfid_behaviors')",
"roslib.load_manifest('pr2_grasp_behaviors')",
"roslib.load_manifest('hrl_trajectory_playback')",
"roslib.load_manifest('pr2_controllers_msgs')",
"roslib.load_manifest('robotis')",
"import rospy",
"impor... |
#! /usr/bin/python
import roslib;
roslib.load_manifest('rfid_demos')
roslib.load_manifest('hrl_pr2_kinematics_tutorials')
# roslib.load_manifest('rfid_people_following')
roslib.load_manifest('std_srvs')
roslib.load_manifest('joy')
import rospy
from smach_ros import IntrospectionServer
from rfid_servoing.srv import ServoSrv
from rfid_behaviors.srv import HandoffSrv
from rfid_behaviors.srv import String_Int32
from rfid_behaviors.srv import FlapEarsSrv
# from rfid_people_following.srv import rfid_gui as gui_srv
from rfid_demos import sm_rfid_delivery
from std_srvs.srv import Empty
from joy.msg import Joy
from cmd_process import CmdProcess
import numpy as np, math
import time
class DemoNode():
def __init__( self ):
rospy.init_node( 'rfid_demo', anonymous = True )
rospy.logout( 'demo_node: Initializing' )
rospy.logout( 'demo_node: Waiting for services' )
rospy.wait_for_service( '/rfid_servo/servo' )
rospy.wait_for_service( '/rfid_orient/orient' )
rospy.wait_for_service( '/rfid_orient/flap' )
rospy.wait_for_service( '/rfid_handoff/initialize' )
rospy.wait_for_service( '/rfid_handoff/handoff' )
rospy.wait_for_service( '/rfid_handoff/wave' )
#rospy.wait_for_service( '/rfid_gui/select' )
rospy.logout( 'demo_node: All services ready.' )
rospy.logout( 'demo_node: Setting up state machine.' )
self.sm = sm_rfid_delivery.sm_delivery()
sis = IntrospectionServer('RFID_delivery', self.sm, '/SM_ROOT')
sis.start()
rospy.logout( 'demo_node: Done setting up state machine.' )
self.last_button = time.time()
self.run_demo = False
self.run_hoinit = False
self.run_handoff = False
self._joy_sub = rospy.Subscriber( 'joy', Joy, self.joy_process )
self._servo = rospy.ServiceProxy( '/rfid_servo/servo', ServoSrv )
self.follow1 = lambda : self._servo( 'person ', 1 ) # Stops at first obs
self.follow = lambda : self._servo( 'person ', 0 ) # Runs forever
self._handoff = rospy.ServiceProxy( '/rfid_handoff/handoff', HandoffSrv )
self.handoff = lambda : self._handoff()
self._hoinit = rospy.ServiceProxy( '/rfid_handoff/initialize', HandoffSrv )
self.hoinit = lambda : self._hoinit()
self._howave = rospy.ServiceProxy( '/rfid_handoff/wave', HandoffSrv )
self.howave = lambda : self._howave()
self._flap = rospy.ServiceProxy( '/rfid_orient/flap', FlapEarsSrv )
self.flap = lambda : self._flap( '' )
self._orient = rospy.ServiceProxy( '/rfid_orient/orient', String_Int32 )
self.orient = lambda tagid: self._orient( tagid )
#self._gui = rospy.ServiceProxy( '/rfid_gui/select', gui_srv )
#self.gui = lambda tags: self._gui( tags )
self._service = rospy.Service( '/rfid_demo/demo', Empty, self.demo )
# self._service = rospy.Service( '/rfid_demo/gui', Empty, self.gui_test )
rospy.logout( 'demo_node: Demo service ready!' )
def joy_process( self, msg ):
if msg.buttons[11] == 1 and time.time() - self.last_button > 1.0:
if msg.buttons[12] == 1: # tri + R1
rospy.logout( 'demo_node: joy_process: Calling demo service' )
p = CmdProcess( ['rosservice', 'call', '/rfid_demo/demo'] )
p.run()
self.last_button = time.time()
elif msg.buttons[13] == 1: # circle + R1
rospy.logout( 'demo_node: joy_process: Calling handoff service' )
p = CmdProcess( ['rosservice', 'call', '/rfid_handoff/handoff'] )
p.run()
self.last_button = time.time()
# SERVO_TOGGLE NO LONGER DEFINED!
# elif msg.buttons[14] == 1: # X + R1
# rospy.logout( 'demo_node: joy_process: Calling servo toggle service' )
# p = CmdProcess( ['rosservice', 'call', '/rfid_servo/stop_next_obs', '1'] )
# p.run()
# self.last_button = time.time()
elif msg.buttons[15] == 1: # square + R1
rospy.logout( 'demo_node: joy_process: Calling handoff initialization service' )
p = CmdProcess( ['rosservice', 'call', '/rfid_handoff/initialize'] )
p.run()
self.last_button = time.time()
elif msg.buttons[9] == 1: # R2 + R1
rospy.logout( 'demo_node: joy_process: Calling handoff wave service' )
p = CmdProcess( ['rosservice', 'call', '/rfid_handoff/wave'] )
p.run()
self.last_button = time.time()
# def gui_test( self, msg = None ):
# tags = self.flap().value
# gui_resp = self.gui( tags )
def demo( self, msg = None ):
rospy.logout( 'demo_node: Calling.' )
self.sm.userdata.tagid = 'person '
outcome = self.sm.execute()
print outcome
if __name__ == '__main__':
dn = DemoNode()
rospy.spin()
| [
[
1,
0,
0.0244,
0.0081,
0,
0.66,
0,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0325,
0.0081,
0,
0.66,
0.0556,
630,
3,
1,
0,
0,
0,
0,
1
],
[
8,
0,
0.0407,
0.0081,
0,
0.... | [
"import roslib;",
"roslib.load_manifest('rfid_demos')",
"roslib.load_manifest('hrl_pr2_kinematics_tutorials')",
"roslib.load_manifest('std_srvs')",
"roslib.load_manifest('joy')",
"import rospy",
"from smach_ros import IntrospectionServer",
"from rfid_servoing.srv import ServoSrv",
"from rfid_behavio... |
#! /usr/bin/python
import roslib
roslib.load_manifest('rfid_demos')
roslib.load_manifest('rfid_explore_room')
import rospy
import smach
import tf
from smach_ros import SimpleActionState, ServiceState, IntrospectionServer
import actionlib
from rfid_behaviors.srv import FlapperSrv, FlapperSrvRequest
from rfid_behaviors.srv import RecorderSrv, RecorderSrvRequest, NextBestVantage
from rfid_behaviors.msg import RecorderReads
from rfid_explore_room.srv import ExploreRoomSrv, ExploreRoomSrvResponse
from explore_hrl.msg import ExploreAction, ExploreGoal
from geometry_msgs.msg import PoseStamped
class Sleeper( smach.State ):
def __init__( self, time ):
smach.State.__init__( self, outcomes = ['succeeded'] )
self.time = time
def execute( self, userdata ):
rospy.sleep( self.time )
return 'succeeded'
def sm_search():
# Create a SMACH state machine
sm_search = smach.StateMachine( outcomes=['succeeded', 'aborted', 'preempted'],
input_keys = ['tagid', 'explore_radius'])
# Open the container
with sm_search:
# Start the RFID recorder
smach.StateMachine.add(
'RECORDER_START',
ServiceState( '/rfid_recorder/record',
RecorderSrv),
transitions = {'succeeded':'FLAPPER_START'})
# Start the ears flapping.
smach.StateMachine.add(
'FLAPPER_START',
ServiceState( '/flapper/flap',
FlapperSrv,
request_slots = ['tagid']),
transitions = {'succeeded':'EXPLORE_ROOM'},
# transitions = {'succeeded':'SLEEPER'},
remapping = {'tagid':'tagid'})
# smach.StateMachine.add('SLEEPER', Sleeper( 5.0 ), transitions = {'succeeded':'FLAPPER_STOP'})
# EXPLORE
def explore_response_cb( userdata, response ):
# result is of ExploreRoomSrvResponse
return response.result
smach.StateMachine.add(
'EXPLORE_ROOM',
ServiceState( '/explore/explore', # Default outcomes
ExploreRoomSrv,
request_slots = [ 'radius' ],
response_cb = explore_response_cb),
remapping = { 'radius':'explore_radius' },
transitions = {'succeeded':'FLAPPER_STOP'}) # input
# Stop the ears flapping.
smach.StateMachine.add(
'FLAPPER_STOP',
ServiceState( '/flapper/flap',
FlapperSrv,
request_slots = ['tagid']),
transitions = {'succeeded':'RECORDER_STOP'},
remapping = {'tagid':'tagid'})
# Start the RFID recorder
smach.StateMachine.add(
'RECORDER_STOP',
ServiceState( '/rfid_recorder/record',
RecorderSrv),
transitions = {'succeeded':'succeeded'})
return sm_search
if __name__ == '__main__':
rospy.init_node('smach_rfid_explore')
sm = sm_search()
sis = IntrospectionServer('sm_rfid_explore', sm, '/SM_ROOT_RFID_EXPLORE')
sis.start()
rospy.sleep(3.0)
sm.userdata.tagid = ''
#sm.userdata.tagid = 'person '
sm.userdata.explore_radius = 2.7
outcome = sm.execute()
sis.stop()
# This old concurrency one didn't work.
# def sm_search():
# # Create a SMACH state machine
# sm_search = smach.Concurrence( outcomes=['succeeded', 'aborted', 'preempted'],
# default_outcome = 'aborted',
# outcome_map = {'succeeded': {'EXPLORE_ROOM':'succeeded'},
# 'aborted': {'EXPLORE_ROOM':'aborted'},
# 'preempted': {'EXPLORE_ROOM':'preempted'}},
# output_keys = ['explore_rfid_reads'],
# input_keys = ['tagid', 'explore_radius'],
# child_termination_cb = lambda arg: True )
# # Note: child_termination_cb: Terminate all other states' execution upon first child complete (Always EXPLORE_ROOM).
# # Open the container
# with sm_search:
# smach.Concurrence.add(
# 'EXPLORE_ROOM',
# SimpleActionState( '/explore', # Default outcomes
# ExploreAction,
# goal_slots = [ 'radius' ]),
# remapping = { 'radius':'explore_radius' }) # input
# smach.Concurrence.add(
# 'RFID_FLAPPER',
# Flapper(), # outcomes: preempted
# remapping = { 'tagid' : 'tagid' }) # input
# smach.Concurrence.add(
# 'RFID_RECORDER',
# Recorder(), # outcomes: preempted
# remapping = { 'rfid_reads' : 'explore_rfid_reads' }) # output
# return sm_search
# import hrl_rfid.ros_M5e_client as rmc
# class Recorder(smach.State):
# def __init__(self):
# smach.State.__init__(self,
# outcomes = ['preempted'],
# output_keys = ['rfid_reads']) # [(RFIDread, ps_ant_map, ps_base_map ), ...]
# self.data = []
# def execute(self, userdata):
# rospy.logout( 'RFID Recorder: Initiated.' )
# self.data = []
# listener = tf.TransformListener()
# rospy.logout( 'RFID Recorder: Waiting on transforms' )
# listener.waitForTransform('/ear_antenna_left', '/map',
# rospy.Time(0), timeout = rospy.Duration(100) )
# listener.waitForTransform('/ear_antenna_right', '/map',
# rospy.Time(0), timeout = rospy.Duration(100) )
# rospy.logout( 'RFID Recorder: Ready' )
# def process_datum( datum ):
# # Hooray for lexical scope (listener)!
# ant_lookup = { 'EleLeftEar': '/ear_antenna_left',
# 'EleRightEar': '/ear_antenna_right' }
# ps_ant = PoseStamped()
# ps_ant.header.stamp = rospy.Time( 0 )
# ps_ant.header.frame_id = ant_lookup[ datum.antenna_name ]
# ps_base = PoseStamped()
# ps_base.header.stamp = rospy.Time( 0 )
# ps_base.header.frame_id = '/base_link'
# try:
# ps_ant_map = listener.transformPose( '/map', ps_ant )
# ps_base_map = listener.transformPose( '/map', ps_base )
# rv = ( datum, ps_ant_map, ps_base_map )
# except:
# rospy.logout( 'RFID Recorder: TF failed. Ignoring read.' )
# rv = None
# return rv
# def add_datum( datum ):
# # Hooray for lexical scope (data)!
# self.data.append( process_datum( datum ))
# # Notes: In this case, the flapper will initiate RFID reads
# # for the proper tagid. Not ideal, but how it is for now.
# rec = rmc.ROS_M5e_Client('ears', callbacks = [add_datum])
# rospy.logout( 'RFID Recorder: Logging Reads.' )
# while not smach.State.preempt_requested( self ):
# rospy.sleep( 0.1 )
# rospy.logout( 'RFID Recorder: Preempt requested. Saving reads.' )
# rec.unregister() # Stop processing new reads
# rospy.sleep( 0.5 ) # Give it some time to settle
# userdata.rfid_reads = list(self.data) # Save the data.
# self.data = []
# return 'preempted'
| [
[
1,
0,
0.0093,
0.0047,
0,
0.66,
0,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.014,
0.0047,
0,
0.66,
0.0625,
630,
3,
1,
0,
0,
0,
0,
1
],
[
8,
0,
0.0187,
0.0047,
0,
0.6... | [
"import roslib",
"roslib.load_manifest('rfid_demos')",
"roslib.load_manifest('rfid_explore_room')",
"import rospy",
"import smach",
"import tf",
"from smach_ros import SimpleActionState, ServiceState, IntrospectionServer",
"import actionlib",
"from rfid_behaviors.srv import FlapperSrv, FlapperSrvReq... |
#! /usr/bin/python
import roslib;
roslib.load_manifest('rfid_people_following')
roslib.load_manifest('std_srvs')
roslib.load_manifest('explore_hrl')
roslib.load_manifest('move_base_msgs')
roslib.load_manifest('actionlib')
roslib.load_manifest('geometry_msgs')
roslib.load_manifest('tf')
roslib.load_manifest('hrl_rfid')
import rospy
import tf
import tf.transformations as tft
import actionlib
from move_base_msgs.msg import MoveBaseAction, MoveBaseGoal
import hrl_rfid.ros_M5e_client as rmc
from rfid_people_following.srv import StringInt32_Int32
from rfid_people_following.srv import String_Int32
from rfid_people_following.srv import Int32_Int32
from rfid_people_following.srv import String_StringArr
from std_srvs.srv import Empty
from geometry_msgs.msg import PointStamped
import actionlib
import explore_hrl.msg
from geometry_msgs.msg import PoseStamped
from geometry_msgs.msg import Quaternion
import numpy as np, math
import time
from threading import Thread
import os
# A more general form of this should be folded back into ros_M5e_client!
# It also appears in new_servo_node (rfid_people_following)
class rfid_poller( Thread ):
def __init__( self, tagid ):
Thread.__init__( self )
self.reader = rmc.ROS_M5e_Client('ears')
self.listener = tf.TransformListener()
self.listener.waitForTransform('/ear_antenna_left', '/map',
rospy.Time(0), timeout = rospy.Duration(100) )
self.listener.waitForTransform('/ear_antenna_right', '/map',
rospy.Time(0), timeout = rospy.Duration(100) )
self.should_run = True
self.should_poll = False
self.data = []
self.tagid = tagid
self.start()
def transform( self, antname ):
ps = PointStamped()
ps2 = PointStamped()
ps2.point.x = 0.1
if antname == 'EleLeftEar':
ps.header.frame_id = '/ear_antenna_left'
ps.header.stamp = rospy.Time( 0 )
ps2.header.frame_id = '/ear_antenna_left'
ps2.header.stamp = rospy.Time( 0 )
elif antname == 'EleRightEar':
ps.header.frame_id = '/ear_antenna_right'
ps.header.stamp = rospy.Time( 0 )
ps2.header.frame_id = '/ear_antenna_right'
ps2.header.stamp = rospy.Time( 0 )
else:
rospy.logout( 'Bad ear' )
return False, 0.0, 0.0, 0.0
try:
ps_map = self.listener.transformPoint( '/map', ps )
x = ps_map.point.x
y = ps_map.point.y
#rospy.logout( 'Done 1' )
ps2_map = self.listener.transformPoint( '/map', ps2 )
x2 = ps2_map.point.x
y2 = ps2_map.point.y
#rospy.logout( 'Done 1' )
# We'll pass back the position of the base (which will be a "safe" place to traverse, whereas the antenna pos not necessarily in the clear)
ps_base = PointStamped()
ps_base.header.frame_id = '/base_link'
ps_base.header.stamp = rospy.Time( 0 )
ps_base_map = self.listener.transformPoint( '/map', ps_base )
x_base = ps_base_map.point.x
y_base = ps_base_map.point.y
#rospy.logout( 'Transform Success ' + ps.header.frame_id )
return True, x_base, y_base, np.arctan2( y2 - y, x2 - x )
except:
rospy.logout( 'Transform failed! ' + ps.header.frame_id )
return False, 0.0, 0.0, 0.0
def start_poller( self ):
# Start appending into self.data
#self.reader.track_mode( self.tagid )
self.should_poll = True
def stop_poller( self ):
# Stop appending into self.data
#self.reader.stop()
self.should_poll = False
def run( self ):
rospy.logout( 'rfid_poller: Starting' )
while self.should_run and not rospy.is_shutdown():
if self.should_poll:
left = self.reader.read('EleLeftEar')[-1]
success, x, y, ang = self.transform( 'EleLeftEar' )
if success:
self.data.append( [left, [x,y,ang]] )
right = self.reader.read('EleRightEar')[-1]
success, x, y, ang = self.transform( 'EleRightEar' )
if success:
self.data.append( [right, [x,y,ang]] )
else:
rospy.sleep( 0.050 )
try: # Shut it down to conserve power. Something of a race condition (exception)
self.reader.stop()
except:
pass
rospy.logout( 'rfid_poller: Exiting' )
def stop( self ):
# Kill off the poller thread.
self.should_run = False
self.join(5)
# if (self.isAlive()):
# raise RuntimeError("rfid_poller: Unable to stop thread")
# A more general form of this should be folded back into orient_node (rfid_people_following)!
class Flapper( Thread ):
def __init__( self, tagid = 'person '):
Thread.__init__( self )
rospy.logout('Flapper: Initializing' )
rospy.wait_for_service( '/rfid_orient/flap' )
rospy.logout('Flapper: flap service ready.' )
self._flap = rospy.ServiceProxy( '/rfid_orient/flap', String_StringArr )
self.flap = lambda : self._flap( tagid )
self.should_run = True
self.should_flap = False
self.start()
def start_flapper( self ):
# Start appending into self.data
#self.reader.track_mode( self.tagid )
self.should_flap = True
def stop_flapper( self ):
# Stop appending into self.data
#self.reader.stop()
self.should_flap = False
def run( self ):
rospy.logout( 'Flapper: Starting' )
r = rospy.Rate( 10 )
while self.should_run and not rospy.is_shutdown():
if self.should_flap:
self.flap()
else:
r.sleep()
rospy.logout( 'Flapper: Exiting' )
def stop( self ):
# Kill off the poller thread.
self.should_run = False
self.join(15)
if (self.isAlive()):
raise RuntimeError("Flapper: Unable to stop thread")
def navstack( x, y, ang ):
try:
rospy.logout( 'Requesting navstack move to <x,y,ang-deg> %3.3f %3.3f %3.3f.' % (x, y, math.degrees(ang)) )
client = actionlib.SimpleActionClient( 'move_base', MoveBaseAction )
client.wait_for_server()
ps = PoseStamped()
ps.header.frame_id = '/map'
ps.header.stamp = rospy.Time(0)
ps.pose.position.x = x
ps.pose.position.y = y
ps.pose.orientation = Quaternion( *tft.quaternion_from_euler( 0.0, 0.0, ang ))
goal = MoveBaseGoal( ps )
client.send_goal( goal )
rospy.logout( 'Waiting for base to stop moving.' )
client.wait_for_result()
rospy.logout( 'Successfully navigated to desired position.' )
return True
except:
rospy.logout( 'Navstack did not achieve desired position.' )
return False
class RFIDSearch():
def __init__( self ):
try:
rospy.init_node( 'rfid_search' )
except:
pass
rospy.logout( 'rfid_search: Initializing.' )
#rospy.wait_for_service( '/rfid_servo/servo' )
rospy.wait_for_service( '/rfid_orient/orient' )
rospy.wait_for_service( '/rfid_orient/flap' )
#rospy.wait_for_service( '/rfid_demo/demo' )
#rospy.wait_for_service( '/rfid_gui/select' )
self.explore_act = actionlib.SimpleActionClient('explore', explore_hrl.msg.ExploreAction)
rospy.logout( 'rfid_search: Waiting for explore.' )
self.explore_act.wait_for_server()
rospy.logout( 'rfid_search: Done Initializing.' )
#self._servo = rospy.ServiceProxy( '/rfid_servo/servo', StringInt32_Int32 )
#self.follow1 = lambda : self._servo( 'person ', 1 ) # Stops at first obs
#self.follow = lambda : self._servo( 'person ', 0 ) # Runs forever
#self._demo = rospy.ServiceProxy( '/rfid_demo/demo', Empty )
#self.demo = lambda : self._demo()
#self._servo_stop = rospy.ServiceProxy( '/rfid_servo/stop_next_obs', Int32_Int32 )
#self.servo_toggle = lambda : self._servo_stop( 1 )
self._orient = rospy.ServiceProxy( '/rfid_orient/orient', String_Int32 )
self.orient = lambda tagid: self._orient( tagid )
self.rp = rfid_poller('person ')
self.flapper = Flapper()
rospy.logout( 'rfid_search: ready to go!' )
def wait_for_finish( self, radius = 2.0 ):
print 'Starting RFID tag scanning'
self.rp.start_poller()
self.flapper.start_flapper()
rospy.sleep( 0.3 )
print 'Starting Search'
goal = explore_hrl.msg.ExploreGoal( radius = radius )
self.explore_act.send_goal(goal)
rospy.sleep( 0.5 )
self.explore_act.wait_for_result()
res = self.explore_act.get_result()
print 'Search Complete: ', res
status = self.explore_act.get_state()
print 'Disabling RFID scanning'
self.flapper.stop_flapper()
self.rp.stop_poller()
print 'Computing Best Position'
readings = self.rp.data
print readings
rr = list( self.rp.data ) # rfid_reads: [ [rssi,[x,y,ang]], ...]
rssi = [ r for r,vec in rr ]
max_rssi, max_pose = rr[ np.argmax( rssi ) ]
print 'Moving to best Position: ', max_pose, ' RSSI: ', max_rssi
navstack( *max_pose )
print 'Executing Remainder of Demo'
# if (os.environ.has_key('ROBOT') and os.environ['ROBOT'] == 'sim'):
# self.follow1() # Only do servoing in simulation
# else:
# try:
# self.demo() # Run the full demo IRL
# except: # for some reason, NoneType throws exception...
# pass
print 'Shutting down threads'
self.rp.stop()
self.flapper.stop()
if status == actionlib.GoalStatus.SUCCEEDED:
return 'succeeded'
else:
return 'aborted'
if __name__ == '__main__':
rs = RFIDSearch()
time.sleep( 3 )
rs.wait_for_finish( radius = 1.7 )
#print rs.flap()
# while True:
# print 'DoneSearching: ', rs.doneSearching()
| [
[
1,
0,
0.0099,
0.0033,
0,
0.66,
0,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0132,
0.0033,
0,
0.66,
0.0303,
630,
3,
1,
0,
0,
0,
0,
1
],
[
8,
0,
0.0166,
0.0033,
0,
0.... | [
"import roslib;",
"roslib.load_manifest('rfid_people_following')",
"roslib.load_manifest('std_srvs')",
"roslib.load_manifest('explore_hrl')",
"roslib.load_manifest('move_base_msgs')",
"roslib.load_manifest('actionlib')",
"roslib.load_manifest('geometry_msgs')",
"roslib.load_manifest('tf')",
"roslib.... |
#! /usr/bin/python
import roslib
roslib.load_manifest('rfid_demos')
import rospy
import smach
from smach_ros import SimpleActionState, ServiceState, IntrospectionServer
import actionlib
from rfid_servoing.msg import ServoAction, ServoGoal
from rfid_artoolkit.msg import UpCloseAction, UpCloseGoal
from pr2_controllers_msgs.msg import PointHeadAction, PointHeadGoal
from explore_hrl.msg import ExploreAction, ExploreActionGoal
from rfid_behaviors.srv import HandoffSrv
from rfid_behaviors.srv import FlapEarsSrv
from rfid_behaviors.srv import OrientSrv, OrientSrvRequest
from robotis.srv import MoveAng, MoveAngRequest
# import rfid_search
import yaml
def sm_delivery():
# Create a SMACH state machine
sm = smach.StateMachine( outcomes = ['succeeded','aborted','preempted'],
input_keys = ['tagid'])
# Open the container
with sm:
# smach.StateMachine.add(
# 'EXPLORE',
# Explore(),
# transitions = { 'succeeded' : 'FLAP_EARS',
# 'aborted' : 'RECOVER_ONCE' })
# smach.StateMachine.add(
# 'RECOVER_ONCE',
# RecoverOnce(),
# transitions = { 'succeeded' : 'EXPLORE',
# 'aborted' : 'aborted' })
# Initial RFID Ear Flapping
smach.StateMachine.add(
'FLAP_EARS',
ServiceState( '/rfid_orient/flap', FlapEarsSrv ),
transitions = { 'succeeded' : 'ORIENT' })
# Orient towards tag
smach.StateMachine.add(
'ORIENT',
ServiceState( '/rfid_orient/orient',
OrientSrv,
request_slots = ['data'],
input_keys=['data']), # tagid (string)
transitions = { 'succeeded' : 'SERVO' },
remapping = {'data':'tagid'}) # input
# Servoing is a basic state machine. Success means servoing finished @ obs.
smach.StateMachine.add(
'SERVO',
SimpleActionState( '/rfid_servo/servo_act',
ServoAction,
goal_slots = ['tagid']), #goal = ServoGoal( 'person ' ),
transitions = { 'succeeded': 'TUCK_LEFT' },
remapping = {'tagid':'tagid'}) # input
# # ARTag scanner. Result is actually stored in result message "status"
# # Remap based on upclose_action result
# def ar_detect_cb( userdata, status, result ):
# if result.status == 'SUCCEEDED': # Actionlib Succeeded: Found the tag!
# userdata.tag_pos = result.ps
# return 'succeeded'
# elif result.status == 'FAILED': # Actionlib Succeed, but no tag found.
# return 'recover'
# elif result.status == 'PREEMPTED': # Actionlib was preempted (higher level)
# return 'preempted'
# else: # result.status == 'RESERVO' # Obstacle from servo cleared. Self-preempt to reservo.
# return 'reservo'
# smach.StateMachine.add(
# 'ARTAG',
# SimpleActionState( '/rfid_artoolkit/upclose_act',
# UpCloseAction,
# goal_slots = ['tagid'], #goal = UpCloseGoal( 'person ' )
# output_keys = ['tag_pos'],
# outcomes = ['succeeded', 'recover', 'preempted', 'reservo'],
# result_cb = ar_detect_cb ),
# transitions = { 'recover' : 'aborted',
# 'reservo' : 'HEAD_REPOS',
# 'succeeded': 'TUCK_LEFT' },
# remapping = {'tagid':'tagid'}) # input
# # Reposition the head:
# goal = PointHeadGoal()
# goal.target.header.frame_id = '/torso_lift_link'
# goal.target.point.x = 0.54
# goal.target.point.z = 0.35
# goal.min_duration = rospy.Duration(0.6)
# smach.StateMachine.add(
# 'HEAD_REPOS',
# SimpleActionState( '/head_traj_controller/point_head_action',
# PointHeadAction,
# goal = goal ),
# transitions = { 'succeeded' : 'SERVO' })
# Tuck Left (non-blocking)
smach.StateMachine.add(
'TUCK_LEFT',
ServiceState( 'robotis/servo_left_pan_moveangle',
MoveAng,
request = MoveAngRequest( 1.350, 0.2, 0 )), # ang (float), angvel (float), blocking (bool)
transitions = {'succeeded':'TUCK_RIGHT'})
# Tuck Right (non-blocking)
smach.StateMachine.add(
'TUCK_RIGHT',
ServiceState( 'robotis/servo_right_pan_moveangle',
MoveAng,
request = MoveAngRequest( -1.350, 0.2, 0 )), # ang (float), angvel (float), blocking (bool)
transitions = {'succeeded':'HANDOFF'})
# Handoff if tag found
smach.StateMachine.add(
'HANDOFF',
ServiceState( '/rfid_handoff/handoff', HandoffSrv ),
transitions = { 'succeeded' : 'succeeded' })
# Execute SMACH plan
return sm
if __name__ == '__main__':
rospy.init_node('smach_example_state_machine')
sm = sm_delivery()
sis = IntrospectionServer('RFID_delivery', sm, '/SM_ROOT')
sis.start()
sm.userdata.tagid = 'person '
outcome = sm.execute()
rospy.spin()
sis.stop()
| [
[
1,
0,
0.0131,
0.0065,
0,
0.66,
0,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0196,
0.0065,
0,
0.66,
0.0625,
630,
3,
1,
0,
0,
0,
0,
1
],
[
1,
0,
0.0261,
0.0065,
0,
0.... | [
"import roslib",
"roslib.load_manifest('rfid_demos')",
"import rospy",
"import smach",
"from smach_ros import SimpleActionState, ServiceState, IntrospectionServer",
"import actionlib",
"from rfid_servoing.msg import ServoAction, ServoGoal",
"from rfid_artoolkit.msg import UpCloseAction, UpCloseGoal",
... |
#! /usr/bin/python
import roslib
roslib.load_manifest('rfid_demos')
roslib.load_manifest('hrl_object_fetching')
roslib.load_manifest('hrl_table_detect')
roslib.load_manifest('hrl_trajectory_playback')
roslib.load_manifest('pr2_overhead_grasping')
import rospy
import smach
import actionlib
from smach_ros import SimpleActionState, ServiceState, IntrospectionServer
# from hrl_object_fetching.srv import DetectTable
from hrl_table_detect.srv import DetectTableInst, DetectTableInstRequest
from hrl_table_detect.srv import DetectTableStart, DetectTableStop
from rfid_behaviors.srv import FloatFloat_Int32 as RotateBackupSrv
from rfid_behaviors.srv import FloatFloat_Int32Request as RotateBackupSrvRequest
from rfid_behaviors.srv import HandoffSrv, HandoffSrvRequest
from hrl_trajectory_playback.srv import TrajPlaybackSrv, TrajPlaybackSrvRequest
import pr2_overhead_grasping.sm_overhead_grasp as sm_overhead_grasp
from pr2_controllers_msgs.msg import PointHeadAction, PointHeadGoal
from geometry_msgs.msg import PointStamped
import sm_rfid_servo_approach
import approach_table.sm_approach as sm_approach
# Overhead grasping requres:
# run: hrl_pr2_gains/change_gains_grasp.py
# roslaunch pr2_overhead_grasping overhead_grasping_server.launch
# Perception requires:
# roslaunch hrl_pr2_lib openni_kinect.launch
# roslaunch hrl_object_fetching tabletop_detect.launch
def sm_fetch_object():
# Create a SMACH state machine
sm = smach.StateMachine(outcomes=['succeeded','aborted','preempted'],
input_keys = [ 'tagid' ])
with sm:
# Servo in towards table
approach = sm_rfid_servo_approach.sm_rfid_servo_approach()
smach.StateMachine.add(
'SERVO_APPROACH', # outcomes: succeeded, aborted, preempted
approach,
remapping = { 'tagid' : 'tagid'}, #input
transitions = { 'succeeded': 'POINT_HEAD' })
# Point Head Down (eventaully roll this and perceive table into own sm?)
pgoal = PointHeadGoal()
pgoal.target.header.frame_id = '/torso_lift_link'
pgoal.target.point.x = 0.50
pgoal.min_duration = rospy.Duration(0.6)
pgoal.max_velocity = 1.0
smach.StateMachine.add(
'POINT_HEAD',
SimpleActionState( '/head_traj_controller/point_head_action',
PointHeadAction,
goal = pgoal ),
transitions = { 'succeeded' : 'PERCEIVE_TABLE' })
# Detect table and determine possible approach directions!
# requires:
# roslaunch hrl_pr2_lib openni_kinect.launch
# roslaunch hrl_object_fetching tabletop_detect.launch
smach.StateMachine.add(
'PERCEIVE_TABLE',
ServiceState( '/table_detect_inst',
DetectTableInst,
request = DetectTableInstRequest( 1.0 ),
response_slots = ['grasp_points']), # PoseArray
transitions = {'succeeded':'PERCEIVE_OBJECT'},
remapping = {'grasp_points':'approach_poses'})
# Setment objects
smach.StateMachine.add(
'PERCEIVE_OBJECT',
ServiceState( '/obj_segment_inst',
DetectTableInst,
request = DetectTableInstRequest( 1.0 ),
response_slots = ['grasp_points']), # PoseArray
transitions = {'succeeded':'APPROACH_TABLE'},
remapping = {'grasp_points':'object_poses'}) #output
# Move to the desired approach vector
sm_table = sm_approach.sm_approach_table()
smach.StateMachine.add(
'APPROACH_TABLE',
sm_table,
remapping = {'table_edge_poses':'approach_poses', # input (PoseArray)
'movebase_pose_global':'approach_movebase_pose', # output (PoseStamped)
'table_edge_global':'table_edge_global'}, # output (PoseStamped)
transitions = {'succeeded':'REPOINT_HEAD'})
# Re-Point Head to table's edge.
def repoint_goal_cb(userdata, goal):
# Convert PoseStamped in userdata to PointHeadGoal
# mobj = userdata.look_points.poses[0] # We'll have head point to first object.
# pgoal = PointHeadGoal()
# pgoal.target.header.frame_id = userdata.look_points.header.frame_id
# pgoal.target.point.x = mobj.pose.position.x
# pgoal.target.point.y = mobj.pose.position.y
# pgoal.target.point.z = mobj.pose.position.z
# pgoal.min_duration = rospy.Duration(0.6)
# pgoal.max_velocity = 1.0
pgoal = PointHeadGoal()
pgoal.target.header.frame_id = '/torso_lift_link'
pgoal.target.point.x = 0.50
pgoal.target.point.y = 0.0
pgoal.target.point.z = -0.35
pgoal.min_duration = rospy.Duration(0.6)
pgoal.max_velocity = 1.0
return pgoal
smach.StateMachine.add(
'REPOINT_HEAD',
SimpleActionState( '/head_traj_controller/point_head_action',
PointHeadAction,
goal_cb = repoint_goal_cb,
input_keys = ['look_points']),
remapping = {'look_points':'object_poses'}, # input (PoseStamped)
transitions = { 'succeeded' : 'PREP_UNFOLD' })
# Prep unfold
smach.StateMachine.add(
'PREP_UNFOLD',
ServiceState( 'rfid_handoff/stow',
HandoffSrv,
request = HandoffSrvRequest()),
transitions = { 'succeeded':'UNFOLD' })
# Unfold
smach.StateMachine.add(
'UNFOLD',
ServiceState( 'traj_playback/unfold',
TrajPlaybackSrv,
request = TrajPlaybackSrvRequest( 0 )),
transitions = { 'succeeded':'MANIPULATE' })
# Manipulate
sm_grasp = sm_overhead_grasp.sm_grasp()
smach.StateMachine.add(
'MANIPULATE',
sm_grasp,
transitions = {'succeeded':'BACKUP'})
# Backup (60cm)
smach.StateMachine.add(
'BACKUP',
ServiceState( '/rotate_backup',
RotateBackupSrv,
request = RotateBackupSrvRequest(0.0, -0.50)),
transitions = { 'succeeded':'PRE_STOW' })
smach.StateMachine.add(
'PRE_STOW',
ServiceState( 'rfid_handoff/stow_grasp',
HandoffSrv,
request = HandoffSrvRequest()),
transitions = { 'succeeded':'succeeded' })
# # Setup robot for further navigation:
# # fold arms, position head, position ear antennas.
# smach.StateMachine.add(
# 'PRE_STOW',
# ServiceState( 'rfid_handoff/pre_stow',
# HandoffSrv,
# request = HandoffSrvRequest()),
# transitions = { 'succeeded':'STOW' })
# smach.StateMachine.add(
# 'STOW',
# ServiceState( 'rfid_handoff/stow',
# HandoffSrv,
# request = HandoffSrvRequest()),
# transitions = { 'succeeded':'succeeded' })
return sm
if __name__ == '__main__':
rospy.init_node('smach_sm_fetch')
sm = sm_fetch_object()
sis = IntrospectionServer('RFID_fetching', sm, '/SM_FETCHING')
sis.start()
#sm.userdata.tagid = 'person '
#sm.userdata.tagid = 'OrangeMedBot'
sm.userdata.tagid = 'SpectrMedBot'
outcome = sm.execute()
sis.stop()
| [
[
1,
0,
0.0098,
0.0049,
0,
0.66,
0,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0147,
0.0049,
0,
0.66,
0.0455,
630,
3,
1,
0,
0,
0,
0,
1
],
[
8,
0,
0.0196,
0.0049,
0,
0.... | [
"import roslib",
"roslib.load_manifest('rfid_demos')",
"roslib.load_manifest('hrl_object_fetching')",
"roslib.load_manifest('hrl_table_detect')",
"roslib.load_manifest('hrl_trajectory_playback')",
"roslib.load_manifest('pr2_overhead_grasping')",
"import rospy",
"import smach",
"import actionlib",
... |
#! /usr/bin/python
import roslib
roslib.load_manifest('rfid_demos')
roslib.load_manifest('robotis')
import rospy
import smach
from smach_ros import SimpleActionState, ServiceState, IntrospectionServer
import actionlib
from rfid_servoing.msg import ServoAction, ServoGoal
from rfid_artoolkit.msg import UpCloseAction, UpCloseGoal
from pr2_controllers_msgs.msg import PointHeadAction, PointHeadGoal
from explore_hrl.msg import ExploreAction, ExploreActionGoal
from rfid_behaviors.srv import HandoffSrv
from rfid_behaviors.srv import FlapEarsSrv
from rfid_behaviors.srv import String_Int32 as OrientSrv
from rfid_behaviors.srv import String_Int32Request as OrientSrvRequest
from robotis.srv import MoveAng, MoveAngRequest
#import rfid_search
import yaml
def sm_rfid_servo_approach():
# Create a SMACH state machine
sm = smach.StateMachine( outcomes = ['succeeded','aborted','preempted'],
input_keys = ['tagid'])
# Open the container
with sm:
# Initial RFID Ear Flapping
smach.StateMachine.add(
'FLAP_EARS',
ServiceState( '/rfid_orient/flap', FlapEarsSrv ),
transitions = { 'succeeded' : 'ORIENT' })
# Orient towards tag
smach.StateMachine.add(
'ORIENT',
ServiceState( '/rfid_orient/orient',
OrientSrv,
request_slots = ['data']), #request = OrientSrvRequest( 'person ' )
transitions = { 'succeeded' : 'SERVO' },
remapping = {'data':'tagid'}) # input
# Servoing is a basic state machine. Success means servoing finished @ obs.
smach.StateMachine.add(
'SERVO',
SimpleActionState( '/rfid_servo/servo_act',
ServoAction,
goal_slots = ['tagid']), #goal = ServoGoal( 'person ' ),
transitions = { 'succeeded': 'TUCK_LEFT' },
remapping = {'tagid':'tagid'}) # input
# Tuck Left (non-blocking)
smach.StateMachine.add(
'TUCK_LEFT',
ServiceState( 'robotis/servo_left_pan_moveangle',
MoveAng,
request = MoveAngRequest( 1.350, 0.2, 0 )), # ang (float), angvel (float), blocking (bool)
transitions = {'succeeded':'TUCK_RIGHT'})
# Tuck Right (non-blocking)
smach.StateMachine.add(
'TUCK_RIGHT',
ServiceState( 'robotis/servo_right_pan_moveangle',
MoveAng,
request = MoveAngRequest( -1.350, 0.2, 0 )), # ang (float), angvel (float), blocking (bool)
transitions = {'succeeded':'succeeded'})
return sm
if __name__ == '__main__':
import optparse
p = optparse.OptionParser()
p.add_option('--tag', action='store', type='string', dest='tagid',
help='Tagid to approach', default='person ')
opt, args = p.parse_args()
print 'SERVO APPROACH to ID: \'%s\'' % (opt.tagid)
rospy.init_node('smach_example_state_machine')
sm = sm_rfid_servo_approach()
sis = IntrospectionServer('RFID_servo_approach', sm, '/SM_RFID_SERVO_APPROACH')
sis.start()
sm.userdata.tagid = opt.tagid
outcome = sm.execute()
sis.stop()
| [
[
1,
0,
0.0208,
0.0104,
0,
0.66,
0,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0312,
0.0104,
0,
0.66,
0.0556,
630,
3,
1,
0,
0,
0,
0,
1
],
[
8,
0,
0.0417,
0.0104,
0,
0.... | [
"import roslib",
"roslib.load_manifest('rfid_demos')",
"roslib.load_manifest('robotis')",
"import rospy",
"import smach",
"from smach_ros import SimpleActionState, ServiceState, IntrospectionServer",
"import actionlib",
"from rfid_servoing.msg import ServoAction, ServoGoal",
"from rfid_artoolkit.msg... |
#! /usr/bin/python
import roslib
roslib.load_manifest('rfid_demos')
import rospy
import smach
from smach_ros import SimpleActionState, ServiceState, IntrospectionServer
import actionlib
import sm_rfid_explore
import sm_next_best_vantage
import sm_rfid_delivery
from geometry_msgs.msg import PoseStamped
from move_base_msgs.msg import MoveBaseAction
def full_delivery():
# Create a SMACH state machine
sm = smach.StateMachine(outcomes=['succeeded','aborted','preempted'],
input_keys = [ 'tagid', 'explore_radius' ])
# Open the container
with sm:
sm_search = sm_rfid_explore.sm_search()
smach.StateMachine.add(
'RFID_SEARCH', # outcomes: succeded, aborted, preempted
sm_search,
remapping = { 'tagid' : 'tagid', # input
'explore_radius' : 'explore_radius', # input
'explore_rfid_reads' : 'explore_rfid_reads' }, # output
transitions={'succeeded':'BEST_VANTAGE'})
sm_vantage = sm_next_best_vantage.sm_best_vantage()
smach.StateMachine.add(
'BEST_VANTAGE', # outcomes: succeeded, aborted, preempted
sm_vantage,
remapping = { 'tagid' : 'tagid', # input
'rfid_reads' : 'explore_rfid_reads' }, # input
transitions = {'succeeded':'DELIVERY'})
sm_delivery = sm_rfid_delivery.sm_delivery()
smach.StateMachine.add(
'DELIVERY', # outcomes: succeeded, aborted, preempted
sm_delivery,
remapping = { 'tagid' : 'tagid'}, #input
transitions = { 'succeeded': 'succeeded' })
# Execute SMACH plan
return sm
if __name__ == '__main__':
rospy.init_node('smach_example_state_machine')
sm = full_delivery()
sis = IntrospectionServer('RFID_full_delivery', sm, '/SM_ROOT_FULL_DELIVERY')
sis.start()
rospy.sleep(3.0)
sm.userdata.tagid = 'person '
sm.userdata.explore_radius = 2.7
outcome = sm.execute()
rospy.spin()
sis.stop()
| [
[
1,
0,
0.0286,
0.0143,
0,
0.66,
0,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0429,
0.0143,
0,
0.66,
0.0833,
630,
3,
1,
0,
0,
0,
0,
1
],
[
1,
0,
0.0571,
0.0143,
0,
0.... | [
"import roslib",
"roslib.load_manifest('rfid_demos')",
"import rospy",
"import smach",
"from smach_ros import SimpleActionState, ServiceState, IntrospectionServer",
"import actionlib",
"import sm_rfid_explore",
"import sm_next_best_vantage",
"import sm_rfid_delivery",
"from geometry_msgs.msg impor... |
#! /usr/bin/python
import roslib
roslib.load_manifest('rfid_demos')
roslib.load_manifest('rfid_behaviors')
roslib.load_manifest('hrl_object_fetching')
roslib.load_manifest('hrl_trajectory_playback')
roslib.load_manifest('pr2_overhead_grasping')
roslib.load_manifest('pr2_controllers_msgs')
import rospy
import smach
import actionlib
from smach_ros import SimpleActionState, ServiceState, IntrospectionServer
from geometry_msgs.msg import PoseStamped
from move_base_msgs.msg import MoveBaseAction
from rfid_behaviors.srv import NextBestVantage
from rfid_behaviors.srv import HandoffSrv, HandoffSrvRequest
from rfid_behaviors.srv import FloatFloat_Int32Request as RotateBackupSrvRequest
from rfid_behaviors.srv import FloatFloat_Int32 as RotateBackupSrv
from pr2_controllers_msgs.msg import PointHeadAction, PointHeadGoal
import sm_rfid_delivery
#from sm_next_best_vantage import BestVantage
import sm_fetch
import sm_rfid_explore
class PrintStr(smach.State):
def __init__(self, ins = 'Hello'):
smach.State.__init__(self, outcomes=['succeeded', 'aborted', 'preempted'])
self.ins = ins
def execute(self, userdata):
rospy.logout( 'Executing PrintStr: %s' % self.ins )
rospy.sleep(4.0)
return 'succeeded'
def cousins_demo():
# Create a SMACH state machine
sm = smach.StateMachine(outcomes=['succeeded','aborted','preempted'],
input_keys = [ 'explore_id', # should be ''
'obj_id',
'person_id',
'explore_radius' ])
with sm:
sm_search = sm_rfid_explore.sm_search()
smach.StateMachine.add(
'RFID_SEARCH', # outcomes: succeded, aborted, preempted
sm_search,
remapping = { 'tagid' : 'explore_id', # input
'explore_radius' : 'explore_radius' },
transitions={'succeeded':'BEST_VANTAGE_OBJ'})
# Get best vantage for obj.
# The NextBestVantage was initialized in the search.
smach.StateMachine.add(
'BEST_VANTAGE_OBJ',
ServiceState( '/rfid_recorder/best_vantage',
NextBestVantage,
request_slots = ['tagid'],
response_slots = ['best_vantage']),
remapping = {'best_vantage':'best_vantage_obj', # output
'tagid':'obj_id'}, # input
transitions = {'succeeded':'MOVE_VANTAGE_OBJ'})
smach.StateMachine.add(
'MOVE_VANTAGE_OBJ',
SimpleActionState( '/move_base',
MoveBaseAction,
goal_slots = [ 'target_pose' ]),
remapping = { 'target_pose' : 'best_vantage_obj' }, # input
transitions = {'aborted':'BEST_VANTAGE_OBJ',
'preempted':'aborted',
'succeeded':'FETCH'})
# # FETCH
# smach.StateMachine.add('FETCH',PrintStr( 'Fetching object' ),
# transitions = { 'succeeded' : 'BEST_VANTAGE_PERSON' })
# Fetch
smach.StateMachine.add(
'FETCH',
sm_fetch.sm_fetch_object(),
remapping = {'tagid':'obj_id'},
transitions = {'succeeded':'POINT_HEAD',
'aborted':'BACKUP'})
# Backup (60cm)
smach.StateMachine.add(
'BACKUP',
ServiceState( '/rotate_backup',
RotateBackupSrv,
request = RotateBackupSrvRequest(0.0, -0.50)),
transitions = { 'succeeded':'PRE_STOW' })
smach.StateMachine.add(
'PRE_STOW',
ServiceState( 'rfid_handoff/stow_grasp',
HandoffSrv,
request = HandoffSrvRequest()),
transitions = { 'succeeded':'POINT_HEAD' })
# Point Head Down (eventaully roll this and perceive table into own sm?)
pgoal = PointHeadGoal()
pgoal.target.header.frame_id = '/torso_lift_link'
pgoal.target.point.x = 0.50
pgoal.target.point.z = 0.30
pgoal.min_duration = rospy.Duration(0.6)
pgoal.max_velocity = 1.0
smach.StateMachine.add(
'POINT_HEAD',
SimpleActionState( '/head_traj_controller/point_head_action',
PointHeadAction,
goal = pgoal ),
transitions = { 'succeeded' : 'BEST_VANTAGE_PERSON' })
# Get best vantage for obj.
# The NextBestVantage was initialized in the search.
smach.StateMachine.add(
'BEST_VANTAGE_PERSON',
ServiceState( '/rfid_recorder/best_vantage',
NextBestVantage,
request_slots = ['tagid'],
response_slots = ['best_vantage']),
remapping = {'best_vantage':'best_vantage_person', # output
'tagid':'person_id'}, # input
transitions = {'succeeded':'MOVE_VANTAGE_PERSON'})
smach.StateMachine.add(
'MOVE_VANTAGE_PERSON',
SimpleActionState( '/move_base',
MoveBaseAction,
goal_slots = [ 'target_pose' ]),
remapping = { 'target_pose' : 'best_vantage_person' }, # input
transitions = {'aborted':'BEST_VANTAGE_PERSON',
'preempted':'aborted',
'succeeded':'DELIVERY'})
sm_delivery = sm_rfid_delivery.sm_delivery()
smach.StateMachine.add(
'DELIVERY', # outcomes: succeeded, aborted, preempted
sm_delivery,
remapping = { 'tagid' : 'person_id'}, #input
transitions = { 'succeeded': 'succeeded' })
return sm
if __name__ == '__main__':
rospy.init_node('smach_rfid_explore')
sm = cousins_demo()
sis = IntrospectionServer('sm_cousins_demo', sm, '/SM_COUSINS_DEMO')
sis.start()
rospy.logout( 'READY TO RUN COUSINS DEMO' )
sm.userdata.explore_id = ''
sm.userdata.obj_id = 'SpectrMedBot'
sm.userdata.person_id = 'person '
sm.userdata.explore_radius = 1.8
# sm.userdata.explore_rfid_reads = []
outcome = sm.execute()
rospy.spin()
sis.stop()
| [
[
1,
0,
0.0114,
0.0057,
0,
0.66,
0,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0171,
0.0057,
0,
0.66,
0.0435,
630,
3,
1,
0,
0,
0,
0,
1
],
[
8,
0,
0.0229,
0.0057,
0,
0.... | [
"import roslib",
"roslib.load_manifest('rfid_demos')",
"roslib.load_manifest('rfid_behaviors')",
"roslib.load_manifest('hrl_object_fetching')",
"roslib.load_manifest('hrl_trajectory_playback')",
"roslib.load_manifest('pr2_overhead_grasping')",
"roslib.load_manifest('pr2_controllers_msgs')",
"import ro... |
#! /usr/bin/python
import roslib
roslib.load_manifest('rfid_demos')
import rospy
import smach
import tf
from smach_ros import SimpleActionState, ServiceState, IntrospectionServer
import actionlib
from geometry_msgs.msg import PoseStamped
from move_base_msgs.msg import MoveBaseAction
from rfid_behaviors.srv import RecorderSrv
from rfid_behaviors.msg import RecorderReads
import numpy as np, math
class BestVantage(smach.State):
def __init__(self):
smach.State.__init__(self,
outcomes=['succeeded', 'aborted'],
input_keys = ['tagid', 'rfid_reads'],
output_keys = ['best_vantage', 'filtered_reads'])
self.initialized = False
self.orig_reads = [] # holds the original data
self.curr_reads = [] # holds data after processing
self.last_pose = None
def execute(self, userdata):
rospy.logout('BestVantage: Calculating' )
if not self.initialized:
self.initialized = True
# [ RFIDread, PoseStamped_Antenna(map frame), PoseStamped_BaseLink(map frame)
self.orig_reads = userdata.rfid_reads # (RecorderReads[])
self.curr_reads = [ r for r in self.orig_reads
if r != None and r.read.rssi != -1 and
r.read.tagID == userdata.tagid ]
else:
rospy.logout( 'BestVantage: First try did not work, eh? Filtering and retrying a new vantage.' )
return 'aborted'
if not self.curr_reads:
rospy.logout( 'BestVantage: No more positive-read poses to consider.' )
return 'aborted'
rssi = [ r.read.rssi for r in self.curr_reads ]
ind = np.argmax( rssi )
best = self.curr_reads[ ind ] # RecorderRead
best_read = best.read
best_ant = best.ps_ant_map
best_base = best.ps_base_map
#print best_read, best_ant, best_base
# We're going to keep the <x,y> location from the baselink (mapframe),
# but keep <ang> (mapframe) from the antenna.
ps = PoseStamped()
ps.header.stamp = rospy.Time.now()
ps.header.frame_id = best_base.header.frame_id
ps.pose.position = best_base.pose.position
ps.pose.orientation = best_ant.pose.orientation
userdata.best_vantage = ps
userdata.filtered_reads = self.curr_reads
return 'succeeded'
def sm_best_vantage():
sm = smach.StateMachine( outcomes = ['succeeded', 'aborted'],
input_keys = ['rfid_reads', 'tagid'])
with sm:
smach.StateMachine.add(
'SELECT_BEST_VANTAGE',
BestVantage(),
remapping = { 'tagid' : 'tagid', # input (string)
'rfid_reads' : 'rfid_reads', # input (RecorderReads)
'best_vantage' : 'best_vantage', # output (PoseStamped)
'filtered_reads' : 'filtered_reads' }, # output (RecorderReads)
transitions = {'succeeded':'MOVE_BEST_VANTAGE'})
smach.StateMachine.add(
'MOVE_BEST_VANTAGE',
SimpleActionState( '/move_base',
MoveBaseAction,
goal_slots = [ 'target_pose' ]),
remapping = { 'target_pose' : 'best_vantage' }, # input (PoseStamped)
transitions = {'aborted':'SELECT_BEST_VANTAGE',
'preempted':'aborted',
'succeeded':'succeeded'})
return sm
if __name__ == '__main__':
import sm_rfid_explore
rospy.init_node('smach_rfid_explore')
sm = smach.StateMachine(outcomes=['succeeded','aborted','preempted'],
input_keys = ['tagid','explore_radius'])
# Open the container
with sm:
sm_search = sm_rfid_explore.sm_search()
smach.StateMachine.add(
'RFID_SEARCH', # outcomes: succeded, aborted, preempted
sm_search,
remapping = { 'tagid' : 'tagid', # input
'explore_radius' : 'explore_radius', # input
'explore_rfid_reads' : 'explore_rfid_reads' }, # output
# transitions={'succeeded':'succeeded'})
transitions={'succeeded':'BEST_VANTAGE'})
sm_vantage = sm_best_vantage()
smach.StateMachine.add(
'BEST_VANTAGE', # outcomes: succeeded, aborted, preempted
sm_vantage,
remapping = { 'tagid' : 'tagid', # input
'rfid_reads' : 'explore_rfid_reads' }, # input
transitions = {'succeeded':'succeeded'})
sis = IntrospectionServer('sm_rfid_explore', sm, '/SM_ROOT_RFID_EXPLORE')
sis.start()
rospy.sleep(3.0)
sm.userdata.tagid = 'person '
sm.userdata.explore_radius = 2.7
# sm.userdata.explore_rfid_reads = []
outcome = sm.execute()
# print sm.userdata.explore_rfid_reads
rospy.spin()
sis.stop()
| [
[
1,
0,
0.0142,
0.0071,
0,
0.66,
0,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0213,
0.0071,
0,
0.66,
0.0714,
630,
3,
1,
0,
0,
0,
0,
1
],
[
1,
0,
0.0284,
0.0071,
0,
0.... | [
"import roslib",
"roslib.load_manifest('rfid_demos')",
"import rospy",
"import smach",
"import tf",
"from smach_ros import SimpleActionState, ServiceState, IntrospectionServer",
"import actionlib",
"from geometry_msgs.msg import PoseStamped",
"from move_base_msgs.msg import MoveBaseAction",
"from ... |
import subprocess as sb
import os
class CmdProcess:
def __init__(self, cmd_list):
self.cmd_list= cmd_list
self.process = None
def run(self):
self.process = sb.Popen(self.cmd_list)
def kill(self):
os.system('kill -2 %d' % self.process.pid)
| [
[
1,
0,
0.0714,
0.0714,
0,
0.66,
0,
394,
0,
1,
0,
0,
394,
0,
0
],
[
1,
0,
0.1429,
0.0714,
0,
0.66,
0.5,
688,
0,
1,
0,
0,
688,
0,
0
],
[
3,
0,
0.6429,
0.7857,
0,
0.6... | [
"import subprocess as sb",
"import os",
"class CmdProcess:\n \n def __init__(self, cmd_list):\n self.cmd_list= cmd_list\n self.process = None\n\n def run(self):\n self.process = sb.Popen(self.cmd_list)",
" def __init__(self, cmd_list):\n self.cmd_list= cmd_list\n ... |
__all__ = [
'demo_node',
'rfid_delivery',
'sm_test',
'rfid_search'
]
| [
[
14,
0,
0.6111,
0.6667,
0,
0.66,
0,
272,
0,
0,
0,
0,
0,
5,
0
]
] | [
"__all__ = [\n'demo_node',\n'rfid_delivery',\n'sm_test',\n'rfid_search'\n]"
] |
#! /usr/bin/python
import roslib
roslib.load_manifest('rfid_demos')
roslib.load_manifest('rfid_behaviors')
roslib.load_manifest('pr2_grasp_behaviors')
roslib.load_manifest('hrl_trajectory_playback')
roslib.load_manifest('pr2_controllers_msgs')
roslib.load_manifest('robotis')
import rospy
import smach
import actionlib
from smach_ros import SimpleActionState, ServiceState, IntrospectionServer
from geometry_msgs.msg import PoseStamped, PoseWithCovarianceStamped
from move_base_msgs.msg import MoveBaseAction, MoveBaseGoal
from rfid_behaviors.srv import NextBestVantage
from rfid_behaviors.srv import HandoffSrv, HandoffSrvRequest
from rfid_behaviors.srv import FloatFloat_Int32Request as RotateBackupSrvRequest
from rfid_behaviors.srv import FloatFloat_Int32 as RotateBackupSrv
from pr2_controllers_msgs.msg import PointHeadAction, PointHeadGoal
from pr2_controllers_msgs.msg import SingleJointPositionAction, SingleJointPositionGoal
from robotis.srv import MoveAng, MoveAngRequest
from hrl_trajectory_playback.srv import TrajPlaybackSrv, TrajPlaybackSrvRequest
import sm_rfid_delivery
import string
#from sm_next_best_vantage import BestVantage
# import sm_fetch
# import sm_rfid_explore
class PrintStr(smach.State):
def __init__(self, ins = 'Hand me an object [ENTER]'):
smach.State.__init__(self, outcomes=['succeeded', 'aborted', 'preempted'])
self.ins = ins
def execute(self, userdata):
rospy.logout( 'Executing PrintStr: %s' % self.ins )
raw_input()
return 'succeeded'
class ConfirmObj(smach.State):
def __init__(self, ins = 'Does the robot have the object [\'yes\' to proceed]?'):
smach.State.__init__(self, outcomes=['succeeded', 'aborted', 'preempted'])
self.ins = ins
def execute(self, userdata):
rospy.logout( 'Executing PrintStr: %s' % self.ins )
f = raw_input()
if string.find( f, 'yes' ) == -1:
return 'aborted'
else:
return 'succeeded'
class InitLocalization(smach.State):
def __init__(self, init_pose = None):
smach.State.__init__(self, outcomes=['succeeded', 'aborted'])
self.init_pose = init_pose
def execute(self, userdata):
rospy.logout( 'Initializing Localization' )
pub = rospy.Publisher( '/initialpose', PoseWithCovarianceStamped )
rospy.sleep( 0.5 )
if not self.init_pose:
msg = PoseWithCovarianceStamped()
msg.header.frame_id = '\map'
msg.pose.pose.position.x = -1.565
msg.pose.pose.position.y = 0.807
msg.pose.pose.position.z = 0.000
msg.pose.pose.orientation.w = 1.000
msg.pose.covariance = [0.25, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.25,
0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0,
0.0, 0.068, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0]
print 'RUNNING: ', msg
raw_input( 'Drive the robot to the initial location (in kitchen by default). Hit [ENTER] when done.' )
msg.header.stamp = rospy.Time(0)
pub.publish( msg )
# for i in xrange( 5 ):
# msg.header.stamp = rospy.Time(0)
# pub.publish( msg )
# rospy.sleep( 0.05 )
return 'succeeded'
def init_local_test():
sm = smach.StateMachine( outcomes=['succeeded','aborted'] )
with sm:
smach.StateMachine.add(
'INIT_LOCALIZATION',
InitLocalization(),
transitions = { 'succeeded':'succeeded' })
return sm
def cousins_demo():
# Create a SMACH state machine
sm = smach.StateMachine(outcomes=['succeeded','aborted','preempted'],
input_keys = [ 'person_id' ])
with sm:
# Just a precation
tgoal = SingleJointPositionGoal()
tgoal.position = 0.040 # all the way up is 0.200, mostly down is 0.040
tgoal.min_duration = rospy.Duration( 2.0 )
tgoal.max_velocity = 1.0
smach.StateMachine.add(
'TORSO_SETUP',
SimpleActionState( 'torso_controller/position_joint_action',
SingleJointPositionAction,
goal = tgoal),
transitions = { 'succeeded': 'INIT_ARM_POSE' })
smach.StateMachine.add(
'INIT_ARM_POSE',
ServiceState( '/traj_playback/hfa_untuck',
TrajPlaybackSrv,
request = TrajPlaybackSrvRequest( False )),
transitions = { 'succeeded':'MOVE_GET_OBJ' })
go = MoveBaseGoal()
go.target_pose.header.frame_id = '/map'
go.target_pose.header.stamp = rospy.Time(0)
go.target_pose.pose.position.x = -5.07
go.target_pose.pose.position.y = 8.725
go.target_pose.pose.orientation.z = 0.926
go.target_pose.pose.orientation.w = 0.377
smach.StateMachine.add(
'MOVE_GET_OBJ',
SimpleActionState( '/move_base',
MoveBaseAction,
goal = go ),
transitions = {'succeeded':'READY_HANDOFF_INIT'})
smach.StateMachine.add(
'READY_HANDOFF_INIT',
PrintStr('Hand me an object [ENTER]'),
transitions = { 'succeeded':'HANDOFF_INIT' })
smach.StateMachine.add(
'HANDOFF_INIT',
ServiceState( 'rfid_handoff/initialize',
HandoffSrv,
request = HandoffSrvRequest()),
transitions = { 'succeeded':'CONFIRM_HANDOFF' })
smach.StateMachine.add(
'CONFIRM_HANDOFF',
ConfirmObj('Does the robot have the object [\'yes\' to proceed]?'),
transitions = { 'succeeded':'ROTATE_AFTER_HANDOFF',
'aborted':'READY_HANDOFF_INIT'} )
smach.StateMachine.add(
'ROTATE_AFTER_HANDOFF',
ServiceState( '/rotate_backup',
RotateBackupSrv,
request = RotateBackupSrvRequest( 3.14, 0.0)), # Full 180-deg spin.
transitions = { 'succeeded':'MOVE_DELIVERY' })
gd = MoveBaseGoal()
gd.target_pose.header.frame_id = '/map'
gd.target_pose.header.stamp = rospy.Time(0)
gd.target_pose.pose.position.x = 2.956
gd.target_pose.pose.position.y = 3.047
gd.target_pose.pose.orientation.z = 0.349
gd.target_pose.pose.orientation.w = 0.937
smach.StateMachine.add(
'MOVE_DELIVERY',
SimpleActionState( '/move_base',
MoveBaseAction,
goal = gd ),
transitions = {'succeeded':'DELIVERY'})
sm_delivery = sm_rfid_delivery.sm_delivery()
smach.StateMachine.add(
'DELIVERY', # outcomes: succeeded, aborted, preempted
sm_delivery,
remapping = { 'tagid' : 'person_id'}, #input
transitions = { 'succeeded': 'TUCKL_SUCC',
'aborted': 'TUCKL_ABOR'})
smach.StateMachine.add(
'TUCKL_SUCC',
ServiceState( '/robotis/servo_left_pan_moveangle',
MoveAng,
request = MoveAngRequest( 1.350, 0.3, 0)),
transitions = { 'succeeded':'TUCKR_SUCC' })
smach.StateMachine.add(
'TUCKR_SUCC',
ServiceState( '/robotis/servo_right_pan_moveangle',
MoveAng,
request = MoveAngRequest( -1.350, 0.3, 0)),
transitions = { 'succeeded':'BACKUP_AFTER_DELIVERY' })
smach.StateMachine.add(
'TUCKL_ABOR',
ServiceState( '/robotis/servo_left_pan_moveangle',
MoveAng,
request = MoveAngRequest( 1.350, 0.3, 0)),
transitions = { 'succeeded':'TUCKR_ABOR' })
smach.StateMachine.add(
'TUCKR_ABOR',
ServiceState( '/robotis/servo_right_pan_moveangle',
MoveAng,
request = MoveAngRequest( -1.350, 0.3, 0)),
transitions = { 'succeeded':'aborted' })
smach.StateMachine.add(
'BACKUP_AFTER_DELIVERY',
ServiceState( '/rotate_backup',
RotateBackupSrv,
request = RotateBackupSrvRequest(0.0, -0.50)),
transitions = { 'succeeded':'ROTATE_AFTER_DELIVERY' })
smach.StateMachine.add(
'ROTATE_AFTER_DELIVERY',
ServiceState( '/rotate_backup',
RotateBackupSrv,
request = RotateBackupSrvRequest( 3.14, 0.0)),
transitions = { 'succeeded':'MOVE_FINAL' })
# Kitchen
# gk = MoveBaseGoal()
# gk.target_pose.header.frame_id = '/map'
# gk.target_pose.header.stamp = rospy.Time(0)
# gk.target_pose.pose.position.x = -1.61
# gk.target_pose.pose.position.y = 0.88
# gk.target_pose.pose.orientation.z = 0.91
# gk.target_pose.pose.orientation.w = 0.40
smach.StateMachine.add(
'MOVE_FINAL',
SimpleActionState( '/move_base',
MoveBaseAction,
goal = go ), # Back down the hallway
transitions = {'succeeded':'succeeded'})
return sm
if False:
rospy.init_node('localization_trial')
sm = smach.StateMachine( outcomes=['succeeded','aborted','preempted'] )
with sm:
# Just a precation
tgoal = SingleJointPositionGoal()
tgoal.position = 0.040 # all the way up is 0.200
tgoal.min_duration = rospy.Duration( 2.0 )
tgoal.max_velocity = 1.0
smach.StateMachine.add(
'TORSO_SETUP',
SimpleActionState( 'torso_controller/position_joint_action',
SingleJointPositionAction,
goal = tgoal),
transitions = { 'succeeded': 'succeeded' })
sm.execute()
if __name__ == '__main__':
# if False:
rospy.init_node('smach_aware_home')
sm = cousins_demo()
sis = IntrospectionServer('sm_aware_home', sm, '/SM_AWARE_HOME')
sis.start()
rospy.logout( 'READY TO RUN AWARE_HOME DEMO' )
sm.userdata.person_id = 'person '
# sm.userdata.explore_radius = 1.5
# sm.userdata.explore_rfid_reads = []
outcome = sm.execute()
# rospy.spin()
sis.stop()
| [
[
1,
0,
0.0066,
0.0033,
0,
0.66,
0,
796,
0,
1,
0,
0,
796,
0,
0
],
[
8,
0,
0.0098,
0.0033,
0,
0.66,
0.0345,
630,
3,
1,
0,
0,
0,
0,
1
],
[
8,
0,
0.0131,
0.0033,
0,
0.... | [
"import roslib",
"roslib.load_manifest('rfid_demos')",
"roslib.load_manifest('rfid_behaviors')",
"roslib.load_manifest('pr2_grasp_behaviors')",
"roslib.load_manifest('hrl_trajectory_playback')",
"roslib.load_manifest('pr2_controllers_msgs')",
"roslib.load_manifest('robotis')",
"import rospy",
"impor... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.