def main(self):
try:
self.angle = 0
while not rospy.is_shutdown():
msg = Joy()
msg.axes = [0] * 8
msg.buttons = [0] * 11
# [3] if 1 arm above, -1 arm down
# [5] if 1 buck and -1 forward
# [4] if -1 left, 1 right
msg.axes[5] = -1.0
msg.axes[4] = self.angle * 2
if self.endflag:
msg.axes = [0] * 8
msg.buttons = [0] * 11
msg.axes[4] = -1
self.pub_.publish(msg)
self.rate.sleep()
except Exception as e:
print(e)
finally:
msg = Joy()
msg.axes = [0] * 8
msg.buttons = [0] * 11
self.pub_.publish(msg)
def main():
print "Howdy partner"
rospy.init_node('read_gps')
global dest_coords
sub2 = rospy.Subscriber('/dest_coords', Float32MultiArray,
callback_gps_dest)
if master_slave_mode:
pub0_ = rospy.Publisher('/gps_steer', Float32, queue_size=5)
pub1_ = rospy.Publisher('/gps_drive', Float32, queue_size=5)
pub2_ = rospy.Publisher('/gps_angle_to_dest', Float32, queue_size=5)
steer_msg = Float32()
drive_msg = Float32()
angle_to_dest_msg = Float32()
else:
pub0_ = rospy.Publisher('joy', Joy, queue_size=5)
msg = Joy()
while dest_coords is None:
if master_slave_mode:
drive_msg.data = 0
pub1_.publish(drive_msg)
else:
msg.axes = []
msg.axes.append(0)
msg.axes.append(0)
msg.axes.append(0)
pub0_.publish(msg)
sub0 = rospy.Subscriber('/unity_gps', Joy, callback_gps)
sub1 = rospy.Subscriber('/unity_heading', Joy, callback_heading)
rate = rospy.Rate(10)
while not rospy.is_shutdown() and not arrived:
rate.sleep()
if master_slave_mode:
steer_msg.data = steer
angle_to_dest_msg.data = angle_to_dest
drive_msg.data = drive
pub0_.publish(steer_msg)
pub1_.publish(drive_msg)
pub2_.publish(angle_to_dest_msg)
else:
#### Initialize joy msg every loop
msg.axes = []
msg.axes.append(steer)
msg.axes.append(drive)
msg.axes.append(drive)
pub0_.publish(msg)
print "destination arrived"
if master_slave_mode:
drive_msg.data = 0
pub1_.publish(drive_msg)
def goToTarget(self):
rate = rospy.Rate(1)
kill_code = 0
while not rospy.is_shutdown():
if(self.target !=""):
if (self.target != "" and self.target["prob"] > self.probabilityThreshlold):
#kill trajectory control
if(kill_code == 0):
os.system("rosnode kill go_home")
os.system("rosnode kill path_to_file")
kill_code = 1
#relative distance calculation
#right movement
movement_offset = Joy()
while(self.target != "" and self.target["x"] + (self.target["w"]/2) > self.aligntarget_x):
movement_offset.axes = [0.2, 0, 0]
self.setpoint.publish(movement_offset)
rospy.loginfo(movement_offset.axes)
rate.sleep()
#left movement
movement_offset = Joy()
while(self.target != "" and self.target["x"] + (self.target["w"]/2) < self.aligntarget_x):
movement_offset.axes = [-0.2, 0, 0]
self.setpoint.publish(movement_offset)
rospy.loginfo(movement_offset.axes)
rate.sleep()
#front movement
movement_offset = Joy()
while(self.target != "" and self.target["y"] + (self.target["h"]/2) < self.aligntarget_y):
movement_offset.axes = [0, 0.2, 0]
self.setpoint.publish(movement_offset)
rospy.loginfo(movement_offset.axes)
rate.sleep()
#back movement
movement_offset = Joy()
while(self.target != "" and self.target["y"] + (self.target["h"]/2) > self.aligntarget_y):
movement_offset.axes = [0, -0.2, 0]
self.setpoint.publish(movement_offset)
rospy.loginfo(movement_offset.axes)
rate.sleep()
if self.target != "" and (self.target["y"] + (self.target["h"]/2)> (self.aligntarget_y-0.1) and (self.target["y"] + (self.target["h"]/2)< self.aligntarget_y+0.1) and (self.target["x"] + (self.target["w"]/2)> self.aligntarget_x-0.1 ) and (self.target["x"] + (self.target["w"]/2)< self.aligntarget_x+0.1)):
rospy.loginfo("Fire!")
#GPIO : send PVM signal for relay to fire and close pwm
os.system("rosservice call /dji_sdk/mfio_config \"mode: 0 channel: 0 init_on_time_us: 2500 pwm_freq: 50\"")
rospy.loginfo("Reseting PWM!")
os.system("sleep 10; rosservice call /dji_sdk/mfio_config \"mode: 0 channel: 0 init_on_time_us: 500 pwm_freq: 50\"")
# calling gohome
os.system("sleep 50;./gohome.sh")
break
def publish(self): cmd = Joy() cmd.header.stamp = rospy.Time.now() cmd.axes = self.axes_data cmd.buttons = self.button_data if self.debug: print cmd self.pub.publish(cmd)
def main():
print "Hello! Welcome to the Pinteraction demo"
print "This program allows you to actuate a pin of your choice to any height and for any duration"
pub = rospy.Publisher('/command', Joy, queue_size=20)
rospy.init_node('demo_interface')
msg = Joy()
while not rospy.is_shutdown():
input_row = raw_input("Please enter the row number (0 to 9): ")
input_col = raw_input("Please enter the column number (0 to 9): ")
input_height = raw_input("Please enter the height you would like to move to (in cm): ")
input_duration = raw_input("Please enter the time duration for the pin to stay there (in seconds): ")
try:
input_row = int(input_row)
input_col = int(input_col)
input_height = float(input_height)
input_duration = float(input_duration)
if input_row>9 or input_col>9 or input_row<0 or input_col<0 or input_height>10 or input_height<0 or input_duration<0:
print "Invalid data input. Please try again"
continue
except Exception, e:
print "Invalid data input. Please try again"
print str(e)
continue
msg.buttons = [input_row, input_col]
msg.axes = [input_height, input_duration]
pub.publish(msg)
print "The pin has been actuated."
input = raw_input("Enter x to exit the program, or any other key to actuate another pin. ")
if input == 'x' or input == 'X':
break
def rcCallback(self, joy_msg):
"""
This function is meant to receive an incoming joy message and analyse the info.
In this case every second incoming message is used to update the self.input_rc list of current 'human' remote data and then published to the flight controller.
:param joy_msg:
:return:
"""
self.counter_input += 1
if self.counter_input % 2 == 0:
self.counter_output += 1
joy_msg = Joy()
# Replay and override current rc
joy_msg.axes = self.input_rc[0:4]
joy_msg.buttons = self.input_rc[4:]
self.input_rc[0] = joy_msg.axes[0]
self.input_rc[1] = joy_msg.axes[1]
self.input_rc[2] = joy_msg.axes[2]
self.input_rc[3] = joy_msg.axes[3]
self.input_rc[4] = joy_msg.buttons[0]
self.input_rc[5] = joy_msg.buttons[1]
self.input_rc[6] = joy_msg.buttons[2]
self.input_rc[7] = joy_msg.buttons[3]
self.pub.publish(joy_msg)
if self.counter_input % 100 == 0:
print 'rc_tunnel_node.py >>', self.counter_input / (
time.time() -
self.start_time), 'rc inputs/sec ', self.counter_output / (
time.time() - self.start_time), 'rc outputs/sec'
def goToTarget(self):
p = 0.6
pAlt = 0.3
rate = rospy.Rate(5)
land_code = 0
while not rospy.is_shutdown():
if self.target != '' and land_code == 0:
# relative distance calculation
# XYZ movement
movement_offset = Joy()
while self.target != '':
xmask = round(self.target.x * p, 5)
ymask = round((self.target.y * -1) * p, 5)
zmask = round((self.aligntarget_z - self.target.z) * pAlt,
5)
movement_offset.axes = [xmask, ymask, zmask]
print(movement_offset.axes)
self.setpoint.publish(movement_offset)
if self.target != '' and round(
abs(ymask),
2) < 0.3 and round(abs(xmask), 2) < 0.3 and round(
abs(zmask), 2) < 0.3:
rospy.loginfo('Landing!')
command = rospy.ServiceProxy(
'/dji_sdk/drone_task_control', DroneTaskControl)
print(
command(DroneTaskControl._request_class.TASK_LAND))
land_code = 1
break # to stop following #place code here
rate.sleep()
def publisher():
# Looping at
rate = rospy.Rate(10) # 10hz
while not rospy.is_shutdown():
pygame.event.pump()
# Empty values arrays
axes_values = []
buttons_values = []
# Initiate the two messages
msg_twist = Twist()
msg_joy = Joy()
# Iterate axes and populate value arrays
for axis in range(j.get_numaxes()):
axes_values.insert(axis, j.get_axis(axis))
for button in range(j.get_numbuttons()):
buttons_values.insert(button, j.get_button(button))
msg_twist.linear.x = axes_values[1] * (-1) * MAX_VELOCITY
msg_twist.angular.z = axes_values[2] * (-1) * MAX_ANGULAR_SPEED
msg_joy.axes = axes_values
msg_joy.buttons = buttons_values
cmd_vel_pub.publish(msg_twist)
joy_pub.publish(msg_joy)
# Preserve looping in specified rate
rate.sleep()
def move(self):
# Check if we have reached the next waypoint. If so, update
self.changeGoalPt()
self.v_max = rospy.get_param('maximum_velocity')
self.resetState()
velDes = self.getXdes()
# Pause to rotate after waypoint
if (rospy.Time.now() - self.last_waypoint_time).to_sec() < self.waypoint_wait_time:
velDes[:3] = [0,0,0]
# Publish Vector
joy_out = Joy()
joy_out.header.stamp = rospy.Time.now()
joy_out.axes = [velDes[0], velDes[1], velDes[2],velDes[3]]
self.vel_ctrl_pub_.publish(joy_out)
# Find future path
if (rospy.Time.now() - self.lastPathPub).to_sec() > 0.5:
self.lastPathPub = rospy.Time.now()
# publish path
self.findPath()
self.resetState()
def talker():
pub = rospy.Publisher('joy', Joy, queue_size=20)
rospy.init_node('test', anonymous=True)
rate = rospy.Rate(100) # 10hz
bits=[]
#print axis,buttons
while not rospy.is_shutdown():
data = s.recvfrom(6144)
app_data = data[0]
app_data_addr = data[1]
app_data=app_data.strip("[]")
app_data=app_data.split(",")
app_data=map(int,app_data)
#print app_data
#app_data=[10,10,0,0,0,0,0,0,0,0]
recv = robot1.receiver(app_data)
app_axis_data,app_button_data=recv.sort_data()
axis,buttons=recv.joystick_data(app_axis_data,app_button_data)
joy=Joy()
joy.axes=axis
joy.buttons=buttons
#hello_str = "hello world %s" % rospy.get_time()
rospy.loginfo(app_data)
rospy.loginfo(buttons)
pub.publish(joy)
rate.sleep()
def default_ros_publish_callback(add, tag, stuff, source):
# ros << osc << gui
# input looks like incoming OSC: /gyrosc/gyro fff [0.48758959770202637, 0.06476165354251862, -0.19856473803520203] ('192.168.0.33', 57527)
if add in publishers.keys():
publisher = publishers[add]
if publisher[1] == 'Joy':
msg = Joy()
msg.axes = stuff[0:4]
msg.buttons = stuff[4:]
elif publisher[1] == 'Motor':
msg = Motor()
msg.motor0 = stuff[0]
msg.motor1 = stuff[1]
msg.motor2 = stuff[2]
msg.motor3 = stuff[3]
elif publisher[1] == 'GUI_cmd':
msg = GUI_cmd()
msg.gui_cmd_0 = stuff[0]
msg.gui_cmd_1 = stuff[1]
msg.gui_cmd_2 = stuff[2]
msg.gui_cmd_3 = stuff[3]
msg.gui_cmd_4 = stuff[4]
msg.gui_cmd_5 = stuff[5]
msg.gui_cmd_6 = stuff[6]
msg.gui_cmd_7 = stuff[7]
else:
print '>>> default_ros_publish_callback: not implemented msg_type:', publisher[
1]
return
publisher[0].publish(msg)
else:
print '>>> default_ros_publish_callback: not implemented topic:', add
def goToTarget(self):
p = 1
pAlt = 0.3
rate = rospy.Rate(15)
while not rospy.is_shutdown():
#rospy.loginfo(self.target)
if (type(self.target) is dict):
#print(self.target)
if (self.target["prob"] > self.probabilityThreshlold
and self.kill == 0):
#SDK Takes control
if (self.ctrlFlag == 0):
rospy.wait_for_service(
'/dji_sdk/sdk_control_authority')
control = rospy.ServiceProxy(
'/dji_sdk/sdk_control_authority',
SDKControlAuthority)
print(
control(SDKControlAuthority._request_class.
REQUEST_CONTROL))
self.ctrlFlag = 1
#Delta Calculation and Coordinate Transformation
x, y = self.cDeltaTransform(self.target)
# p-controller mask
xmask = round(x * p, 5)
ymask = round(y * p, 5)
zmask = 0 # localposition fusion required
movement_offset = Joy()
movement_offset.axes = [xmask, ymask, zmask]
rospy.loginfo(movement_offset.axes)
self.setpoint.publish(movement_offset)
rate.sleep()
def goToTarget(self):
p = 1
pAlt = 0.3
rate = rospy.Rate(15)
land_code = 0
while not rospy.is_shutdown():
if land_code == 0:
# relative distance calculation
# XYZ movement
movement_offset = Joy()
x, y = self.get_target_location()
while x != '' and y != '' and self.localDJI != '':
print(x, y)
xmask = round(x * p, 5)
ymask = round(y * p, 5)
#zmask = round((self.aligntarget_z-self.localDJI.z)*pAlt*-1,5)
zmask = round(self.localDJI.z * pAlt * -1, 5)
movement_offset.axes = [xmask, ymask, zmask]
print(movement_offset.axes)
self.setpoint.publish(movement_offset)
if abs(x) < 0.1 and abs(y) < 0.1 and round(abs(zmask),
2) < 0.1:
rospy.loginfo('Landed!')
command = rospy.ServiceProxy(
'/dji_sdk/drone_task_control', DroneTaskControl)
#print(command(DroneTaskControl._request_class.TASK_LAND))
#land_code = 1
#break # to stop following #place code here
x, y = self.get_target_location()
rate.sleep()
def getCoord(string):
string = string.data
s1, s2 = string.split(" ")
global x, y
x = float(s1)
y = float(s2)
rospy.loginfo("got dot")
if stopped:
road = sg.det_points_road(x, y, Rmap)
if road != 'Not on the road':
route = sg.find_route(cur_road, road.id)
s = ""
for i in range(len(route)):
s += str(route[i])
pub_route.publish(s)
msg = Joy()
msg.header.seq = 0
msg.header.stamp.secs = 0
msg.header.stamp.nsecs = 0
msg.header.frame_id = ''
msg.axes = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
msg.buttons = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
msg.buttons[7] = 1
else:
rospy.loginfo("WARNING: requested dot is not on the road")
def _get_joy(self):
joy = Joy()
joy.header.frame_id = 'keyboard'
joy.header.stamp = rospy.Time.now()
joy.axes = self._axes
joy.buttons = self._buttons
return joy
def simulated_navigation(self,
forward=True,
duration=rospy.Duration(60, 0)):
"""
Walk for 1 meter
"""
response = self.ACTION_FAIL
start = rospy.Time.now()
self.set_current_location_as_home()
buttons = Joy()
buttons.header.stamp = rospy.Time.now()
buttons.header.frame_id = 'base_link'
direction = 1.0 if forward else -1.0
buttons.axes = [0.0, direction, 0.0, 0.0, 0.0, 0.0, 0.0]
buttons.buttons = [0, 0, 1, 0, 0, 0, 0, 0, 0]
for _ in range(3):
self._setpoint_pub.publish(buttons)
self._rate.sleep()
home_pos = np.array([self.home.geo.latitude, self.home.geo.longitude])
while (rospy.Time.now() - start < duration) and (
not rospy.is_shutdown()) and (not self.external_intervened):
cur_pos = np.array(
[self.global_pose.latitude, self.global_pose.longitude])
if np.linalg.norm(cur_pos - home_pos) > self._radius:
# self.embrace_pose()
response = self.ACTION_SUCCESS
break
if (rospy.Time.now() - start) > duration:
response = self.OUT_OF_DURATION
if self.external_intervened:
response = self.EXTERNAL_INTERVENTION
return response
def publish_joy(self):
t_now = rospy.Time.now()
# determine changes in state
buttons_change = array_equal(self.last_joy.buttons,
self.target_joy.buttons)
axes_change = array_equal(self.last_joy.axes, self.target_joy.axes)
# new message
if not (buttons_change and axes_change):
joy = Joy()
if not axes_change:
# do ramped_vel for every single axis
for i in range(len(self.target_joy.axes)):
joy.axes.append(
self.ramped_vel(self.last_joy.axes[i],
self.target_joy.axes[i],
self.last_send_time, t_now))
else:
joy.axes = self.last_joy.axes
joy.buttons = self.target_joy.buttons
self.last_joy = joy
self.publisher.publish(self.last_joy)
self.last_send_time = t_now
def publish(self, state):
curr_time = rospy.get_rostime()
# limit to 20hz
# print str((curr_time - self.last_pub_time).to_sec())
if (curr_time - self.last_pub_time).to_sec() < 0.05:
return
self.last_pub_time = curr_time
joy_msg = Joy()
joy_msg.header.stamp = rospy.Time.now()
joy_msg.buttons = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
for i in range(0, 17):
joy_msg.buttons[i] = state[i]
joy_msg.axes = [
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0.213169, 0.
]
for i in range(0, 4):
if state[i] <= 127:
joy_msg.axes[i] = (127 - state[i + 17]) / 127.0
else:
joy_msg.axes[i] = (state[i] - 127) / 128.0
for i in range(0, 12):
joy_msg.axes[i + 4] = -state[i + 21] / 255.0
self.joy_pub.publish(joy_msg)
def idle_controller():
joy_msg = Joy()
joy_msg.axes = [0.0 for i in range(8)]
joy_msg.buttons = [0 for i in range(15)]
joy_msg.axes[2] = 1.0
joy_msg.axes[5] = 1.0
return joy_msg
def hoverInPlace(self):
# Safety hovering
# Publish Vector, stay in place
joy_out = Joy()
joy_out.header.stamp = rospy.Time.now()
joy_out.axes = [0.0, 0.0, 0.0, 0.0]
self.vel_ctrl_pub_.publish(joy_out)
def publish_joy(self):
t_now = rospy.Time.now()
# determine changes in state
buttons_change = array_equal(self.last_joy.buttons, self.target_joy.buttons)
axes_change = array_equal(self.last_joy.axes, self.target_joy.axes)
# if the desired value is the same as the last value, there's no
# need to publish the same message again
if not(buttons_change and axes_change):
# new message
joy = Joy()
if not axes_change:
# do ramped_vel for every single axis
for i in range(len(self.target_joy.axes)):
if self.target_joy.axes[i] == self.last_joy.axes[i]:
joy.axes.append(self.last_joy.axes[i])
else:
joy.axes.append(self.ramped_vel(self.last_joy.axes[i],
self.target_joy.axes[i],self.last_send_time,t_now))
else:
joy.axes = self.last_joy.axes
joy.buttons = self.target_joy.buttons
self.last_joy = joy
self.publisher.publish(self.last_joy)
self.last_send_time = t_now
def compare_all(data):
global k
last_row = csv_data[k-frequency_offset]
diff = Quaternion()
diff.x = round(float(last_row[1])-convert_ppm(data.channels[3]),4)
diff.y = round(float(last_row[2])-convert_ppm(data.channels[1]),4)
diff.z = round(float(last_row[4])-convert_ppm(data.channels[0]),4)
diff.w = round(float(last_row[5])+convert_ppm(data.channels[2]),4)
testing_pub.publish(diff)
if (k < len(csv_data)):
row = csv_data[k]
#log for post processing
#joystick log
c = csv.writer(open("/home/jinahadam/catkin_ws/src/testing/gps_joy.csv", "ab"))
c.writerow([data.header.stamp.secs,row[1],row[2],row[4],row[5]])
#rc Inn log
c = csv.writer(open("/home/jinahadam/catkin_ws/src/testing/rc_in.csv", "ab"))
c.writerow([data.header.stamp.secs,convert_ppm(data.channels[3]),convert_ppm(data.channels[1]),convert_ppm(data.channels[0]),convert_ppm(data.channels[2])])
msg = Joy()
msg.axes = (float(row[1]),float(row[2]),float(row[3]),float(row[4]),float(row[5]),float(row[6]),float(row[7]))
msg.buttons = (0,0,0,0,0,0,0,0,0,0,0)
k = k + 1
pub.publish(msg)
else:
#k = 0
print("Joystick & RC In data logged with GPS Time")
exit()
def __init__(self):
self.settings_ = termios.tcgetattr(sys.stdin)
self.joy_pub = rospy.Publisher('/robot/joy', Joy, queue_size = 1)
self.stop_ = rospy.get_param("~stop", 0.5)
self.button_flg = [0]*11
self.joy_axis = [0]*6
self.hand_status = 0
self.motion = 0
self.start_flg = 1
pygame.init()
pygame.joystick.init()
try:
self.j = pygame.joystick.Joystick(0)# create a joystick instance
self.j.init() # init
print('Joystick: ' + self.j.get_name())
print('bottun : ' + str(self.j.get_numbuttons()))
pygame.event.get()
except pygame.error:
print('No connect joystick')
print('exit')
pygame.quit()
sys.exit()
finally:
msg = Joy()
msg.axes = [0]*8
msg.buttons = [0]*11
self.joy_pub.publish(msg)
def callback(self, in_msg):
out_msg = Joy(header=in_msg.header)
map_axes = self.mappings["axes"]
map_btns = self.mappings["buttons"]
out_msg.axes = [0.0] * len(map_axes)
out_msg.buttons = [0] * len(map_btns)
in_dic = {"axes": in_msg.axes, "buttons": in_msg.buttons}
for i, exp in enumerate(map_axes):
try:
out_msg.axes[i] = self.evaluator.reval(exp, in_dic)
except NameError as e:
rospy.logerr(
"You are using vars other than 'buttons' or 'axes': %s" %
e)
except UnboundLocalError as e:
rospy.logerr("Wrong form: %s" % e)
except Exception as e:
raise e
for i, exp in enumerate(map_btns):
try:
if self.evaluator.reval(exp, in_dic) > 0:
out_msg.buttons[i] = 1
except NameError as e:
rospy.logerr(
"You are using vars other than 'buttons' or 'axes': %s" %
e)
except UnboundLocalError as e:
rospy.logerr("Wrong form: %s" % e)
except Exception as e:
raise e
self.pub.publish(out_msg)
def cbJoy(self, joy_msg):
out_msg = Joy()
out_msg.header = joy_msg.header
#
out_msg.axes = [0.] * 6
# A, B, X, Y, LB, RB, back, start, power, btn_stick_left, btn stick right
# 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
out_msg.buttons = [0] * 10
# X -> A
out_msg.buttons[0] = joy_msg.buttons[0]
# circle -> B
out_msg.buttons[1] = joy_msg.buttons[2]
# square -> X
out_msg.buttons[2] = joy_msg.buttons[1]
# triangle -> Y
out_msg.buttons[3] = joy_msg.buttons[3]
# share -> start
out_msg.buttons[7] = joy_msg.buttons[8]
# logo -> Power
out_msg.buttons[8] = joy_msg.buttons[24]
# accelerator
out_msg.axes[1] = (joy_msg.axes[2] - joy_msg.axes[3]) / 2.
# steering wheel -> Left/Right Stick
out_msg.axes[3] = joy_msg.axes[0]
# up_down
out_msg.axes[2] = 1.
out_msg.axes[5] = 1.
if joy_msg.buttons[4] == 1 and joy_msg.buttons[5] == 0: # RT
out_msg.axes[5] = -joy_msg.axes[1]
elif joy_msg.buttons[4] == 0 and joy_msg.buttons[5] == 1: # LT
out_msg.axes[2] = -joy_msg.axes[1]
self.pub_joy.publish(out_msg)
def simulated_rotation(self, degree, duration=rospy.Duration(60, 0)):
"""
Rotate for [degree] degree
"""
response = self.ACTION_FAIL
start = rospy.Time.now()
heading = self.heading
offset = degree / 180. * np.pi
buttons = Joy()
buttons.header.stamp = rospy.Time.now()
buttons.header.frame_id = 'base_link'
buttons.axes = [0.0, 0.0, 0.0, -1.0, 0.0, 0.0, 0.0]
buttons.buttons = [0, 0, 1, 0, 0, 0, 0, 0, 0]
for _ in range(3):
self._setpoint_pub.publish(buttons)
self._rate.sleep()
while (rospy.Time.now() - start < duration) and (
not rospy.is_shutdown()) and (not self.external_intervened):
current_heading = self.heading
if abs(current_heading - heading) > offset:
self.sit_pose()
response = self.ACTION_SUCCESS
break
if (rospy.Time.now() - start) > duration:
response = self.OUT_OF_DURATION
if self.external_intervened:
response = self.EXTERNAL_INTERVENTION
return response
def set_x(self, change):
yaw = self.StreamAttitude.yaw_y
msg = Joy()
msg.axes = [change, 0, self.height, 0]
self.position_control.publish(msg)
time.sleep(1)
return
def set_z(self, change):
yaw = self.StreamAttitude.yaw_y
msg = Joy()
msg.axes = [0, change, self.height, 0] #double check these values
self.position_control.publish(msg)
time.sleep(1)
return
def comando_robo():
# Cria o publisher
pub = rospy.Publisher('roboComandoVelocidade', Joy, queue_size=10)
# Inicia o no
rospy.init_node('comando_robo', anonymous=True)
# Frequencia de envio dos comandos
rate = rospy.Rate(10)
# Loop inifinito para envio do comando
while not rospy.is_shutdown():
# Valores a serem enviados
vel_left = 1
vel_right = 2
# montando o array com as velocidades para os quatro motores
velocidades = [vel_left, vel_left, vel_right, vel_right]
# Monta a mensagem a ser enviada
mensagem = Joy()
mensagem.axes = velocidades
# Publica no no
pub.publish(mensagem)
# Envia uma mensagem ao usuario
rospy.loginfo('Vel L: ' + str(vel_left) + ' Vel R: ' + str(vel_right))
# Pausa o codigo pelo tempo especificado
rate.sleep()
def rush(self):
# Safety violation test, rush in x direction
# Publish Vector
joy_out = Joy()
joy_out.header.stamp = rospy.Time.now()
joy_out.axes = [self.v_max * 1.5, 0., 0., 0.]
self.vel_ctrl_pub_.publish(joy_out)
def main():
global drive
global steer
rospy.init_node('obs_avoid')
#Subscribers
sub0 = rospy.Subscriber('/lidar_drive', Float32, callback_lidar_drive)
sub1 = rospy.Subscriber('/gps_steer', Float32, callback_gps_steer)
sub2 = rospy.Subscriber('/gps_drive', Float32, callback_gps_drive)
sub3 = rospy.Subscriber('/lane_steer', Float32, callback_lane_steer)
sub4 = rospy.Subscriber('/gps_angle_to_dest', Float32,
callback_angle_to_dest)
sub4 = rospy.Subscriber('/vision_drive', Float32, callback_vision_drive)
#Publishers
pub_ = rospy.Publisher('joy', Joy, queue_size=5)
msg = Joy()
rate = rospy.Rate(10)
while not rospy.is_shutdown():
#Basic choice for drive component, we pick
drive = determine_drive()
steer = determine_steer()
rate.sleep()
msg.axes = []
msg.axes.append(steer)
msg.axes.append(drive)
msg.axes.append(drive)
#rospy.loginfo(msg)
pub_.publish(msg)
def run(self):
joy = Joy()
joy.axes = (0, 0, 0, 0, 0, 0)
status = 0
try:
print (textwrap.dedent(TeleopKey.msg))
print (self.params_msg())
while True:
key = self.get_key()
if key in self.move_bindings.keys():
joy.axes = self.move_bindings[key]
elif key in self.claw_bindings.keys():
self.claw_bindings[key]()
elif key in self.param_bindings.keys():
self.params[self.param_bindings[key][0]]\
*= self.param_bindings[key][1]
if self.param_bindings[key][0] == 'drive_speed':
self.param_client.update_configuration(
{'DRIVE_SPEED': self.params['drive_speed']}
)
elif self.param_bindings[key][0] == 'turn_speed':
self.param_client.update_configuration(
{'TURN_SPEED': self.params['turn_speed']}
)
# Update params once now to make sure no params were
# set to invalid values.
server_config = self.param_client.get_configuration()
self.update_params(server_config)
if (status == 14):
print (textwrap.dedent(TeleopKey.msg))
print (self.params_msg())
status = (status + 1) % 15
else:
joy.axes = (0, 0, 0, 0, 0, 0)
if (key == '\x03'):
break
self.pub.publish(joy)
except Exception as e:
print('Something went wrong:')
for exception in traceback.format_exception_only(type(e), e):
print(exception)
traceback.print_exc()
finally:
joy.axes = (0, 0, 0, 0, 0, 0)
self.pub.publish(joy)
termios.tcsetattr(sys.stdin, termios.TCSADRAIN, self.settings)
def joy_callback(self, data):
joy = Joy()
joy.header.stamp = rospy.Time.now()
joy.axes = self.convert(data.axes)
joy.buttons = data.buttons
self.prev_input_axes = list(data.axes)
joy_pub = rospy.Publisher("/joy_relative/page_" + str(self.crt_page), Joy)
joy_pub.publish(joy)
def toPS3Msg(self):
joy = Joy()
joy.header = self.orig_msg.header
joy.buttons = [0] * 17
joy.axes = [0] * 20
if self.center:
joy.buttons[16] = 1
if self.select:
joy.buttons[0] = 1
if self.start:
joy.buttons[3] = 1
if self.L3:
joy.buttons[1] = 1
if self.R3:
joy.buttons[2] = 1
if self.square:
joy.axes[15] = -1.0
joy.buttons[15] = 1
if self.up:
joy.axes[4] = -1.0
joy.buttons[4] = 1
if self.down:
joy.axes[6] = -1.0
joy.buttons[6] = 1
if self.left:
joy.axes[7] = -1.0
joy.buttons[7] = 1
if self.right:
joy.axes[5] = -1.0
joy.buttons[5] = 1
if self.triangle:
joy.axes[12] = -1.0
joy.buttons[12] = 1
if self.cross:
joy.axes[14] = -1.0
joy.buttons[14] = 1
if self.circle:
joy.axes[13] = -1.0
joy.buttons[13] = 1
if self.L1:
joy.axes[10] = -1.0
joy.buttons[10] = 1
if self.R1:
joy.axes[11] = -1.0
joy.buttons[11] = 1
if self.L2:
joy.axes[8] = -1.0
joy.buttons[8] = 1
if self.R2:
joy.axes[9] = -1.0
joy.buttons[9] = 1
joy.axes[0] = self.left_analog_x
joy.axes[1] = self.left_analog_y
joy.axes[2] = self.right_analog_x
joy.axes[3] = self.right_analog_y
return joy
def main():
global joy
pygame.midi.init()
rospy.init_node('midi_joy')
# parse the arg
argv = rospy.myargv()
if len(argv) == 0:
rospy.logfatal("You need to specify config yaml file")
sys.exit(1)
config_file = argv[1]
joy_pub = rospy.Publisher("/joy", Joy, queue_size=10)
autorepeat_rate = rospy.get_param("~autorepeat_rate", 0)
if autorepeat_rate == 0:
r = rospy.Rate(1000)
else:
r = rospy.Rate(autorepeat_rate)
with open(config_file, "r") as f:
config = yaml.load(f)
# open the device
controller = openMIDIInputByName(config["device_name"])
joy = Joy()
joy.axes = [0.0] * len(config["analogs"])
# automatically mapping to buttons from axes if it has NOTE_OFF or NOTE_ON MIDI commands
button_configs = [c for c in config["analogs"]
if c[0] == MIDICommand.NOTE_ON or c[0] == MIDICommand.NOTE_OFF]
if config.has_key("output"):
out_controller = openMIDIOutputByName(config["device_name"])
s = rospy.Subscriber("~set_feedback", JoyFeedbackArray, lambda msg: feedback_array_cb(out_controller, config, msg))
joy.buttons = [0] * len(button_configs)
while not rospy.is_shutdown():
joy.header.stamp = rospy.Time.now()
p = False
while controller.poll():
data = controller.read(1)
for elem_set in data:
p = True
(command, ind, val) = MIDIParse(elem_set)
try:
index = config["analogs"].index((command, ind))
joy.axes[index] = val
if command == MIDICommand.NOTE_ON or command == MIDICommand.NOTE_OFF:
button_index = button_configs.index((command, ind))
if val == 0.0:
joy.buttons[button_index] = 0
else:
joy.buttons[button_index] = 1
except:
rospy.logwarn("unknown MIDI message: (%d, %d, %f)" % (command, ind, val))
if (autorepeat_rate != 0) or p:
joy_pub.publish(joy)
r.sleep()
def on_message(self, message_raw):
message = json.loads(message_raw)
if message['msg']=='lag':
self.send( json.dumps({
'start':message['start'],
}))
if message['msg']=='joy':
msg = Joy()
msg.header.stamp = rospy.Time.now()
msg.axes = message['axes']
msg.buttons = message['buttons']
joy_pub.publish(msg)
def send(self):
joy_msg = Joy()
joy_msg.header.stamp = rospy.Time.now()
buttons = (self.ui.button_0, self.ui.button_1, self.ui.button_2, self.ui.button_3, self.ui.button_4,
self.ui.button_5, self.ui.button_6, self.ui.button_7, self.ui.button_8, self.ui.button_9,
self.ui.button_10, self.ui.button_11)
joy_msg.buttons = [b.isChecked() for b in buttons]
joy_msg.axes = [mult*s.value()/100.0 for s, mult in
zip((self.ui.rollSlider, self.ui.pitchSlider, self.ui.yawSlider, self.ui.altSlider), (-1.0, 1.0, -1.0, 1.0))]
for label, value in zip((self.ui.rollLabel, self.ui.pitchLabel, self.ui.yawLabel, self.ui.altLabel), joy_msg.axes):
label.setText('%0.2f' % value)
self.pub.publish(joy_msg)
def run(self):
blub=Joy()
while(self.run):
data=ord(self.ser.read(1))
if data==255:
data=ord(self.ser.read(1))
if data==255:
data=ord(self.ser.read(1))
if data==255:
data=ord(self.ser.read(1))
if data==24:
data=self.ser.read(7)
axes = struct.unpack('BBBBBBB', data)
for x in axes:
blub.axes.append((x-128)/127.0)
print blub.axes
data=self.ser.read(2)
button = struct.unpack('H', data)[0]
blub.buttons.insert(0,int(button/2048))
button-=(int(button/2048))*button
blub.buttons.insert(0,int(button/1024))
button-=(int(button/1024))*button
blub.buttons.insert(0,int(button/512))
button-=(int(button/512))*button
blub.buttons.insert(0,int(button/256))
button-=(int(button/256))*button
blub.buttons.insert(0,int(button/128))
button-=(int(button/128))*button
blub.buttons.insert(0,int(button/64))
button-=(int(button/64))*button
blub.buttons.insert(0,int(button/32))
button-=(int(button/32))*button
blub.buttons.insert(0,int(button/16))
button-=(int(button/16))*button
blub.buttons.insert(0,int(button/8))
button-=(int(button/8))*button
blub.buttons.insert(0,int(button/4))
button-=(int(button/4))*button
blub.buttons.insert(0,int(button/2))
button-=(int(button/2))*button
blub.buttons.insert(0,int(button))
print blub
blub.axes=list()
blub.buttons=list()
self.ser.close()
def main():
rospy.sleep(1)
rospy.init_node('trackpoint_joy')
trackpoint_joy_pub = rospy.Publisher('/trackpoint/joy', Joy)
tp_file = open( "/dev/input/mice", "rb" )
while not rospy.is_shutdown():
buf = tp_file.read(3)
button = ord( buf[0] )
bLeft = button & 0x1
bMiddle = ( button & 0x4 ) > 0
bRight = ( button & 0x2 ) > 0
x,y = struct.unpack( "bb", buf[1:] )
rospy.loginfo("L:%d, M: %d, R: %d, x: %d, y: %d\n" % (bLeft, bMiddle, bRight, x, y) )
joy_msg = Joy()
joy_msg.header.stamp = rospy.Time.now()
joy_msg.axes = [x, y]
joy_msg.buttons = [bLeft, bMiddle, bRight]
trackpoint_joy_pub.publish(joy_msg)
# rospy.sleep(0.1)
tp_file.close();
def comapre_single_channel(data):
global k
last_row = csv_data[k-frequency_offset]
lat = Pose2D()
lat.x = float(last_row[1])
lat.y = convert_ppm(data.channels[3])
lat.theta = 0
latency_ch.publish(lat)
if (k < len(csv_data)):
row = csv_data[k]
msg = Joy()
msg.axes = (float(row[1]),float(row[2]),float(row[3]),float(row[4]),float(row[5]),float(row[6]),float(row[7]))
msg.buttons = (0,0,0,0,0,0,0,0,0,0,0)
k = k + 1
pub.publish(msg)
else:
k = 0
def main():
pub = rospy.Publisher('ernest_sensors/imu', Imu, queue_size=10)
eyes = rospy.Publisher('ernest_sensors/eyes', Range, queue_size=10)
nunchuck = rospy.Publisher('ernest_sensors/joy', Joy, queue_size=10)
nunchuck_giro = rospy.Publisher('ernest_sensors/joy_giro', Imu, queue_size=10)
comm = ArduinoCommunicator()
rospy.init_node('ernest_sensors')
for line in comm.loop():
print line
try:
x, y, z, dis, joy_x, joy_y, giro_x, giro_y, giro_z, but_c, but_z = line.split(",")
imu = Imu()
imu.header.frame_id = "imu"
imu.linear_acceleration.x = -float(x)
imu.linear_acceleration.y = float(z)
imu.linear_acceleration.z = float(y)
r = Range()
r.header.frame_id = "imu"
r.radiation_type = 1
r.field_of_view = 0.5
r.min_range = 0.20
r.max_range = 3
r.range = float(dis)/100.0
j = Joy()
j.axes = [
maprange(float(joy_x), 25, 226, -1, 1),
maprange(float(joy_y), 32, 223, -1, 1)
]
j.buttons = [int(but_c), int(but_z)]
imu2 = Imu()
imu2.header.frame_id = "imu"
imu2.linear_acceleration.x = (float(giro_y) - 512) / 512.0
imu2.linear_acceleration.y = -(float(giro_x) - 512) / 512.0
imu2.linear_acceleration.z = -(float(giro_z) - 512) / 512.0
pub.publish(imu)
eyes.publish(r)
nunchuck.publish(j)
nunchuck_giro.publish(imu2)
except ValueError:
continue
def diff(data):
global k
last_row = csv_data[k-frequency_offset]
diff = Quaternion()
diff.x = round(float(last_row[1])-convert_ppm(data.channels[3]),4)
diff.y = round(float(last_row[2])-convert_ppm(data.channels[1]),4)
diff.z = round(float(last_row[4])-convert_ppm(data.channels[0]),4)
diff.w = round(float(last_row[5])+convert_ppm(data.channels[2]),4)
testing_pub.publish(diff)
if (k < len(csv_data)):
row = csv_data[k]
msg = Joy()
msg.axes = (float(row[1]),float(row[2]),float(row[3]),float(row[4]),float(row[5]),float(row[6]),float(row[7]))
msg.buttons = (0,0,0,0,0,0,0,0,0,0,0)
k = k + 1
pub.publish(msg)
else:
k = 0
def main(device_name, autorepeat_rate, frame_id):
rospy.loginfo("reading %s" % (device_name))
joy_pub = rospy.Publisher('joy', Joy)
with open(device_name, "rb" ) as tp_file:
prev_bLeft = 0
prev_bMiddle = 0
prev_bRight = 0
while not rospy.is_shutdown():
if autorepeat_rate == 0:
buf = tp_file.read(3)
else:
r,w,e = select.select([tp_file], [], [], 1.0 / autorepeat_rate)
if tp_file in r:
buf = os.read(tp_file.fileno(), 3)
else:
buf = None
if buf == None:
x, y = (0, 0)
bLeft = prev_bLeft
bMiddle = prev_bMiddle
bRight = prev_bRight
else:
button = ord( buf[0] )
bLeft = button & 0x1
bMiddle = ( button & 0x4 ) > 0
bRight = ( button & 0x2 ) > 0
x,y = struct.unpack( "bb", buf[1:] )
joy_msg = Joy()
joy_msg.header.stamp = rospy.Time.now()
joy_msg.header.frame_id = frame_id
joy_msg.axes = [x, y]
joy_msg.buttons = [bLeft, bMiddle, bRight]
joy_pub.publish(joy_msg)
prev_bLeft = bLeft
prev_bMiddle = bMiddle
prev_bRight = bRight
def publish(self, active_keys):
logdebug("Publishing!")
# in_event = self._device.read_one()
# while in_event is None:
# # rospy.sleep(0.1)
# in_event = self._device.read_one()
# if in_event is None:
# continue
# if in_event.type == ecodes.EV_KEY:
# break
# else:
# in_event = None
# if in_event is None:
# return
# if in_event.type == ecodes.EV_KEY:
msg = Joy(header=Header(stamp=Time.now()))
msg.axes = [0.0] * self._axes_count
msg.buttons = [0] * self._button_count
# active_keys = self._device.active_keys(verbose=False)
loginfo("active_keys : {}".format(active_keys))
for k in active_keys:
msg.buttons[key_map[k]] = 1
loginfo("msg.buttons : {}".format(msg.buttons))
self._pub.publish(msg)
def handler(data):
try:
recived = byteify(json.loads(data))
if 'trans' in recived and 'rot' in recived:
# Send joystic data
joy = Joy()
joy.axes = (recived['trans'] + recived['rot'])
joy_pub.publish(joy)
# Send twists data
twist = Twist()
twist.angular.x = recived['rot'][0]
twist.angular.y = recived['rot'][1]
twist.angular.z = recived['rot'][2]
twist.linear.x = recived['trans'][0]
twist.linear.y = recived['trans'][1]
twist.linear.z = recived['trans'][2]
twist_pub.publish(twist)
except AttributeError, e:
print e
def talker1(x, y):
msg = Joy()
msg.axes = [0, 0, 0, -x, y, 0]
msg.buttons = [0,0,0]
pub2.publish(msg)
def twist_cb(msg): # twist -> joy callback res_ = hash_client_([msg.linear.x, msg.angular.z]) jmsg_ = Joy(); jmsg_.axes = res_.bin jmsg_.header.stamp = rospy.get_rostime(); pub_.publish(jmsg_)
while not quit and not rospy.is_shutdown():
rate.sleep()
with mutex:
joy.header.stamp = rospy.Time.now()
pub.publish(joy)
if __name__=="__main__":
settings = termios.tcgetattr(sys.stdin)
rospy.init_node('joystick_keyboard_emulator')
print msg
try:
joy.axes = [0.0] * 10
joy.buttons = [0] * 10
thread = threading.Thread(target = publisher)
thread.start()
while not rospy.is_shutdown():
key = getKey()
with mutex:
if key in moveBindings.keys():
for (axis,action) in moveBindings[key]:
if action == 0:
joy.axes[axis] = 0.0
else:
joy.axes[axis] += action * scale
joy.axes[axis] = min(max(-1,joy.axes[axis]),1)
elif key in [str(x) for x in range(0,10)]:
joy.buttons[int(key)] = 1 - joy.buttons[int(key)]
from beachbot_pathgen import Generator
rospy.init_node("server_node", disable_signals=True)
pub2 = rospy.Publisher('joy', Joy)
pub3 = rospy.Publisher('states', State)
app = Flask(__name__)
@app.route("/hallo")
def hallo():
return "Hallo!"
msg1 = Joy()
msg1.buttons = [0,0,0,0,0,0,0]
msg1.axes = [0,0,0,0,0,0]
class WebsocketApp(WebSocketApplication):
broadcast_rate = rospy.Rate(18)
def on_open(self):
print("Websocket Open")
ros_t = threading.Thread(target=self.ros_thread)
ros_t.daemon = True
ros_t.start()
return
# self.broadcast_ros(["test"])
def on_message(self, message):
if type(message) is str:
msg = json.loads(message)
self.pubCommand.publish(self.command)
#=======================#
# Some Classes #
#=======================#
from drone_video_display import DroneVideoDisplay
from PySide import QtCore, QtGui
#==========================#
# Button/Axis Defaults #
#==========================#
data = Joy()
data.buttons = [0]*12
data.axes = [0.0]*8
ShutDownNode = 0
ButtonEmergency = 1
TakeoffLand = 2
Up = 3
Down = 4
JoytoWay = 5
AxisRoll = 6
AxisPitch = 7
AxisYaw = 3
#============================#
# Scale Factor Defaults #
#============================#
ScaleRoll = 1.0
#!/usr/bin/env python
import rospy
from sensor_msgs.msg import Joy
from geometry_msgs.msg import Twist
from sensor_msgs.msg import Range
rospy.init_node("teleop_withRange")
pub = rospy.Publisher('cmd_vel', Twist, queue_size=10)
gJoy = Joy()
gJoy.axes = [0,0,0,0,0,0]
gRange = Range()
twist = Twist()
something_in_front = True
def callback_joy(joy):
global gJoy
gJoy = joy
def callback_range(ranges):
global gRange
gRange = ranges
rospy.Subscriber('range', Range, callback_range)
rospy.Subscriber('joy', Joy, callback_joy)
r = rospy.Rate(20)
#rospy.spin()
while not rospy.is_shutdown():
print "Object %f far away" % gRange.range
def talker2(index, is_pressed):
msg = Joy()
msg.axes = [1.2, 3.4]
msg.buttons = [0,0,0]
pub2.publish(msg)