def connnect_thread(self, addr, report_type):
try:
self.addr = addr
self.xarm = XArmAPI(port=addr,
enable_heartbeat=True,
enable_report=True,
report_type=report_type, do_not_open=True)
self.xarm.register_maable_mtbrake_changed_callback(self.report_brake_callback)
self.xarm.register_state_changed_callback(self.report_state_callback)
self.xarm.register_connect_changed_callback(self.report_connected_callback)
self.xarm.register_report_location_callback(self.report_location_callback, report_cartesian=True, report_joints=True)
self.xarm.register_error_warn_changed_callback(self.report_warn_error_callback)
self.xarm.register_cmdnum_changed_callback(self.report_cmdnum_callback)
self.xarm.connect()
if not self.xarm.connected:
time.sleep(0.5)
# threading.Timer(1, self.init_robot).start()
self.report_type = report_type
return True
except Exception as e:
self.report_que.put({
'type': 'connect',
'item': {
'mainConnected': False,
'reportConnected': False
}
})
def __init__(self, port, *args, **kwargs):
if port not in self._instances:
self._arm = XArmAPI(port, *args, **kwargs)
else:
instance = self._instances[port]
if not hasattr(instance, '_arm'):
instance._arm = XArmAPI(port, *args, **kwargs)
else:
self._arm = instance._arm
def __init__(self):
""" Virtually private constructor. """
if XArmWrapperSingleton.__instance is not None:
raise SingletonException("This class is a singleton!")
else:
self.params = {
'speed': 100,
'acc': 2000,
'angle_speed': 20,
'angle_acc': 500,
'events': {},
'variables': {},
'callback_in_thread': True,
'quit': False
}
XArmWrapperSingleton.__instance = self
self.arm = XArmAPI('192.168.1.229', do_not_open=True)
self.end_effector = ArduinoUdp('192.168.1.230')
self.arm_is_busy = False
self.arm.connect()
self.arm.clean_warn()
self.arm.clean_error()
self.blower(0)
self.vacuum_granular(0)
self.vacuum_solid(0)
print(self.move_granular(0))
print(self.move_syringe(0))
print(self.move_cylinder(0))
time.sleep(1)
self.arm.motion_enable(True)
self.arm.set_mode(0)
self.arm.set_state(0)
self.initial_position()
time.sleep(1)
self.arm.register_error_warn_changed_callback(
self.error_warn_change_callback)
self.arm.register_state_changed_callback(
self.state_changed_callback)
self.arm.register_report_location_callback(
self.location_change_callback)
if hasattr(self.arm, 'register_count_changed_callback'):
def count_changed_callback(data):
pprint('counter val: {}'.format(data['count']))
self.arm.register_count_changed_callback(
count_changed_callback)
self.arm.register_connect_changed_callback(
self.connect_changed_callback)
def __init__(self):
ip = '192.168.1.217'
self.arm = XArmAPI(ip, do_not_open=False)
self.arm.register_error_warn_changed_callback(self.hangle_err_warn_changed)
print('xArm Version: {}'.format(self.arm.version))
self.arm.motion_enable(enable=True)
self.arm.set_mode(0)
self.arm.set_state(state=0)
self.arm.set_state(state=0)
print('arm.last_used_tcp_acc:',self.arm.last_used_tcp_acc)
# self.arm.reset(wait=True)
self.xx_init = 422.4
self.yy_init = -216.9
self.zz_init = 30
self.tcp_roll = 17.8
self.tcp_pitch = 77.4
self.tcp_yaw = 47.3
self.init_pos()
self.zz_init_move = 100
self.zz_play = 0
self.hand = InspireHandR()
self.arm.set_tcp_jerk(10000)
import sys
import time
sys.path.append(os.path.join(os.path.dirname(__file__), '../../..'))
from xarm.wrapper import XArmAPI
from configparser import ConfigParser
parser = ConfigParser()
parser.read('../robot.conf')
try:
ip = parser.get('xArm', 'ip')
except:
ip = input('Please input the xArm ip address[192.168.1.194]:')
if not ip:
ip = '192.168.1.194'
arm = XArmAPI(ip)
arm.motion_enable(True)
arm.clean_error()
arm.set_mode(0)
arm.set_state(0)
time.sleep(1)
code = arm.set_bio_gripper_enable(True)
print('set_bio_gripper_enable, code={}'.format(code))
code = arm.set_bio_gripper_speed(300)
print('set_bio_gripper_speed, code={}'.format(code))
while arm.connected and arm.error_code == 0:
code = arm.open_bio_gripper()
print('open_bio_gripper, code={}'.format(code))
if len(sys.argv) >= 2:
ip = sys.argv[1]
else:
try:
from configparser import ConfigParser
parser = ConfigParser()
parser.read('../robot.conf')
ip = parser.get('xArm', 'ip')
except:
ip = input('Please input the xArm ip address:')
if not ip:
print('input error, exit')
sys.exit(1)
########################################################
arm = XArmAPI(ip, enable_report=True)
arm.motion_enable(enable=True)
arm.ft_sensor_enable(0)
arm.clean_error()
arm.clean_warn()
arm.ft_sensor_enable(1)
time.sleep(0.5)
arm.ft_sensor_set_zero()
while arm.connected and arm.error_code == 0:
# ft_raw_force and ft_ext_force will update by reporting socket
print('raw_force: {}'.format(arm.ft_raw_force))
print('exe_force: {}'.format(arm.ft_ext_force))
# # get_ft_sensor_data() will get the last ext_force
#
# Copyright (c) 2018, UFACTORY, Inc.
# All rights reserved.
#
# Author: Vinman <*****@*****.**> <*****@*****.**>
import os
import sys
import time
sys.path.append(os.path.join(os.path.dirname(__file__), '../..'))
from xarm.wrapper import XArmAPI
from xarm.core import ControllerError, ControllerWarn
xarm = XArmAPI('192.168.1.113', do_not_open=True, is_radian=False)
def hangle_err_warn_changed(item):
if item['error_code'] != 0:
controller_error = ControllerError(item['error_code'])
print('ControllerError[code: {}, desc: {}]'.format(
controller_error.code, controller_error.description))
if 10 <= item['error_code'] <= 17 or item['error_code'] == 28:
xarm.get_servo_debug_msg(show=True)
# TODO handle error
else:
pass
# TODO handle error
# # clean error
# xarm.clean_error()
import sys
import os
sys.path.append(os.path.join(os.path.dirname(__file__), '../../..'))
'''
sys.path.append()将不在同一目录下模块的路径添加到程序中
os.path.join()将多个路径组合后返回
os.path.dirname(__file__)返回该脚本所在的完整路径
'''
from xarm.wrapper import XArmAPI
from voice_recognition import Msp
from voice_feedback import Voice_feedback
from pour_tea_01 import Pour_tea_01
from pour_tea_02 import Pour_tea_02
arm_left = XArmAPI('192.168.1.151')
arm_right = XArmAPI('192.168.1.209') # 连接控制器
arm_left.motion_enable(enable=True)
arm_right.motion_enable(enable=True) # 使能
arm_left.set_mode(0)
arm_right.set_mode(0) # 运动模式：位置控制模式
arm_left.set_state(state=0)
arm_right.set_state(state=0) # 运动状态：进入运动状态
voice = Msp()
voice_feedback = Voice_feedback()
pt_01 = Pour_tea_01(arm_left, arm_right)
if len(sys.argv) >= 2:
ip = sys.argv[1]
else:
try:
from configparser import ConfigParser
parser = ConfigParser()
parser.read('../robot.conf')
ip = parser.get('xArm', 'ip')
except:
ip = input('Please input the xArm ip address:')
if not ip:
print('input error, exit')
sys.exit(1)
########################################################
arm = XArmAPI(ip)
arm.motion_enable(enable=True)
arm.set_mode(0)
arm.set_state(state=0)
arm.reset(wait=True)
speed = 50
angles = [[0, 14, -25, 0, 12.9, 0], [-14, 40, -75, 0, 33.4, -13.8],
[21.9, 50, -80, 50, 37, 29]]
arm.set_pause_time(1)
for _ in range(10):
for angle in angles:
code = arm.set_servo_angle(angle=angle,
# Copyright (c) 2019, UFACTORY, Inc.
# All rights reserved.
#
# Author: Vinman <*****@*****.**> <*****@*****.**>
"""
Description: Servo cartesian
"""
import os
import sys
import time
import datetime
sys.path.append(os.path.join(os.path.dirname(__file__), '../../..'))
from xarm.wrapper import XArmAPI
arm = XArmAPI('192.168.1.201')
arm.motion_enable(enable=True)
arm.set_mode(0)
arm.set_state(state=0)
arm.reset(wait=True)
#set start point by joint motion
# arm.set_position(*[200, 0, 200, 180, 0, 0], wait=True)
arm.set_servo_angle(angle=[0, -42.6, 3.2, 0, 39.4, 0], speed=60, wait=True)
print(arm.get_position())
arm.set_mode(1)
arm.set_state(0)
time.sleep(0.1)
class XArmHandler(object):
def __init__(self, ui):
super(XArmHandler, self).__init__()
self.ui = ui
self.xarm = None
self.addr = None
self.report_type = 'normal'
self.cmd_que = queue.Queue(100)
self.cmd_thread = XArmThread(self.cmd_que)
self.cmd_thread.signal.connect(self.run_cmd)
self.cmd_thread.start()
# threading.Thread(target=self._handle_cmd_thread, daemon=True).start()
self.report_que = queue.Queue()
self.report_thread = XArmThread(self.report_que)
self.report_thread.signal.connect(self.update_ui)
self.report_thread.start()
def run_cmd(self, item):
try:
if self.xarm and self.xarm.connected:
func = getattr(self.xarm, item['cmd'])
# log(item['cmd']+':', func(*item.get('args', []), **item.get('kwargs', {})))
ret = func(*item.get('args', []), **item.get('kwargs', {}))
if isinstance(ret, int) and ret == TCP_OR_JOINT_LIMIT:
self.ui.reset_flag()
logger.debug('cmd: {}, ret:{}, args: {}, kwargs: {}'.format(item['cmd'], ret, item.get('args', []),
item.get('kwargs', {})))
else:
self.cmd_que.queue.clear()
logger.debug('cmd: {}, ret: xArm is not connected'.format(item['cmd']))
except:
pass
def connect(self, addr, report_type='normal'):
try:
logger.debug('try connect to {}, report: {}'.format(addr, report_type))
if self.xarm and self.xarm.connected:
logger.info('disconnect from {}'.format(self.addr))
self.xarm.disconnect()
except Exception as e:
print(e)
threading.Thread(target=self.connnect_thread, args=(addr, report_type), daemon=True).start()
def connnect_thread(self, addr, report_type):
try:
self.addr = addr
self.xarm = XArmAPI(port=addr,
enable_heartbeat=True,
enable_report=True,
report_type=report_type, do_not_open=True)
self.xarm.register_maable_mtbrake_changed_callback(self.report_brake_callback)
self.xarm.register_state_changed_callback(self.report_state_callback)
self.xarm.register_connect_changed_callback(self.report_connected_callback)
self.xarm.register_report_location_callback(self.report_location_callback, report_cartesian=True, report_joints=True)
self.xarm.register_error_warn_changed_callback(self.report_warn_error_callback)
self.xarm.register_cmdnum_changed_callback(self.report_cmdnum_callback)
self.xarm.connect()
if not self.xarm.connected:
time.sleep(0.5)
# threading.Timer(1, self.init_robot).start()
self.report_type = report_type
return True
except Exception as e:
self.report_que.put({
'type': 'connect',
'item': {
'mainConnected': False,
'reportConnected': False
}
})
def disconnect(self):
try:
if self.xarm and self.xarm.connected:
self.xarm.disconnect()
# logger.info('diconnect from {}'.format(self.addr))
except Exception as e:
print(e)
def update_ui(self, data):
item = data['item']
if data['type'] == 'brake':
maable, mtbrake = item['maable'], item['mtbrake']
self.ui.axis_ui.brake_changed_callback(list(map(lambda x: bool(x[0] & x[1]), zip(mtbrake, maable))))
maable_value = 0
for i, v in enumerate(maable):
if v is True:
maable_value += pow(2, i)
mtbrake_value = 0
for i, v in enumerate(mtbrake):
if v is True:
mtbrake_value += pow(2, i)
self.ui.update_maable_mtbrake(maable_value, mtbrake_value)
# self.ui.update_maable_mtbrake(maable, mtbrake)
# mtbrake = [mtbrake & 0x01, mtbrake >> 1 & 0x01, mtbrake >> 2 & 0x01, mtbrake >> 3 & 0x01,
# mtbrake >> 4 & 0x01, mtbrake >> 5 & 0x01, mtbrake >> 6 & 0x01, mtbrake >> 7 & 0x01]
# maable = [maable & 0x01, maable >> 1 & 0x01, maable >> 2 & 0x01, maable >> 3 & 0x01,
# maable >> 4 & 0x01, maable >> 5 & 0x01, maable >> 6 & 0x01, maable >> 7 & 0x01]
# self.ui.axis_ui.brake_changed_callback(list(map(lambda x: bool(x[0] & x[1]), zip(mtbrake, maable))))
elif data['type'] == 'error':
self.ui.update_warn_error([item['warnCode'], item['errorCode']])
if item['errorCode'] != 0 or item['warnCode'] != 0:
if item['warnCode'] != 0:
logger.warn('warn: code: {}, desc: {}'.format(item['warnCode'], ControlWarn(item['warnCode']).description))
if item['errorCode'] != 0:
logger.error('error: code: {}, desc: {}'.format(item['errorCode'], ControlError(item['errorCode']).description))
else:
logger.info('warn: {}, error: {}'.format(item['warnCode'], item['errorCode']))
if item['errorCode'] != 0:
try:
self.get_servo_debug_msg()
except Exception as e:
logger.error(str(e))
elif data['type'] == 'state':
state = item['state']
self.ui.update_state(state)
elif data['type'] == 'connect':
self.ui.update_connect_status([item['mainConnected'], item['reportConnected']])
elif data['type'] == 'location':
pos = item['position']
angles = item['angles']
self.ui.axis_ui.update_joints(angles)
self.ui.cartesian_ui.update_cartesians(pos)
elif data['type'] == 'cmdnum':
cmdnum = item['cmdnum']
self.ui.update_cmd_count(cmdnum)
def report_state_callback(self, item):
self.report_que.put({
'type': 'state',
'item': item
})
def report_cmdnum_callback(self, item):
self.report_que.put({
'type': 'cmdnum',
'item': item
})
def report_connected_callback(self, item):
self.report_que.put({
'type': 'connect',
'item': item
})
def report_location_callback(self, item):
try:
pos = item['cartesian']
angles = item['joints']
location = {
'position': [float('{:.1f}'.format(p * RAD_DEGREE)) if 2 < i < 6 else float('{:.1f}'.format(p)) for i, p in enumerate(pos)],
'angles': [float('{:.1f}'.format(angle * RAD_DEGREE)) for angle in angles],
}
self.report_que.put({
'type': 'location',
'item': location
})
except Exception as e:
print(e)
pass
def report_brake_callback(self, item):
self.report_que.put({
'type': 'brake',
'item': item
})
def report_warn_error_callback(self, item):
self.report_que.put({
'type': 'error',
'item': item
})
def get_servo_debug_msg(self, only_log_error_servo=True):
if self.ui.main_ui.window.log_window.isHidden():
self.ui.main_ui.window.log_window.show()
self.ui.main_ui.logAction.setText('Close-Log')
try:
if self.xarm and self.xarm.connected:
ret = self.xarm.get_servo_debug_msg()
if ret[0] in [0, x2_config.UX2_ERR_CODE, x2_config.UX2_WAR_CODE]:
logger.log('=' * 50)
for i in range(1, 8):
servo = '机械臂第{}轴'.format(i)
log_servo_error(servo, ret[i * 2 - 1], ret[i * 2], only_log_error_servo=only_log_error_servo)
log_servo_error('机械爪', ret[15], ret[16], only_log_error_servo=only_log_error_servo)
logger.log('=' * 50)
elif ret[0] == 3:
logger.debug('cmd: get_servo_debug_msg, ret: 通信错误')
else:
logger.debug('cmd: get_servo_debug_msg, ret: xArm is not connected')
except Exception as e:
print(e)
def init_robot(self):
global on_init
with lock:
on_init = True
if self.xarm and self.xarm.connected:
if self.xarm.warn_code != 0:
logger.debug('clean warn:', self.xarm.clean_warn())
if self.xarm.error_code != 0:
logger.debug('clean error:', self.xarm.clean_error())
time.sleep(0.3)
logger.debug('motion enable:', self.xarm.motion_enable(enable=True))
time.sleep(0.5)
logger.debug('set state:', self.xarm.set_state(0))
time.sleep(0.2)
self.xarm.get_version()
logger.info('xarm_version:', self.xarm.version)
with lock:
on_init = False
def put_cmd_que(self, item):
self.cmd_que.put(item)
if len(sys.argv) >= 2:
ip = sys.argv[1]
else:
try:
from configparser import ConfigParser
parser = ConfigParser()
parser.read('../robot.conf')
ip = parser.get('xArm', 'ip')
except:
ip = input('Please input the xArm ip address:')
if not ip:
print('input error, exit')
sys.exit(1)
########################################################
arm = XArmAPI(ip)
arm.motion_enable(enable=True)
arm.set_mode(0)
arm.set_state(state=0)
time.sleep(1)
# go to "Zero Position"
arm.move_gohome()
# go to start position
print(arm.set_position(300, 0, 300, 180, 0, 0, wait=True))
time.sleep(0.5)
# set to mode 1
arm.set_mode(1)
arm.set_state(state=0)
time.sleep(1)
# test move pitch continually, roll+90
if len(sys.argv) >= 2:
ip = sys.argv[1]
else:
try:
from configparser import ConfigParser
parser = ConfigParser()
parser.read('../robot.conf')
ip = parser.get('xArm', 'ip')
except:
ip = input('Please input the xArm ip address:')
if not ip:
print('input error, exit')
sys.exit(1)
########################################################
arm = XArmAPI(ip)
arm.motion_enable(enable=True)
arm.set_mode(0)
arm.set_state(state=0)
arm.reset(wait=True)
speed = math.radians(50)
while (p.isConnected()):
p.stepSimulation()
targetPositions = arm.get_servo_angle(is_radian=True)[1]
#print("targetPositions=",targetPositions)
for i in range(len(paramIds)):
targetPos = targetPositions[i]
p.setJointMotorControl2(xarm,
if len(sys.argv) >= 2:
ip = sys.argv[1]
else:
try:
from configparser import ConfigParser
parser = ConfigParser()
parser.read('../robot.conf')
ip = parser.get('xArm', 'ip')
except:
ip = input('Please input the xArm ip address:')
if not ip:
print('input error, exit')
sys.exit(1)
########################################################
arm = XArmAPI(ip)
arm.motion_enable(enable=True)
arm.set_mode(0)
arm.set_state(state=0)
time.sleep(1)
arm.reset(wait=True)
# set cartesian velocity control mode
arm.set_mode(5)
arm.set_state(0)
time.sleep(1)
arm.vc_set_cartesian_velocity([100, 0, 0, 0, 0, 0])
time.sleep(2)
arm.vc_set_cartesian_velocity([0, -100, 0, 0, 0, 0])
def callback_connect_changed(item):
print('connect changed:', item)
def callback_error_warn_changed(item):
print('error warn changed:', item)
def callback_mtable_mtbrake_changed(item):
print('maable mtbrake changed:', item)
def callback_report_location(item):
print('location report:', item)
arm = XArmAPI('192.168.1.113', do_not_open=True)
arm.register_cmdnum_changed_callback(callback=callback_cmdnum_changed)
arm.register_state_changed_callback(callback=callback_state_changed)
arm.register_connect_changed_callback(callback=callback_connect_changed)
arm.register_error_warn_changed_callback(callback=callback_error_warn_changed)
arm.register_mtable_mtbrake_changed_callback(callback=callback_mtable_mtbrake_changed)
arm.register_report_location_callback(callback=callback_report_location)
arm.connect()
arm.motion_enable(enable=True)
arm.set_mode(0)
arm.set_state(state=0)
time.sleep(5)
arm.disconnect()
import os
import sys
import time
sys.path.append(os.path.join(os.path.dirname(__file__), '../../..'))
from xarm.wrapper import XArmAPI
from configparser import ConfigParser
parser = ConfigParser()
parser.read('../robot.conf')
try:
ip = parser.get('xArm', 'ip')
except:
ip = input('Please input the xArm ip address[192.168.1.194]:')
if not ip:
ip = '192.168.1.194'
arm = XArmAPI(ip)
time.sleep(0.5)
if arm.warn_code != 0:
arm.clean_warn()
if arm.error_code != 0:
arm.clean_error()
code, states = arm.get_cgpio_state()
print('get_cgpio_state, code={}'.format(code))
print('state: {} {}'.format(states[0], states[1]))
print('digit_io: {:x} {:x} {:x} {:x}'.format(*states[2:6]))
print('analog: {:f} {:f} {:f} {:f}'.format(*states[6:10]))
print('input_conf: {}'.format(states[10]))
print('output_conf: {}'.format(states[11]))
import sys
import time
sys.path.append(os.path.join(os.path.dirname(__file__), '../../..'))
from xarm.wrapper import XArmAPI
from configparser import ConfigParser
parser = ConfigParser()
parser.read('../robot.conf')
try:
ip = parser.get('xArm', 'ip')
except:
ip = input('Please input the xArm ip address[192.168.1.194]:')
if not ip:
ip = '192.168.1.194'
arm = XArmAPI(ip)
time.sleep(0.5)
if arm.warn_code != 0:
arm.clean_warn()
if arm.error_code != 0:
arm.clean_error()
last_digitals = [-1, -1]
while arm.connected and arm.error_code != 19 and arm.error_code != 28:
code, digitals = arm.get_tgpio_digital()
if code == 0:
if digitals[0] == 1 and digitals[0] != last_digitals[0]:
print('IO0 input high level')
if digitals[1] == 1 and digitals[1] != last_digitals[1]:
print('IO1 input high level')
last_digitals = digitals
import os
import sys
import time
sys.path.append(os.path.join(os.path.dirname(__file__), '../../..'))
from xarm.wrapper import XArmAPI
arm = XArmAPI('192.168.1.201')
arm.motion_enable(enable=True)
arm.set_mode(0)
arm.set_state(state=0)
time.sleep(1)
# arm.set_state(4)
offset1 = [100, 0, 0, 0, 0, 0]
offset2 = [150, 0, 0, 0, 0, 0]
arm.set_position(207, 0, 112, 180, 0, 0, wait=True, is_radian=False)
arm.set_tcp_offset(offset=offset1)
arm.save_conf()
time.sleep(1)
print(arm.get_position())
arm.set_tcp_offset(offset=offset2)
arm.save_conf()
print(arm.get_position())
if len(sys.argv) >= 2:
ip = sys.argv[1]
else:
try:
from configparser import ConfigParser
parser = ConfigParser()
parser.read('../robot.conf')
ip = parser.get('xArm', 'ip')
except:
ip = input('Please input the xArm ip address:')
if not ip:
print('input error, exit')
sys.exit(1)
########################################################
arm = XArmAPI(ip)
arm.motion_enable(enable=True)
arm.clean_error()
arm.set_mode(0)
arm.set_state(0)
time.sleep(0.1)
# set pid parameters for force control
Kp = 0.005 # range: 0 ~ 0.05
Ki = 0.00006 # range: 0 ~ 0.0005
Kd = 0.000 # range: 0 ~ 0.05
v_max = 100.0 # max adjust velocity(mm/s), range: 0 ~ 200
arm.set_force_control_pid([Kp]*6, [Ki]*6, [Kd]*6, [v_max]*6)
ref_frame = 1 # 0 : base , 1 : tool
force_axis = [0, 0, 1, 0, 0, 0] # only control force along z axis
if len(sys.argv) >= 2:
ip = sys.argv[1]
else:
try:
from configparser import ConfigParser
parser = ConfigParser()
parser.read('./robot1.conf')
ip = parser.get('xArm', 'ip')
except:
ip = input('Please input the xArm ip address:')
if not ip:
print('input error, exit')
sys.exit(1)
########################################################
arm = XArmAPI(ip, is_radian=True)
arm.motion_enable(enable=True)
arm.set_mode(0)
arm.set_state(state=0)
arm.reset(wait=True)
poses = [[300, 0, 100, -180, 0, 0], [300, 100, 100, -3.1416, 0, 0],
[400, 100, 100, -3.1416, 0, 0], [400, -100, 100, -3.1416, 0, 0],
[300, 0, 300, -3.1416, 0, 0]]
ret = arm.set_position(*poses[0], speed=50, wait=True, is_radian=False)
print('set_position, ret: {}'.format(ret))
arm.set_position(x=300,
#!/usr/bin/env python3
# Software License Agreement (BSD License)
#
# Copyright (c) 2018, UFACTORY, Inc.
# All rights reserved.
#
# Author: Vinman <*****@*****.**> <*****@*****.**>
import os
import sys
import time
sys.path.append(os.path.join(os.path.dirname(__file__), '../..'))
from xarm.wrapper import XArmAPI
xarm = XArmAPI('192.168.1.113')
xarm.motion_enable(enable=True)
xarm.set_mode(0)
xarm.set_state(state=0)
time.sleep(5)
xarm.disconnect()
import sys
import time
sys.path.append(os.path.join(os.path.dirname(__file__), '../../..'))
from xarm.wrapper import XArmAPI
from configparser import ConfigParser
parser = ConfigParser()
parser.read('../robot.conf')
try:
ip = parser.get('xArm', 'ip')
except:
ip = input('Please input the xArm ip address[192.168.1.194]:')
if not ip:
ip = '192.168.1.194'
arm = XArmAPI(ip)
time.sleep(0.5)
if arm.warn_code != 0:
arm.clean_warn()
if arm.error_code != 0:
arm.clean_error()
print('set IO0 high level')
arm.set_tgpio_digital(0, 1)
time.sleep(2)
print('set IO1 high level')
arm.set_tgpio_digital(1, 1)
time.sleep(2)
print('set IO0 low level')
arm.set_tgpio_digital(0, 0)
print('set IO1 low level')
ip = sys.argv[1]
else:
try:
from configparser import ConfigParser
parser = ConfigParser()
parser.read('../robot.conf')
ip = parser.get('xArm', 'ip')
except:
ip = input('Please input the xArm ip address:')
if not ip:
print('input error, exit')
sys.exit(1)
########################################################
arm = XArmAPI(ip)
arm.motion_enable(enable=True)
arm.set_mode(0)
arm.set_state(state=0)
arm.reset(wait=True)
arm.set_mode(1)
arm.set_state(state=0)
speed = math.radians(5)
while (p.isConnected()):
p.stepSimulation()
targetPositions=[]
for i in range(len(paramIds)):
c = paramIds[i]
targetPos = p.readUserDebugParameter(c)
if len(sys.argv) >= 2:
ip = sys.argv[1]
else:
try:
from configparser import ConfigParser
parser = ConfigParser()
parser.read('../robot.conf')
ip = parser.get('xArm', 'ip')
except:
ip = input('Please input the xArm ip address:')
if not ip:
print('input error, exit')
sys.exit(1)
########################################################
arm = XArmAPI(ip)
arm.motion_enable(enable=True)
arm.set_mode(0)
arm.set_state(state=0)
arm.reset(wait=True)
speed = 50
arm.set_servo_angle(angle=[90, 0, 0, 0, 0], speed=speed, wait=True)
print(arm.get_servo_angle(), arm.get_servo_angle(is_radian=True))
arm.set_servo_angle(angle=[90, 0, -60, 0, 0], speed=speed, wait=True)
print(arm.get_servo_angle(), arm.get_servo_angle(is_radian=True))
arm.set_servo_angle(angle=[90, -30, -60, 0, 0], speed=speed, wait=True)
print(arm.get_servo_angle(), arm.get_servo_angle(is_radian=True))
arm.set_servo_angle(angle=[0, -30, -60, 0, 0], speed=speed, wait=True)
print(arm.get_servo_angle(), arm.get_servo_angle(is_radian=True))
if len(sys.argv) >= 2:
ip = sys.argv[1]
else:
try:
from configparser import ConfigParser
parser = ConfigParser()
parser.read('../robot.conf')
ip = parser.get('xArm', 'ip')
except:
ip = input('Please input the xArm ip address:')
if not ip:
print('input error, exit')
sys.exit(1)
########################################################
arm = XArmAPI(ip, is_radian=True)
arm.motion_enable(enable=True)
arm.set_mode(0)
arm.set_state(state=0)
arm.reset(wait=True)
Z_GROUND = 91.05
arm.set_position(x=300,
y=-50,
z=Z_GROUND,
roll=-180,
pitch=0,
yaw=0,
speed=100,
if len(sys.argv) >= 2:
ip = sys.argv[1]
else:
try:
from configparser import ConfigParser
parser = ConfigParser()
parser.read('../robot.conf')
ip = parser.get('xArm', 'ip')
except:
ip = input('Please input the xArm ip address:')
if not ip:
print('input error, exit')
sys.exit(1)
########################################################
arm = XArmAPI(ip, is_radian=True)
arm.motion_enable(enable=True)
arm.set_mode(0)
arm.set_state(state=0)
arm.reset(wait=True)
paths = [
[300, 0, 150, -180, 0, 0],
[300, 200, 250, -180, 0, 0],
[500, 200, 150, -180, 0, 0],
[500, -200, 250, -180, 0, 0],
[300, -200, 150, -180, 0, 0],
[300, 0, 250, -180, 0, 0],
[300, 200, 350, -180, 0, 0],
[500, 200, 250, -180, 0, 0],
sys.path.append(os.path.join(os.path.dirname(__file__), '../../..'))
from xarm.wrapper import XArmAPI
#######################################################
"""
Just for test example
"""
if len(sys.argv) >= 2:
ip = sys.argv[1]
else:
try:
from configparser import ConfigParser
parser = ConfigParser()
parser.read('../robot.conf')
ip = parser.get('xArm', 'ip')
except:
ip = input('Please input the xArm ip address:')
if not ip:
print('input error, exit')
sys.exit(1)
########################################################
arm = XArmAPI(ip, is_radian=True)
arm.motion_enable(enable=True)
arm.set_mode(0)
arm.set_state(state=0)
arm.load_trajectory('test.traj')
arm.playback_trajectory()
Move joint
set_servo_angle:
1. explicit setting is_radian=True, the param roll/yaw/pitch unit is radians
2. explicit setting wait=True to wait for the arm to complete
get_servo_angle:
1. explicit setting is_radian=True, the returned value(roll/yaw/pitch) unit is radians
"""
import os
import sys
import math
sys.path.append(os.path.join(os.path.dirname(__file__), '../../..'))
from xarm.wrapper import XArmAPI
arm = XArmAPI('192.168.1.113')
arm.motion_enable(enable=True)
arm.set_mode(0)
arm.set_state(state=0)
arm.reset(wait=True)
speed = math.radians(30)
arm.set_servo_angle(angle=[math.radians(60), 0, 0, 0, 0],
speed=speed,
is_radian=True,
wait=True)
print(arm.get_servo_angle(is_radian=True))
arm.set_servo_angle(angle=[math.radians(60),
math.radians(-45), 0, 0, 0],
if len(sys.argv) >= 2:
ip = sys.argv[1]
else:
try:
from configparser import ConfigParser
parser = ConfigParser()
parser.read('../robot.conf')
ip = parser.get('xArm', 'ip')
except:
ip = input('Please input the xArm ip address:')
if not ip:
print('input error, exit')
sys.exit(1)
########################################################
arm = XArmAPI(ip, is_radian=True)
arm.motion_enable(enable=True)
arm.set_mode(0)
arm.set_state(state=0)
arm.reset(wait=True)
speed = 50
arm.set_servo_angle(servo_id=1,
angle=90,
speed=speed,
is_radian=False,
wait=True)
print(arm.get_servo_angle(), arm.get_servo_angle(is_radian=True))
arm.set_servo_angle(servo_id=2,
angle=-60,
import sys
import time
sys.path.append(os.path.join(os.path.dirname(__file__), '../../..'))
from xarm.wrapper import XArmAPI
from configparser import ConfigParser
parser = ConfigParser()
parser.read('../robot.conf')
try:
ip = parser.get('xArm', 'ip')
except:
ip = input('Please input the xArm ip address[192.168.1.194]:')
if not ip:
ip = '192.168.1.194'
arm = XArmAPI(ip)
time.sleep(0.5)
if arm.warn_code != 0:
arm.clean_warn()
if arm.error_code != 0:
arm.clean_error()
value = 1
for i in range(8):
code = arm.set_cgpio_digital(i, value)
print('set_cgpio_digital({}, {}), code={}'.format(i, value, code))
value = 2.6
code = arm.set_cgpio_analog(0, value)
print('set_cgpio_analog(0, {}), code={}'.format(value, code))
