一、介绍
阅读本篇文章前建议先参考前期文章：
树莓派基础实验34：L298N模块驱动直流电机实验
树莓派综合项目2：智能小车（一）四轮驱动
树莓派综合项目2：智能小车（二）tkinter图形界面控制
《智能小车（一）四轮驱动》中，实现了代码输入对四个电机的简单控制。《智能小车（二）tkinter图形界面控制》中，实现了本地图形界面控制小车的前进后退、转向和原地转圈。
本实验中将使用无线电遥控设备控制小车的前进后退、转向和原地转圈。使用传统无线电通信设备通信仍然是非常重要的通信方式，比如无线电台、对讲机，航模、车模、船模遥控等等。与手机移动网络、WIFI连接相比，无线电连接有它独特的优势，遥控距离远，实时性好，操作灵活，不受网络信号限制。
其它基础内容可以参考文集：树莓派基础实验。
二、组件
★Raspberry Pi 3 B 全套*1
★睿思凯Frsky XM 迷你接收机*1
★电平反向器模块*1
★睿思凯Frsky Taranis X9D PLUS SE2019遥控器*1
★L298N扩展板模块*1
★智能小车底板模块*1
★减速电机和车轮*4
★跳线若干
三、实验原理
本实验中使用的遥控系统可以自行选择其它品牌的产品，如国产的天地飞还不错。
睿思凯Frsky Taranis X9D PLUS SE2019遥控器
这里的遥控器就是像电视机遥控器、空调遥控器一样可以不用接触到被控设备，而通过一个手持器件，使用无线电与被控设备进行通信，从而达到对设备的控制。
遥控器想到达到与小车通信的功能需要有两部分配合完成。即：发射器（遥控器）与接收机。遥控器上的控制杆转为无线电波发送给接收机，而接收机通过接收无线电波，读取遥控器上控制杆的读数，并转为数字信号发送到树莓派中。
接收机输出两种信号，一种是模拟信号PWM，一种是SBUS数字信号。
Frsky XM 接收机
Frsky XM 参数
由于每一路遥控器通道都需要一个PWM采集器进行采集，但是对于树莓派来说不可能使用多个定时器来采集多个通道的PWM，这对于树莓派的GPIO端口资源来说十分浪费，因此我采用的就是SBUS信号，可以在一个管脚中传输多路控制信号。
S-BUS其实是一种串口通信协议，采用100000的波特率，数据位点8bits，停止位点2bits，偶效验，即8E2的串口通信。使用树莓派的串口GPIO（TXD/RXD）中的RXD端口接收接收机的SBUS输出信号，解析出每路通道的控制信号，进而控制小车行进。
但是S-BUS采用的是反向电平传输，也就是说，在S-BUS的发送端高低电平是反向的，协议中的所有高电平都被转换成低电平，协议中的所有低电平都被转换成高电平。所以在S-BUS的接收端需要增加一个高低电平反向器来进行电平反转。
电平反相器
关于解析无线电接收机PWM、SBUS信号的更详细内容，请参考树莓派基础实验39：解析无线电接收机PWM、SBUS信号。
四、实验步骤
第1步： 连接电路。在树莓派综合项目2：智能小车（一）四轮驱动中的接线基础上，接入电平反向器、无线电接收机。
树莓派（name） | 树莓派（BOARD） | L298N小车扩展板 |
|---|---|---|
GPIO.0 | 11 | ENA |
GPIO.2 | 13 | IN1 |
GPIO.3 | 15 | IN2 |
GPIO.1 | 12 | ENB |
GPIO.4 | 16 | IN3 |
GPIO.5 | 18 | IN4 |
GND | GND | 电池组供电负极 |
关于这里树莓派GND、L298N小车扩展板的电池组供电负极相连，是特殊情况下的情况，经测试发现： 如果树莓派用的是充电头供电，而L298N扩展板用的是电池组供电，这两个负极必须相连，否则马达不动。 如果树莓派用的是L298N扩展板接出来的5V供电，即两者同一个电源，则这里不用连接。
L298N小车扩展板 | 电池组 | 树莓派 | 电压表头 | 马达 |
|---|---|---|---|---|
电池 （-） | 电池 （-） | | | |
5V供电 | | 电源接口 | | |
（-） | | | （-） | |
T1（L后） | | | | （-） |
T2（L前） | | | | （-） |
T3（R前） | | | | （-） |
T4（R后） | | | | （-） |
树莓派（name） | 树莓派（BOARD） | 电平反向器 | 无线电接收机 |
|---|---|---|---|
| | A6 | SBUS_OUT |
RXD | 10 | B6 | |
3.3V | 1 | VCC | |
0V | 9 | GND | |
5V | 2 | | VCC |
0V | 14 | | GND |
这里也要注意，由于树莓派的GPIO只能接收3.3V的最高输入，所以电平反相器的电源也只能使用3.3V，若反向后接收的信号需要是5V，则电平反相器的电源就使用5V。
智能小车四轮驱动电路图
树莓派智能小车
这里我将18650电池组换成了航模使用的格氏ACE锂电池（3S/11.1V/2200MAH/40C），电压更高，能给树莓派提供更稳定的电源，动力性也更好，效果非常不错。
第2步： 编写电机的驱动程序，文件名为motor_4w.py。与树莓派综合项目2：智能小车（一）四轮驱动中的程序完全相同。
该车的行进控制与履带车的行进控制类似：
前进和后退很简单，左右两边的方向都朝前或朝后，速度一致； 原地顺时针旋转时，左边轮子前进，右边轮子后退，速度一致； 原地逆时针旋转时，左边轮子后退，右边轮子前进，速度一致； 偏左前进时，左右两边的方向都朝前，左轮速度比右轮速度慢一点； 偏右前进时，左右两边的方向都朝前，左轮速度比右轮速度快一点； 偏左后退时，左右两边的方向都朝后，左轮速度比右轮速度慢一点； 偏右后退时，左右两边的方向都朝后，左轮速度比右轮速度快一点；
motor_4w.py：
代码语言：txt复制#!/usr/bin/env python
#-*- coding: utf-8 -*-
#本模块只含SMPcar()一个类，用于树莓派对电机信号的控制
#通过GPIO输出信号，直接对某个电机的转动方向、速度进行控制
import RPi.GPIO as GPIO
class SMPcar():
'''控制小车四轮动作的类'''
ENA = 11 #使能信号A，左边两轮
IN1 = 13 #信号输入1
IN2 = 15 #信号输入2
ENB = 12 #使能信号B，右边两轮
IN3 = 16 #信号输入3
IN4 = 18 #信号输入4
GPIO.setwarnings(False) #关闭警告
def setGPIO(self):
'''初始化引脚'''
GPIO.setmode(GPIO.BOARD)
GPIO.setup(SMPcar.ENA, GPIO.OUT)
GPIO.setup(SMPcar.IN1, GPIO.OUT)
GPIO.setup(SMPcar.IN2, GPIO.OUT)
GPIO.setup(SMPcar.ENB, GPIO.OUT)
GPIO.setup(SMPcar.IN3, GPIO.OUT)
GPIO.setup(SMPcar.IN4, GPIO.OUT)
def pwm(self,pwm):
'''初始化PWM（脉宽调制），返回PWM对象'''
EN_pwm = GPIO.PWM(pwm, 500)
EN_pwm.start(0)
return EN_pwm
def changespeed(self,pwm,speed):
'''通过改变占空比改变马达转速'''
pwm.ChangeDutyCycle(speed)
def clockwise(self,in1_pin,in2_pin):
'''马达顺时针转的信号'''
GPIO.output(in1_pin, 1)
GPIO.output(in2_pin, 0)
def counter_clockwise(self,in1_pin,in2_pin):
'''马达逆时针转的信号'''
GPIO.output(in1_pin, 0)
GPIO.output(in2_pin, 1)
def stop_car(self,in1_pin,in2_pin):
'''马达制动的信号'''
GPIO.output(in1_pin, 0)
GPIO.output(in2_pin, 0)
#使能信号为低电平，或者高电平（占空比设为100，IN1和IN2都为0或1时）马达制动
def destroy(self,A,B):
'''结束程序时清空GPIO状态'''
A.stop()
B.stop()
GPIO.cleanup() # Release resource
if __name__ == '__main__': # 本模块单独测试时运行使用
try:
smpcar = SMPcar() #创建树莓派小车对象
smpcar.setGPIO() #初始化引脚
ENA_pwm=smpcar.pwm(smpcar.ENA) #初始化使能信号PWM，A为左边车轮
ENB_pwm=smpcar.pwm(smpcar.ENB) #初始化使能信号PWM，B为右边车轮
while True:
'''通过输入的命令改变马达转动'''
cmd = raw_input("Command, E.g. ff30ff30 :")
direction = cmd[0] #只输入字母b时，小车刹车
A_direction = cmd[0:2] #字符串0/1两位为控制A（左边车轮）方向信号
B_direction = cmd[4:6] #4/5位为控制B（右边车轮）方向信号
A_speed = cmd[2:4] #字符串2/3两位为控制A（左边车轮）速度信号
B_speed = cmd[6:8] #字符串6/7两位为控制B（右边车轮）速度信号
print (A_direction,B_direction,A_speed,B_speed) #测试用
if A_direction == "ff": #控制A（左边车轮）顺时针信号
smpcar.clockwise(smpcar.IN1,smpcar.IN2)
if A_direction == "00": #控制A（左边车轮）逆时针信号
smpcar.counter_clockwise(smpcar.IN1,smpcar.IN2)
if B_direction == "ff": #控制B（右边车轮）顺时针信号
smpcar.clockwise(smpcar.IN3,smpcar.IN4)
if B_direction == "00": #控制B（右边车轮）逆时针信号
smpcar.counter_clockwise(smpcar.IN3,smpcar.IN4)
if direction == "b": #小车刹车，IN1和IN2都为0，马达制动
smpcar.stop_car(smpcar.IN1,smpcar.IN2)
smpcar.stop_car(smpcar.IN3,smpcar.IN4)
continue #跳出本次循环
# 通过输入的两位数字设置占空比，改变马达转速
smpcar.changespeed(ENA_pwm,int(A_speed))
smpcar.changespeed(ENB_pwm,int(B_speed))
except KeyboardInterrupt: # When 'Ctrl C' is pressed, the child program destroy() will be executed.
smpcar.destroy(ENA_pwm,ENB_pwm)
finally:
smpcar.destroy(ENA_pwm,ENB_pwm)第3步： 小车行进控制模块，文件名为moving_control.py，设计小车的移动行为，方向控制分为：原地左转弯、原地右转弯、直线前进、直线后退、刹车，而向前左偏移开进或右偏移开进等，由左右两边不同的速度（油门）来控制。
moving_control.py:
代码语言：txt复制#-*- coding: utf-8 -*-
#本模块只含MovingControl()一个类，针对遥控器的控制方式，设计小车的移动行为
#方向控制分为：原地左转弯、原地右转弯、直线前进、直线后退、刹车
#而向前左偏移开进或右偏移开进等，由左右两边不同的速度（油门）来控制
class MovingControl():
def __init__(self, smpcar,pwm1,pwm2):
self.smpcar=smpcar
self.ENA_pwm=pwm1
self.ENB_pwm=pwm2
self.rudder_value = 0
self.acc_value = 0
def accelerator(self,rate_left=1,rate_right=1):
'''速度（油门）控制'''
#rate_left为向左偏移行进时，降低左边轮的速度
#rate_right为向右偏移行进时，降低右边轮的速度
self.smpcar.changespeed(self.ENA_pwm,self.acc_value * rate_left)
self.smpcar.changespeed(self.ENB_pwm,self.acc_value * rate_right)
def leftTurn(self):
'''原地左转弯'''
self.smpcar.counter_clockwise(self.smpcar.IN1,self.smpcar.IN2) #左边车轮后退
self.smpcar.clockwise(self.smpcar.IN3,self.smpcar.IN4) #右边车轮前进
def rightTurn(self):
'''原地右转弯'''
self.smpcar.clockwise(self.smpcar.IN1,self.smpcar.IN2)
self.smpcar.counter_clockwise(self.smpcar.IN3,self.smpcar.IN4)
def forward(self):
'''直线前进'''
self.smpcar.clockwise(self.smpcar.IN1,self.smpcar.IN2)
self.smpcar.clockwise(self.smpcar.IN3,self.smpcar.IN4)
def reverse(self):
'''直线后退'''
self.smpcar.counter_clockwise(self.smpcar.IN1,self.smpcar.IN2)
self.smpcar.counter_clockwise(self.smpcar.IN3,self.smpcar.IN4)
def brake(self):
'''刹车'''
self.smpcar.stop_car(self.smpcar.IN1,self.smpcar.IN2)
self.smpcar.stop_car(self.smpcar.IN3,self.smpcar.IN4)第4步： 编写SBUS信号接收解析模块，文件名为sbus_receiver_pi.py，与树莓派基础实验39：解析无线电接收机PWM、SBUS信号中的Python2程序有所不同，下面的程序在Python3中运行，并标注了两者的不同之处。
sbus_receiver_pi.py：
代码语言：txt复制#!/usr/bin/env python
#-*- coding: utf-8 -*-
#本模块只含SBUSReceiver()一个类，用于获取和解析遥控器接收机的SBUS输出信号
#并能返回每个通道的数值，遥控器的failsafe信号状态，每次获得数据帧的长度和这次数据的延迟时间
#import array #python2运行时需要，array模块是python中实现的一种高效的数组存储类型
import serial #serial模块封装了对串行端口的访问
#import binascii #python2运行时需要，binascii模块包含很多在二进制和ASCII编码的二进制表示转换的方法
#import codecs #python2运行时需要，Python中专门用作编码转换的模块
import time
class SBUSReceiver():
def __init__(self, _uart_port='/dev/ttyAMA0'):
#初始化树莓派串口参数
self.ser = serial.Serial(
port=_uart_port, #树莓派的硬件串口/dev/ttyAMA0
baudrate = 100000, #波特率为100k
parity=serial.PARITY_EVEN, #偶校验
stopbits=serial.STOPBITS_TWO,#2个停止位
bytesize=serial.EIGHTBITS, #8个数据位
timeout = 0,
)
# 常数
#这里注意：Python2 与Python3 的编码方式是不同的
#self.START_BYTE = b'x0f' #python2运行时用这句，起始字节为0x0f
#self.END_BYTE = b'x00' #python2运行时用这句，结束字节为0x00
self.START_BYTE = 0x0f #python3运行时用这句，起始字节为0x0f
self.END_BYTE = 0x00 #python3运行时用这句，结束字节为0x00
self.SBUS_FRAME_LEN = 25 #SBUS帧有25个字节
self.SBUS_NUM_CHAN = 18 #18个通道
self.OUT_OF_SYNC_THD = 10
self.SBUS_NUM_CHANNELS = 18 #18个通道
self.SBUS_SIGNAL_OK = 0 #信号正常为0
self.SBUS_SIGNAL_LOST = 1 #信号丢失为1
self.SBUS_SIGNAL_FAILSAFE = 2 #输出failsafe信号时为2
# 堆栈变量初始化
self.isReady = True
self.lastFrameTime = 0
self.sbusBuff = bytearray(1) # 用于同步的单个字节
#bytearray(n) 方法返回一个长度为n的初始化数组；
'''这里Python2与Python3存储数据的编码格式会不同'''
self.sbusFrame = bytearray(25) # 单个SBUS数据帧，25个字节
# 接收到的各频道值，前面的Python2中使用了数组
#self.sbusChannels = array.array('H', [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
#array.array(typecode,[initializer]) --typecode:元素类型代码；initializer:初始化器，若数组为空，则省略初始化器
# 接收到的各频道值，Python3中这里也可以使用列表
self.sbusChannels = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
self.failSafeStatus = self.SBUS_SIGNAL_FAILSAFE
def get_rx_channels(self):
"""
用于读取最后的SBUS通道值
返回:由18个无符号短元素组成的数组，包含16个标准通道值 2个数字(ch17和18)
"""
return self.sbusChannels
def get_rx_channel(self, num_ch):
"""
用于读取最后的SBUS某一特定通道的值
num_ch: 要读取的某个通道的通道序号
返回:某一通道的值
"""
return self.sbusChannels[num_ch]
def get_failsafe_status(self):
"""
用于获取最后的FAILSAFE状态
返回: FAILSAFE状态值
"""
return self.failSafeStatus
def decode_frame(self):
"""
对每帧数据进行解码，每个通道的值在两个或三个不同的字节之间，要读取出来很麻烦
不过futaba已经发布了下面的解码代码
"""
def toInt(_from):
#encode() 方法以指定的编码格式编码字符串。
#int() 函数用于将一个字符串或数字转换为整型。
#return int(codecs.encode(_from, 'hex'), 16) #Python2中要使用这句，转换编码格式
return _from #Python3中要使用这句，即不用转换编码格式
#CH1 = [data2]的低3位 [data1]的8位（678 12345678 = 678,12345678）
self.sbusChannels[0] = ((toInt(self.sbusFrame[1]) |toInt(self.sbusFrame[2])<<8) & 0x07FF);
#CH2 = [data3]的低6位 [data2]的高5位（345678 12345 = 345678,12345 ）
self.sbusChannels[1] = ((toInt(self.sbusFrame[2])>>3 |toInt(self.sbusFrame[3])<<5) & 0x07FF);
#CH3 = [data5]的低1位 [data4]的8位 [data3]的高2位（8 12345678 12 = 8,12345678,12）
self.sbusChannels[2] = ((toInt(self.sbusFrame[3])>>6 |toInt(self.sbusFrame[4])<<2 |toInt(self.sbusFrame[5])<<10) & 0x07FF);
self.sbusChannels[3] = ((toInt(self.sbusFrame[5])>>1 |toInt(self.sbusFrame[6])<<7) & 0x07FF);
self.sbusChannels[4] = ((toInt(self.sbusFrame[6])>>4 |toInt(self.sbusFrame[7])<<4) & 0x07FF);
self.sbusChannels[5] = ((toInt(self.sbusFrame[7])>>7 |toInt(self.sbusFrame[8])<<1 |toInt(self.sbusFrame[9])<<9) & 0x07FF);
self.sbusChannels[6] = ((toInt(self.sbusFrame[9])>>2 |toInt(self.sbusFrame[10])<<6) & 0x07FF);
self.sbusChannels[7] = ((toInt(self.sbusFrame[10])>>5 |toInt(self.sbusFrame[11])<<3) & 0x07FF);
self.sbusChannels[8] = ((toInt(self.sbusFrame[12]) |toInt(self.sbusFrame[13])<<8) & 0x07FF);
self.sbusChannels[9] = ((toInt(self.sbusFrame[13])>>3 |toInt(self.sbusFrame[14])<<5) & 0x07FF);
self.sbusChannels[10] = ((toInt(self.sbusFrame[14])>>6 |toInt(self.sbusFrame[15])<<2|toInt(self.sbusFrame[16])<<10) & 0x07FF);
self.sbusChannels[11] = ((toInt(self.sbusFrame[16])>>1 |toInt(self.sbusFrame[17])<<7) & 0x07FF);
self.sbusChannels[12] = ((toInt(self.sbusFrame[17])>>4 |toInt(self.sbusFrame[18])<<4) & 0x07FF);
self.sbusChannels[13] = ((toInt(self.sbusFrame[18])>>7 |toInt(self.sbusFrame[19])<<1|toInt(self.sbusFrame[20])<<9) & 0x07FF);
self.sbusChannels[14] = ((toInt(self.sbusFrame[20])>>2 |toInt(self.sbusFrame[21])<<6) & 0x07FF);
self.sbusChannels[15] = ((toInt(self.sbusFrame[21])>>5 |toInt(self.sbusFrame[22])<<3) & 0x07FF);
#17频道，第24字节的最低一位
if toInt(self.sbusFrame[23]) & 0x0001 :
self.sbusChannels[16] = 2047
else:
self.sbusChannels[16] = 0
#18频道，第24字节的低第二位，所以要右移一位
if (toInt(self.sbusFrame[23]) >> 1) & 0x0001 :
self.sbusChannels[17] = 2047
else:
self.sbusChannels[17] = 0
#帧丢失位为1时，第24字节的低第三位，与0x04进行与运算
self.failSafeStatus = self.SBUS_SIGNAL_OK
if toInt(self.sbusFrame[23]) & (1 << 2):
self.failSafeStatus = self.SBUS_SIGNAL_LOST
#故障保护激活位为1时，第24字节的低第四位，与0x08进行与运算
if toInt(self.sbusFrame[23]) & (1 << 3):
self.failSafeStatus = self.SBUS_SIGNAL_FAILSAFE
def update(self):
"""
我们需要至少2帧大小，以确保找到一个完整的帧
所以我们取出所有的缓存（清空它），读取全部数据，直到捕获新的数据
首先找到END BYTE并向后查找SBUS_FRAME_LEN，看看它是否是START BYTE
"""
#我们是否有足够的数据在缓冲区和有没有线程在后台?
if self.ser.inWaiting() >= self.SBUS_FRAME_LEN*2 and self.isReady: #inWaiting()返回接收缓存中的字节数
self.isReady = False #表明有线程在运行，isReady = False
# 读取所有临时帧数据
tempFrame = self.ser.read(self.ser.inWaiting())
# 在缓冲区帧的每个字符中，我们寻找结束字节
for end in range(0, self.SBUS_FRAME_LEN):
#寻找结束字节，从后向前查找
if tempFrame[len(tempFrame)-1-end] == self.END_BYTE :
#从最后的命中点减去SBUS_FRAME_LEN寻找起始字节
if tempFrame[len(tempFrame)-end-self.SBUS_FRAME_LEN] == self.START_BYTE :
# 如果相等，则帧数据正确，数据以8E2包到达，因此它已经被校验过
# 从临时帧数据中取出刚验证正确的一段正确帧数据
lastUpdate = tempFrame[len(tempFrame)-end-self.SBUS_FRAME_LEN:len(tempFrame)-1-end]
if not self.sbusFrame == lastUpdate: #相等即表示没有操作，不用再次解码
self.sbusFrame = lastUpdate
self.decode_frame() #调用解码函数
self.lastFrameTime = time.time() # 跟踪最近的更新时间
self.isReady = True
break
if __name__ == '__main__':
sbus = SBUSReceiver('/dev/ttyAMA0')
while True:
time.sleep(0.005)
# X8R的SBUS信号是间隔6ms发送一次，一次持续发送3ms；
# 不要调用sbus.update()太快，如果sbus.ser.inWaiting()>50,且增长很多，可以调用sbus.update()快点，即time.sleep()延迟短点；
# 如果sbus.ser.inWaiting()<50,可以调用sbus.update()慢点，即time.sleep()延迟长点；
sbus.update()
#在您的代码中，您可以调用sbus.get_rx_channels()来获取所有数据，或者调用sbus.get_rx_channels()[n]来获取第n个通道的值；
#或get_rx_channel(self, num_ch)来获得第num_ch个通道的值；
print(sbus.get_failsafe_status(), sbus.get_rx_channels(), str(sbus.ser.inWaiting()).zfill(4) , (time.time()-sbus.lastFrameTime))
#str() 函数将对象转化为适于人阅读的形式，将指定的值转换为字符串。
#zfill() 方法返回指定长度的字符串，原字符串右对齐，前面填充0。
#(time.time()-sbus.lastFrameTime)用于展示得到最近这次数据的延迟第5步： 编写树莓派智能小车的主程序，文件名为smartcar.py，将这4个Python文件放入一个文件夹后，只运行本文件就可以了。
smartcar.py：
代码语言：txt复制#!/usr/bin/env python
#-*- coding: utf-8 -*-
#本模块为树莓派小车的主程序
from motor_4w import SMPcar
from sbus_receiver_pi import SBUSReceiver
from moving_control import MovingControl
import time
try:
sbus_receiver = SBUSReceiver('/dev/ttyAMA0') #初始化实例
smp_car = SMPcar() #初始化实例
smp_car.setGPIO() #初始化引脚
ENA_pwm = smp_car.pwm(smp_car.ENA) #初始化使能信号PWM，A为左边车轮
ENB_pwm = smp_car.pwm(smp_car.ENB) #初始化使能信号PWM，B为右边车轮
smartcar = MovingControl(smp_car,ENA_pwm,ENB_pwm) ##初始化实例
acc_value_sbus = 172 #3通道，即油门的值，最低时为172
while True:
time.sleep(0.005)
sbus_receiver.update() #获取一个完整的帧数据
aileron_value = sbus_receiver.get_rx_channel(0) #1通道为副翼通道，这里控制车原地转向
elevator_value = sbus_receiver.get_rx_channel(1)#2通道为升降舵通道，这里控制车前进后退
smartcar.rudder_value = sbus_receiver.get_rx_channel(3)#4通道为方向舵通道，这里控制车左右偏移行进
if sbus_receiver.get_rx_channel(2):
acc_value_sbus = sbus_receiver.get_rx_channel(2) #3通道为油门通道，这里控制车速度
#将172~1811的油门通道值转换为0~100的占空比信号，
smartcar.acc_value = int(100*(acc_value_sbus-172)/(1811-172))
if 970 < smartcar.rudder_value < 1100: #没有左右偏移时，中间值为992，但遥控器微调时会有上下浮动
smartcar.accelerator()
elif smartcar.rudder_value >=1100: #向右偏移行进时
rate_right = (1811.0 - smartcar.rudder_value)/(1811-1100)
#最大值一般为1811，这里使用浮点类型，所以一定要使用1811.0
smartcar.accelerator(1,rate_right)
elif smartcar.rudder_value <=970: #向左偏移行进时
rate_left = (smartcar.rudder_value - 172.0)/(970-172)
#最小值为172，这里使用浮点类型，所以一定要使用172.0
smartcar.accelerator(rate_left,1)
print(elevator_value,smartcar.acc_value,aileron_value,smartcar.rudder_value)#测试数据用
if aileron_value >= 1100: #原地左转弯
smartcar.leftTurn()
elif aileron_value <= 970: #原地右转弯
smartcar.rightTurn()
else :
smartcar.brake() #停车
if elevator_value >=1100: #前进
smartcar.forward()
elif elevator_value <=970: #后退
smartcar.reverse()
#循环最后，这里不能再用停车了
except KeyboardInterrupt:
smp_car.destroy(ENA_pwm,ENB_pwm)
finally:
smp_car.destroy(ENA_pwm,ENB_pwm)
操控演示视频：
https://www.bilibili.com/video/BV1Q5411L75a/
最近太忙，这篇文章拖了很久才完成，当中克服了一个个不懂的技术难点和BUG，不过终于实现了遥控小车的想法，成功将无线电遥控和树莓派结合起来。
辛苦是值得的，学到不少东西，后面将陆续把各种传感器加入进来，实现智能化。
这个项目的代码90%是我原创瞎写的，有需要参考的同学可以下载：
树莓派智能小车项目python源代码下载
