[AndrewLNguyen]

你好。我试图创建以下这些步骤的代码:
1.机器人到达吊舱区域的一个点。
2.它将检查可行性，看看它是否可以通过线性或关节移动到达那个点。
3.如果可以，它将通过使用solveIK_all()来求解所有可能的配置，看看它是否会在pod的壁上碰撞。
4.如果所有测试点没有碰撞，结束代码。
我有麻烦得到我需要的结果，并了解如何正确使用SolveIK_All。到目前为止，我的程序输出了一个关节和使用SolveIK_All求解的许多其他关节。我不知道为什么有些地方有超过6个轴。附件是我的代码和文件。我可以得到帮助来纠正我的代码吗?

代码:

这个宏展示了如何创建一个程序来移动机器人通过一组点
这些点被自动创建为参考目标周围的立方体网格
如果不能从一个点到下一个点进行线性运动，机器人将遵循关节运动
从robodk。robolink导入* # API与RoboDK通信
从robodk。Robomath导入* #基本矩阵操作
从随机导入均匀#随机计算rz(绕Z轴旋转)

#参考目标器的名称
REFERENCE_TARGET = 'RefTarget'

#检查碰撞
CHECK_COLLISIONS = False

#启动RoboDK API
RDK = Robolink()

#设置碰撞检查打开或关闭
RDK。setCollisionActive(COLLISION_ON if CHECK_COLLISIONS else COLLISION_OFF)

# Run on robot:强制程序在连接的机器人上运行(与右键单击程序，然后选择“Run on robot”的行为相同)
# RDK.setRunMode (RUNMODE_RUN_ROBOT)

找到车站里唯一的机器人
机器人= RDK。项目(ITEM_TYPE_ROBOT”)
如果不是robot.Valid():
引发异常("Robot not valid or not available")

#获取活动参考系
frame = robot.getLink(ITEM_TYPE_FRAME)
如果不是，frame.Valid():
frame = robot.Parent()
robot.setPoseFrame(框架)

#获取机器人的参考姿态
frame_pose = robot.PoseFrame()

#获取激活工具
tool = robot.getLink(ITEM_TYPE_TOOL)
如果不是tool.Valid():
工具=机器人。AddTool(transl(0,0,75)， "Tool Grid")
robot.setPoseTool(工具)

#获取目标引用RefTarget
target_ref = RDK。项目(REFERENCE_TARGET ITEM_TYPE_TARGET)
如果不是target_ref.Valid():
target_ref = RDK。添加目标(REFERENCE_TARGET, frame, robot)

#获取参考位置(姿态=目标相对于参考帧的4x4矩阵)
pose_ref = target_ref.Pose()
startpoint = target_ref. joint ()
config_ref = robot.JointsConfig(起始点)

#检索工具姿势
tool_pose = tool.PoseTool()

#获取自由度或坐标轴(num_dofs = 6对于一个6轴机器人)
num_dofs = len(robot. jointhome ().list())

获取目标参考系的参考系
ref_frame = target_ref.Parent()


#函数定义检查两个机器人配置是否相同
#配置设置为[后/前，下臂/上臂，翻转/非翻转]位(int值)
Def config_equal(config1, config2):
如果config1[0] != config2[0]或config1[1] != config2[1]或config1[2] != config2[2]:
返回假
还真


#创建一个新程序
prog = RDK.AddProgram('AutoCreated')

这将使程序生成稍微快一些
# prog.ShowInstructions(假)

#开始创建程序或移动机器人:
Program_or_robot = prog
program_or_robot.setPoseTool (tool_pose)

program_or_robot.MoveJ (target_ref)
lastjoint =起始点
Rz = 0
Ntargets = 0
对于(-100,101,100)范围内的tz:
对于范围(0,401,200)内的ty:
对于范围(100，-5001，-250)的tx:
Ntargets = Ntargets + 1
#计算围绕工具Z轴的随机旋转
#rz = uniform(-20*pi/180, 20*pi/180)

#计算新目标的位置:相对于机器人基座进行平移，并围绕工具旋转
Newtarget_pose = transl(tx, ty, tz) * pose_ref * rotz(rz)

#首先，确保目标是可到达的:
newtarget_关节=机器人。SolveIK(newtarget_pose, lastjoint, tool_pose, frame_pose)
如果len(newtarget_joints.list()) < num_dofs:
打印('……目标无法到达!!跳过目标”)
继续

创建新的目标器:
newtarget_name = 'Auto ' T%.0f，%.0f，%. 0f。0 f Rz = %。1f' % (tx, ty, tz, rz)
print('创建目标%i: %s' % (ntargets, newtarget_name))
newtarget = RDK。AddTarget(newtarget_name, ref_frame, robot)

在这一点上，目标是可到达的。
我们必须检查我们是否可以进行线性移动。我们有两种方法:
can_move_linear = True

# -------------------------------
#验证方法:使用机器人。MoveL_Test选项来检查机器人是否可以进行线性运动
这种方法更健壮，应该提供100%准确的结果，但可能需要更多的时间
#机器人。如果碰撞检查被激活，MoveL_Test也可以考虑碰撞
问题=机器人。MoveL_Test (lastjoints newtarget_pose)
Can_move_linear = (issue == 0)
#我们可以通过检索机器人关节来检索最终的关节位置
如果can_move_linear:
newtarget_joint = robot. joint ()

# ---------------------------------

如果can_move_linear:
很好，我们不需要修改目标。
然而，我们可以在目标中设置关节，因为这可以让我们在需要的时候检索机器人的配置
newtarget. setascartesianttarget() #默认行为
newtarget.setJoints (newtarget_joints)
在setjoint之后设置setPose是很重要的，因为它可能会重新计算关节来匹配目标
newtarget.setPose (newtarget_pose)

添加线性运动
program_or_robot.MoveL (newtarget)

其他:
#打印(newtarget_joints)
检查我们是否可以做一个关节运动(检查碰撞)
问题=机器人。MoveJ_Test (lastjoints newtarget_joints)
can_move_joint = (issue == 0)

#求出所有可能的配置
关节= robot.SolveIK_All(newtarget_pose)

如果没有can_move_关节:
#跳过这一点
print("跳过运动到:" + str(newtarget_joint))
打印(关节)
继续

#确保我们有一个共同的目标和一个共同的运动
newtarget. setasjointttarget() #默认行为

设置关节目标的姿势并不重要，除非我们想要检索姿势
或者我们想使用笛卡尔坐标进行后期处理
newtarget.setPose (newtarget_pose)

确保我们在关节目标的姿势之后设置关节，因为它可能会重新计算姿势
newtarget.setJoints (newtarget_joints)

添加关节运动
program_or_robot.MoveJ (newtarget)

记住最后一个动作的关节位置
lastjoint = newtarget_joint

#在最后显示指令更快:
prog.ShowInstructions(真正的)

隐藏目标更干净，更难以意外移动目标
# prog.ShowTargets(假)

print('程序用%i目标完成' % ntargets)

[艾伯特]

您的代码不正确，因为SolveIK_All将返回一个列表的列表。您假设SolveIK_All只返回一个解决方案，这对于大多数机器人来说是非常不可能的。

SolveIK_All的返回值是一个具有6xN个解的二维矩阵，其中N为6轴机器人的可用解的个数。RoboDK的一些版本返回6轴机器人的8xN解决方案数组。在这种情况下，您可以忽略额外的2个值。

迭代所有可能的解决方案的一个简单方法是使用Python中的默认迭代器并过滤额外的值:

代码:

joints_all = robot.SolveIK_All(pose_target)
对于joints_all中的关节:
Joints_6dof = list(关节)[0:6]
打印(joints_6dof)

[AndrewLNguyen]

您的代码不正确，因为SolveIK_All将返回一个列表的列表。您假设SolveIK_All只返回一个解决方案，这对于大多数机器人来说是非常不可能的。

SolveIK_All的返回值是一个具有6xN个解的二维矩阵，其中N为6轴机器人的可用解的个数。RoboDK的一些版本返回6轴机器人的8xN解决方案数组。在这种情况下，您可以忽略额外的2个值。

迭代所有可能的解决方案的一个简单方法是使用Python中的默认迭代器并过滤额外的值:

代码:

joints_all = robot.SolveIK_All(pose_target)
对于joints_all中的关节:
Joints_6dof = list(关节)[0:6]
打印(joints_6dof)

嗨,艾伯特。谢谢你!现在在下面的代码中正确地发布了结果。但我想知道，它所求解的不同机器人关节构型是否适用于吊舱，这意味着机器人关节不会与任何吊舱壁相撞。

代码:

这个宏展示了如何创建一个程序来移动机器人通过一组点
这些点被自动创建为参考目标周围的立方体网格
如果不能从一个点到下一个点进行线性运动，机器人将遵循关节运动
从robodk。robolink导入* # API与RoboDK通信
从robodk。Robomath导入* #基本矩阵操作
从随机导入均匀#随机计算rz(绕Z轴旋转)

#参考目标器的名称
REFERENCE_TARGET = 'RefTarget'

#检查碰撞
CHECK_COLLISIONS = False

#启动RoboDK API
RDK = Robolink()

#设置碰撞检查打开或关闭
RDK。setCollisionActive(COLLISION_ON if CHECK_COLLISIONS else COLLISION_OFF)

# Run on robot:强制程序在连接的机器人上运行(与右键单击程序，然后选择“Run on robot”的行为相同)
# RDK.setRunMode (RUNMODE_RUN_ROBOT)

找到车站里唯一的机器人
机器人= RDK。项目(ITEM_TYPE_ROBOT”)
如果不是robot.Valid():
引发异常("Robot not valid or not available")

#获取活动参考系
frame = robot.getLink(ITEM_TYPE_FRAME)
如果不是，frame.Valid():
frame = robot.Parent()
robot.setPoseFrame(框架)

#获取机器人的参考姿态
frame_pose = robot.PoseFrame()

#获取激活工具
tool = robot.getLink(ITEM_TYPE_TOOL)
如果不是tool.Valid():
工具=机器人。AddTool(transl(0,0,75)， "Tool Grid")
robot.setPoseTool(工具)

#获取目标引用RefTarget
target_ref = RDK。项目(REFERENCE_TARGET ITEM_TYPE_TARGET)
如果不是target_ref.Valid():
target_ref = RDK。添加目标(REFERENCE_TARGET, frame, robot)

#获取参考位置(姿态=目标相对于参考帧的4x4矩阵)
pose_ref = target_ref.Pose()
startpoint = target_ref. joint ()
config_ref = robot.JointsConfig(起始点)

#检索工具姿势
tool_pose = tool.PoseTool()

#获取自由度或坐标轴(num_dofs = 6对于一个6轴机器人)
num_dofs = len(robot. jointhome ().list())

获取目标参考系的参考系
ref_frame = target_ref.Parent()


#函数定义检查两个机器人配置是否相同
#配置设置为[后/前，下臂/上臂，翻转/非翻转]位(int值)
Def config_equal(config1, config2):
如果config1[0] != config2[0]或config1[1] != config2[1]或config1[2] != config2[2]:
返回假
还真


#创建一个新程序
prog = RDK.AddProgram('AutoCreated')

这将使程序生成稍微快一些
# prog.ShowInstructions(假)

#开始创建程序或移动机器人:
Program_or_robot = prog
program_or_robot.setPoseTool (tool_pose)

program_or_robot.MoveJ (target_ref)
lastjoint =起始点
Rz = 0
Ntargets = 0
对于(-100,101,100)范围内的tz:
对于范围(0,401,200)内的ty:
对于范围(100，-5001，-250)的tx:
Ntargets = Ntargets + 1
#计算围绕工具Z轴的随机旋转
#rz = uniform(-20*pi/180, 20*pi/180)

#计算新目标的位置:相对于机器人基座进行平移，并围绕工具旋转
Newtarget_pose = transl(tx, ty, tz) * pose_ref * rotz(rz)

#首先，确保目标是可到达的:
newtarget_关节=机器人。SolveIK(newtarget_pose, lastjoint, tool_pose, frame_pose)
如果len(newtarget_joints.list()) < num_dofs:
打印('……目标无法到达!!跳过目标”)
继续

创建新的目标器:
newtarget_name = 'Auto ' T%.0f，%.0f，%. 0f。0 f Rz = %。1f' % (tx, ty, tz, rz)
print('创建目标%i: %s' % (ntargets, newtarget_name))
newtarget = RDK。AddTarget(newtarget_name, ref_frame, robot)

在这一点上，目标是可到达的。
我们必须检查我们是否可以进行线性移动。我们有两种方法:
can_move_linear = True

# -------------------------------
#验证方法:使用机器人。MoveL_Test选项来检查机器人是否可以进行线性运动
这种方法更健壮，应该提供100%准确的结果，但可能需要更多的时间
#机器人。如果碰撞检查被激活，MoveL_Test也可以考虑碰撞
问题=机器人。MoveL_Test (lastjoints newtarget_pose)
Can_move_linear = (issue == 0)
#我们可以通过检索机器人关节来检索最终的关节位置
如果can_move_linear:
newtarget_joint = robot. joint ()

# ---------------------------------

如果can_move_linear:
很好，我们不需要修改目标。
然而，我们可以在目标中设置关节，因为这可以让我们在需要的时候检索机器人的配置
newtarget. setascartesianttarget() #默认行为
newtarget.setJoints (newtarget_joints)
在setjoint之后设置setPose是很重要的，因为它可能会重新计算关节来匹配目标
newtarget.setPose (newtarget_pose)

添加线性运动
program_or_robot.MoveL (newtarget)

其他:
#打印(newtarget_joints)
检查我们是否可以做一个关节运动(检查碰撞)
问题=机器人。MoveJ_Test (lastjoints newtarget_joints)
can_move_joint = (issue == 0)

#求出所有可能的配置
joints_all = robot.SolveIK_All(newtarget_pose)
对于joints_all中的关节:
Joints_6dof = list(关节)[0:6]
打印(joints_6dof)

如果没有can_move_关节:
#跳过这一点
print("跳过运动到:" + str(newtarget_joint))
继续

#确保我们有一个共同的目标和一个共同的运动
newtarget. setasjointttarget() #默认行为

设置关节目标的姿势并不重要，除非我们想要检索姿势
或者我们想使用笛卡尔坐标进行后期处理
newtarget.setPose (newtarget_pose)

确保我们在关节目标的姿势之后设置关节，因为它可能会重新计算姿势
newtarget.setJoints (newtarget_joints)

添加关节运动
program_or_robot.MoveJ (newtarget)

记住最后一个动作的关节位置
lastjoint = newtarget_joint

#在最后显示指令更快:
prog.ShowInstructions(真正的)

隐藏目标更干净，更难以意外移动目标
# prog.ShowTargets(假)

print('程序用%i目标完成' % ntargets)

[艾伯特]

您的代码看起来不太好，因为您没有正确地遍历所有解决方案。

你应该用逆运动学给出的每一个可能的解来测试你的机器人运动:

代码:

#寻找一个有效的配置来移动
joints_valid =无
joints_all = robot.SolveIK_All(newtarget_pose)
对于joints_all中的关节:
打印(关节)
检查我们是否可以做一个关节运动(检查碰撞)
问题=机器人。MoveJ_Test (lastjoints newtarget_joints)
can_move_joint = (issue == 0)

如果can_move_joints:
Joints_valid =关节
打破

如果joints_valid不为None:
print(“找到有效接头!”))

[AndrewLNguyen]

您的代码看起来不太好，因为您没有正确地遍历所有解决方案。

你应该用逆运动学给出的每一个可能的解来测试你的机器人运动:

代码:

#寻找一个有效的配置来移动
joints_valid =无
joints_all = robot.SolveIK_All(newtarget_pose)
对于joints_all中的关节:
打印(关节)
检查我们是否可以做一个关节运动(检查碰撞)
问题=机器人。MoveJ_Test (lastjoints newtarget_joints)
can_move_joint = (issue == 0)

如果can_move_joints:
Joints_valid =关节
打破

如果joints_valid不为None:
print(“找到有效接头!”))

嗨，艾伯特，当我尝试这个代码时，它不起作用，所以我修改了它，但我想我遇到了我不打算找到的解决方案。代码没有打印出舱内有效的关节配置。有什么问题吗?我修改了下面的代码，以便如果没有有效的关节，它将只使用RoboDK生成的默认关节并跳过这一点。我是新的编码，所以我会感谢所有的帮助。

代码:

#寻找一个有效的配置来移动
joints_valid =无
joints_all = robot.SolveIK_All(newtarget_pose)
对于joints_all中的关节:
Joints_6dof = list(关节)[0:6]
打印(joints_6dof)
检查我们是否可以做一个关节运动(检查碰撞)
问题=机器人。MoveJ_Test (lastjoints newtarget_joints)
can_move_joint = (issue == 0)
如果can_move_joints:
Joints_valid =关节
print(“找到有效接头!”)+ str (joints_valid))
其他:
#跳过这一点
print("Use" + str(newtarget_joint)+"instead")

整个代码:

代码:

这个宏展示了如何创建一个程序来移动机器人通过一组点
这些点被自动创建为参考目标周围的立方体网格
如果不能从一个点到下一个点进行线性运动，机器人将遵循关节运动
从robodk。robolink导入* # API与RoboDK通信
从robodk。Robomath导入* #基本矩阵操作
从随机导入均匀#随机计算rz(绕Z轴旋转)
导入numpy为np

#参考目标器的名称
REFERENCE_TARGET = 'RefTarget'

#检查碰撞
CHECK_COLLISIONS = False

#启动RoboDK API
RDK = Robolink()

#设置碰撞检查打开或关闭
RDK。setCollisionActive(COLLISION_ON if CHECK_COLLISIONS else COLLISION_OFF)

# Run on robot:强制程序在连接的机器人上运行(与右键单击程序，然后选择“Run on robot”的行为相同)
# RDK.setRunMode (RUNMODE_RUN_ROBOT)

找到车站里唯一的机器人
机器人= RDK。项目(ITEM_TYPE_ROBOT”)
如果不是robot.Valid():
引发异常("Robot not valid or not available")

#获取活动参考系
frame = robot.getLink(ITEM_TYPE_FRAME)
如果不是，frame.Valid():
frame = robot.Parent()
robot.setPoseFrame(框架)

#获取机器人的参考姿态
frame_pose = robot.PoseFrame()

#获取激活工具
tool = robot.getLink(ITEM_TYPE_TOOL)
如果不是tool.Valid():
工具=机器人。AddTool(transl(0,0,75)， "Tool Grid")
robot.setPoseTool(工具)

用关节角度定义机器人的home位置
home_joint = [0，-90,90，-90，-90,0]
robot.setJointsHome (home_joints)
robot.setJoints (robot.JointsHome ())

#获取目标引用RefTarget
target_ref = RDK。项目(REFERENCE_TARGET ITEM_TYPE_TARGET)
如果不是target_ref.Valid():
target_ref = RDK。添加目标(REFERENCE_TARGET, frame, robot)

#获取参考位置(姿态=目标相对于参考帧的4x4矩阵)
pose_ref = target_ref.Pose()
startpoint = target_ref. joint ()
config_ref = robot.JointsConfig(起始点)

#检索工具姿势
tool_pose = tool.PoseTool()

#获取自由度或坐标轴(num_dofs = 6对于一个6轴机器人)
num_dofs = len(robot. jointhome ().list())

获取目标参考系的参考系
ref_frame = target_ref.Parent()


#函数定义检查两个机器人配置是否相同
#配置设置为[后/前，下臂/上臂，翻转/非翻转]位(int值)
Def config_equal(config1, config2):
如果config1[0] != config2[0]或config1[1] != config2[1]或config1[2] != config2[2]:
返回假
还真


#创建一个新程序
prog = RDK.AddProgram('AutoCreated')

这将使程序生成稍微快一些
# prog.ShowInstructions(假)

#开始创建程序或移动机器人:
Program_or_robot = prog
program_or_robot.setPoseTool (tool_pose)

program_or_robot.MoveJ (target_ref)
lastjoint =起始点
Rz = 0
Ntargets = 0
对于(0,378,100)范围内的tz:
对于(- 378,178,100)范围内的ty:
对于范围(-700，-150,100)的tx:
Ntargets = Ntargets + 1
#计算围绕工具Z轴的随机旋转
#rz = uniform(-20*pi/180, 20*pi/180)

#计算新目标的位置:相对于机器人基座进行平移，并围绕工具旋转
Newtarget_pose = transl(tx, ty, tz) * pose_ref * rotz(rz)

#首先，确保目标是可到达的:
newtarget_关节=机器人。SolveIK(newtarget_pose, lastjoint, tool_pose, frame_pose)
如果len(newtarget_joints.list()) < num_dofs:
打印('……目标无法到达!!跳过目标”)
继续

创建新的目标器:
newtarget_name = 'Auto ' T%.0f，%.0f，%. 0f。0 f Rz = %。1f' % (tx, ty, tz, rz)
print('创建目标%i: %s' % (ntargets, newtarget_name))
newtarget = RDK。AddTarget(newtarget_name, ref_frame, robot)

在这一点上，目标是可到达的。
我们必须检查我们是否可以进行线性移动。我们有两种方法:
can_move_linear = True

# -------------------------------
#验证方法:使用机器人。MoveL_Test选项来检查机器人是否可以进行线性运动
这种方法更健壮，应该提供100%准确的结果，但可能需要更多的时间
#机器人。如果碰撞检查被激活，MoveL_Test也可以考虑碰撞
问题=机器人。MoveL_Test (lastjoints newtarget_pose)
Can_move_linear = (issue == 0)
#我们可以通过检索机器人关节来检索最终的关节位置
如果can_move_linear:
newtarget_joint = robot. joint ()

# ---------------------------------

如果can_move_linear:
很好，我们不需要修改目标。
然而，我们可以在目标中设置关节，因为这可以让我们在需要的时候检索机器人的配置
newtarget. setascartesianttarget() #默认行为
newtarget.setJoints (newtarget_joints)
在setjoint之后设置setPose是很重要的，因为它可能会重新计算关节来匹配目标
newtarget.setPose (newtarget_pose)

添加线性运动
program_or_robot.MoveL (newtarget)

其他:
#打印(newtarget_joints)
检查我们是否可以做一个关节运动(检查碰撞)
#issues = robot。MoveJ_Test (lastjoints newtarget_joints)
#can_move_joint = (issue == 0)

#寻找一个有效的配置来移动
joints_valid =无
joints_all = robot.SolveIK_All(newtarget_pose)
对于joints_all中的关节:
Joints_6dof = list(关节)[0:6]
打印(joints_6dof)
检查我们是否可以做一个关节运动(检查碰撞)
问题=机器人。MoveJ_Test (lastjoints newtarget_joints)
can_move_joint = (issue == 0)
如果can_move_joints:
Joints_valid =关节
print(“找到有效接头!”)+ str (joints_valid))
其他:
#跳过这一点
print("Use" + str(newtarget_joint)+"instead")


#确保我们有一个共同的目标和一个共同的运动
newtarget. setasjointttarget() #默认行为

设置关节目标的姿势并不重要，除非我们想要检索姿势
或者我们想使用笛卡尔坐标进行后期处理
newtarget.setPose (newtarget_pose)

确保我们在关节目标的姿势之后设置关节，因为它可能会重新计算姿势
newtarget.setJoints (newtarget_joints)

添加关节运动
program_or_robot.MoveJ (newtarget)

记住最后一个动作的关节位置
lastjoint = newtarget_joint

#在最后显示指令更快:
prog.ShowInstructions(真正的)

隐藏目标更干净，更难以意外移动目标
# prog.ShowTargets(假)

print('程序用%i目标完成' % ntargets)