使用EV3主机上的按键控制小车还是比较麻烦，能不能通过遥控来控制小车呢？

当然可以！

乐高提供了一个红外线传感器和遥控器：

但是红外遥控器需要很强的方向性，而且那个遥控器太简陋了，连个摇杆都没有。

还有一种方式是使用蓝牙手柄，这样我们就可以找一个游戏手柄直接通过蓝牙控制小车，太方便了有木有！

我找了一个任天堂的游戏手柄：

理论上支持蓝牙的游戏手柄都是可用的，标准游戏手柄按键如下：

┌──────┐ ┌──────┐

┌┴─────┐│ ┌┴─────┐│

┌─┴──────┴┴──────────────────┴──────┴┴─┐

│ ┌─┐ ┌─┐ ┌─┐ │

│ ┌─┐ └─┘ └─┘ ┌─┐│X│ │

│ ┌─┘ └─┐ - + │Y│└─┘┌─┐ │

│ └─┐ ┌─┘ ┌─┐ ┌─┐ └─┘┌─┐│A│ │

│ └─┘ └─┘ └─┘ │B│└─┘ │

│ ┌─┐ S H ┌─┐ └─┘ │

│ ┌─┘ └─┐ ┌─┘ └─┐ │

│ └─┐ ┌─┘ └─┐ ┌─┘ │

│ └─┘ └─┘ │

│ ──────────────────────── │

│ / \ │

│ / \ │

└────/ \────┘

把游戏手柄和EV3主机用蓝牙连起来很简单，但是怎么用Python程序读取手柄的输入？

一般来说，从外部设备读取输入时，应用程序并不直接与外设打交道，而是由操作系统通过驱动程序连接外设，然后，通过操作系统提供的API读取输入。Windows程序可以通过DirectX访问外设，运行在网页的JavaScript程序可以通过浏览器提供的Gamepad API。

EV3主机运行的是Debian Linux，那么Python程序如何在Linux下读取手柄的输入？

在Linux中，系统把每个外设都映射为文件，每个设备的输入也被映射为文件。/proc目录挂载的就是Linux的虚拟文件系统，映射Linux的进程信息和设备信息。我们登录到EV3，查看/proc/bus/input/devices文件：

$ cat /proc/bus/input/devices

I: Bus=0000 Vendor=0000 Product=0000 Version=0000

N: Name="LEGO MINDSTORMS EV3 Speaker"

P: Phys=

S: Sysfs=/devices/platform/sound/input/input0

U: Uniq=

H: Handlers=kbd event0

B: PROP=0

B: EV=40001

B: SND=6

I: Bus=0019 Vendor=0001 Product=0001 Version=0100

N: Name="EV3 Brick Buttons"

P: Phys=gpio-keys/input0

S: Sysfs=/devices/platform/gpio_keys/input/input1

U: Uniq=

H: Handlers=kbd event1

B: PROP=0

B: EV=3

B: KEY=1680 0 0 10004000

这个文件列出了目前系统可用的输入设备，上述两段分别代表扬声器和按钮设备。如果我们把蓝牙手柄连接到EV3，再查看文件，发现多了一段内容：

I: Bus=0005 Vendor=057e Product=2009 Version=0001

N: Name="Pro Controller"

P: Phys=00:17:ec:13:d8:1d

S: Sysfs=/devices/platform/soc@1c00000/serial8250.2/tty/ttyS2/hci0/hci0:2/0005:057E:2009.0003/input/input4

U: Uniq=00:90:e3:9b:ec:e9

H: Handlers=event2

B: PROP=0

B: EV=10001b

B: KEY=ffff0000 0 0 0 0 0 0 0 0 0

B: ABS=3001b

B: MSC=10

我们通过N: Name="xxx"来搜索手柄设备，然后，通过H: Handlers=xxx获取设备的输入文件。例如，上述蓝牙手柄的名称是Pro Controller，输入是event2，对应到系统文件就是/dev/input/event2。Python代码实现如下：

定义InputDevice类表示输入设备：

class InputDevice():

def __init__(self):

self.name = ''

self.handler = ''

def __str__(self):

return '' % (self.name, self.handler)

def setName(self, name):

if len(name) >= 2 and name.startswith('"') and name.endswith('"'):

name = name[1:len(name)-1]

self.name = name

def setHandler(self, handlers):

for handler in handlers.split(' '):

if handler.startswith('event'):

self.handler = handler

定义函数listDevices()通过读取/proc/bus/input/devices文件获取所有设备：

def listDevices():

devices = []

with open('/proc/bus/input/devices', 'r') as f:

device = None

while True:

s = f.readline()

if s == '':

break

s = s.strip()

if s == '':

devices.append(device)

device = None

else:

if device is None:

device = InputDevice()

if s.startswith('N: Name='):

device.setName(s[8:])

elif s.startswith('H: Handlers='):

device.setHandler(s[12:])

return devices

定义函数detectJoystick()通过名字模糊查找手柄设备：

def detectJoystick(joystickNames):

for device in listDevices():

for joystickName in joystickNames:

if joystickName in device.name:

# 返回输入文件:

return '/dev/input/%s' % device.handler

# 未找到返回None:

return None

搜索到手柄设备后打开文件读取输入：

eventFile = detectJoystick(['Controller'])

if eventFile:

with open(eventFile, 'rb') as infile:

while True:

# 读取输入

现在最关键的问题来了：eventX文件应该以何种格式读取？

让我们搜索一下Linux文档，在input.txt中详细说明了eventX文件的输入格式。Linux系统把每一个输入事件都封装为一个C结构体让我们直接读取：

struct input_event {

struct timeval time; // 16字节时间戳

unsigned short type; // 2字节事件类型

unsigned short code; // 2字节事件代码

unsigned int value; // 4字节事件值

};

每次读取24字节并按照C的struct类型解码，即可得到手柄输入的全部信息。在Python程序中，可以用struct读取：

FORMAT = 'llHHI'

EVENT_SIZE = struct.calcsize(FORMAT)

with open(eventFile, 'rb') as infile:

while True:

event = infile.read(EVENT_SIZE)

_, _, t, c, v = struct.unpack(FORMAT, event)

print('t = %s, c = %s, v = %s' % (t, c, v))

注意到unpack()方法的返回值，我们丢弃了前两个8字节整数，保留了t、c、v，分别是2字节无符号整数、2字节无符号整数和4字节无符号整数。

根据Linux文档，再打印出每个事件的详细数据，把手柄的按键和摇杆都按一遍，就可以得到按键编码如下：

t==1时表示按键，此时v==1表示按下，v==0表示释放，v==2表示持续按下，对应的c表示按键编码。要检测A、B按钮按下，可以这么写：

if t == 1 and v == 1:

if c == 305:

# Button A pressed

pass

if c == 304:

# Button B pressed

pass

摇杆数据则比较复杂，类型t==3表示摇杆，如果c==0，表示左摇杆的左右移动，如果c==1，表示左摇杆的上下移动，v的值介于0~65535，32768表示中心值，越往两侧偏移越多则越接近最大和最小值：

0

▲

│

0 65535

│

▼

65535

现在我们就可以通过一个读取手柄的无限循环来控制小车：

def joystickLoop(robot, eventFile):

FORMAT = 'llHHI'

EVENT_SIZE = struct.calcsize(FORMAT)

with open(eventFile, 'rb') as infile:

while True:

event = infile.read(EVENT_SIZE)

_, _, t, c, v = struct.unpack(FORMAT, event)

if t == 1 and v == 1:

if c == 305:

# A键加速:

robot.setSpeed(1)

elif c == 304:

# B键减速:

robot.setSpeed(-1)

elif c == 307:

# X键退出:

return robot.inactive()

elif t == 3:

if c == 1:

# 左摇杆上下移动:

speed = 0

if v < 32768:

# 加速:

speed = 1

elif v > 32768:

# 减速:

speed = -1

robot.setSpeed(speed)

但是另一个问题来了：主线程通过死循环读取手柄输入，那么怎么读取超声波传感器的数据？

可以利用Python的threading启动多线程，在另一个线程中不断检测超声波传感器，并在条件达到的时候自动停车：

def autoStopLoop(robot):

while robot.active:

if robot.speed > 0 and robot.ultrasonic.distance() < 200:

robot.setSpeed(0)

wait(100)

joystickEvent = detectJoystick(['Controller'])

robot = Robot()

t = threading.Thread(target=autoStopLoop, args=(robot,))

t.start()

joystickLoop(robot, joystickEvent)

到此为止，一个蓝牙手柄控制的机器人程序就宣告完成。试试效果：

参考源码