魔改车钥匙实现远程控车：（2）距离感应的实现
  • 2022-08-16 08:54:41
  • 需要阅读6分钟
  • 浏览量 0 次

前言

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

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 <BLEDevice.h>
#include <BLEUtils.h>
#include <BLEScan.h>
#include <BLEAdvertisedDevice.h>

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);
}

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

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

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

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

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

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

结合经典蓝牙和 BLE

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

#include "BluetoothSerial.h"
#include <BLEDevice.h>
#include <BLEUtils.h>
#include <BLEScan.h>
#include <BLEAdvertisedDevice.h>

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

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

总结

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

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

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

  • Arduino
  • 车
    • 最后修改于： 2022-08-16 10:04:41； 备注： add a post (16d61a1)
    上一篇
    使用 compose 的 Canvas 自定义绘制实现 LCD 显示数字效果
    下一篇
    使用 Jetpack Compose 实现一个计算器APP