def __init__(self, *args):
super(HardwareTest, self).__init__(*args)
rospy.init_node('base_test')
self.message_received = False
self.sss = simple_script_server()
try:
# move_
if not rospy.has_param('~move_x'):
self.fail(
'Parameter move_x does not exist on ROS Parameter Server')
self.move_x = rospy.get_param('~move_x')
if not rospy.has_param('~move_y'):
self.fail(
'Parameter move_ does not exist on ROS Parameter Server')
self.move_y = rospy.get_param('~move_y')
if not rospy.has_param('~move_theta'):
self.fail(
'Parameter move_ does not exist on ROS Parameter Server')
self.move_theta = rospy.get_param('~move_theta')
except KeyError, e:
self.fail('Parameters not set properly')
def __init__(self, *args):
super(PythonAPITest, self).__init__(*args)
rospy.init_node('test_python_api_test')
self.sss=simple_script_server()
self.as_cb_executed = False
self.ss_stop_cb_executed = False
self.ns_global_prefix = "/script_server"
def __init__(self, *args):
super(HardwareTest, self).__init__(*args)
rospy.init_node('sound_test')
self.message_received = False
self.sss = simple_script_server()
self.record = []
def __init__(self, *args):
super(HardwareTest, self).__init__(*args)
rospy.init_node('test_hardware_test')
torso_joint_states = []
self.message_received = False
self.sss = simple_script_server()
def __init__(self):
self.sss = simple_script_server()
self.detection_service = rospy.ServiceProxy(
'/object_detection/detect_object', DetectObjects)
self.arm_state = rospy.Subscriber("/arm_controller/state",
JointTrajectoryControllerState,
self.get_joint_state)
self.listener = tf.TransformListener(True, rospy.Duration(10.0))
# initialize components (not needed for simulation)
"""
self.sss.init("tray")
self.sss.init("torso")
self.sss.init("arm")
self.sss.init("sdh")
self.sss.init("base")
"""
# move to initial positions
handle_arm = self.sss.move("arm", "folded", False)
handle_torso = self.sss.move("torso", "home", False)
handle_sdh = self.sss.move("sdh", "home", False)
self.sss.move("tray", "down")
handle_arm.wait()
handle_torso.wait()
handle_sdh.wait()
if not self.sss.parse:
print "Please localize the robot with rviz"
def __init__(self):
self.sss = simple_script_server()
self.panels = []
self.stop_buttons = []
self.init_buttons = []
self.recover_buttons = []
self.CreateControlPanel()
def __init__(self, *args):
super(UnitTest, self).__init__(*args)
rospy.init_node('component_test')
self.message_received = False
self.sss = simple_script_server()
self.command_traj = JointTrajectory()
# get parameters
try:
# component
if not rospy.has_param('~component'):
self.fail('Parameter component does not exist on ROS Parameter Server')
self.component = rospy.get_param('~component')
# movement command
if not rospy.has_param('~test_target'):
self.fail('Parameter test_target does not exist on ROS Parameter Server')
self.test_target = rospy.get_param('~test_target')
# movement command
if not rospy.has_param('~default_target'):
self.fail('Parameter default_target does not exist on ROS Parameter Server')
self.default_target = rospy.get_param('~default_target')
# time to wait before
self.wait_time = rospy.get_param('~wait_time', 5)
# error range
if not rospy.has_param('~error_range'):
self.fail('Parameter error_range does not exist on ROS Parameter Server')
self.error_range = rospy.get_param('~error_range')
except KeyError, e:
self.fail('Parameters not set properly')
def __init__(self):
# Visualization topics:
self.visual_cart_footprint_estimator = rospy.Publisher(
"/visual_cart_footprint_estimator", PolygonStamped, queue_size=1)
self.visual_laser_msg = rospy.Publisher("/cart_filtered_scan",
LaserScan,
queue_size=1)
self.visual_cart = rospy.Publisher("/isolated_cart_scan",
LaserScan,
queue_size=1)
# The cart status:
self.the_cart_pub = rospy.Publisher("/cart_is_holded",
String,
queue_size=1)
self.ref_cart_legs = [(1.375, 0.225), (0.705, 0.225), (0.705, -0.225),
(1.375, -0.225)]
self.the_cart = False
# Cart footprint estimator message
self.cart_footprint_estimator = PolygonStamped()
self.cart_footprint_estimator.header.frame_id = "base_link"
# Handlers and feedback data:
self.filtered_laser_msg = LaserScan()
self.cart_isolated_laser_msg = LaserScan()
self.laser_projection = lg.LaserProjection()
self.sss = simple_script_server()
def __init__(self, num_steps, intervall):
rospy.init_node("recorder")
self.sss = simple_script_server()
#assign members
self.do_tf = False
self.do_verbose = True
self.intervall = intervall
self.num_steps = num_steps
self.srv_set_model_state = rospy.ServiceProxy(
'/gazebo/set_model_state', SetModelState)
self.req_set = SetModelStateRequest()
self.req_set.model_state.model_name = "robot"
self.req_set.model_state.reference_frame = "map"
if do_tf == True:
self.tf_br = broadcaster(
"/map",
"/odom_combined",
)
def __init__(self,buttons):
global initialized
self.sss = simple_script_server()
gtk.Frame.__init__(self)
self.em_stop = False
self.set_label("general")
self.set_shadow_type(gtk.SHADOW_IN)
self.vbox = gtk.VBox(False, 0)
self.add(self.vbox)
#hbox=gtk.HBox(True, 0)
#image = gtk.Image()
#image.set_from_file(roslib.packages.get_pkg_dir("cob_command_gui") + "/common/files/icons/batti-040.png")
#hbox.pack_start(image, False, False, 0)
#label = gtk.Label("40 %")
#hbox.pack_start(label, False, False, 0)
#self.vbox.pack_start(hbox, False, False, 5)
hbox=gtk.HBox(True, 0)
self.status_image = gtk.Image()
#self.status_image.set_from_file(roslib.packages.get_pkg_dir("cob_command_gui") + "/common/files/icons/weather-clear.png")
hbox.pack_start(self.status_image, False, False, 0)
self.status_label = gtk.Label("Status OK")
hbox.pack_start(self.status_label, False, False, 0)
self.vbox.pack_start(hbox, False, False, 5)
butstop = gtk.Button("Stop all")
butstop.connect("clicked", lambda w: self.stop_all(buttons.stop_buttons))
self.vbox.pack_start(butstop, False, False, 5)
butinit = gtk.Button("Init all")
butinit.connect("clicked", lambda w: self.init_all(buttons.init_buttons))
self.vbox.pack_start(butinit, False, False, 5)
butrec = gtk.Button("Recover all")
butrec.connect("clicked", lambda w: self.recover_all(buttons.recover_buttons))
self.vbox.pack_start(butrec, False, False, 5)
butrec = gtk.Button("Halt all")
butrec.connect("clicked", lambda w: self.halt_all(buttons.halt_buttons))
self.vbox.pack_start(butrec, False, False, 5)
plan_check = gtk.CheckButton("Planning")#
plan_check.connect("toggled", self.planned_toggle)
self.vbox.pack_start(plan_check, False, False, 5)
base_mode_check = gtk.CheckButton("Base Diff")
base_mode_check.connect("toggled", self.base_mode_toggle)
self.vbox.pack_start(base_mode_check, False, False, 5)
confirm_com_check = gtk.CheckButton("Confirm Commands")
confirm_com_check.set_active(confirm_commands_enabled)
confirm_com_check.connect("toggled", self.confirm_com_toggle)
self.vbox.pack_start(confirm_com_check, False, False, 5)
but = gtk.Button(stock=gtk.STOCK_QUIT )
but.connect("clicked", lambda w: gtk.main_quit())
self.vbox.pack_start(but, False, False, 5)
initialized = True
def __init__(self):
self._sss = sss = simple_script_server()
#self.sss.init("head")
sss.init("torso")
sss.init("arm_left")
sss.init("arm_right")
sss.init("gripper_left")
sss.init("gripper_right")
sss.init("base")
def __init__(self, test_type): self.sss = simple_script_server() ### GET PARAMETERS ### self.base_params = None self.actuators = [] self.sensors = [] if test_type == 'long_time_test': self.init_long_time_test() elif test_type == 'daily_morning_show': self.init_daily_morning_show()
def __init__(self):
self.sss = simple_script_server()
self.station0 = [0, 0, 0.0]
self.station1 = [15, 7.2, 0.0]
self.station2 = [33, 0.0, 0.0]
self.station3 = [26, -37, 0]
self.station4 = [-9.2, -37, 0]
self.station5 = self.station3
self.station6 = self.station0
self.goals = []
self.goals.append(self.station0)
self.goals.append(self.station1)
self.goals.append(self.station2)
self.goals.append(self.station3)
self.goals.append(self.station4)
self.goals.append(self.station5)
self.goals.append(self.station6)
def __init__(self):
# Visualization topics:
self.visual_cart_safety_footprint = rospy.Publisher(
"/visual_cart_safety_footprint", PolygonStamped, queue_size=10)
self.visual_cart_footprint_estimator = rospy.Publisher(
"/visual_cart_footprint_estimator", PolygonStamped, queue_size=10)
self.visual_laser_msg = rospy.Publisher("/cart_filtered_scan",
LaserScan,
queue_size=1)
self.visual_cart = rospy.Publisher("/isolated_cart_scan",
LaserScan,
queue_size=1)
# The cart status:
self.ref_cart_legs = [(1.375, 0.225), (0.705, 0.225), (0.705, -0.225),
(1.375, -0.225)]
self.the_cart = False
self.cart_legs = []
self.cart_area = 0.2
self.cart_wheel_diameter = 0.11
# Cart safty footprint message
self.cart_safety_footprint = PolygonStamped()
self.cart_safety_footprint.header.stamp = rospy.Time.now()
self.cart_safety_footprint.header.frame_id = "base_link"
self.cart_safety_footprint.polygon.points = [
Point(1.375, 0.225, 0.0),
Point(1.375, -0.225, 0.0),
Point(0.705, -0.225, 0.0),
Point(0.705, 0.225, 0.0)
]
# Cart footprint estimator message
self.cart_footprint_estimator = PolygonStamped()
self.cart_footprint_estimator.header.frame_id = "base_link"
# Robot status:
self.current_position = Odometry()
self.standing_position = []
# Handlers and feedback data:
self.filtered_laser_msg = LaserScan()
self.cart_isolated_laser_msg = LaserScan()
self.laser_projection = lg.LaserProjection()
self.sss = simple_script_server()
def __init__(self):
rospy.loginfo("Waiting /arm_kinematics/get_ik service...")
rospy.wait_for_service('/arm_kinematics/get_ik')
rospy.loginfo("/arm_kinematics/get_ik has been found!")
rospy.loginfo("Waiting /get_grasp_configurations service...")
rospy.wait_for_service('/get_grasp_configurations')
rospy.loginfo("/get_grasp_configurations has been found!")
rospy.loginfo("Waiting /get_grasps_from_position service...")
rospy.wait_for_service('/get_grasps_from_position')
rospy.loginfo("/get_grasps_from_position has been found!")
self.sss = simple_script_server()
self.iks = rospy.ServiceProxy('/arm_kinematics/get_ik', GetPositionIK)
# initialize components (not needed for simulation)
self.sss.init("tray")
self.sss.init("torso")
self.sss.init("arm")
self.sss.init("sdh")
self.sss.init("base")
# move to initial positions
#handle_arm = self.sss.move("arm","folded",False)
#handle_torso = self.sss.move("torso","home",False)
#handle_sdh = self.sss.move("sdh","home",False)
#self.sss.move("tray","down")
#handle_arm.wait()
#handle_torso.wait()
#handle_sdh.wait()
if not self.sss.parse:
print "Please localize the robot with rviz"
self.sss.wait_for_input()
self.listener = tf.TransformListener(True, rospy.Duration(10.0))
rospy.sleep(2)
def __init__(self, *args):
super(UnitTest, self).__init__(*args)
self.sss = simple_script_server()
rospy.init_node('tactile_test')
self.message_received = False
self.actual_values = []
try:
#tactile topic
if not rospy.has_param('~topic'):
self.fail(
'Parameter topic does not exist on ROS Parameter Server')
self.topic = rospy.get_param('~topic')
# minimum required value
if not rospy.has_param('~min_tactile_value'):
self.fail(
'Parameter min_tactile_value does not exist on ROS Parameter Server'
)
self.min_tactile_value = rospy.get_param('~min_tactile_value')
except KeyError, e:
self.fail('Parameters not set properly')
def __init__(self):
self.sss = simple_script_server()
self.pose = ''
self.joint_state = []
try:
opts, args = getopt.getopt(sys.argv[1:], "h:p:", ["pose="])
rospy.loginfo(args)
except getopt.GetoptError:
print 'python save_position.py -p <posename>'
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
print 'python save_position.py -p <posename>'
sys.exit()
elif opt in ("-p", "--pose"):
self.pose = arg
else:
print 'Invalid syntax, please use "python save_position.py -p <posename>"'
rospy.loginfo(self.pose)
if self.pose == '':
rospy.logerr("posename cannot be empty")
print 'python save_position.py -p <posename>'
sys.exit()
rospy.loginfo(self.pose)
self.param = '/script_server/arm/' + self.pose
rospy.loginfo(self.param)
self.ready = 0
rospy.Subscriber('/arm_controller/state',
JointTrajectoryControllerState, self.get_joint_state)
def __init__(self, *args):
super(UnitTest, self).__init__(*args)
rospy.init_node('calibration_test')
self.message_received = False
self.sss = simple_script_server()
# get parameters
try:
# movement command
if not rospy.has_param('~test_target_torso'):
self.fail('Parameter test_target_torso does not exist on ROS Parameter Server')
self.test_target_torso = rospy.get_param('~test_target_torso')
if not rospy.has_param('~test_target_head'):
self.fail('Parameter test_target_head does not exist on ROS Parameter Server')
self.test_target_head = rospy.get_param('~test_target_head')
if not rospy.has_param('~test_target_arm'):
self.fail('Parameter test_target_arm does not exist on ROS Parameter Server')
self.test_target_arm = rospy.get_param('~test_target_arm')
except KeyError, e:
self.fail('Parameters not set properly')
def __init__(self):
self.available_poses = ['home', 'folded', 'waveleft', 'waveright']
self.sss = simple_script_server()
def run():
test = ComponentTest('daily_morning_show')
#light_test = HardwareTest('daily_morning_show_lights')
sss = simple_script_server()
# Check that em_stop is not pressed
while test.check_em_stop():
dialog_client(0, 'Release EM-stop and press ' 'OK' '')
# Initialize
test.log_file.write('\n[INITIALIZE] [%s]' % (time.strftime('%H:%M:%S')))
if test.base_params:
test.log_file.write('\n base: ')
if test.init_component('base'):
test.log_file.write('\t<<OK>>')
else:
test.log_file.write('\t<<FAIL>>')
for component in test.actuators:
test.log_file.write('\n %s: ' % (component['name']))
if test.init_component(component['name']):
test.log_file.write('\t<<OK>>')
else:
test.log_file.write('\t<<FAIL>>')
rospy.sleep(1)
#### MOVE TEST 1 ###
test.log_file.write('\n\n[MOVE_TEST_1] [%s]' % (time.strftime('%H:%M:%S')))
if test.base_params:
# Move base
test.log_file.write('\n base: ')
if test.move_base_rel(test.base_params) and dialog_client(
1, 'Did the robot move?'):
test.log_file.write('\t<<OK>>')
else:
test.log_file.write('\t<<FAIL>>')
test.get_diagnostics('base')
# Move actuators
for component in test.actuators:
test.log_file.write('\n %s: ' % (component['name']))
if test.move_actuator_daily(component) and test.dialog(
component['name'], component['test_target']):
test.log_file.write('\t<<OK>>')
else:
test.log_file.write('\t<<FAIL>>')
test.get_diagnostics(component['name'])
### RECOVER TEST ###
test.log_file.write('\n\n[RECOVER_TEST] [%s]' %
(time.strftime('%H:%M:%S')))
test.recover_test()
### MOVE TEST 2 ###
test.log_file.write('\n\n[MOVE_TEST_2] [%s]' % (time.strftime('%H:%M:%S')))
if test.base_params:
# Move base
test.log_file.write('\n base: ')
if test.move_base_rel(test.base_params) and dialog_client(
1, 'Did the robot move?'):
test.log_file.write('\t<<OK>>')
else:
test.log_file.write('\t<<FAIL>>')
test.get_diagnostics('base')
# Move actuators
for component in test.actuators:
test.log_file.write('\n %s: ' % (component['name']))
if test.move_actuator_daily(component) and test.dialog(
component['name'], component['test_target']):
test.log_file.write('\t<<OK>>')
else:
test.log_file.write('\t<<FAIL>>')
test.get_diagnostics(component['name'])
# Change lights, test mimics and sound
# This part is completely "hardcoded", only use with Cob4!
if True:
test.log_file.write('\n\n[MIMICS, SOUNDS & LEDS] [%s]' %
(time.strftime('%H:%M:%S')))
test.log_file.write('\n mimics:')
sss.set_mimic("mimic", "asking")
rospy.sleep(1)
mimic_working = dialog_client(1, 'Do you see the question-mark?')
sss.set_mimic("mimic", "default")
if mimic_working:
test.log_file.write('\t<<OK>>')
else:
test.log_file.write('\t<<FAIL>>')
test.log_file.write('\n sound:')
sss.say(["test 1, 2, 3"])
rospy.sleep(1)
sound_working = dialog_client(
1, 'Did you hear me speak? (Next: Lights, so pay attention!)')
if sound_working:
test.log_file.write('\t<<OK>>')
else:
test.log_file.write('\t<<FAIL>>')
test.log_file.write('\n LEDs:')
sss.set_light("light_base", "cyan")
sss.set_light("light_torso", "cyan")
rospy.sleep(1.0)
sss.set_light("light_base", "yellow")
sss.set_light("light_torso", "yellow")
rospy.sleep(3.0)
sss.set_light("light_base", "red")
sss.set_light("light_torso", "red")
rospy.sleep(3.0)
sss.set_light("light_base", "cyan")
sss.set_light("light_torso", "cyan")
rospy.sleep(3.0)
lights_changed = dialog_client(
1,
'Did you see the lights change from "cyan" to "yellow" to "red" and back?'
)
if lights_changed:
test.log_file.write('\t<<OK>>')
else:
test.log_file.write('\t<<FAIL>>')
# Sensor test
test.log_file.write('\n\n[SENSOR_TEST] [%s]' % (time.strftime('%H:%M:%S')))
for sensor in test.sensors:
test.log_file.write('\n %s: ' % (sensor['name']))
if test.check_sensor(sensor['topic'], sensor['msg_type']):
test.log_file.write('<<OK>>')
else:
test.log_file.write('<<NO_MSG>>')
test.log_file.close()
def main():
rospy.init_node('tf_position_retrieval')
tf_listener = tf.TransformListener()
#subscribe to tf message where the pattern information are published
rospy.Subscriber("/tf", tf.msg.tfMessage, cb_tf)
#todo: read in pose list from parameter server
if (not rospy.has_param("/script_server/arm/calibration_poses")):
rospy.logerr("No arm calibration poses given.")
exit(0)
else:
calib_poses = sorted(
rospy.get_param("/script_server/arm/calibration_poses"))
rospy.loginfo("arm calibration poses: %s", calib_poses)
kinect_transforms = []
#create instance of script server
sss = simple_script_server()
for item in calib_poses:
#move arm to the given position (blocking call
print "start move arm"
sss.move("arm", item)
print "arm arrived"
rospy.sleep(2.0)
time_after_movement = rospy.Time.now()
# only take pose if time stamp is new than the time directly after the arm movement
while ((last_pattern_transform.header.stamp - time_after_movement) <=
0):
print "wait for newest time stamp"
rospy.spin()
#current_transform = last_pattern_transform.transform
print "loopup transform"
(trans, rot) = tf_listener.lookupTransform('/base_link',
'/openni_camera',
rospy.Time(0))
current_transform.transform.translation = trans
current_transform.transform.rotation = rot
kinect_transforms.append(current_transform)
print "calc mean"
#calculate the mean
mean_x = 0
mean_y = 0
mean_z = 0
mean_roll = 0
mean_pitch = 0
mean_raw = 0
for item in kinect_transforms:
mean_x += item.transform.translation.x
mean_y += item.transform.translation.y
mean_z += item.transform.translation.z
(roll, pitch, yaw) = tf.transformations.euler_from_quaternion([
item.transform.rotation.x, item.transform.rotation.y,
item.transform.rotation.z, item.transform.rotation.w
])
mean_roll += roll
mean_pitch += pitch
mean_yaw += yaw
mean_x /= len(kinect_transforms)
mean_y /= len(kinect_transforms)
mean_z /= len(kinect_transforms)
mean_roll /= len(kinect_transforms)
mean_pitch /= len(kinect_transforms)
mean_raw /= len(kinect_transforms)
rospy.loginfo("%s %s %s %s %s %s", mean_x, mean_y, mean_z, mean_roll,
mean_pitch, mean_yaw)
def __init__(self):
self._sss = simple_script_server()
self._sss.say("sound", ["I am listening to you"])
def __init__(self):
self.sss = simple_script_server()
self.station1 = [40, -3, 1.57]
self.station2 = [40, -10, -1.57]
self.station3 = [39.2, -23, 0]
self.num_iterations = 10
def init_long_time_test(self):
rospy.init_node('component_test_all')
### GET PARAMETERS ###
self.wait_time = 3 # waiting time (in seconds) for state message
self.wait_time_recover = 1
# Message types
self.actuator_msg = JointTrajectoryControllerState
self.scan_msg = LaserScan
self.kinect_msg = PointCloud2
self.image_msg = Image
self.msg_received = False
self.sss = simple_script_server()
# Get base goals
try:
params = rospy.get_param('/component_test/components/base/params')
params.update(rospy.get_param('/component_test/components/base/goals'))
self.base_params = params
self.base_params['performed_tests'] = 0
self.base_params['recovered_tests'] = 0
self.base_params['failed_tests'] = 0
except:
pass
# Get actuator parameters
try:
params_actuator = rospy.get_param('/component_test/components/actuators')
for k in params_actuator.keys():
params_actuator[k]['performed_tests'] = 0
params_actuator[k]['recovered_tests'] = 0
params_actuator[k]['failed_tests'] = 0
self.actuators.append(params_actuator[k])
except:
pass
# Get sensor parameters
try:
params = rospy.get_param('/component_test/components/sensors')
for k in params.keys():
self.sensors.append(params[k])
except:
pass
if not self.base_params and not self.actuators and not self.sensors:
raise NameError('Couldn\'t find any components to test under /component_test namespace. '
'You need to define at least one component in order to run the program (base, actuator, sensor). '
'View the documentation to see how to define test-components.')
# Get maximum test duration and rounds
self.test_duration = None
self.test_rounds = None
try:
self.test_duration = 60.0 * float(rospy.get_param('/component_test/test_duration'))
except:
pass
try:
self.test_rounds = int(rospy.get_param('/component_test/test_rounds'))
except:
pass
if not self.test_duration and not self.test_rounds:
raise NameError('Both maximum duration and maximum test rounds are undefined!'
'\nPlease pass at least one of the two parameters. '
'\nMax duration must be given in minutes and max rounds as an integer.')
# if one of the duration-limiting parameters is not set, we set it to "infinite"
if self.test_duration == None or self.test_duration == 0:
self.test_duration = 1e100
if self.test_rounds == None or self.test_rounds == 0:
self.test_rounds = 1e100
# Get log-file directory
try:
log_dir = rospy.get_param('/component_test/result_dir')
except:
raise NameError('Test-result directory is undefined.')
# Subscribe to toplevel-state topic
self.toplevel_state_received = False
sub_top_state = rospy.Subscriber("/diagnostics_toplevel_state", DiagnosticStatus, self.cb_toplevel_state)
abort_time = rospy.Time.now() + rospy.Duration(self.wait_time)
while not self.toplevel_state_received and rospy.get_rostime() < abort_time:
rospy.sleep(0.1)
if not self.toplevel_state_received:
raise NameError('Could not subscribe to "/diagnostics_toplevel_state" topic')
self.toplevel_error = False
# Create and prepare log file
if self.base_params or self.actuators:
complete_name = '%s/component_test_results_%s.txt' %(log_dir, time.strftime("%Y%m%d_%H-%M"))
self.log_file = open(complete_name,'w')
# Log all tested components
self.log_file.write('Long-term component test')
self.log_file.write('\n%s \n%s' %(time.strftime('%d.%m.%Y'), time.strftime('%H:%M:%S')))
self.print_topic('TESTED COMPONENTS')
if self.base_params:
self.log_file.write('\n base')
if self.actuators:
for actuator in self.actuators:
self.log_file.write('\n ' + actuator['name'])
# Log test parameters
self.print_topic('TEST PARAMETERS')
params = rospy.get_param('/component_test/components')
for key in params:
self.log_file.write('\n%s:' %(key))
params_2 = rospy.get_param('/component_test/components/%s' %(key))
for key_2 in params_2:
self.log_file.write('\n %s:' %(key_2))
params_3 = rospy.get_param('/component_test/components/%s/%s' %(key, key_2))
for key_3, value in params_3.iteritems():
self.log_file.write('\n %s: %s' %(key_3, value))
self.print_topic('TEST LOG')
self.log_file.write('\n[<ROUND_NO.>] [<TIMESTAMP>]'
'\n <COMPONENT> \t[<DURATION>]')
def __init__(self, *args):
super(UnitTest, self).__init__(*args)
rospy.init_node('component_test')
self.message_received = False
self.sss = simple_script_server()
def __init__(self, *args):
super(UnitTest, self).__init__(*args)
rospy.init_node(NAME)
self.sss = simple_script_server()
def __init__(self):
self.sss = simple_script_server()
self.panels = []
self.CreateControlPanel()
def __init__(self):
self.script_action_server = actionlib.SimpleActionServer(
"cob_command_gui_rviz", ScriptAction, self.execute_cb, False)
self.script_action_server.start()
self.sss = simple_script_server()
# GNU Lesser General Public License LGPL for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License LGPL along with this program.
# If not, see <http://www.gnu.org/licenses/>.
#
#################################################################
import roslib
roslib.load_manifest('cob_monitoring')
import rospy
from cob_msgs.msg import *
from simple_script_server import *
sss = simple_script_server()
class battery_monitor():
def __init__(self):
rospy.Subscriber("/power_state", PowerState, self.power_state_callback)
self.rate = rospy.Rate(1 / 10.0) # check every 10 sec
self.warn_announce_time = rospy.Duration(300.0)
self.error_announce_time = rospy.Duration(120.0)
self.last_announced_time = rospy.Time.now()
## Battery monitoring
### TODO: make values parametrized through yaml file (depending on env ROBOT)
def power_state_callback(self, msg):
if msg.relative_capacity <= 10.0:
rospy.logerr("Battery empty, recharge now! Battery state is at " +
def __init__(self):
self.sss = simple_script_server()
self.action_server = actionlib.SimpleActionServer("/sdh_gripper_grasp_posture_controller", GraspHandPostureExecutionAction, self.execute, False)
self.query_service = rospy.Service('/sdh_gripper_grasp_status', GraspStatus, self.query_cb)
self.action_server.start()
time.sleep(1)
