手柄遥控四驱小车实验

    前面曾实验过四驱小车,以及如何获取ps4手柄数据,今天想想如何尝试两者结合起来,用ps4手柄操作四驱小车实现四向行走;以前文章参考:
1、ps4手柄蓝牙连接树莓派:https://www.shumeijiang.com/2021/08/04/树莓派和手柄-蓝牙连接;
2、ps4手柄数据获取:https://www.shumeijiang.com/2021/08/04/树莓派和手柄-数据获取;
3、四驱小车驱动封装:https://www.shumeijiang.com/2021/09/23/四驱小车循迹实验-直流电机驱动封装
组装效果:
    其中将手柄数据获取部分做了简化,然后检测手柄的右侧摇杆数据;当Axis等于2时,表示左右动作,当Axis等于5时,表示前后动作;具体如下表格:
摇杆含义
Axis2大于0向右
Axis2小于0向左
Axis5大于0后退
Axis5小于0前进
代码示例:

#!/usr/bin/env python
#coding:utf-8

'''
from JiuJiang
树莓酱的操作实例
https:://www.shumeijiang.com
'''

#import RPi.GPIO as GPIO ##引入GPIO模块
import time    ##引入time库
import pygame

#引入驱动类
from baseAct import baseAct
#实例化驱动类并赋值四个电机所占引脚值
act = baseAct(17, 16, 13, 12, 19, 18, 21, 20)
done = False

#手柄获取初始化
pygame.init()
pygame.joystick.init()

try:
    while not done:
        #检测手柄状态 手柄关闭则检测关闭
        for event in pygame.event.get():
            if event.type == pygame.QUIT:  #是否关闭
                done = True

        #获取摇杆数量
        joystick_count = pygame.joystick.get_count()
        for i in range(joystick_count):
            joystick = pygame.joystick.Joystick(i) #挨个创建摇杆对象
            joystick.init() #摇杆初始化
            axes = joystick.get_numaxes() #获取摇杆轴数

            #挨个获取轴的数据
            for n in range(axes):
                axis = joystick.get_axis(n) #获取指定轴的位置 数字表示
                if axis == 0.0:
                    continue

                #数据收集
                if n == 2:  #左右
                    if axis > 0:
                        act.turn_right(0.5, 50, 50, True)
                    else:
                        act.turn_left(0.5, 50, 50, True)
                elif n == 5: #前后
                    if axis > 0:
                        act.act_backward(0.5, 50, 50)
                    else:
                        act.act_forward(0.5, 50, 50, True)

                time.sleep(0.2)

except KeyboardInterrupt:
    print('停止检测')
执行效果:
    不过实验还是存在一些问题,比如力矩体现,连贯性体现等还是不够完美;后续会实验小车安装摄像头然后实现手机远程视频功能。

四驱小车循迹实验-循迹实现

    前两篇文章已经介绍了如何组装四驱小车以及小车的驱动类封装;接下来这篇文章将尝试驱动类调用以及小车循迹测试。
    小车组装文章:https://www.shumeijiang.com/2021/09/23/四驱小车循迹实验-小车组装/。
    小车驱动类封装文章:https://www.shumeijiang.com/2021/09/23/四驱小车循迹实验-直流电机驱动封装/
#循迹实验效果
#实现效果:
    从上面gif图以及视频可看到,小车遇到直线会直行前进,由于手工贴的胶带不是很直所以小车会实时调整前进的角度;当遇到转弯时,同样会一点点进行转弯直到寻找到黑线线条;
传感器示例
    上图模拟小车前面并排的三个红外避障传感器,分别是ONE,TWO,THREEE;默认黑线位于TWO传感器正下方为直行;由于小车要不停向前移动,但是黑线有弯曲或者转弯的情况,所以小车会出现三个传感器分别接触黑线的情况;通过不同的传感器被触发事件,从而得出小车现在的行走方向以及判断是否要做方向调整,具体原理如下(1为检测到黑线触发事件,0为未检测到黑线):

1、ONE=1,THREE=0 说明黑线偏转右侧,此时小车应向右转向;
2、ONE=0,THREE=1 说明黑线偏转左侧,此时小车应向左转向;
3、ONE=0,TWO=1,THREE=0 说明黑线在中心方向,小车需直行;
4、ONE=1,TWO=1,THREE=1 说明遇到横线,小车需停顿;
5、ONE=0,TWO=0,THREE=0 说明小车失去黑线,此时需寻找或者停止。
#实现代码

#!/usr/bin/env python
#coding:utf-8

'''
from JiuJiang
树莓酱的操作实例
http:://www.shumeijiang.com
'''

import RPi.GPIO as GPIO
import time

GPIO.setwarnings(False)

#引入驱动类
from baseAct import baseAct
#实例化驱动类并赋值四个电机所占引脚值
act = baseAct(17, 16, 13, 12, 19, 18, 21, 20)

#三个传感器检测黑线
senseOne = 22
senseTwo = 23
senseThree = 24

#一个检测障碍物
checkPin = 25

GPIO.setmode(GPIO.BCM)
GPIO.setup(senseOne, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.setup(senseTwo, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(senseThree, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.setup(checkPin, GPIO.IN, pull_up_down=GPIO.PUD_UP)

#事件注册 注意不同传感器触发事件不同
GPIO.add_event_detect(senseOne, GPIO.RISING, bouncetime=200)
GPIO.add_event_detect(senseTwo, GPIO.FALLING, bouncetime=200)
GPIO.add_event_detect(senseThree, GPIO.RISING, bouncetime=200)
GPIO.add_event_detect(checkPin, GPIO.FALLING, bouncetime=200)

#检测事件
def check_event(pin):
    status = GPIO.event_detected(pin)
    return status

#检测状态
def check_status(pin):
    status = GPIO.input(pin)
    return status

#find
done = False
try:
    while not done:
   
        #障碍物检测
        front_status = check_event(checkPin)
        print("front status is %d"% front_status)
        if front_status == 1:
            print('有障碍物 停止')
            act.act_backward(0.5, 50, 50)
            done = True
            break

        #检测各传感器状态
        #status = find_way(senseOne, senseTwo, senseThree)
        sOne = check_event(senseOne)
        sTwo = check_event(senseTwo)
        sThree = check_event(senseThree)

        print('sOne is %d'% sOne)
        print('sTwo is %d'% sTwo)
        print('sThreee is %d' % sThree)
       
        way_type = 'forward'
        #继续前行
        if sOne == 0 and sThree==0:
            act.act_forward(0.15, 50, 40, True)
            print('forward')

        #遇到横线停顿
        elif sOne == 1 and sThree == 1:
            time.sleep(0.5)
            print('wait')

        #向右侧转弯调整
        elif sOne == 1 and sThree == 0:
            #act.turn_right(0.15, 50, 40)

            #检测是否居中
            find = False
            while not find:
                oneStatus = check_event(senseOne)
                twoStatus = check_event(senseTwo)
                threeStatus = check_event(senseThree)
                print('run right---->>')
                print('one status is %d'% oneStatus)
                print('two status is %d'% twoStatus)
                print('three status is %d'% threeStatus)

                if oneStatus==0 and twoStatus==1 and threeStatus==0:
                    find = True
                    break

                act.turn_right(0.15, 55, 45, True)
                time.sleep(0.2)
                   
            print('right')
            way_type = 'right'

        #向左侧转弯调整
        elif sOne == 0 and sThree == 1:

            find = False
            while not find:
                oneStatus = check_event(senseOne)
                twoStatus = check_event(senseTwo)
                threeStatus = check_event(senseThree)
                print('run left<<----')
                print('one status is %d'% oneStatus)
                print('two status is %d'% twoStatus)
                print('three status is %d'% threeStatus)

                if oneStatus==0 and twoStatus==1 and threeStatus==0:
                    find = True
                    break

                act.turn_left(0.15, 55, 45, True)
                time.sleep(0.2)

            print('left')
            way_type = 'left'
        else:
            pass

        print('once')
        #time.sleep(0.2)

        #if sOne==0 and sTwo==0 and sThree==0:
            #act.act_break()
            #print('stop!!!!')
            #break

except KeyboardInterrupt:
    pass

GPIO.cleanup()
从上面的代码可以看到循迹的策略和流程如下:

1、首先注册one和three分别一个RISING(低变高)事件,因为默认情况下这两个传感器没有遇到黑线而是地板,所以触发低电平事件(传感器低电平触发检测);

2、two注册一个FALLING(高变低)事件,因为默认two传感器红外被黑色线条吸收,从而不产生障碍物检测,所以检测状态为高电平;

3、checkPin为小车前方障碍物检测,如果遇到前方障碍物,小车停车并后退,这个不是重点不做详细介绍;

4、one、two、three传感器的防抖时间bouncetime,异或说检测间隔为200毫秒,这个可以自己调节,主要用于探测黑线的频率;

5、紧接着进入一个while循环,每次都检测三个传感器状态,当发现:
(1)one和three都没有触发RISING事件,我们认为此时黑线还在中间,所以直行;
(2)one和three都触发RISING事件,说明遇到横线,所以停顿;
(3)one触发,three没有触发,说明直行后黑线弯曲,触发了右侧one传感器;为了黑线居中,这个时候小车就需要右转,但是由于不知道黑线弯曲程度(后续可实验图像识别),所以小车进入一个找线环节,以0.15秒的步伐,一点点右转,同时占空比调为55,赫兹设置为45,降低右转速度;当two传感器触发FALLING事件,说明小车归正,则继续触发直行策略,以此类推;
(4)one没有触发,three触发,说明直行后黑线向左弯曲,触发左转动作,具体细节同右转相似;

6、如此,小车便会直行、停顿、左转和右转;当然程序还有很多不足的地方,后续还会继续优化。
#事件检测(边沿检测)部分可参考文章:https://www.shumeijiang.com/2020/03/15/gpio之event_detected系列函数/

四驱小车循迹实验-直流电机驱动封装

    上篇文章已经介绍了四驱小车如何组装,这篇文章我们将继续介绍如何驱动小车前进后退以及左转右转;因为小车循迹的过程中,会遇到左转线、直线、右转线以及停顿标示;这个时候就需要小车能实现左转、右转、直行、停车、后退等动作。
#直流电机驱动板L298N驱动原理:
直流电机转动效果IN1IN2IN3IN4
MOTOR-A正向(调速)高电平/PWM低电平
反向(调速)低电平高电平/PWM
停止低电平低电平
刹车高电平高电平
MOTOR-B正向(调速)高电平/PWM低电平
反向(调速)低电平高电平/PWM
停止低电平低电平
刹车高电平高电平
    从上面表格可见,motorA连接引脚IN1和IN2,当IN1高电平IN2低电平的时候,电机正向转动,其中IN1输入PWM进行调速和扭矩变化;反之IN1低电平和IN2高电平的时候电机反向转动,从而实现倒车;其他电机以此类推。
#其中PWM控制转速和扭矩,示例如下:
1、创建PWM实例:p = GPIO.PWM(channel, frequency);
2、开始PWM:p.start(duty_cycle)  #duty_cycle为占空比;
3、更改频率,更改扭矩:p.ChangeFrequency(frequency);
4、更改占空比,更改转速:p.ChangeDutyCycle(duty_cycle);
5、PWM停止:p.stop()
#代码示例

#!/usr/bin/env python
#coding:utf-8

'''
from JiuJiang
树莓酱的操作实例
https:://www.shumeijiang.com
'''

import RPi.GPIO as GPIO ##引入GPIO模块
import time    ##引入time库
GPIO.setmode(GPIO.BCM)

#驱动类
class baseAct:
    def __init__(self, ain1, ain2, ain3, ain4, bin1, bin2, bin3, bin4):
        self.ain1 = ain1
        self.ain2 = ain2
        self.ain3 = ain3
        self.ain4 = ain4
        self.bin1 = bin1
        self.bin2 = bin2
        self.bin3 = bin3
        self.bin4 = bin4
        GPIO.setup(self.ain1, GPIO.OUT)
        GPIO.setup(self.ain2, GPIO.OUT)
        GPIO.setup(self.ain3, GPIO.OUT)
        GPIO.setup(self.ain4, GPIO.OUT)
        GPIO.setup(self.bin1, GPIO.OUT)
        GPIO.setup(self.bin2, GPIO.OUT)
        GPIO.setup(self.bin3, GPIO.OUT)
        GPIO.setup(self.bin4, GPIO.OUT)

    #结束动作
    def act_stop(self, duration, slow_time=0.15):

        #执行时间
        duration = float(duration)-slow_time
        time.sleep(duration)
   
        #self.init_move('forward', duration, 50, 50)

        if slow_time:
            #执行缓冲慢行
            self.apwm1.ChangeDutyCycle(20)
            self.apwm3.ChangeDutyCycle(20)
            self.bpwm1.ChangeDutyCycle(20)
            self.bpwm3.ChangeDutyCycle(20)
            time.sleep(slow_time)

        #结束动作
        self.apwm1.stop()
        self.apwm3.stop()
        self.bpwm1.stop()
        self.bpwm3.stop()
        GPIO.output(self.ain2, GPIO.LOW)
        GPIO.output(self.ain4, GPIO.LOW)
        GPIO.output(self.bin2, GPIO.LOW)
        GPIO.output(self.bin4, GPIO.LOW)

    ##PWM初始化
    def init_move(self, act_type, duration, duty_ratio, hz_num):

        if act_type == 'forward':
            hpin1 = self.ain1
            lpin1 = self.ain2
            hpin2 = self.ain3
            lpin2 = self.ain4
            hpin3 = self.bin1
            lpin3 = self.bin2
            hpin4 = self.bin3
            lpin4 = self.bin4
        elif act_type == 'backward':
            hpin1 = self.ain2
            lpin1 = self.ain1
            hpin2 = self.ain4
            lpin2 = self.ain3
            hpin3 = self.bin2
            lpin3 = self.bin1
            hpin4 = self.bin4
            lpin4 = self.bin3
        elif act_type == 'turn_left':
            hpin1 = self.ain1  
            lpin1 = self.ain2  #右前电机前进 pin2低电平则前进
            hpin2 = self.ain3
            lpin2 = self.ain4  #右后电机前进
            hpin3 = self.bin2
            lpin3 = self.bin1  #左前电机后退 pin2高电平则后退
            hpin4 = self.bin4
            lpin4 = self.bin3  #左后电机后退
        elif act_type == 'turn_right':
            hpin1 = self.ain2
            lpin1 = self.ain1  #右前电机后退  pin2高电平则后退
            hpin2 = self.ain4
            lpin2 = self.ain3  #右后电机后退
            hpin3 = self.bin1
            lpin3 = self.bin2  #左前电机前进  pin2高电平则前进
            hpin4 = self.bin3
            lpin4 = self.bin4  #左后电机前进
        else:
            print "不支持的类型"
            pass

        #挨个实例化每个电机的PWM实例
        self.apwm1 = GPIO.PWM(hpin1, hz_num) #实例PWM 并可自定义hz
        self.apwm1.start(0)           #初始占空比为0
        GPIO.output(hpin1, GPIO.HIGH) #设置单个电机一个高电压
        GPIO.output(lpin1, GPIO.LOW)  #另一个低电压
        self.apwm1.ChangeDutyCycle(duty_ratio) #设置用户自定义占空比

        #驱动第二个电机
        self.apwm3 = GPIO.PWM(hpin2, hz_num)
        self.apwm3.start(0)
        GPIO.output(hpin2, GPIO.HIGH)
        GPIO.output(lpin2, GPIO.LOW)
        self.apwm3.ChangeDutyCycle(duty_ratio)

        #驱动第三个电机
        self.bpwm1 = GPIO.PWM(hpin3, hz_num)
        self.bpwm1.start(0)
        GPIO.output(hpin3, GPIO.HIGH)
        GPIO.output(lpin3, GPIO.LOW)
        self.bpwm1.ChangeDutyCycle(duty_ratio)

        #驱动第四个电机
        self.bpwm3 = GPIO.PWM(hpin4, hz_num)
        self.bpwm3.start(0)
        GPIO.output(hpin4, GPIO.HIGH)
        GPIO.output(lpin4, GPIO.LOW)
        self.bpwm3.ChangeDutyCycle(duty_ratio)

    ##前进
    def act_forward(self, duration, duty_ratio, hz_num=50, close_slow=False):
        self.init_move('forward', duration, duty_ratio, hz_num)

        if close_slow:
            slow_time = 0
        else:
            slow_time = 0.15

        #停止动作 并执行缓冲
        self.act_stop(duration, slow_time)

    ##后退
    def act_backward(self, duration, duty_ratio, hz_num):
        self.init_move('backward', duration, duty_ratio, hz_num)
        #停止动作 并缓冲执行
        self.act_stop(duration)

    ##向左转
    def turn_left(self, duration, duty_ratio, hz_num, serial=False):
        self.init_move('turn_left', duration, duty_ratio, hz_num) #左转执行
        slow_time = 0.05  #减速时间
        if serial==True:
            slow_time = 0
        self.act_stop(duration, slow_time)  #动作停止

    ##向右转
    def turn_right(self, duration, duty_ratio, hz_num, serial=False):
        self.init_move('turn_right', duration, duty_ratio, hz_num) #右转执行
        slow_time = 0.05  #减速时间
        if serial==True:
            slow_time = 0 #连续不减速
        self.act_stop(duration, slow_time)  #动作停止

    ##刹车
    def act_break(self):
        GPIO.output(self.ain1, GPIO.HIGH)
        GPIO.output(self.ain2, GPIO.HIGH)
        GPIO.output(self.ain3, GPIO.HIGH)
        GPIO.output(self.ain4, GPIO.HIGH)

        GPIO.output(self.bin1, GPIO.HIGH)
        GPIO.output(self.bin2, GPIO.HIGH)
        GPIO.output(self.bin3, GPIO.HIGH)
        GPIO.output(self.bin4, GPIO.HIGH)
    如上代码可见,封装了直流电机驱动类baseAct,以及直行、后退、左转、右转和刹车等方法;实例化类后便可直接调用,其中ain1、ain2、ain3、ain4为左侧电机驱动板引脚,bin1、bin2、bin3、bin4为右侧电机驱动板引脚,分别对应即可。
#参考文章:https://www.shumeijiang.com/2020/05/04/直流电机驱动变速实验/

四驱小车循迹实验-小车组装

    从本篇文章开始,我们将进行四驱小车的循迹实验;因为曾经看到过相关的比赛,所以想着自己能不能组装一个可以循迹的四驱小车,花了中秋假期三天的时间,从组装到代码开发调试,小车终于可以循迹跑起来了;下面先从组装开始说起。
#材料准备
1、四驱小车底盘,网上都有卖,包含四个直流电机以及一个亚克力板;
2、树莓派3B+一个,这个不做限制,只要能跑代码即可;
3、四路红外避障传感器,当然也可以用其他循迹传感器;原理是一样,都是利用红外线遇到黑线,红外线被吸收,从而不产生反射的原理。
4、两个L298N直流电机驱动模块,用于四个电机的驱动;
5、两个供电充电宝,分别给树莓派和直流电机供电;
6、一个数显降压稳压模块,用于电机电压的控制;
7、一个船型开关,用于小车电源的开关(非必须);
8、一个降温小风扇,一方面用于给树莓派降温,另一方面防止充电宝供电中断;
9、一卷黑色胶带,后续循迹实验用于铺设循迹轨道;
10、雪糕棒以及热熔枪用于粘合;
11、扎带用于固定充电宝以及其他物品;
#组装效果
前面
侧面
后面
上面
#其中第一张图,三个并列的红外传感器,需要注意间距和高低位置;高低校准是放置在地面检测灯亮起,遇到黑线红灯熄灭即可,如果发现红灯不亮或者不灭可以调节可调电阻调整探测距离;彼此间距,校准是当黑线不在中间探测器下方时,左右传感器在N个移动周期内能检测到黑线即可。
#接线部分:
1、左侧电机L298N驱动板
(1)IN1接18;
(2)IN2接19;
(3)IN3接20;
(4)IN4接21;
2、右侧电机L298N驱动板
(1)IN1接17;
(2)IN2接16;
(3)IN3接13;
(4)IN4接12;
3、四路红外避障传感器
(1)IN1接22;
(2)IN2接23;
(3)IN3接24;
(4)IN4接25;
(5)GND接GND;
(6)VCC接3.3V;
组装和接线完成后,下一篇文章会讲解我自己封装的驱动程序。
#传感器参考文章:https://www.shumeijiang.com/2021/09/02/四路红外避障传感器实验/

四驱小车驱动实验(三)

#实验目的:上两次实验试验了基本的前进和转弯动作;这次我们实验两个目标,一个是通过充电宝供电驱动小车转动;另一个目标是组合红外避障传感器,当遇到障碍物时,小车自动停止并后退,以免撞击到障碍物。
#接线效果如图:
接线示例
#实验代码:
代码示例
#注:其中驱动类使用解释可参考文章:
(1)http://www.shumeijiang.com/2020/05/24/四驱小车驱动实验(一)
(2)http://www.shumeijiang.com/2020/05/27/四驱小车驱动实验(二)

#!/usr/bin/env python
#coding:utf-8

'''
from JiuJiang
树莓酱的操作实例
http:://www.shumeijiang.com
'''

import RPi.GPIO as GPIO ##引入GPIO模块
import time    ##引入time库

#引入驱动类
from baseAct import baseAct
#实例化驱动类并赋值四个电机所占引脚值
act = baseAct(17, 16, 13, 12, 19, 18, 21, 20)

sensePin = 27  ##红外避障传感器
GPIO.setup(sensePin, GPIO.IN) ##设置为接收模式

##实验开始
try:
    while True:
        run_time = 0.05  ##执行前端时间 也是障碍物检测间隔时间
        status = GPIO.input(sensePin)
        if status == 0:
            print '发现障碍物'
            act.act_backward(0.5, 50, 50)  ##检测到障碍物则立即后退
            break;   ##后退后停止动作
        else:
            act.act_forward(run_time, 50, 50, True)  ##没有障碍物则继续前进

except KeyboardInterrupt:
    pass

GPIO.cleanup()
#视频效果如下:
#实验效果:
1、执行代码 Python jiujiang.py;
2、当前方没有障碍物或者离障碍物较远时,小车继续前进;
3、当接近障碍物时,可见小车红外避障传感器探测警告灯亮起,小车则立刻后退,然后停止动作。
#下期预告:下期我们将在此次实验的基础上增加更多的动作,比如遇到障碍物后,停止前进,然后左右转弯寻找没有障碍物的方向,然后继续前进;敬请期待。

四驱小车驱动实验(二)

#实验目的:在实验(一)的基础上继续探索新的动作;此次实验主要展示左转和右转以及和直行和后退的组合动作。
#接线图以及直行和后退参考文章:http://www.shumeijiang.com/2020/05/24/四驱小车驱动实验(一)/
#左转代码:原理是左前和左后电机后退,右前和右后电机前进。
左转代码示例
#右转代码:原理是左前和左后电机前进,右前和右后电机后退。
右转代码示例
#方法封装:
封装方法
#组合动作调用:
执行代码
#实验效果:
1、执行代码 Python jiujiang.py;
2、可见四个电机直行前进1秒,然后停顿0.5秒(自定义停顿);
3、然后可见左转执行0.2秒,并停顿0.5秒;
4、然后继续直行1秒,停顿0.5秒;
5、紧接着执行右转0.2秒,停顿0.5秒;
6、最后四个电机执行后退1秒;
7、其中方法第一个参数为执行秒数,第二个参数为占空比,第三个为频率。
#视频效果如下:

四驱小车驱动实验(一)

#实验目的:通过组合四个直流电机和两个电机驱动板以及编写控制代码,实现不同的直流电机集体协作,从而实现预期动作的效果;本篇文章主要实现四个电机的协同前进和后退动作。
#接线效果如图:
接线效果
#注解:实验通过一个可显示电压的降压模块,以及两个直流电机驱动板,驱动四个直流电机进行动作的执行。
其中驱动原理可参考文章:http://www.shumeijiang.com/2020/05/04/直流电机驱动变速实验/
#关键代码:
电机初始化
#如上图代码可见:
1、每个电机都需要单独实例化PWM,使用PWM的原因是我们希望通过改变占空比从而实现调节电机的转速效果。
2、其中每个电机的高低电平设置引脚都为可变变量,我们只需要通过不同的赋值,即可实现电机的前转和后转效果。
3、前进和后退赋值见下图;
赋值示例
#执行时间设置和动作停止:
动作停止以及缓冲
#如上图可见:
1、用户可指定前进或后退的执行时间,见代码time.sleep(duration)
2、其中执行时间内,可执行缓冲时间,即在执行时间的最后一段时间,降低占空比,从而实现缓慢停止的效果;当然也可以不加,执行也没有问题。
#封装前进和后退动作以及调用示例:
类前进和后退方法
#驱动类可发送邮件至lee.chuke@foxmai.com获取;
#视频效果如下: