四足机器人vrep和python仿真的问题

把课程的代码移植到了python上，但实现不了课程中的仿真，不知道什么问题，有大佬能帮忙看下吗？代码如下

import sim
import time
import numpy as np
import gait_plan
import inverse_kinematics

print('Program started')
sim.simxFinish(-1)
clientID = sim.simxStart('127.0.0.1', 19999, True, True, 5000, 5)
if clientID != -1:
    print('Connected to remote API server')

    # Now try to retrieve data in a blocking fashion (i.e. a service call):
    res, objs = sim.simxGetObjects(clientID, sim.sim_handle_all, sim.simx_opmode_blocking)
    if res == sim.simx_return_ok:
        print('Number of objects in the scene: ', len(objs))
    else:
        print('Remote API function call returned with error code: ', res)

    # time.sleep(2)
    sim.simxStartSimulation(clientID, sim.simx_opmode_oneshot)  # 开启仿真
    res, lb_rot_1 = sim.simxGetObjectHandle(clientID, 'lb_rot_1', sim.simx_opmode_blocking)
    res, lb_rot_2 = sim.simxGetObjectHandle(clientID, 'lb_rot_2', sim.simx_opmode_blocking)
    res, lb_rot_3 = sim.simxGetObjectHandle(clientID, 'lb_rot_3', sim.simx_opmode_blocking)
    res, lf_rot_1 = sim.simxGetObjectHandle(clientID, 'lf_rot_1', sim.simx_opmode_blocking)
    res, lf_rot_2 = sim.simxGetObjectHandle(clientID, 'lf_rot_2', sim.simx_opmode_blocking)
    res, lf_rot_3 = sim.simxGetObjectHandle(clientID, 'lf_rot_3', sim.simx_opmode_blocking)
    res, rb_rot_1 = sim.simxGetObjectHandle(clientID, 'rb_rot_1', sim.simx_opmode_blocking)
    res, rb_rot_2 = sim.simxGetObjectHandle(clientID, 'rb_rot_2', sim.simx_opmode_blocking)
    res, rb_rot_3 = sim.simxGetObjectHandle(clientID, 'rb_rot_3', sim.simx_opmode_blocking)
    res, rf_rot_1 = sim.simxGetObjectHandle(clientID, 'rf_rot_1', sim.simx_opmode_blocking)
    res, rf_rot_2 = sim.simxGetObjectHandle(clientID, 'rf_rot_2', sim.simx_opmode_blocking)
    res, rf_rot_3 = sim.simxGetObjectHandle(clientID, 'rf_rot_3', sim.simx_opmode_blocking)
    # 设置电机力矩
    # 第一条腿
    rb_rot_1_force = 70
    rb_rot_2_force = 70
    rb_rot_3_force = 70
    # 第二条腿
    rf_rot_1_force = 70
    rf_rot_2_force = 70
    rf_rot_3_force = 70
    # 第三条腿
    lb_rot_1_force = 70
    lb_rot_2_force = 70
    lb_rot_3_force = 70
    # 第四条腿
    lf_rot_1_force = 70
    lf_rot_2_force = 70
    lf_rot_3_force = 70

    # 设置电机角度参数
    # 第一条腿
    rb_rot_1_pos = 0
    rb_rot_2_pos = 0
    rb_rot_3_pos = 0
    # 第二条腿
    rf_rot_1_pos = 0
    rf_rot_2_pos = 0
    rf_rot_3_pos = 0
    # 第三条腿
    lb_rot_1_pos = 0
    lb_rot_2_pos = 0
    lb_rot_3_pos = 0
    # 第四条腿
    lf_rot_1_pos = 0
    lf_rot_2_pos = 0
    lf_rot_3_pos = 0

    # 设置电机力矩
    res = sim.simxSetJointMaxForce(clientID, lb_rot_1, lb_rot_1_force, sim.simx_opmode_blocking)
    res = sim.simxSetJointMaxForce(clientID, lb_rot_2, lb_rot_2_force, sim.simx_opmode_blocking)
    res = sim.simxSetJointMaxForce(clientID, lb_rot_3, lb_rot_3_force, sim.simx_opmode_blocking)
    res = sim.simxSetJointMaxForce(clientID, lf_rot_1, lf_rot_1_force, sim.simx_opmode_blocking)
    res = sim.simxSetJointMaxForce(clientID, lf_rot_2, lf_rot_2_force, sim.simx_opmode_blocking)
    res = sim.simxSetJointMaxForce(clientID, lf_rot_3, lf_rot_3_force, sim.simx_opmode_blocking)
    res = sim.simxSetJointMaxForce(clientID, rb_rot_1, rb_rot_1_force, sim.simx_opmode_blocking)
    res = sim.simxSetJointMaxForce(clientID, rb_rot_2, rb_rot_2_force, sim.simx_opmode_blocking)
    res = sim.simxSetJointMaxForce(clientID, rb_rot_3, rb_rot_3_force, sim.simx_opmode_blocking)
    res = sim.simxSetJointMaxForce(clientID, rf_rot_1, rf_rot_1_force, sim.simx_opmode_blocking)
    res = sim.simxSetJointMaxForce(clientID, rf_rot_2, rf_rot_2_force, sim.simx_opmode_blocking)
    res = sim.simxSetJointMaxForce(clientID, rf_rot_3, rf_rot_3_force, sim.simx_opmode_blocking)
    time.sleep(1)

    startTime = time.time()
    # print('startTime:{}'.format(startTime))
    # 当前时间
    currentTime = 0
    # 步态标志位
    gait_state = 2
    lb_x = 0
    rb_x = 0
    lf_x = 0
    rf_x = 0
    lb_z = 0
    rf_z = 0
    lf_z = 0
    rb_z = 0
    sim_time = 0
    sim_realtime = 0
    while currentTime < 100:
        currentTime = time.time()
        currentTime = np.around(currentTime - startTime, 3)
        # print('currentTime:{}'.format(currentTime))
        if currentTime < 5:
            # walk步态
            if gait_state == 2:
                lb_x = -0.1
                rb_x = -0.1
                lf_x = 0.1
                rf_x = 0.1
                lb_z = -0.482
                rf_z = -0.482
                lf_z = -0.482
                rb_z = -0.482
                pass
            # trot步态
            elif gait_state == 1:
                lb_x = -0.1
                rb_x = 0.1
                lf_x = 0.1
                rf_x = -0.1
                lb_z = -0.482
                rf_z = -0.482
                lf_z = -0.482
                rb_z = -0.482
                pass
            rec, sim_time = np.around(sim.simxGetFloatSignal(clientID, 'time',
                                                             sim.simx_opmode_blocking), 2)
            
            print('sim_time：{}'.format(sim_time))

        else:
            res, sim_realtime = np.around(sim.simxGetFloatSignal(clientID, 'time',
                                                                 sim.simx_opmode_blocking), 2)
            
            print('sim_realtime：{}'.format(sim_realtime))

            if gait_state == 2:
                T = 1
                time1 = np.around(sim_realtime - sim_time, 2)
                time2 = np.around(sim_realtime - sim_time + 0.25, 2)
                time3 = np.around(sim_realtime - sim_time + 0.5, 2)
                time4 = np.around(sim_realtime - sim_time + 0.75, 2)
                
                # print(
                #     'time1:{}'.format(time1) + 'time2:{}'.format(time2) + 'time3:{}'.format(time3) + 'time4:{}'.format(
                #         time4))
                T1 = np.around(np.mod(time1, T), 2)
                T2 = np.around(np.mod(time2, T), 2)
                T3 = np.around(np.mod(time3, T), 2)
                T4 = np.around(np.mod(time4, T), 2)

                lb_x, lb_z = gait_plan.gait_plan(T1, T)
                rf_x, rf_z = gait_plan.gait_plan(T2, T)
                rb_x, rb_z = gait_plan.gait_plan(T3, T)
                lf_x, lf_z = gait_plan.gait_plan(T4, T)
                # print('lb_x:{}'.format(lb_x) + 'lb_z:{}'.format(lb_z) + 'rf_x:{}'.format(rf_x) + 'rf_z:{}'.format(
                #     rf_z) + 'rb_x{}:'.format(rb_x) + 'rb_z:{}'.format(rb_z) + 'lf_x:{}'.format(lf_x) + 'lf_z:{}'.format(
                #     lf_z))
                time1 = time1
                time2 = time2 + 0.25
                time3 = time3 + 0.5
                time4 = time4 + 0, 75
                pass
            elif gait_state == 1:
                T = 0.4
                time1 = sim_realtime - sim_time
                T1 = np.mod(time1, T)
                time2 = sim_realtime - sim_time + 0.2
                T2 = np.mod(time2, T)
                lb_x, lb_z = gait_plan.gait_plan(T1, T)
                rf_x, rf_z = gait_plan.gait_plan(T1, T)
                rb_x, rb_z = gait_plan.gait_plan(T2, T)
                lf_x, lf_z = gait_plan.gait_plan(T2, T)
                pass
            pass

        # 单腿逆运动学
        lb_rot_1_pos, lb_rot_2_pos, lb_rot_3_pos = inverse_kinematics.inverse_kinematic(lb_x, -0.15, lb_z)
        lf_rot_1_pos, lf_rot_2_pos, lf_rot_3_pos = inverse_kinematics.inverse_kinematic(lf_x, -0.15, lf_z)
        rb_rot_1_pos, rb_rot_2_pos, rb_rot_3_pos = inverse_kinematics.inverse_kinematic(rb_x, -0.15, rb_z)
        rf_rot_1_pos, rf_rot_2_pos, rf_rot_3_pos = inverse_kinematics.inverse_kinematic(rf_x, -0.15, lf_z)
        rec = sim.simxSetJointTargetPosition(clientID, lb_rot_1, -lb_rot_1_pos, sim.simx_opmode_oneshot)
        rec = sim.simxSetJointTargetPosition(clientID, lb_rot_2, lb_rot_2_pos, sim.simx_opmode_oneshot)
        rec = sim.simxSetJointTargetPosition(clientID, lb_rot_3, lb_rot_3_pos, sim.simx_opmode_oneshot)
        rec = sim.simxSetJointTargetPosition(clientID, rf_rot_1, rf_rot_1_pos, sim.simx_opmode_oneshot)
        rec = sim.simxSetJointTargetPosition(clientID, rf_rot_2, rf_rot_2_pos, sim.simx_opmode_oneshot)
        rec = sim.simxSetJointTargetPosition(clientID, rf_rot_3, rf_rot_3_pos, sim.simx_opmode_oneshot)
        rec = sim.simxSetJointTargetPosition(clientID, rb_rot_1, -rb_rot_1_pos, sim.simx_opmode_oneshot)
        rec = sim.simxSetJointTargetPosition(clientID, rb_rot_2, rb_rot_2_pos, sim.simx_opmode_oneshot)
        rec = sim.simxSetJointTargetPosition(clientID, rb_rot_3, rb_rot_3_pos, sim.simx_opmode_oneshot)
        rec = sim.simxSetJointTargetPosition(clientID, lf_rot_1, lf_rot_1_pos, sim.simx_opmode_oneshot)
        rec = sim.simxSetJointTargetPosition(clientID, lf_rot_2, lf_rot_2_pos, sim.simx_opmode_oneshot)
        rec = sim.simxSetJointTargetPosition(clientID, lf_rot_3, lf_rot_3_pos, sim.simx_opmode_oneshot)
        pass
    sim.simxStopSimulation(clientID, sim.simx_opmode_blocking)
    sim.simxFinish(clientID)
else:
    print('Failed connecting to remote API server')
    pass
print('Program ended')