DFRobot专区
直播中

HonestQiao

8年用户 520经验值
擅长:嵌入式技术
私信 关注

【FireBeetle Board ESP32-E IoT 开发板试用体验】iBeacon定位初阶

本帖最后由 HonestQiao 于 2021-9-8 19:00 编辑

FireBeetle Board ESP32-E IoT 开发板支持iBeacon，因此，这篇文章中，我们进行了iBeacon的基础应用：通过RSSI进行距离测算。本次的操作，是在Mac环境下的Arduino中进行的。在其他操作系统下面，代码没有差异，Arduino和串口的操作方法，根据系统具体而定。
为了方便同时操作两块ESP32开发版，我同时使用了Arduino和Arduino IDE两个编辑器，两者独立运行，分别对应一块开发版，可以同时进行烧录和串口监控运行状态。

通过本篇文章，你可以了解到：
1. 关于蓝牙测距的基础知识
2. 低功耗iBeacon发射端
3. iBeacon扫描端
4. ESP32中断与定时器
5. ESP32-C3板载三色LED颜色显示

下面进入正题：
1. 关于蓝牙测距的基础知识
我们先了解下，什么是iBeacon:
引用: iBeacon是Apple推出的一项低耗能蓝牙技术，由蓝牙设备发射包含指定信息的信号，再由移动设备接收信号，从而实现近场通信。
这里有两个重点：一个是蓝牙技术，一个是低功耗。
通过蓝牙技术，可以进行近距离设备发现和近场通讯。
而低功耗，能够让设备以较小的功耗持续运行

然后，我们再了解一下蓝牙测距的知识：
引用: 任何无线电波，经过发射后，都会随着传播距离的增加，都会发生衰减。
而蓝牙信标发射的信号强度(rssi)与收发设备之间的距离，由于衰减的原因，在某种程度上是正相关的。
因此通过合理的参数设置和运算转化，可以通过探测到的rssi的值，来反推出发送设备与接收设备间的距离。

但是，需要给大家一点点冷静：因为这个衰减，受环境因素影响非常大。在不同的环境中，相关的经验参数，可能存在着较大的差异。
但是好在，距离与信号强度(rssi)是正相关的，在同一个环境中，如果干扰不多变化不大的化，还是可以用于非精准距离测量的，下面是一个基本的公示：
iShot2021-09-07 19.28.41.png
其中，A和n都是经验值，发射端和接收端相隔1米时的信号强度，n是环境衰减因子，需要通过反复测量和计算得到。关于这两个经验值的获取，在后续iBeacon接收端中会进行说明。
为了测量的更精准，还有应用更复杂，考虑因素更多的公示；同时，也会使用多个iBeacon发送设备，来实现三角定位(通过三个发射设备，来确定接收设备的具体位置)来实现更高的精度。
因为这篇文章，是初阶的，所以我们仅使用1块FireBeetle Board ESP32-E IoT 开发板来做iBeacon发射端，一个ESP32-C3来做接收端。
WechatIMG2776.jpeg WechatIMG2775.jpeg


2. 低功耗iBeacon发射端

发射端，我们使用一块FireBeetle Board ESP32-E IoT开发板，这个开发板支持iBeacon和低功耗运行。
这部分的代码，我们直接使用Arduino的例子->FireBeetle Board ESP32-E的例子->ESP32 BLE Arduino->BLE_iBeacon，具体操作如下：
iShot2021-09-07 19.40.40.png
具体代码如下：
  1. /*
  2.    Based on Neil Kolban example for IDF: https://github.com/nkolban/esp32-snippets/blob/master/cpp_utils/tests/BLE%20Tests/SampleScan.cpp
  3.    Ported to Arduino ESP32 by PCBreflux
  4. */


  7. /*
  8.    Create a BLE server that will send periodic iBeacon frames.
  9.    The design of creating the BLE server is:
  10.    1. Create a BLE Server
  11.    2. Create advertising data
  12.    3. Start advertising.
  13.    4. wait
  14.    5. Stop advertising.
  15.    6. deep sleep

  17.    创建一个蓝牙服务，将会周期性的发送iBeacon帧。
  18.    具体功能如下：
  19.    1. 创建蓝牙服务
  20.    2. 创建广告信息
  21.    3. 开始广告
  22.    4. 等待
  23.    5. 停止广告
  24.    6. 深度睡眠
  25.    
  26. */

  28. #include "sys/time.h"

  30. #include "BLEDevice.h"
  31. #include "BLEUtils.h"
  32. #include "BLEBeacon.h"
  33. #include "esp_sleep.h"

  35. #define GPIO_DEEP_SLEEP_DURATION     5  // sleep x seconds and then wake up
  36. RTC_DATA_ATTR static time_t last;        // remember last boot in RTC Memory
  37. RTC_DATA_ATTR static uint32_t bootcount; // remember number of boots in RTC Memory

  39. #ifdef __cplusplus
  40. extern "C" {
  41. #endif

  43. uint8_t temprature_sens_read();
  44. //uint8_t g_phyFuns;

  46. #ifdef __cplusplus
  47. }
  48. #endif

  50. // See the following for generating UUIDs:
  51. // https://www.uuidgenerator.net/
  52. BLEAdvertising *pAdvertising;
  53. struct timeval now;

  55. // 该发射端的UUID
  56. #define BEACON_UUID           "8ec76ea3-6668-48da-9866-75be8bc86f4d" // UUID 1 128-Bit (may use linux tool uuidgen or random numbers via https://www.uuidgenerator.net/)

  58. // 设置Beacon帧信息
  59. void setBeacon() {

  61.   BLEBeacon oBeacon = BLEBeacon();
  62.   oBeacon.setManufacturerId(0x4C00); // fake Apple 0x004C LSB (ENDIAN_CHANGE_U16!)
  63.   oBeacon.setProximityUUID(BLEUUID(BEACON_UUID));
  64.   oBeacon.setMajor((bootcount & 0xFFFF0000) >> 16);
  65.   oBeacon.setMinor(bootcount&0xFFFF);
  66.   BLEAdvertisementData oAdvertisementData = BLEAdvertisementData();
  67.   BLEAdvertisementData oScanResponseData = BLEAdvertisementData();
  68.   
  69.   oAdvertisementData.setFlags(0x04); // BR_EDR_NOT_SUPPORTED 0x04
  70.   
  71.   std::string strServiceData = "";
  72.   
  73.   strServiceData += (char)26;     // Len
  74.   strServiceData += (char)0xFF;   // Type
  75.   strServiceData += oBeacon.getData();
  76.   oAdvertisementData.addData(strServiceData);
  77.   
  78.   pAdvertising->setAdvertisementData(oAdvertisementData);
  79.   pAdvertising->setScanResponseData(oScanResponseData);

  81. }

  83. void setup() {

  85.    
  86.   Serial.begin(115200);
  87.   gettimeofday(&now, NULL);

  89.   Serial.printf("start ESP32 %dn",bootcount++);

  91.   Serial.printf("deep sleep (%lds since last reset, %lds since last boot)n",now.tv_sec,now.tv_sec-last);

  93.   last = now.tv_sec;
  94.   
  95.   // Create the BLE Device
  96.   BLEDevice::init("");

  98.   // Create the BLE Server
  99.   // BLEServer *pServer = BLEDevice::createServer(); // <-- no longer required to instantiate BLEServer, less flash and ram usage

  101.   pAdvertising = BLEDevice::getAdvertising();
  102.   
  103.   setBeacon();
  104.    // Start advertising
  105.   pAdvertising->start();
  106.   Serial.println("Advertizing started...");
  107.   delay(100);
  108.   pAdvertising->stop();
  109.   Serial.printf("enter deep sleepn");
  110.   esp_deep_sleep(1000000LL * GPIO_DEEP_SLEEP_DURATION);
  111.   Serial.printf("in deep sleepn");
  112. }

  114. void loop() {
  115. }
在上面的代码中，会发送广告信息，我们不用管它。
关键在于iBeacon帧的设置setBeacon()，以及这个设备的BEACON_UUID，该UUID值，可以进行修改；再就是esp_deep_sleep()实现深度睡眠。
设置后代码后，我们把FireBeetle Board ESP32-E IoT开发板连上电脑的USB口，按照如下步骤进行设置：
1）选择开发版：
iShot2021-09-07 19.52.33.png
2）设置调试信息级别：
iShot2021-09-07 19.52.55.png
3）选择串口：
iShot2021-09-07 19.54.14.png
4）编译代码：
iShot2021-09-07 19.57.23.png
5）下载代码：
iShot2021-09-07 19.59.37.png
6）运行监控：
iShot2021-09-07 20.10.50.png

3. iBeacon扫描端

扫描/接收端，我们使用一块ESP32-C3-Mini1 开发板，这个开发板支持蓝牙，并有一个板载三色LED，便于我们显示不同的状态的。
这部分的代码，我们直接使用Arduino的例子->ESP32 C3 Dev Module的例子->ESP32 BLE Arduino->BLE_Beacon_Scanner，具体操作如下：
iShot2021-09-08 17.50.29.png
这个例子，用于基础的Beacon和iBeacon扫描，为了适应我们的需要，进行了适当的修改，具体代码如下：
  1. /*
  2.    Based on Neil Kolban example for IDF: https://github.com/nkolban/esp32-snippets/blob/master/cpp_utils/tests/BLE%20Tests/SampleScan.cpp
  3.    Ported to Arduino ESP32 by Evandro Copercini
  4.    Changed to a beacon scanner to report iBeacon, EddystoneURL and EddystoneTLM beacons by beegee-tokyo
  5. */

  7. #include

  9. #include
  10. #include
  11. #include
  12. #include
  13. #include
  14. #include
  15. #include

  17. #include "esp_system.h"
  18. #include "led_strip.h"

  20. #define ENDIAN_CHANGE_U16(x) ((((x)&0xFF00) >> 8) + (((x)&0xFF) << 8))

  22. // RSSI经验参数
  23. #define A 66
  24. #define n 2.0

  26. // 目标SSID
  27. #define IBEACON_MY_SSID "8ec76ea3-6668-48da-9866-75be8bc86f4d"

  29. // ESP32-C3板载LED
  30. #define CONFIG_BLINK_LED_RMT_CHANNEL 0
  31. #define BLINK_GPIO 8

  33. // 延时时间
  34. #define TIME_DELAY 500

  36. // 循环处理参数
  37. static uint8_t s_loop = 0;
  38. static uint8_t s_led_idx = 0;

  40. // LED处理
  41. static uint8_t s_led_state = 0;
  42. static led_strip_t *pStrip_a;

  44. static unsigned long ms = 0;

  46. // Beacon扫描时间
  47. int scanTime = 5;  //In seconds

  49. // 延时计数，防止发射端睡眠时被认为掉线
  50. int delaymax = 30;

  52. // 蓝牙
  53. BLEScan *pBLEScan;
  54. static float dis = 0;

  56. hw_timer_t *timer = NULL;
  57. volatile SemaphoreHandle_t timerSemaphore;
  58. portMUX_TYPE timerMux = portMUX_INITIALIZER_UNLOCKED;

  60. volatile uint32_t isrCounter = 0;
  61. volatile uint32_t lastIsrAt = 0;

  63. // 通过RSSI计算距离
  64. float calcDistByRSSI(int rssi)
  65. {
  66.   int iRssi = abs(rssi);
  67.   float power = (iRssi-A)/(10*n);
  68.   return pow(10, power);
  69. }

  71. // 定时器设置
  72. void ARDUINO_ISR_ATTR onTimer() {
  73.   // 定时器触发时，将设置信号量，以便loop部分检测使用
  74.   // Increment the counter and set the time of ISR
  75.   portENTER_CRITICAL_ISR(&timerMux);
  76.   isrCounter++;
  77.   lastIsrAt = millis();
  78.   portEXIT_CRITICAL_ISR(&timerMux);
  79.   // Give a semaphore that we can check in the loop
  80.   xSemaphoreGiveFromISR(timerSemaphore, NULL);
  81.   // It is safe to use digitalRead/Write here if you want to toggle an output
  82. }

  84. // 点亮LED
  85. static void blink_led(void) {
  86.   /* If the addressable LED is enabled */
  87.   if (s_led_state) {
  88.     Serial.print("LED ONn");
  89.     /* Set the LED pixel using RGB from 0 (0%) to 255 (100%) for each color */
  90.     if(s_led_idx>0) {
  91.       // 正常状态为绿色
  92.       pStrip_a->set_pixel(pStrip_a, 0, 0, 32, 0);
  93.     } else {
  94.       // 白色
  95.       pStrip_a->set_pixel(pStrip_a, 0, 32, 32, 32);
  96.     }
  97.     /* Refresh the strip to send data */
  98.     pStrip_a->refresh(pStrip_a, 100);
  99.   } else {
  100.     Serial.print("LED OFFn");
  101.     /* Set all LED off to clear all pixels */
  102.     // pStrip_a->clear(pStrip_a, 50);
  103.     // 红色
  104.     pStrip_a->set_pixel(pStrip_a, 0, 32, 0, 0);
  105.     pStrip_a->refresh(pStrip_a, 100);
  106.   }
  107. }

  109. // 设置LED
  110. static void configure_led(void) {
  111.   Serial.print("configured to blink addressable LED!");
  112.   pStrip_a = led_strip_init(CONFIG_BLINK_LED_RMT_CHANNEL, BLINK_GPIO, 1);
  113.   pStrip_a->clear(pStrip_a, 50);
  114. }

  116. // 蓝牙发现处理
  117. class MyAdvertisedDeviceCallbacks : public BLEAdvertisedDeviceCallbacks {
  118.   void onResult(BLEAdvertisedDevice advertisedDevice) {
  119.     if (advertisedDevice.haveName()) {
  120.       Serial.print("Device name: ");
  121.       Serial.println(advertisedDevice.getName().c_str());
  122.       Serial.println("");
  123.     }

  125.     if (advertisedDevice.haveServiceUUID()) {
  126.       return;
  127.       // BLEUUID devUUID = advertisedDevice.getServiceUUID();
  128.       // Serial.print("Found ServiceUUID: ");
  129.       // Serial.println(devUUID.toString().c_str());
  130.       // Serial.println("");
  131.     } else {
  132.       if (advertisedDevice.haveManufacturerData() == true) {
  133.         std::string strManufacturerData = advertisedDevice.getManufacturerData();

  135.         uint8_t cManufacturerData[100];
  136.         strManufacturerData.copy((char *)cManufacturerData, strManufacturerData.length(), 0);

  138.         // iBeacon帧检测
  139.         if (strManufacturerData.length() == 25 && cManufacturerData[0] == 0x4C && cManufacturerData[1] == 0x00) {
  140.           Serial.println("Found an iBeacon!");
  141.           BLEBeacon oBeacon = BLEBeacon();
  142.           oBeacon.setData(strManufacturerData);
  143.           Serial.printf("iBeacon Framen");
  144.           dis = calcDistByRSSI(advertisedDevice.getRSSI());
  145.           Serial.printf("ID: %04X Major: %d Minor: %d UUID: %s Power: %d RSSI: %d Dis:%0.3fn", oBeacon.getManufacturerId(), ENDIAN_CHANGE_U16(oBeacon.getMajor()), ENDIAN_CHANGE_U16(oBeacon.getMinor()), oBeacon.getProximityUUID().toString().c_str(), oBeacon.getSignalPower(), advertisedDevice.getRSSI(), dis);
  146.           // 目标SSID检测
  147.           if (strcmp(oBeacon.getProximityUUID().toString().c_str(), IBEACON_MY_SSID) == 0) {
  148.             Serial.printf("********iBeacon ssid found********n");
  149.             s_led_idx = delaymax;
  150.           }
  151.         } else {
  152.           return;
  153.           // Serial.println("Found another manufacturers beacon!");
  154.           // Serial.printf("strManufacturerData: %d ", strManufacturerData.length());
  155.           // for (int i = 0; i < strManufacturerData.length(); i++) {
  156.           //   Serial.printf("[%X]", cManufacturerData[i]);
  157.           // }
  158.           // Serial.printf("n");
  159.         }
  160.       }
  161.     }
  162.     return;

  164.     // uint8_t *payLoad = advertisedDevice.getPayload();

  166.     // BLEUUID checkUrlUUID = (uint16_t)0xfeaa;

  168.     // if (advertisedDevice.getServiceUUID().equals(checkUrlUUID)) {
  169.     //   if (payLoad[11] == 0x10) {
  170.     //     Serial.println("Found an EddystoneURL beacon!");
  171.     //     BLEEddystoneURL foundEddyURL = BLEEddystoneURL();
  172.     //     std::string eddyContent((char *)&payLoad[11]);  // incomplete EddystoneURL struct!

  174.     //     foundEddyURL.setData(eddyContent);
  175.     //     std::string bareURL = foundEddyURL.getURL();
  176.     //     if (bareURL[0] == 0x00) {
  177.     //       size_t payLoadLen = advertisedDevice.getPayloadLength();
  178.     //       Serial.println("DATA-->");
  179.     //       for (int idx = 0; idx < payLoadLen; idx++) {
  180.     //         Serial.printf("0x%08X ", payLoad[idx]);
  181.     //       }
  182.     //       Serial.println("nInvalid Data");
  183.     //       return;
  184.     //     }

  186.     //     Serial.printf("Found URL: %sn", foundEddyURL.getURL().c_str());
  187.     //     Serial.printf("Decoded URL: %sn", foundEddyURL.getDecodedURL().c_str());
  188.     //     Serial.printf("TX power %dn", foundEddyURL.getPower());
  189.     //     Serial.println("n");
  190.     //   } else if (payLoad[11] == 0x20) {
  191.     //     Serial.println("Found an EddystoneTLM beacon!");
  192.     //     BLEEddystoneTLM foundEddyURL = BLEEddystoneTLM();
  193.     //     std::string eddyContent((char *)&payLoad[11]);  // incomplete EddystoneURL struct!

  195.     //     eddyContent = "01234567890123";

  197.     //     for (int idx = 0; idx < 14; idx++) {
  198.     //       eddyContent[idx] = payLoad[idx + 11];
  199.     //     }

  201.     //     foundEddyURL.setData(eddyContent);
  202.     //     Serial.printf("Reported battery voltage: %dmVn", foundEddyURL.getVolt());
  203.     //     Serial.printf("Reported temperature from TLM class: %.2fCn", (double)foundEddyURL.getTemp());
  204.     //     int temp = (int)payLoad[16] + (int)(payLoad[15] << 8);
  205.     //     float calcTemp = temp / 256.0f;
  206.     //     Serial.printf("Reported temperature from data: %.2fCn", calcTemp);
  207.     //     Serial.printf("Reported advertise count: %dn", foundEddyURL.getCount());
  208.     //     Serial.printf("Reported time since last reboot: %dsn", foundEddyURL.getTime());
  209.     //     Serial.println("n");
  210.     //     Serial.print(foundEddyURL.toString().c_str());
  211.     //     Serial.println("n");
  212.     //   }
  213.     // }
  214.   }
  215. };

  217. void setup() {
  218.   Serial.begin(115200);
  219.   Serial.println("Scanning...");

  221.   // 配置LED
  222.   configure_led();

  224.   // 创建信号量
  225.   timerSemaphore = xSemaphoreCreateBinary();

  227.   // 定时器设置
  228.   timer = timerBegin(0, 80, true);
  229.   timerAttachInterrupt(timer, &onTimer, true);
  230.   timerAlARMWrite(timer, 1000 * 1000, true);
  231.   timerAlarmEnable(timer);

  233.   // 蓝牙初始化
  234.   BLEDevice::init("");
  235.   pBLEScan = BLEDevice::getScan();  //create new scan
  236.   pBLEScan->setAdvertisedDeviceCallbacks(new MyAdvertisedDeviceCallbacks());
  237.   pBLEScan->setActiveScan(true);  //active scan uses more power, but get results faster
  238.   pBLEScan->setInterval(100);
  239.   pBLEScan->setWindow(99);  // less or equal setInterval value
  240. }

  242. void loop() {
  243.   ms = millis();
  244.   // put your main code here, to run repeatedly:
  245.   if (s_loop==0) {
  246.     // 蓝牙扫描
  247.     BLEScanResults foundDevices = pBLEScan->start(scanTime, false);
  248.     Serial.print("Devices found: ");
  249.     Serial.println(foundDevices.getCount());
  250.     Serial.println("Scan done!");
  251.     pBLEScan->clearResults();  // delete results fromBLEScan buffer to release memory
  252.   }
  253.   s_loop++;
  254.   if(s_loop==8) {
  255.     // 每循环8次，进行1次扫描
  256.     s_loop = 0;
  257.   }
  258.   // If Timer has fired
  259.   if (xSemaphoreTake(timerSemaphore, 0) == pdTRUE) {
  260.     // 状态和延时次数处理
  261.     if (s_led_idx > 0) {
  262.       s_led_idx--;
  263.     }
  264.     if (s_led_idx > 0) {
  265.       // 检测到的情况下，常亮绿色
  266.       s_led_state = 1;
  267.     } else {
  268.       // 没有检测到的情况下，红白切换
  269.       s_led_state = !s_led_state;
  270.     }

  272.     uint32_t isrCount = 0, isrTime = 0;
  273.     // Read the interrupt count and time
  274.     portENTER_CRITICAL(&timerMux);
  275.     isrCount = isrCounter;
  276.     isrTime = lastIsrAt;
  277.     portEXIT_CRITICAL(&timerMux);
  278.     // Print it
  279.     Serial.print("onTimer no. ");
  280.     Serial.print(isrCount);
  281.     Serial.print(" at ");
  282.     Serial.print(isrTime);
  283.     Serial.print(" ms");
  284.     Serial.print(" loop:");
  285.     Serial.print(s_loop);
  286.     Serial.print(" idx:");
  287.     Serial.print(s_led_idx);
  288.     Serial.print(" state:");
  289.     Serial.print(s_led_state);

  291.     Serial.println(" ");
  292.     blink_led();
  293.     // timerWrite(timer, 0);
  294.   }

  296.   // 延时处理，去掉本轮处理已经用掉 的时间
  297.   ms = millis() - ms;
  298.   if(ms>TIME_DELAY) {
  299.     ms = 0;
  300.   } else {
  301.     ms = TIME_DELAY - ms;
  302.   }
  303.   delay(ms);  
  304. }
以上代码中，需要使用led_strip.h，在附件中一并提供。
在标准示例代码的基础上，我们添加了几个部分：
1）LED的处理，包括设置和点亮处理；当检测到对应的设备后，常亮绿色显示，否则红白交替显示。对应的函数为configure_led()、blink_led()，用于设置和控制板载3色LED
2）定时器的处理：我们需要做LED交替显示，同时又要进行蓝牙Beacon扫描，所以通过定时器配合，来进行信号量的设置，从而在loop中，根据信号量的情况，来进行LED的控制。对应的函数为onTimer()
3）RSSI测距基本算法，对应的函数为calcDistByRSSI()
这个代码中，做了详细的注释，大家可以仔细查看。

在Arduino IDE的操作步骤如下：
选择开发版：
iShot2021-09-08 17.53.02.png
选择串口和设置：
iShot2021-09-08 17.53.34.png
编译下载：
iShot2021-09-08 17.53.41.png
运行监控：
iShot2021-09-08 17.56.59.png
上述运行解控界面中，如下部分，显示了搜索到的iBeacon信息：
  1. Found an iBeacon!
  2. iBeacon Frame
  3. ID: 004C Major: 0 Minor: 91 UUID: 8ec76ea3-6668-48da-9866-75be8bc86f4d Power: 0 RSSI: -30 Dis:0.016
  4. ********iBeacon ssid found********
其中，Dis就表示位置信息。
在本部分的代码中，包含如下的经验设置和距离计算函数：
  1. // RSSI经验参数
  2. #define A 66
  3. #define n 2.0
这两个经验值，可以通过运行时，上述iBeacon Frame值来设置。1）将设备相距1米放置，获取此时的rssi值，设为A
2）通过在电脑上，利用上述函数，调整n的值，使得计算结果接近1
3）然后将设备分别放置0.5米和2米，获取rssi值，并且调整n，使得结果接近距离值
以上需要多次取样，进行计算，以使得结果尽可能的准确。

4. ESP32中断与定时器
。。。
ESP32 芯片提供两组硬件定时器，每组包含两个通用硬件定时器。
通过下面的代码，可以很容易使用定时器：
  1. // 定时器设置
  2. void ARDUINO_ISR_ATTR onTimer() {
  3.   isrCounter++;
  4.   //定时器逻辑处理，可以写自己的代码
  5. }

  7. //setup中设置
  8.   // 定时器设置
  9.   timer = timerBegin(0, 80, true);
  10.   timerAttachInterrupt(timer, &onTimer, true);
  11.   timerAlarmWrite(timer, 1000 * 1000, true);
  12.   timerAlarmEnable(timer);
因为Ardunio中，ESP32定时器的处理，设计到中断，因此，在定时器触发后，处理逻辑需要快准狠，不能调用任何会阻塞 CPU 的 API，否则会导致混乱。因此，上面的代码中，我们通过在定时触发处理逻辑中设置信号量，然后在loop逻辑中进行检测和处理，避免了对中断的影响。

5. ESP32-C3板载三色LED颜色显示
ESP32-C3板载LED的显示，需要通过pixel方式进行处理，其基本代码来源于ESP-IDF中的例子。
主要的调用方式如下：
  1. #include "led_strip.h"

  3. // RMT通道
  4. #define CONFIG_BLINK_LED_RMT_CHANNEL 0
  5. // GPIO针脚
  6. #define BLINK_GPIO 8

  8. // 定义处理句柄
  9. static led_strip_t *pStrip_a;

  11. // 初始化
  12. pStrip_a = led_strip_init(CONFIG_BLINK_LED_RMT_CHANNEL, BLINK_GPIO, 1);

  14. // 清除显示
  15. pStrip_a->clear(pStrip_a, 50);

  17. // 设置颜色
  18. /* Set the LED pixel using RGB from 0 (0%) to 255 (100%) for each color */
  19. pStrip_a->set_pixel(pStrip_a, 0, 32, 0, 0);
  20. pStrip_a->set_pixel(pStrip_a, 0, 0, 32, 0); //绿色

  22. // 刷新显示
  23. pStrip_a->refresh(pStrip_a, 100);

6. 扩展研究：
在本文中，我们只使用了1块iBeacon发射设备，并且使用了最基础的RSSI距离算法。在实际应用中，会布置多个iBacon设备，从而同时通过多个设备，来提高定位精度。以及使用更为优化的算法，来提高精度减小误差。

7. 实际效果：见视频


实际效果

更多回帖

0 0 0

相关帖子

ESP32 Arduino 定时器 iBeacon
发帖
电子发烧友APP
|投诉反馈|电子发烧友网
© 2021 bbs.elecfans.com
湘ICP备2023018690号
×
20
完善资料，
赚取积分