Webots搭建强化学习二轮避障小车

1 新建一个项目

向导→新项目目录

 

 

 完成创建之后的样子如下

 2 创建二轮小车实体：
        按照下图中图示的顺序创建一个机器人节点

然后在创建的机器人节点中的孩子节点（children node）下，添加一个transform节点。这个是为后续添加boundingObject做准备的，操作过程如下（注意添加transform之后将translation中y坐标的值设置为0.1或者其他的正值，将robot节点的坐标系抬高，要不然创建出来的实体会一半嵌进地里）：

 修改transform节点的坐标 translation，将y值设置为0.1，上移坐标的位置

 然后在创建的transform节点下的children节点添加一个Shape，后面并通过这个shape选择一个形状，将会选一个圆柱，操作如下：

 

 添加圆柱并设置圆柱的外观显示。单纯添加圆柱为白色，添加外观设置之后可视化效果更好

 

 外观设置中，2，3，4步骤为对应的选项，操作2中颜色自选，操作3中Value可以设置为1，操作4设置为0，就可以得到下面这个柱子

 然后修改圆柱的大小，将高度设置为5cm，对应里面的坐标为0.05，圆柱的半径设置为0.035，即3.5cm。

 然后添加边界属性与物理属性。不加边界掉地里就找不着了。为了更方便的区分，将transform节点改一个名字，比如Body。方法如下，单击Transform节点，然后在Node DEF下面输入Body

完成上一步之后，就可以添加上文提到的两个属性，分别是boundingObject与physics。boundingObject我们使用刚才改名的Body，然后physics属性点击弹出后直接添加即可，如下 需要注意的是，在添加physics属性之前，可以先将仿真的按钮关闭。否则添加physics属性之后，实体就会直接掉在地上。按钮的位置如下：

 

  添加完成后，如果出现围绕实体的白色的边界线，就说明设置成功。如果边界线跟添加实体的边界有偏差，就说明坐标等细节有问题。可能是Transform（改名后为Body）节点下的坐标设置有问题，如果出现问题可以自查。弄完后大概就是这个样子：

然后就可以进行下一步，添加一个轮子。单击Transform（改名后为Body）节点，选择Add（就那个“+”号），打开节点目录，选择一个HingeJoint节点。这个HingeJoint节点先不展开说，大概上可以理解为添加一个转轴，转轴的两端连接两个节点，一端是主体（Body），另一端需要连接一个Solid节点，下面会使用这个Solid节点制作一个轮子

 然后打开新增的HingeJoint节点，里面有三个属性，第一个是针对主节点的，第二个Device用来添加一个Motor，第三个终端节点就是要添加轮子的节点。下面两张图对应着前两个节点的修改

然后打开添加的Motor节点，给Motor改改名字。这里就改为motorRight。修改名字方便后续对于Motor的调用

 然后创建一个轮子出来。点击endPoint，添加一个Solid节点。然后单击Solid节点，同样的方法添加一个Shape节点。然后用上文相同的方法，在Shape节点下添加一个圆柱

单击Shape节点，添加一个圆柱。然后请各位自行修改颜色属性，就不过多赘述了，添加好大概样子如下（后面会修改Solid的坐标以及圆柱的大小，来让endPoint变成一个合格的轮子）

修改圆柱的大小，并修改Solid节点的translation与rotation属性，将轮子放在指定的位置上。修改的数值如下（这个可以根据各位的喜好自行定义），可以按照图示的位置与数值修改

然后给新添加的Shape节点改个名字。这个修改操作是为了给endPoint节点添加边界属性准备的。在添加boundingObject之后，添加物理属性，同时也给physics属性也改一个名字。操作如下：

下面给物理属性改个名字，同上操作

下面就是很关键的一步，这一步确保轮子能绕轴转动。打开HingeJoint节点下的endPoint节点，把translation的数值，直接复制到HingeJoint的第一个属性下面的anchor属性中，保持二者相同。然后点击position观察轮子是否按照指定转轴转动。如果转轴异常，可以修改axis的数值为 “0 1 0”或“0 0 1”，然后变动position的数值继续测试

 这样第一个轮子就创建成功了，记得保存各位，要不然辛苦白费了。第二个轮子会很轻松，因为是对称的，只需修改少量数据即可。点击刚创建的HingeJoint节点，复制，粘贴，出现一个相同的HingeJoint节点。然后打开新节点，按照图示修改数值。这样小車的主体部分就设计好了。

3 运动测试：

先保存最后的结果，很重要，很重要。然后点开仿真按钮，小車就掉下来了。双击小車的主体，在左侧会出现两个电机的控制台。然后就可以进行简单的运动测试了

滑动右侧蓝色点可以手动控制小车，此处遇到一个问题：滑动蓝色点小车轮子转动但小车不动，原因是之前设置车轮位置的时候车轮最下方与小车的Body最下方齐平，因此小车无法运动，将轮子的translation和对应的anchor的y坐标改为0.09后，小车就可以动起来啦

4 编写控制器：

向导→新机器人控制器→下一步→Python→…可劲点就行了，点到结束。这里使用Python语言来创建控制器程序。

先简单写一个包含前进/后退/转向/静止的代码逻辑，通过键盘输入进行控制。按键就是你键盘上最光亮的几个按键。代码如下

from controller import Robot

MAX_SPEED = 6.28
robot = Robot()

timestep = int(robot.getBasicTimeStep())

#获取键盘输入
key = robot.getKeyboard()
key.enable(timestep)

#获取电机
motor_right = robot.getDevice("motorRight")
motor_left = robot.getDevice("motorLeft")

#设置电机模式与电机初始速度
motor_right.setPosition(float("inf"))
motor_right.setVelocity(0.0)

motor_left.setPosition(float("inf"))
motor_left.setVelocity(0.0)

while robot.step(timestep) != -1:
    
    key_ = key.getKey()
    
    if key_ == ord('W'):
        motor_right.setVelocity(MAX_SPEED)
        motor_left.setVelocity(MAX_SPEED)
    if key_ == ord('S'):
        motor_right.setVelocity(-MAX_SPEED)
        motor_left.setVelocity(-MAX_SPEED)
    if key_ == ord('A'):
        motor_right.setVelocity(-0.4 * MAX_SPEED)
        motor_left.setVelocity(0.4 * MAX_SPEED)
    if key_ == ord('D'):
        motor_right.setVelocity(0.4 * MAX_SPEED)
        motor_left.setVelocity(-0.4 * MAX_SPEED)
    if key_ == ord(' '):
        motor_right.setVelocity(0.0)
        motor_left.setVelocity(0.0)
        pass

 将控制器与小车建立连接

 键盘控制小车运动的视频如下

双轮小车键盘控制

5 添加距离传感器

在Tramsform（Body）节点的基础上，添加一个Solid节点，是和前面添加的HingeJoint并列的节点。然后在Solid节点的children属性里添加Shape，并在Shape下添加一个圆柱，并调节尺寸，坐标，边界与物理属性。这些所有的步骤上文都有详细的介绍。还请上翻查看。

按照图中标记的顺序。第一步：单击Transform节点，添加Solid。第二步：单击Solid节点，添加Shape。
            第一步：单击Transform节点，添加Solid。
            第二步：单击Solid节点，添加Shape。
            第三步：单击Shape节点，添加圆柱（Cylinder）。
            第四步：修改Cylinder属性值，修改Solid下的translation属性值。
            第五步：修改Shape的名称为sensor，然后保存保存保存。

然后添加Solid节点下的boundingObject属性与physics属性。boundingObject属性用刚才修改的 sensor 。physics正常添加即可。可以通过白色的边界线来确定边界添加的准确与否。
在刚才添加的Solid节点上单击，选择Add，添加一个距离传感器

然后把Solid节点的translation的数值直接复制到距离传感器的translation中。这时就可以看到坐标的移动了。然后点击查看→可选显示→显示距离传感器射线。这个时候可以看到距离传感器的射线，不过应该不太明显。
接着修改距离传感器的rotation，使得距离传感器的射线朝向小車的前方，并保存。如下图：

然后复制粘贴再添加两个距离传感器，修改rotation的angle数值使得距离传感器的射线朝向两个轮子，与原来前向垂直。然后修改距离传感器的名字，打开距离传感器节点，里面有name选项，直接修改名字即可。最后添加控制器程序，我直接写在原来的控制器里，如下图：

 修改之后的代码如下（这个时候可以运行仿真，控制小车运动，然后可以观察传感器的输出

from controller import Robot

MAX_SPEED = 6.28
robot = Robot()

timestep = int(robot.getBasicTimeStep())

#获取三个距离传感器的数值
ds_forward = robot.("sensor_forward")
ds_forward.enable(timestep)
ds_right = robot.getDistanceSensor("sensor_right")
ds_right.enable(timestep)
ds_left = robot.getDistanceSensor("sensor_left")
ds_left.enable(timestep)


#获取键盘输入
key = robot.getKeyboard()
key.enable(timestep)

#获取电机
motor_right = robot.getDevice("motorRight")
motor_left = robot.getDevice("motorLeft")

#设置电机模式与电机初始速度
motor_right.setPosition(float("inf"))
motor_right.setVelocity(0.0)

motor_left.setPosition(float("inf"))
motor_left.setVelocity(0.0)

while robot.step(timestep) != -1:

    distance_f = ds_forward.getValue()
    distance_l = ds_left.getValue()
    distance_r = ds_right.getValue()
    print("distance_f:",distance_f)
    print("distance_l:",distance_l)
    print("distance_r:",distance_r)
    
    key_ = key.getKey()
    
    if key_ == ord('W'):
        motor_right.setVelocity(-MAX_SPEED)
        motor_left.setVelocity(-MAX_SPEED)
    if key_ == ord('S'):
        motor_right.setVelocity(MAX_SPEED)
        motor_left.setVelocity(MAX_SPEED)
    if key_ == ord('A'):
        motor_right.setVelocity(-0.4 * MAX_SPEED)
        motor_left.setVelocity(0.4 * MAX_SPEED)
    if key_ == ord('D'):
        motor_right.setVelocity(0.4 * MAX_SPEED)
        motor_left.setVelocity(-0.4 * MAX_SPEED)
    if key_ == ord(' '):
        motor_right.setVelocity(0.0)
        motor_left.setVelocity(0.0)
        pass

6.Webots双轮小车避障简单的控制逻辑

小車有三个距离传感器，前/左/右各有一个。小车在循环中处于直行状态，当检测到前方有障碍物时，判断左右两侧的距离传感器的数值，进而转向距离传感器大的方向。在直行的同时，也会检测两侧的距离，当两侧距离障碍物过于接近的时候，也会启动转向的判定逻辑。控制代码如下：

from controller import Robot
import time

# create the Robot instance.
robot = Robot()

# get the time step of the current world.
timestep = int(robot.getBasicTimeStep())

speed = 6.0

#获取电机
motor_right = robot.getDevice("motorRight")
motor_left = robot.getDevice("motorLeft")

#设置电机模式与电机初始速度
motor_right.setPosition(float("inf"))
motor_right.setVelocity(0.0)
motor_left.setPosition(float("inf"))
motor_left.setVelocity(0.0)

#获取三个距离传感器的数值
ds_forward = robot.getDevice("sensor_forward")
ds_forward.enable(timestep)
ds_right = robot.getDevice("sensor_right")
ds_right.enable(timestep)
ds_left = robot.getDevice("sensor_left")
ds_left.enable(timestep)

def Left():
    for i in range(15):
        if robot.step(timestep) != -1:
            ls = -speed
            rs = speed
                
            motor_left.setVelocity(ls)
            motor_right.setVelocity(rs)

def Right():
    for i in range(15):
        if robot.step(timestep) != -1:
            ls = speed
            rs = -speed
                
            motor_left.setVelocity(ls)
            motor_right.setVelocity(rs)

def Forward():
    while True:
        if robot.step(timestep) != -1:
            ls = -speed
            rs = -speed
                
            motor_left.setVelocity(ls)
            motor_right.setVelocity(rs)
            
            ds = ds_forward.getValue()
            ds_l = ds_left.getValue()
            ds_r = ds_right.getValue()  
            
        if float(ds)<800.0 or float(ds_l)<200.0 or float(ds_r)<200.0:# or float(ds_left)<1000.0 or float(ds_right)<1000.0:
            break
    
    if ds_l >= ds_r:
        return "L"
    return "R"

while True:
    direction = Forward()
    if direction == "L":
        Left()
    else:
        Right()

避障视频如下

二轮小车避障

7.Pycharm编写控制程序连接并控制Webots中实体的方法

如果说要做强化学习，基本上离不开Tensorflow，Pytorch之类的库，但这些玩意想在Webots里运行是不现实的。所以说可以使用Pycharm来运行控制程序，然后调用Webots提供的接口来控制机器人的运动。下面介绍Pycharm连接Webots的方法。

这个其实可以搜到很多的方法，大概上可以这样做：

找到该项目的文件集合，找到controllers目录，使用Pycharm打开。

然后设置Pycharm。打开File→选择Settings→打开Project ：controllers→打开Project ：Structure→选择Add，然后添加Webots下的目录，根据自己安装的Webots来定。我的是“D:\Webots\Webots\lib\controller\python39”

然后设置Configurations，在环境变量里添加：;Path=D:\Webots\Webots\lib\controller\;D:\Webots\Webots\msys64\mingw64\bin\;D:\Webots\Webots\msys64\mingw64\bin\cpp 也是根据自己的Webots目录来定（注意一开始的 “；”）。然后点击Apply应用。如果正常的话，现在打开Webots仿真，在controller里选择 “extern”。然后在Pycharm运行程序，就可以实现控制。

设置好上述之后，先在Pycharm中运行，再打开webots仿真开始按钮，外部控制小车视频如下

外部控制小车

8.Tensorflow编写DQN强化学习算法用于小车的避障

我们需要在刚才的小車的基础上修改一下坐标。意思就是让小车整体向下移动。下面我会给出图示，将Robot节点的children下的所有节点中的translation中的y值都减少0.08。使得小車的整体向下移动。

然后很关键的一点，我们需要使用Supervisor来重置机器人的状态。只需要把Supervisor对应的节点选择为True即可。

 8.1 思路

这个算是为了后续的强化学习任务做铺垫

设置了一个圈子，并设置围栏的高度。DQN算法的Observation仅仅包含三个距离传感器数据。其实这个数据偏少，各位可以给小車自行添加GPS，陀螺仪等，也可以使用激光雷达代替距离传感器，以此来丰富Observation的数据量。然后因为DQN算法只适用于离散值，所以会预先编写一个控制器，将动作离散化，即小車只有三个动作：前进 / 左转+前进 / 右转+前进。当然也可以通过DDPG算法来控制连续的动作

这里先说个小点子，如果动作只有前进/ 左转 / 右转，且Reward不加特殊设定的话，训练出来的小車很容易原地自转，避了个好障。

8.2 控制器程序

如果接触过强化学习，应该对Gym不陌生。这个控制器的作用就是将小車改造成类似于Gym中的强化学习环境。因此，需要编写Reset()与Step()函数。Reset()函数用于重置系统的状态。Step()函数用于驱动小車运动，这个项目的运动输入是 [0,1,2]。因为小车没有安装陀螺仪等传感器，无法获得小车的姿态数据。因此在驱动小车进行转向（转向均为旋转90度）时默认为开环控制，不对旋转角度进行修正。各位有实际需求的，可以自行加装闭环控制程序，像是典型的PID之类。然后下面是控制器类的代码：我的文件名称为Env.py

from controller import Supervisor
import time
import numpy as np


class Env():

    def __init__(self):

        self.name = "car"
        self.version = 1.0
        self.action_space = 3
        self.obs_space = 4
        self.terminal = False
        self.robot = Supervisor()
        self.timestep = 32

        self.max_speed = 6.28

        self.motor_1 = self.robot.getDevice("motorLeft")
        self.motor_2 = self.robot.getDevice("motorRight")

        self.motor_1.setVelocity(0.0)
        self.motor_2.setVelocity(0.0)

        self.motor_1.setPosition(float("inf"))

        self.motor_2.setPosition(float("inf"))

        self.ds_front = self.robot.getDevice("sensor_forward")
        self.ds_left = self.robot.getDevice("sensor_left")
        self.ds_right = self.robot.getDevice("sensor_right")

        self.ds_front.enable(self.timestep)
        self.ds_left.enable(self.timestep)
        self.ds_right.enable(self.timestep)

    def step(self, action):

        df = dr = dl = 0

        if action == 0:
            for i in range(11):
                self.robot.step(self.timestep)
                self.motor_1.setVelocity(-6.0)
                self.motor_2.setVelocity(-6.0)
                df = self.ds_front.getValue()
                dl = self.ds_left.getValue()
                dr = self.ds_right.getValue()

        elif action == 1:
            for i in range(11):
                self.robot.step(self.timestep)
                self.motor_1.setVelocity(-6.0)
                self.motor_2.setVelocity(6.0)
            for i in range(11):
                self.robot.step(self.timestep)
                self.motor_1.setVelocity(-6.0)
                self.motor_2.setVelocity(-6.0)

                df = self.ds_front.getValue()
                dl = self.ds_left.getValue()
                dr = self.ds_right.getValue()
        else:
            for i in range(11):
                self.robot.step(self.timestep)
                self.motor_1.setVelocity(6.0)
                self.motor_2.setVelocity(-6.0)
            for i in range(11):
                self.robot.step(self.timestep)
                self.motor_1.setVelocity(-6.0)
                self.motor_2.setVelocity(-6.0)

                df = self.ds_front.getValue()
                dl = self.ds_left.getValue()
                dr = self.ds_right.getValue()

        self.motor_1.setVelocity(0)
        self.motor_2.setVelocity(0)

        terminal = False
        reward = -1

        if df < 400.0 or dr < 400.0 or dl < 400.0:
            terminal = True
            reward = -15.0

        return [np.array([df, dl, dr]).reshape(1, 1, 3), reward, terminal]

    def reset(self):

        self.robot.simulationResetPhysics()  # 重置机器人的状态，主要是是translation和rotation
        name = self.robot.getFromDef("car")
        trans = name.getField("translation")
        rotation = name.getField("rotation")
        trans.setSFVec3f([0, -0.01, 0])

        return np.array([1000.0, 1000.0, 1000.0]).reshape(1, 1, 3)

DQN.py

import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
from tensorflow.keras import Sequential, layers
from tensorflow.keras.models import load_model
from collections import deque
from Env import Env
import numpy as np
import random
import time


class Agent(object):

    def __init__(self, ):

        self.steps = 0
        self.var = 1e-1 / 2
        self.e = 1e-5
        self.Model = self.model_()
        self.Target = self.model_()
        self.replay_memory = deque(maxlen=1000)

    def model_(self):

        model = Sequential(name="DQN")
        model.add(layers.Dense(100, "relu"))
        model.add(layers.Dense(100, "relu"))
        model.add(layers.Dense(3, None))
        model.compile("adam", "mse")
        return model

    def add(self, obs, action, reward, n_s, done):

        if action == 0 and not done:
            reward += 2.0
        self.replay_memory.append((obs, action, reward, n_s, done))

    def sample(self, obs):

        self.var -= self.e
        if np.random.uniform() <= self.var:
            return np.random.randint(3)
        return np.argmax(self.Model.predict(obs))

    def data(self):

        batch = random.sample(self.replay_memory, 64)
        Obs, Action, Reward, N_s, Done = [], [], [], [], []
        for (obs, action, reward, n_s, done) in batch:
            Obs.append(obs)
            Action.append(action)
            Reward.append(reward)
            N_s.append(n_s)
            Done.append(done)
        return np.array(Obs).astype("float32"), np.array(Action).astype("int64"), np.array(Reward).astype("float32"), \
            np.array(N_s).astype("float32"), np.array(Done).astype("float32")

    def learn(self):

        if self.steps % 50 == 0:
            self.Target.set_weights(self.Model.get_weights())

        if self.steps % 2 == 0 and len(self.replay_memory) >= 80:

            Obs, Action, Reward, N_s, Done = self.data()
            Q = self.Model.predict(Obs.reshape(64, 1, 3))
            Q_ = self.Target.predict(N_s.reshape(64, 1, 3))

            for i in range(64):
                if Done[i]:
                    Q[i][0][Action[i]] = 0.01 * Reward[i]
                Q[i][0][Action[i]] = 0.01 * (Reward[i] + 0.9 * np.argmax(Q_[i][0]))

            self.Model.fit(Obs.reshape(64, 1, 3), Q, verbose=0)


env = Env()
agent = Agent()
Scores = []
# new_model = model_()
# agent.Model = load_model("car.h5")
agent.Model = agent.model_()
agent.Target = agent.Model

for times in range(500):
    time_ = 0
    s = env.reset()
    Score = 0

    while True:

        time_ += 1
        agent.steps += 1
        a = agent.sample(s)
        next_s, reward, done = env.step(a)
        agent.add(s, a, reward, next_s, done)
        agent.learn()
        Score += reward
        s = next_s

        if done or time_ == 30:
            Scores.append(Score)
            print('episode:', times, 'score:', Score, 'max:', np.max(Scores))
            break

    # 提前终止训练
    # if np.mean(Scores[-3:]) >= -25:
    #    agent.Model.save("car.h5")
    #    break

agent.Model.save("car.h5")

运行DQN.py，训练视频如下

DQN训练

---

测试视频可以看到机器人会后仰，这是因为机器人只有两个轮子支撑Body，解决方法是给机器人添加一个万向轮

创建万向“轮”

为了轮子打了个引号呢？

因为这是个假轮子，不会转的。

加个假轮子垫着，以免机器跑起来会后仰。

先添加一个solid，为solid添加形状，选择球形，设置边界和物理属性，调整半径和位置，作为前轮，然后复制一个后轮，修改位置即可

添加障碍物

障碍添加完成后如下

加上DQN训练的视频如下

DQN训练