前言

在 上一篇文章 中，我们讲了魔改实现远程控车的基本思路，但是我们仅仅实现了主动控制，对于距离感知被动解锁尚未实现，本篇文章的内容就是实现距离感应自动解锁。

ps: 又是隔了这么久，终于又想继续折腾这玩意儿了，毕竟已经拆了一把钥匙了，不继续折腾下去就太亏了。

实现思路

整体介绍

在上文中，我们提到过，可以通过检测特定蓝牙设备的 RSSI 值来判断设备距离车辆的位置。

RSSI 即 Received Signal Strength Indication，直译过来就是接受信号强度指示的意思，目前很多物联网设备就是使用的 RSSI 作为定位和判断距离的手段，所以这个方案理论上是没有任何问题的。

简单理解，就是信号强度越大，即 RSSI 值越大，就说明两个设备之间的距离越近，而对于我们的需求来说，并不需要实现复杂的算法来计算出较为精确的距离，只需要测试后设置一个合适的阈值即可，因为信号强度会受到所处环境，遮挡物，甚至设备本身工况的各个方面的因素影响，如果非得通过一系列复杂的算法求出精确距离属实是大可不必的。

使用经典蓝牙

在上文中，我们有说过为什么最终会选择支持经典蓝牙的 ESP32 而不是更加便宜但是只支持 BLE 的 ESP32C3 作为控制主板。

如果忘记了没关系，我在这里简单复述一遍，因为 BLE 不支持连接，只支持发送广播包，这样附近所有的设备都可以截获到我和主板通信的数据包，对于安全没有保障，虽然 BLE 支持配对，但是 ESP32C3 的 MicroPython 不支持。

并且，由于不支持配对，我无法获取到手机的真实 MAC 地址，也就无法继续通过 MAC 地址判断特定设备的距离。

那么问题来了，经典蓝牙支持配对，但是可以拿到已配对设备的 RSSI 吗？

查找了一圈的文档和各个论坛，最终发现，在 Arduino 的经典蓝牙支持库中，无法直接获取到 RSSI ……

只能获取到 RSSI 变化量……

而且无法拿到初始量，一开始获取到的就是变化量……

也就是说，我压根没法通过经典蓝牙拿到正确的 RSSI 值……

而且，即使是获取 RSSI 变化量也特别繁琐……

怎么办？总不能放弃吧？

或许，可以使用 BLE ？

使用 BLE

万幸的是， ESP32 开发板支持经典蓝牙和 BLE 双模。

也就是说，虽然经典蓝牙拿不到 RSSI，但是我可以用 BLE 拿了。

但是问题又来了，我扫描哪个设备的 BLE 信号？

扫描手机是不现实的，因为手机系统限制，无法一直对外发送广播包，即使我自己写一个 APP， 不停的向外发送广播包也不可能，因为安卓系统为了省电，对蓝牙使用做出了很大的限制：

如果长时间扫描设备或发送广播包会被系统强制关闭；如果手机息屏也会被系统强制关闭。

也就是说，如果我扫描的是手机的 RSSI 的话，我每次靠近车前还得掏出手机，打开 APP，并且保持 APP 在前台运行直至车辆解锁……

这么麻烦，那我为什么不直接用车钥匙呢？？

正当我一筹莫展的时候，低头看见了我手上戴的手环！

对啊，为什么不直接扫描我的手环呢？

因为我戴的小米手环，可以在设置中开启持续对外广播功能，虽然官方说这样会增大耗电量，但是经过我半个月的测试下来，实际增加的耗电量几乎可以忽略不计的。

而且，扫描小米手环还有一个好处，就是小米手环的 MAC 是固定的真实 MAC ，不像手机那样是随机 MAC。

那么我们来看看能不能获取到 RSSI 呢，依旧是使用官方示例代码进行简单的修改：

/*
   Based on Neil Kolban example for IDF: https://github.com/nkolban/esp32-snippets/blob/master/cpp_utils/tests/BLE%20Tests/SampleScan.cpp
   Ported to Arduino ESP32 by Evandro Copercini
*/

#include 
#include 
#include 
#include 

int scanTime = 5; // 每次扫描时间（单位：秒）

class MyAdvertisedDeviceCallbacks: public BLEAdvertisedDeviceCallbacks { // 扫描结果回调
    void onResult(BLEAdvertisedDevice advertisedDevice) {
      if (advertisedDevice.getAddress().equals(BLEAddress("11:22:33:44:55:66"))) {  // 过滤我的小米手环的 MAC
        Serial.printf("Advertised Device: %s \n", advertisedDevice.toString().c_str());
        Serial.print(" RSSI: ");
        Serial.println(advertisedDevice.getRSSI());
        Serial.print("FIND!");
        if (advertisedDevice.getRSSI() >= -100) {  // 获取并判断 RSSI 值是否大于 -100 （其实这个值填大了，对于我的测试环境 RSSI 压根不会小于 -100，早在小于 -100 之前就已经扫描不到设备了）
          Serial.print("SUIT!");
        }
      }
    }
};

void start_scan() {  // 开始扫描
  Serial.println("Scanning...");
  BLEDevice::init("");
  BLEScan* pBLEScan = BLEDevice::getScan(); //create new scan
  pBLEScan->setAdvertisedDeviceCallbacks(new MyAdvertisedDeviceCallbacks());
  pBLEScan->setActiveScan(true); //active scan uses more power, but get results faster
  BLEScanResults foundDevices = pBLEScan->start(scanTime);
  Serial.print("Devices found: ");
  Serial.println(foundDevices.getCount());
  Serial.println("Scan done!");
}

void setup() {
  Serial.begin(115200);
}

void loop() {  // 在 loop 中循环扫描
  start_scan();
  delay(5);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

上面代码我已经在注释中大致解释了每个部分都是什么用处，这里补充说明一点，扫描方法 start_scan 是阻塞函数，阻塞时间就是设置的扫描时间。

把上面代码编译后烧录进 ESP32 ，运行完美，成功扫描到我的手环，并且获取到了 RSSI 。

这么一说，是不是觉得使用小米手环简直完美了啊，其实不然，原因也很简单，上面说了，它的 MAC 是固定的真实地址，换句话来说就是，如果有人通过某种手段拿到了你的手环的 MAC 地址，然后再使用某种设备伪造这个 MAC 地址，岂不就是可以把我车开走了？

不过现在先暂时不考虑这么多，先验证思路可行性再说。

既然扫描 RSSI 没问题了，那是不是意味着现在就可用了呢？

非也，因为虽然 ESP32 支持经典蓝牙和 BLE 双模，但是并不意味着它支持同时开启 BLE 和经典蓝牙啊，所以我们下一步是测试混合使用经典蓝牙和 BLE。

结合经典蓝牙和 BLE

我们将上一篇文章中编写的经典蓝牙代码和本文中的 BLE 代码混合在一起：

#include "BluetoothSerial.h"
#include 
#include 
#include 
#include 

#if !defined(CONFIG_BT_ENABLED) || !defined(CONFIG_BLUEDROID_ENABLED)
#error Bluetooth is not enabled! Please run `make menuconfig` to and enable it
#endif

#if !defined(CONFIG_BT_SPP_ENABLED)
#error Serial Bluetooth not available or not enabled. It is only available for the ESP32 chip.
#endif

#define LED_CONNECT 2
#define LED_POWER 15

#define PIN_POWER 13
#define PIN_LOCK 12
#define PIN_LOOP 14

int scanTime = 5; // BLE 扫描时间（S）
int isScanedDevice = 0; // BLE本次是否搜索到指定设备

boolean isConnectDevice = false; // 是否连接上了经典蓝牙

BluetoothSerial SerialBT;
boolean confirmRequestPending = true;

void get_start() {
    digitalWrite(LED_POWER, HIGH);
    digitalWrite(PIN_POWER, HIGH);
}

void cut_power() {
    digitalWrite(LED_POWER, LOW);
    digitalWrite(PIN_POWER, LOW);
}

void lock_car() {
    digitalWrite(PIN_LOCK, LOW);
    delay(500);
    digitalWrite(PIN_LOCK, HIGH);
    delay(1000);
    digitalWrite(LED_POWER, LOW);
    digitalWrite(PIN_POWER, LOW);
}

void luncher_car() {
    digitalWrite(PIN_LOCK, LOW);
    delay(300);
    digitalWrite(PIN_LOCK, HIGH);
    delay(1000);
    digitalWrite(PIN_LOOP, LOW);
    delay(8000);
    digitalWrite(PIN_LOOP, HIGH);
}

void shut_down_car() {
    digitalWrite(PIN_LOOP, LOW);
    delay(8000);
    digitalWrite(PIN_LOOP, HIGH);
}

void find_my_car() {
    digitalWrite(PIN_LOOP, LOW);
    delay(200);
    digitalWrite(PIN_LOOP, HIGH);
    delay(300);
    digitalWrite(PIN_LOOP, LOW);
    delay(200);
    digitalWrite(PIN_LOOP, HIGH);
}

void click_loop() {
    digitalWrite(PIN_LOOP, LOW);
    delay(200);
    digitalWrite(PIN_LOOP, HIGH);
}

void click_lock() {
    digitalWrite(PIN_LOCK, LOW);
    delay(200);
    digitalWrite(PIN_LOCK, HIGH);
}

void read_status() {
  int power_value = digitalRead(PIN_POWER);
  int loop_value = digitalRead(PIN_LOOP);
  int lock_value = digitalRead(PIN_LOCK);

  char s[200];
  sprintf(s, "power %d, loop %d, lock %d\n", power_value, loop_value, lock_value);
  SerialBT.print(s);
}

class MyAdvertisedDeviceCallbacks: public BLEAdvertisedDeviceCallbacks {
    void onResult(BLEAdvertisedDevice advertisedDevice) {
      if (advertisedDevice.getAddress().equals(BLEAddress("11:22:33:44:55:66"))) {
        isScanedDevice = 1;
        if (advertisedDevice.getRSSI() >= -100) {
          // 这个地方表示扫描到了指定 BLE 设备，且 RSSI 满足阈值
          Serial.print("Power On by ble， rssi= ");
          Serial.println(advertisedDevice.getRSSI());

          get_start();
          // TODO 这里应该加上触发解锁按键，避免钥匙检测失效
        }
        else {
          // 这个地方表示扫描到了指定 BLE 设备，但是 RSSI 未达到阈值
        
          Serial.println("Power Off by ble rsssi not suit!");

          lock_car();
        }
      }
    }
};

void start_scan() {
  isScanedDevice = 0;
  BLEDevice::init("");
  BLEScan* pBLEScan = BLEDevice::getScan(); //create new scan
  pBLEScan->setAdvertisedDeviceCallbacks(new MyAdvertisedDeviceCallbacks());
  pBLEScan->setActiveScan(true); //active scan uses more power, but get results faster
  BLEScanResults foundDevices = pBLEScan->start(scanTime);
  if (isScanedDevice == 0) {
      // 这里表示本次扫描已经结束，但是没有扫描到指定 BLE 设备
      Serial.println("Power Off by ble not found!");

      lock_car();
  }
}

void BTConfirmRequestCallback(uint32_t numVal)
{
  confirmRequestPending = true;
  Serial.println(numVal);
}

void BTAuthCompleteCallback(boolean success)
{
  confirmRequestPending = false;
  if (success)
  {
    Serial.println("Pairing success!!");
  }
  else
  {
    Serial.println("Pairing failed, rejected by user!!");
  }
}

// Bt_Status callback function
void Bt_Status (esp_spp_cb_event_t event, esp_spp_cb_param_t *param) {

  if (event == ESP_SPP_SRV_OPEN_EVT) {
    Serial.println ("Client Connected");
    digitalWrite(LED_CONNECT, HIGH);
    isConnectDevice = true;
    confirmRequestPending = false;
    // Do stuff if connected
  }

  else if (event == ESP_SPP_CLOSE_EVT ) {
    Serial.println ("Client Disconnected");
    digitalWrite(LED_CONNECT, LOW);
    isConnectDevice = false;
    // Do stuff if not connected
  }
}

void setup()
{
  Serial.begin(115200);

  pinMode(LED_CONNECT, OUTPUT);
  pinMode(LED_POWER, OUTPUT);
  
  pinMode(PIN_POWER, OUTPUT);
  pinMode(PIN_LOCK, OUTPUT);
  pinMode(PIN_LOOP, OUTPUT);

  digitalWrite(PIN_LOCK, HIGH);
  digitalWrite(PIN_LOOP, HIGH);
  
  SerialBT.enableSSP();
  SerialBT.onConfirmRequest(BTConfirmRequestCallback);
  SerialBT.onAuthComplete(BTAuthCompleteCallback);
    // Define the Bt_Status callback
  SerialBT.register_callback (Bt_Status);
  SerialBT.begin("equationl's Auto"); //Bluetooth device name
  Serial.println("The device started, now you can pair it with bluetooth!");
}

void loop()
{
  if (!isConnectDevice) {  // 只有在没有连接经典蓝牙的情况下才扫描 BLE 设备，否则经典蓝牙的数据交互将被 start_scan 阻塞
    start_scan();  // 开始搜索 BLE 设备
  }

  if (confirmRequestPending)
  {
    if (Serial.available())
    {
      int dat = Serial.read();
      if (dat == '1')
      {
        SerialBT.confirmReply(true);
      }
      else
      {
        SerialBT.confirmReply(false);
      }
    }
  }
  else
  {
    if (Serial.available())
    {
      SerialBT.write(Serial.read());
    }
    if (SerialBT.available())
    {
      int msg = SerialBT.read();
      Serial.write(msg);
      if (msg == '1') {
        get_start();
      }
      if (msg == '2') {
        cut_power();
      }
      if (msg == '3') {
        lock_car();
      }
      if (msg == '4') {
        luncher_car();
      }
      if (msg == '5') {
        shut_down_car();
      }
      if (msg == '6') {
        find_my_car();
      }
      if (msg == '7') {
        click_loop();
      }
      if (msg == '8') {
        click_lock();
      }
      if (msg == 'r') {
        read_status();
      }
    }
  }  
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257

上述代码有几点需要说明：

1. 之前我们有说过，扫描 BLE 是阻塞方法，所以虽然经过测试，BLE 和经典蓝牙不会互相干扰，可以同时传输数据，但是由于扫描 BLE 会阻塞 loop 进程，导致经典蓝牙的数据传输被强行阻塞。因此我们这里加了一个判断，如果经典蓝牙已被连接，则不再扫描 BLE 设备。
2. 上面的代码中，扫描 BLE 设备是一直在循环运行的，也就是说，不管是扫描到符合条件的设备，还是扫描不到，都会不断的触发给遥控器上电或断电，其实这里并没有什么问题，因为如果遥控器连接的这个 Pin 已经处于高电平状态，再给它一个高电平是不会有什么变化的，所以这里就直接这样写了，就不额外多加判断条件了。

自此，感应解锁部分也完成了，同时也兼顾到了被动连接控制。

总结

没想到兜兜转转最终还是用回了 BLE，总感觉有点怪怪的呢。

不过虽然用上了 BLE 做距离感应，但是实际上经典蓝牙还是有它的存在意义的，那就是用来做手动控制和参数设置。

没错，又挖坑了，下一步目标是实现参数设置，例如设置感应解锁每次扫描时间、RSSI 阈值、信任的 MAC 地址等。

本文首发于我的博客：likehide.com