V-REP和Python的联合仿真

最新推荐文章于 2024-04-30 19:24:04 发布
最新推荐文章于 2024-04-30 19:24:04 发布
阅读量395 收藏 4
点赞数 1
文章标签： python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40679158/article/details/134252751
版权

机器人仿真软件 各类免费的的机器人仿真软件优缺点汇总_robot 仿真 软件收费么_dyannacon的博客-CSDN博客

课程地址 https://class.guyuehome.com/p/t_pc/course_pc_detail/column/p_605af87be4b007b4183a42e7

课程资料 guyueclass: 古月学院课程代码

旋转变换 旋转的左乘与右乘 - 知乎

四足机器人站立控制原理 【基础知识】四足机器人的站立姿态控制原理 - 知乎

单腿逆解参考 https://github.com/richardbloemenkamp/Robotdog

Vrep文档

Vrep放大object

Vrep 导入模型步骤：

1. plugins-->urdf import导入机器人URDF文件

2. 删除机器人对象中的world_joint和world_link_visual

3. 双击设置机器人参数

碰撞参数设置：body参数设置，自身碰撞勾选前四个勾，leg参数设置，自身碰撞勾选后四个勾，即不计算与自身的碰撞关系

设置关节参数

调节颜色

python联合仿真

remote API路径：C:\Program Files\CoppeliaRobotics\CoppeliaSimEdu\programming\remoteApiBindings

1. 选择仿真器

2. 创建Vrep脚本用于远程连接

3. 绑定脚本到机器人

4. 编辑脚本，添加远程连接代码

4. 编写python脚本并测试（将腿部足端位置转换为关节的角度）

连接V-REP需要从remote API路径拷贝相关文件

"""
连接VREP Server并测试控制四足机器人
"""
try:
    import sim
except ImportError:
    print('--------------------------------------------------------------')
    print('"sim.py" could not be imported. This means very probably that')
    print('either "sim.py" or the remoteApi library could not be found.')
    print('Make sure both are in the same folder as this file,')
    print('or appropriately adjust the file "sim.py"')
    print('--------------------------------------------------------------')
    print('')

    sim = None

import time
import numpy as np


def start_simulation():
    sim.simxFinish(-1)
    # 开启套接字与server进行通信
    clientID = sim.simxStart('127.0.0.1', 19999, True, True, 5000, 5)
    if clientID != -1:
        print('Connected to remote API server with ClientID ', clientID)
        # 开始模拟
        sim.simxStartSimulation(clientID, sim.simx_opmode_oneshot)

        return clientID
    else:
        return -1


def get_joints(client_id):
    # 机器人电机力矩参数
    rotation_forces = [
        # RB
        [500, 500, 500],
        # RF
        [500, 500, 500],
        # LB
        [500, 500, 500],
        # LF
        [500, 500, 500]
    ]

    # 获取机器人关节对象句柄
    rec, rb_rot_1 = sim.simxGetObjectHandle(client_id, 'rb_rot_1', sim.simx_opmode_blocking)
    rec, rb_rot_2 = sim.simxGetObjectHandle(client_id, 'rb_rot_2', sim.simx_opmode_blocking)
    rec, rb_rot_3 = sim.simxGetObjectHandle(client_id, 'rb_rot_3', sim.simx_opmode_blocking)

    rec, rf_rot_1 = sim.simxGetObjectHandle(client_id, 'rf_rot_1', sim.simx_opmode_blocking)
    rec, rf_rot_2 = sim.simxGetObjectHandle(client_id, 'rf_rot_2', sim.simx_opmode_blocking)
    rec, rf_rot_3 = sim.simxGetObjectHandle(client_id, 'rf_rot_3', sim.simx_opmode_blocking)

    rec, lb_rot_1 = sim.simxGetObjectHandle(client_id, 'lb_rot_1', sim.simx_opmode_blocking)
    rec, lb_rot_2 = sim.simxGetObjectHandle(client_id, 'lb_rot_2', sim.simx_opmode_blocking)
    rec, lb_rot_3 = sim.simxGetObjectHandle(client_id, 'lb_rot_3', sim.simx_opmode_blocking)

    rec, lf_rot_1 = sim.simxGetObjectHandle(client_id, 'lf_rot_1', sim.simx_opmode_blocking)
    rec, lf_rot_2 = sim.simxGetObjectHandle(client_id, 'lf_rot_2', sim.simx_opmode_blocking)
    rec, lf_rot_3 = sim.simxGetObjectHandle(client_id, 'lf_rot_3', sim.simx_opmode_blocking)

    # 设置电机力矩
    rec = sim.simxSetJointForce(client_id, rb_rot_1, rotation_forces[0][0], sim.simx_opmode_blocking)
    rec = sim.simxSetJointForce(client_id, rb_rot_2, rotation_forces[0][1], sim.simx_opmode_blocking)
    rec = sim.simxSetJointForce(client_id, rb_rot_3, rotation_forces[0][2], sim.simx_opmode_blocking)

    rec = sim.simxSetJointForce(client_id, rf_rot_1, rotation_forces[1][0], sim.simx_opmode_blocking)
    rec = sim.simxSetJointForce(client_id, rf_rot_2, rotation_forces[1][1], sim.simx_opmode_blocking)
    rec = sim.simxSetJointForce(client_id, rf_rot_3, rotation_forces[1][2], sim.simx_opmode_blocking)

    rec = sim.simxSetJointForce(client_id, lb_rot_1, rotation_forces[2][0], sim.simx_opmode_blocking)
    rec = sim.simxSetJointForce(client_id, lb_rot_2, rotation_forces[2][1], sim.simx_opmode_blocking)
    rec = sim.simxSetJointForce(client_id, lb_rot_3, rotation_forces[2][2], sim.simx_opmode_blocking)

    rec = sim.simxSetJointForce(client_id, lf_rot_1, rotation_forces[3][0], sim.simx_opmode_blocking)
    rec = sim.simxSetJointForce(client_id, lf_rot_2, rotation_forces[3][1], sim.simx_opmode_blocking)
    rec = sim.simxSetJointForce(client_id, lf_rot_3, rotation_forces[3][2], sim.simx_opmode_blocking)

    return [rb_rot_1, rb_rot_2, rb_rot_3], \
           [rf_rot_1, rf_rot_2, rf_rot_3], \
           [lb_rot_1, lb_rot_2, lb_rot_3], \
           [lf_rot_1, lf_rot_2, lf_rot_3]


def leg_inverse_kine(x, y, z):
    # h,hu和hl分别是单条腿杆件的长度
    h = 0.15
    hu = 0.35
    hl = 0.382
    dyz = np.sqrt(y**2 + z**2)
    lyz = np.sqrt(dyz**2 - h**2)
    gamma_yz = -np.arctan(y/z)
    gamma_h_offset = -np.arctan(h/lyz)
    gamma = gamma_yz - gamma_h_offset

    lxzp = np.sqrt(lyz**2 + x**2)
    n = (lxzp**2 - hl**2 - hu**2) / (2 * hu)
    beta = -np.arccos(n / hl)

    alfa_xzp = -np.arctan(x/lyz)
    alfa_off = np.arccos((hu + n) / lxzp)
    alfa = alfa_xzp + alfa_off

    return gamma, alfa, beta


if __name__ == '__main__':
    # 机器人电机角度参数
    rb_poses = [40*np.pi/180, 0, 0]
    rf_poses = [0, 0, 0]
    lb_poses = [0, 0, 0]
    lf_poses = [0, 0, 0]

    client_id = start_simulation()
    if client_id != -1:
        joints = get_joints(client_id)
        rb_joints = joints[0]
        rf_joints = joints[1]
        lb_joints = joints[2]
        lf_joints = joints[3]

        time.sleep(1)
        timeout = 60
        start_time = time.time()
        curr_time = time.time()

        # 初始关节角度
        rb_poses = leg_inverse_kine(0, -0.3, -0.632)
        rf_poses = leg_inverse_kine(0, -0.3, -0.632)
        lb_poses = leg_inverse_kine(0, -0.3, -0.632)
        lf_poses = leg_inverse_kine(0, -0.3, -0.632)

        while curr_time - start_time < timeout:
            # 设置关节角度
            rec = sim.simxSetJointTargetPosition(client_id, rb_joints[0], -rb_poses[0], sim.simx_opmode_oneshot)
            rec = sim.simxSetJointTargetPosition(client_id, rb_joints[1], rb_poses[1], sim.simx_opmode_oneshot)
            rec = sim.simxSetJointTargetPosition(client_id, rb_joints[2], rb_poses[2], sim.simx_opmode_oneshot)

            rec = sim.simxSetJointTargetPosition(client_id, rf_joints[0], rf_poses[0], sim.simx_opmode_oneshot)
            rec = sim.simxSetJointTargetPosition(client_id, rf_joints[1], rf_poses[1], sim.simx_opmode_oneshot)
            rec = sim.simxSetJointTargetPosition(client_id, rf_joints[2], rf_poses[2], sim.simx_opmode_oneshot)

            rec = sim.simxSetJointTargetPosition(client_id, lb_joints[0], -lb_poses[0], sim.simx_opmode_oneshot)
            rec = sim.simxSetJointTargetPosition(client_id, lb_joints[1], lb_poses[1], sim.simx_opmode_oneshot)
            rec = sim.simxSetJointTargetPosition(client_id, lb_joints[2], lb_poses[2], sim.simx_opmode_oneshot)

            rec = sim.simxSetJointTargetPosition(client_id, lf_joints[0], lf_poses[0], sim.simx_opmode_oneshot)
            rec = sim.simxSetJointTargetPosition(client_id, lf_joints[1], lf_poses[1], sim.simx_opmode_oneshot)
            rec = sim.simxSetJointTargetPosition(client_id, lf_joints[2], lf_poses[2], sim.simx_opmode_oneshot)

            curr_time = time.time()
            # print("curr time :", curr_time - start_time)

        # 完成模拟
        sim.simxStopSimulation(client_id, sim.simx_opmode_blocking)
        sim.simxFinish(client_id)
    else:
        print('Failed connecting to remote API server')

显示足端轨迹

1. 打开shape编辑模式，并在vertex编辑模式下选择节点，在添加dummy

将dummy移动到腿部object下

2. 添加图用于创建curve

3. 设置3D Curve

4. 修改位置控制速度上限（将速度上限修改为500）

步态控制

utils.py

import sim
import numpy as np


def start_simulation():
    sim.simxFinish(-1)
    # 开启套接字与server进行通信
    clientID = sim.simxStart('127.0.0.1', 19999, True, True, 5000, 5)
    if clientID != -1:
        print('Connected to remote API server with ClientID ', clientID)
        # 开始模拟
        sim.simxStartSimulation(clientID, sim.simx_opmode_oneshot)

        return clientID
    else:
        return -1


def get_joints(client_id):
    # 机器人电机力矩参数
    rotation_forces = [
        # RB
        [500, 500, 500],
        # RF
        [500, 500, 500],
        # LB
        [500, 500, 500],
        # LF
        [500, 500, 500]
    ]

    # 获取机器人关节对象句柄
    rec, rb_rot_1 = sim.simxGetObjectHandle(client_id, 'rb_rot_1', sim.simx_opmode_blocking)
    rec, rb_rot_2 = sim.simxGetObjectHandle(client_id, 'rb_rot_2', sim.simx_opmode_blocking)
    rec, rb_rot_3 = sim.simxGetObjectHandle(client_id, 'rb_rot_3', sim.simx_opmode_blocking)

    rec, rf_rot_1 = sim.simxGetObjectHandle(client_id, 'rf_rot_1', sim.simx_opmode_blocking)
    rec, rf_rot_2 = sim.simxGetObjectHandle(client_id, 'rf_rot_2', sim.simx_opmode_blocking)
    rec, rf_rot_3 = sim.simxGetObjectHandle(client_id, 'rf_rot_3', sim.simx_opmode_blocking)

    rec, lb_rot_1 = sim.simxGetObjectHandle(client_id, 'lb_rot_1', sim.simx_opmode_blocking)
    rec, lb_rot_2 = sim.simxGetObjectHandle(client_id, 'lb_rot_2', sim.simx_opmode_blocking)
    rec, lb_rot_3 = sim.simxGetObjectHandle(client_id, 'lb_rot_3', sim.simx_opmode_blocking)

    rec, lf_rot_1 = sim.simxGetObjectHandle(client_id, 'lf_rot_1', sim.simx_opmode_blocking)
    rec, lf_rot_2 = sim.simxGetObjectHandle(client_id, 'lf_rot_2', sim.simx_opmode_blocking)
    rec, lf_rot_3 = sim.simxGetObjectHandle(client_id, 'lf_rot_3', sim.simx_opmode_blocking)

    # 设置电机力矩
    rec = sim.simxSetJointForce(client_id, rb_rot_1, rotation_forces[0][0], sim.simx_opmode_blocking)
    rec = sim.simxSetJointForce(client_id, rb_rot_2, rotation_forces[0][1], sim.simx_opmode_blocking)
    rec = sim.simxSetJointForce(client_id, rb_rot_3, rotation_forces[0][2], sim.simx_opmode_blocking)

    rec = sim.simxSetJointForce(client_id, rf_rot_1, rotation_forces[1][0], sim.simx_opmode_blocking)
    rec = sim.simxSetJointForce(client_id, rf_rot_2, rotation_forces[1][1], sim.simx_opmode_blocking)
    rec = sim.simxSetJointForce(client_id, rf_rot_3, rotation_forces[1][2], sim.simx_opmode_blocking)

    rec = sim.simxSetJointForce(client_id, lb_rot_1, rotation_forces[2][0], sim.simx_opmode_blocking)
    rec = sim.simxSetJointForce(client_id, lb_rot_2, rotation_forces[2][1], sim.simx_opmode_blocking)
    rec = sim.simxSetJointForce(client_id, lb_rot_3, rotation_forces[2][2], sim.simx_opmode_blocking)

    rec = sim.simxSetJointForce(client_id, lf_rot_1, rotation_forces[3][0], sim.simx_opmode_blocking)
    rec = sim.simxSetJointForce(client_id, lf_rot_2, rotation_forces[3][1], sim.simx_opmode_blocking)
    rec = sim.simxSetJointForce(client_id, lf_rot_3, rotation_forces[3][2], sim.simx_opmode_blocking)

    return [rb_rot_1, rb_rot_2, rb_rot_3], \
           [rf_rot_1, rf_rot_2, rf_rot_3], \
           [lb_rot_1, lb_rot_2, lb_rot_3], \
           [lf_rot_1, lf_rot_2, lf_rot_3]


def leg_inverse_kine(x, y, z):
    """
    求四足机器人单条腿的逆运动学，输入足端位置，返回单腿关节的旋转的角度
    """
    # h,hu和hl分别是单条腿杆件的长度
    h = 0.15
    hu = 0.35
    hl = 0.382
    dyz = np.sqrt(y ** 2 + z ** 2)
    lyz = np.sqrt(dyz ** 2 - h ** 2)
    gamma_yz = -np.arctan(y / z)
    gamma_h_offset = -np.arctan(h / lyz)
    gamma = gamma_yz - gamma_h_offset

    lxzp = np.sqrt(lyz ** 2 + x ** 2)
    n = (lxzp ** 2 - hl ** 2 - hu ** 2) / (2 * hu)
    beta = -np.arccos(n / hl)

    alfa_xzp = -np.arctan(x / lyz)
    alfa_off = np.arccos((hu + n) / lxzp)
    alfa = alfa_xzp + alfa_off

    return gamma, alfa, beta


def pose_control(roll, pitch, yaw, pos_x, pos_y, pos_z):
    """
    输入
    """
    b = 0.4
    l = 0.8
    w = 0.7
    # 基座的高度
    h = 0.732

    # 转换角度
    R = roll * np.pi / 180
    P = pitch * np.pi / 180
    Y = yaw * np.pi / 180

    pos = np.mat([pos_x, pos_y, pos_z]).T

    # 定义旋转矩阵
    rotx = np.mat([[1, 0, 0],
                   [0, np.cos(R), -np.sin(R)],
                   [0, np.sin(R), np.cos(R)]])

    roty = np.mat([[np.cos(P), 0, -np.sin(P)],
                   [0, 1, 0],
                   [np.sin(P), 0, np.cos(P)]])

    rotz = np.mat([[np.cos(Y), -np.sin(Y), 0],
                   [np.sin(Y), np.cos(Y), 0],
                   [0, 0, 1]])

    rot_mat = rotx * roty * rotz

    # 基座位置
    body_struct = np.mat([[l / 2, b / 2, h],
                          [l / 2, -b / 2, h],
                          [-l / 2, b / 2, h],
                          [-l / 2, -b / 2, h]]).T

    # 足端位置
    footpoint_struct = np.mat([[l / 2, w / 2, 0],
                               [l / 2, -w / 2, 0],
                               [-l / 2, w / 2, 0],
                               [-l / 2, -w / 2, 0]]).T

    leg_pose = np.mat(np.zeros((3, 4)))

    for i in range(4):
        leg_pose[:, i] = -pos - rot_mat * body_struct[:, i] + footpoint_struct[:, i]

    return np.squeeze(np.array(leg_pose[:, 3])), np.squeeze(np.array(leg_pose[:, 0])), \
           np.squeeze(np.array(leg_pose[:, 1])), np.squeeze(np.array(leg_pose[:, 2]))


def cycloid(dt: float, period: float = 1.0, xs: float = -0.1, xf: float = 0.1, zs: float = -0.582, h: float = 0.1):
    """
    计算摆线上在给定时间t处的坐标。

    参数：
    t (float): 当前时间点
    Ts (float): 摆线运动总时间，默认为1.0
    xs (float): 起始x坐标，默认为-0.1
    xf (float): 终点x坐标，默认为0.1
    zs (float): 起始z坐标，默认为-0.582
    h (float): 摆线垂直位移，默认为0.1

    返回：
    tuple[float, float]: xep和zep的坐标值
    """
    sigma = 2 * np.pi * dt / period
    x_p = (xf - xs) * ((sigma - np.sin(sigma)) / (2 * np.pi)) + xs
    y_p = h * (1 - np.cos(sigma)) / 2 + zs
    return x_p, y_p


if __name__ == '__main__':
    for pos in pose_control(30, 0, 0, 0, 0, 0.732):
        print(pos)

main.py

import time
from utils import *

walk_period = 1.0
trot_period = 0.4

gait = 1


def cal_phase(dt, T, factor, zs = -0.482, h = 0.15):
    if dt < T * factor:
        return cycloid(dt, period=T * factor, zs=zs, h=h)
    else:
        return 0.1 - 0.2 / (T * (1 - factor)) * (dt - T * factor), zs


def walk_gait(dt):
    zs = -0.482
    h = 0.15

    lb_dt = dt % walk_period
    rf_dt = (dt + 0.25) % walk_period
    rb_dt = (dt + 0.5) % walk_period
    lf_dt = (dt + 0.75) % walk_period

    lb_pos = cal_phase(lb_dt, T=walk_period, factor=0.25, zs=zs, h=h)
    rf_pos = cal_phase(rf_dt, T=walk_period, factor=0.25, zs=zs, h=h)
    rb_pos = cal_phase(rb_dt, T=walk_period, factor=0.25, zs=zs, h=h)
    lf_pos = cal_phase(lf_dt, T=walk_period, factor=0.25, zs=zs, h=h)

    return lb_pos, rf_pos, rb_pos, lf_pos


def trot_gait(dt):
    zs = -0.482
    h = 0.1

    dt_1 = dt % trot_period
    dt_2 = (dt + 0.2) % trot_period

    pos_1 = cal_phase(dt_1, T=trot_period, factor=0.5, zs=zs, h=h)
    pos_2 = cal_phase(dt_2, T=trot_period, factor=0.5, zs=zs, h=h)
    return pos_1, pos_2


if __name__ == '__main__':
    # 连接到V-REP服务器
    clientID = start_simulation()

    # 检查连接是否成功
    if clientID != -1:
        joints = get_joints(clientID)
        rb_joints = joints[0]
        rf_joints = joints[1]
        lb_joints = joints[2]
        lf_joints = joints[3]

        timeout = 60
        start_time = time.time()
        curr_time = start_time

        sim_start_time, sim_curr_time = None, None
        lb_pos, rf_pos, rb_pos, lf_pos = None, None, None, None

        # 获取仿真时间
        while curr_time - start_time < timeout:
            res, sim_curr_time = sim.simxGetFloatSignal(clientID, 'time', sim.simx_opmode_oneshot)
            if res == sim.simx_return_ok:
                if sim_start_time is None:
                    sim_start_time = sim_curr_time

                print("time ", sim_curr_time - sim_start_time)

            if sim_start_time:
                dt = sim_curr_time - sim_start_time
                if gait == 0:
                    # dt = (sim_curr_time - sim_start_time) % walk_period
                    lb_pos, rf_pos, rb_pos, lf_pos = walk_gait(dt)
                elif gait == 1:
                    # dt = (sim_curr_time - sim_start_time) % trot_period
                    pos_1, pos_2 = trot_gait(dt)
                    lb_pos = pos_1
                    rf_pos = pos_1
                    rb_pos = pos_2
                    lf_pos = pos_2

                # 从足端位置求解关节角度
                rb_pose = leg_inverse_kine(rb_pos[0], -0.15, rb_pos[1])
                rf_pose = leg_inverse_kine(rf_pos[0], -0.15, rf_pos[1])
                lb_pose = leg_inverse_kine(lb_pos[0], -0.15, lb_pos[1])
                lf_pose = leg_inverse_kine(lf_pos[0], -0.15, lf_pos[1])

                rec = sim.simxSetJointTargetPosition(clientID, rb_joints[0], -rb_pose[0], sim.simx_opmode_oneshot)
                rec = sim.simxSetJointTargetPosition(clientID, rb_joints[1], rb_pose[1], sim.simx_opmode_oneshot)
                rec = sim.simxSetJointTargetPosition(clientID, rb_joints[2], rb_pose[2], sim.simx_opmode_oneshot)

                rec = sim.simxSetJointTargetPosition(clientID, rf_joints[0], rf_pose[0], sim.simx_opmode_oneshot)
                rec = sim.simxSetJointTargetPosition(clientID, rf_joints[1], rf_pose[1], sim.simx_opmode_oneshot)
                rec = sim.simxSetJointTargetPosition(clientID, rf_joints[2], rf_pose[2], sim.simx_opmode_oneshot)

                rec = sim.simxSetJointTargetPosition(clientID, lb_joints[0], -lb_pose[0], sim.simx_opmode_oneshot)
                rec = sim.simxSetJointTargetPosition(clientID, lb_joints[1], lb_pose[1], sim.simx_opmode_oneshot)
                rec = sim.simxSetJointTargetPosition(clientID, lb_joints[2], lb_pose[2], sim.simx_opmode_oneshot)

                rec = sim.simxSetJointTargetPosition(clientID, lf_joints[0], lf_pose[0], sim.simx_opmode_oneshot)
                rec = sim.simxSetJointTargetPosition(clientID, lf_joints[1], lf_pose[1], sim.simx_opmode_oneshot)
                rec = sim.simxSetJointTargetPosition(clientID, lf_joints[2], lf_pose[2], sim.simx_opmode_oneshot)

        # 停止仿真并断开与V-REP的连接
        sim.simxStopSimulation(clientID, sim.simx_opmode_oneshot)
        sim.simxFinish(clientID)

    else:
        print("无法连接到V-REP")

walk步态

trot步态

-朝汐-
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
vrep和python联合仿真资料.zip
03-27
建议电脑端打开该网页免积分下载！手机端可能会显示vip专享 vrep和python联合仿真资料，配套讲解视频：https://www.bilibili.com/video/BV1z7411X7aK/
Python与V-REP联合仿真
weixin_46931550的博客
03-02 586
python与Vrep联合仿真
【CoppeliaSim】Vrep与Python实现联合控制的通讯问题
See_Star的博客
07-15 2619
本文主要介绍如何将CoppeliaSim与Python联合起来进行仿真， 针对于他们直接的联合控制进行配置。 一、The B0-based remote API 这是官方对两个API的说明： 链接：https://www.coppeliarobotics.com/helpFiles/en/remoteApiOverview.htm 基于B0的远程API：这表示远程API的第二个版本。 它基于BlueZero中间件及其CoppeliaSim的接口插件。 与传统的远程API相比，它更易于使用且更具灵活性，最
Vrep+Python实现小车运动仿真
zihan_li的博客
01-04 827
Vrep官网下载速度比较慢这里推荐网盘下载coppeliasim/vrep官网软件安装包（免费百度网盘链接）-CSDN博客我ubuntu系统版本用的18.04，这里下载的是4.0版本的，经过测试最新的4.5版本在进行多台AGV控制的时候，出现了无法获取句柄。而且网上资料也多是旧版本的。下载完之后解压，并配置环境 ubuntu使用命令vrep打开软件需要在安装目录导出3个文件如果Vrep3.6版本1.找到 vrep.py和 vrepConst.py两个文件安装目录/programming/remoteAp
[vrep]与python建立通讯
weixin_43164804的博客
11-01 271
问题01：无法控制部分关节的角度 原因：关节配置没有修改 control loop enabled也需要点上
V-rep（CoppeliaSim）添加相机，与python联合仿真，并使用python读取V-rep中的RGB图与深度图
weixin_41837701的博客
12-28 2362
本文主要介绍了如何使用python与V-rep联合仿真，并用OpenCV可视化V-rep中视觉传感器所能看到的 **RGB图**和**深度
疫情让我使用V-rep仿真（结合pythonAPI）实现机器人视觉巡线+pid调速，
锡城小凯的博客
04-07 9885
因为疫情原因，在家上网课。因为放假前完全没有想到会放如此长的‘假’，所以我把所有学习用的开发板、硬件、开发教程书籍都放在了学校实验室里，从而现在不但不能在家做实物，也不能去学校做实物的尴尬情形。随后因为一门课（计算机控制技术）改变了这种尴尬的情形。 张老师推荐我们使用Vrep进行机器人仿真，并且实现pid控制，于是乎我马上利用空闲时间研究了这款软件，做了机器人视觉巡线+...
python机器人编程——VREP数字孪生四轴机械臂联合仿真
JAMES费的空间
06-06 4376
本篇利用前期对机械臂的运动控制python编程基础上，构建一个三轴机械臂仿真系统，系统使用vrep环境及内置的三轴机械臂模型与python进行通讯实现。最终实现python控制的机械臂的抓取。
python机器人编程——差速AGV机器人VREP仿真python联动控制实现
JAMES费的空间
09-30 3964
本篇是《python机器人编程——差速机器人小车的控制，控制模型、轨迹跟踪，轨迹规划、自动泊车》系列的姊妹篇。来通过python去实现vrep下仿真小车的联动控制，为该篇提出的无人控制方法提供一个验证的环境，从而可以完善相应的控制方式，进一步深入探索。
python联合vrep_vrep-python 控制方法
weixin_39599046的博客
12-22 1025
python控制程序 .py 文件控制vrep常常包括以下步骤：1.引入模块import vrep2.建立连接，先关闭上一次连接print(‘Program started‘)# Close potential connectionsvrep.simxFinish(-1)clientID = vrep.simxStart(‘127.0.0.1‘, 19997, True, True, 5000, ...
v-rep循迹小车－python远程控制
09-21
利用python远程控制v-rep循迹小车完成仿真，包含源码，场景文件和仿真视频
V-REP-YouBot-Demo：V-REP平台上的YouBot Control演示
02-03
基于V-REP平台的入门级教程及Demo，从零开始学习如何在V-REP平台上进行机器人的仿真和交互。我们定了一个小目标，完成一个Demo。使用官方提供的KUKA公司的YouBot机器人模型来实验机器人的感知和控制过程，控制机器人...
基于Matlab实现机器人仿真库（源码）.rar
05-06
1、资源内容：基于MATLAB作为外部API的V-Rep（CoppeliaSim）机器人仿真库（完整源码+说明文档+数据）.rar 2、代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 3、适用对象：计算机，电子信息...
V-rep仿真（结合pythonAPI）实现机器人视觉巡线+pid调速.zip
04-07
张老师推荐我们使用Vrep进行机器人仿真，并且实现pid控制，于是乎我马上利用空闲时间研究了这款软件，做了机器人视觉巡线+pid调速。 在实现视觉巡线之前我提交了多次作业，从简单的灰度巡线到视觉巡线。
python学习笔记----循环语句（四）
取个名字太难了a的博客
04-28 1008
随机数种子在生成随机数的过程中起到一个非常重要的作用。它是用于初始化随机数生成算法（伪随机数生成器）的初始值。随机数种子的作用可重复性：当你使用特定的种子值初始化随机数生成器时，即使在不同的运行环境或不同时间，生成的随机数序列都将是相同的。这对于调试和测试非常重要，因为它允许程序的行为在使用随机数时保持一致。控制随机性：种子提供了一种方法来控制随机数生成过程。通过改变种子，你可以获得不同的随机数序列，这对于模拟和其他需要随机输入的应用非常有用。
SpringBoot中实现发送邮件
最新发布
m0_64289188的博客
04-30 546
当你添加了spring-boot-starter-mail依赖后，Spring Boot会自动配置JavaMailSender实例，并根据application.yml文件中的属性来配置这个实例。你可以直接在需要发送邮件的地方通过@Autowired注解将JavaMailSender实例注入到你的类中，然后使用它来发送邮件。：首先，需要在你的pom.xml文件中添加Spring Boot的邮件发送器依赖。，简化了在Spring Boot应用程序中发送电子邮件的设置过程。Spring Boot的。
python复习（三）
qq_43710593的博客
04-29 341
类是一种面向。
链表刷题集
yajunjiao的专栏
04-30 519
本文主要列举了一些刷的题，不多，有那么几道，也建议各位去建立自己的刷题集。积少成多。
【python】python基础1
七月尘上
04-29 385
注释：单行注释：#多行注释：“”“”“”批量注释：ctl+?,取消注释继续执行一次就行标识符命名规范：1、变量名、类名、函数名只能由数字、字母、下划线组成2、不能以数字开头3、严格区分大小写4、不能以关键字命名定义变量的方式：1、var1 = 值12、var1,var2=值1，值23、var1,var2=值1交换两个变量的值：输出命令解析：sep:输出内容以什么进行分割end:输出以什么结尾file:输出内容以文件形式输出到指定文件。
v-rep简单循迹小车仿真
04-29
好的，以下是实现简单循迹小车仿真的步骤： 1. 下载和安装V-REP仿真软件，选择适合你操作系统的版本。 2. 在V-REP中创建一个新场景，然后添加一个小车模型。可以从V-REP自带的模型库中选择一个或者自己创建一个。 3. 添加一个视觉传感器，用于检测小车前方的黑线，以及两个轮子的驱动。可以使用V-REP自带的传感器模型，或者自己创建一个。 4. 编写控制小车的程序。可以使用Lua或Python脚本语言来编写程序。程序应该包括以下步骤： a. 读取视觉传感器的数据，检测小车前方是否有黑线。 b. 如果有黑线，则调整轮子的角度，使小车沿着黑线行驶。 c. 如果没有黑线，则直行或者转弯，直到找到下一条黑线为止。 5. 运行程序，在V-REP中观察小车是否能够沿着黑线行驶。 以上就是实现简单循迹小车仿真的步骤。希望能对你有所帮助。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值