mirror of
https://github.com/meshcore-dev/MeshCore.git
synced 2026-03-30 14:55:46 +00:00
243 lines
7.3 KiB
C++
243 lines
7.3 KiB
C++
#include "SerialBLEInterface.h"
|
|
|
|
// See the following for generating UUIDs:
|
|
// https://www.uuidgenerator.net/
|
|
|
|
#define SERVICE_UUID "6E400001-B5A3-F393-E0A9-E50E24DCCA9E" // UART service UUID
|
|
#define CHARACTERISTIC_UUID_RX "6E400002-B5A3-F393-E0A9-E50E24DCCA9E"
|
|
#define CHARACTERISTIC_UUID_TX "6E400003-B5A3-F393-E0A9-E50E24DCCA9E"
|
|
|
|
#define ADVERT_RESTART_DELAY 1000 // millis
|
|
|
|
void SerialBLEInterface::begin(const char* device_name, uint32_t pin_code) {
|
|
_pin_code = pin_code;
|
|
|
|
// Create the BLE Device
|
|
BLEDevice::init(device_name);
|
|
BLEDevice::setSecurityCallbacks(this);
|
|
BLEDevice::setMTU(MAX_FRAME_SIZE);
|
|
|
|
BLESecurity sec;
|
|
sec.setStaticPIN(pin_code);
|
|
sec.setAuthenticationMode(ESP_LE_AUTH_REQ_SC_MITM_BOND);
|
|
|
|
//BLEDevice::setPower(ESP_PWR_LVL_N8);
|
|
|
|
// Create the BLE Server
|
|
pServer = BLEDevice::createServer();
|
|
pServer->setCallbacks(this);
|
|
|
|
// Create the BLE Service
|
|
pService = pServer->createService(SERVICE_UUID);
|
|
|
|
// Create a BLE Characteristic
|
|
pTxCharacteristic = pService->createCharacteristic(CHARACTERISTIC_UUID_TX, BLECharacteristic::PROPERTY_READ | BLECharacteristic::PROPERTY_NOTIFY);
|
|
pTxCharacteristic->setAccessPermissions(ESP_GATT_PERM_READ_ENC_MITM);
|
|
pTxCharacteristic->addDescriptor(new BLE2902());
|
|
|
|
BLECharacteristic * pRxCharacteristic = pService->createCharacteristic(CHARACTERISTIC_UUID_RX, BLECharacteristic::PROPERTY_WRITE);
|
|
pRxCharacteristic->setAccessPermissions(ESP_GATT_PERM_WRITE_ENC_MITM);
|
|
pRxCharacteristic->setCallbacks(this);
|
|
|
|
pServer->getAdvertising()->addServiceUUID(SERVICE_UUID);
|
|
}
|
|
|
|
// -------- BLESecurityCallbacks methods
|
|
|
|
uint32_t SerialBLEInterface::onPassKeyRequest() {
|
|
BLE_DEBUG_PRINTLN("onPassKeyRequest()");
|
|
return _pin_code;
|
|
}
|
|
|
|
void SerialBLEInterface::onPassKeyNotify(uint32_t pass_key) {
|
|
BLE_DEBUG_PRINTLN("onPassKeyNotify(%u)", pass_key);
|
|
}
|
|
|
|
bool SerialBLEInterface::onConfirmPIN(uint32_t pass_key) {
|
|
BLE_DEBUG_PRINTLN("onConfirmPIN(%u)", pass_key);
|
|
return true;
|
|
}
|
|
|
|
bool SerialBLEInterface::onSecurityRequest() {
|
|
BLE_DEBUG_PRINTLN("onSecurityRequest()");
|
|
return true; // allow
|
|
}
|
|
|
|
void SerialBLEInterface::onAuthenticationComplete(esp_ble_auth_cmpl_t cmpl) {
|
|
if (cmpl.success) {
|
|
BLE_DEBUG_PRINTLN(" - SecurityCallback - Authentication Success");
|
|
//deviceConnected = true;
|
|
} else {
|
|
BLE_DEBUG_PRINTLN(" - SecurityCallback - Authentication Failure*");
|
|
|
|
//pServer->removePeerDevice(pServer->getConnId(), true);
|
|
pServer->disconnect(pServer->getConnId());
|
|
adv_restart_time = millis() + ADVERT_RESTART_DELAY;
|
|
}
|
|
}
|
|
|
|
// -------- BLEServerCallbacks methods
|
|
|
|
void SerialBLEInterface::onConnect(BLEServer* pServer) {
|
|
}
|
|
|
|
void SerialBLEInterface::onConnect(BLEServer* pServer, esp_ble_gatts_cb_param_t *param) {
|
|
BLE_DEBUG_PRINTLN("onConnect(), conn_id=%d, mtu=%d", param->connect.conn_id, pServer->getPeerMTU(param->connect.conn_id));
|
|
}
|
|
|
|
void SerialBLEInterface::onMtuChanged(BLEServer* pServer, esp_ble_gatts_cb_param_t* param) {
|
|
BLE_DEBUG_PRINTLN("onMtuChanged(), mtu=%d", pServer->getPeerMTU(param->mtu.conn_id));
|
|
|
|
deviceConnected = true;
|
|
}
|
|
|
|
void SerialBLEInterface::onDisconnect(BLEServer* pServer) {
|
|
BLE_DEBUG_PRINTLN("onDisconnect()");
|
|
if (_isEnabled) {
|
|
adv_restart_time = millis() + ADVERT_RESTART_DELAY;
|
|
|
|
// loop() will detect this on next loop, and set deviceConnected to false
|
|
}
|
|
}
|
|
|
|
// -------- BLECharacteristicCallbacks methods
|
|
|
|
void SerialBLEInterface::onWrite(BLECharacteristic* pCharacteristic, esp_ble_gatts_cb_param_t* param) {
|
|
uint8_t* rxValue = pCharacteristic->getData();
|
|
int len = pCharacteristic->getLength();
|
|
|
|
if (len > MAX_FRAME_SIZE) {
|
|
BLE_DEBUG_PRINTLN("ERROR: onWrite(), frame too big, len=%d", len);
|
|
} else if (recv_queue_len >= FRAME_QUEUE_SIZE) {
|
|
BLE_DEBUG_PRINTLN("ERROR: onWrite(), recv_queue is full!");
|
|
} else {
|
|
recv_queue[recv_queue_len].len = len;
|
|
memcpy(recv_queue[recv_queue_len].buf, rxValue, len);
|
|
recv_queue_len++;
|
|
}
|
|
}
|
|
|
|
// ---------- public methods
|
|
|
|
void SerialBLEInterface::enable() {
|
|
if (_isEnabled) return;
|
|
|
|
_isEnabled = true;
|
|
clearBuffers();
|
|
|
|
// Start the service
|
|
pService->start();
|
|
|
|
// Start advertising
|
|
|
|
//pServer->getAdvertising()->setMinInterval(500);
|
|
//pServer->getAdvertising()->setMaxInterval(1000);
|
|
|
|
pServer->getAdvertising()->start();
|
|
adv_restart_time = 0;
|
|
}
|
|
|
|
void SerialBLEInterface::disable() {
|
|
_isEnabled = false;
|
|
|
|
BLE_DEBUG_PRINTLN("SerialBLEInterface::disable");
|
|
|
|
pServer->getAdvertising()->stop();
|
|
pService->stop();
|
|
oldDeviceConnected = deviceConnected = false;
|
|
adv_restart_time = 0;
|
|
}
|
|
|
|
size_t SerialBLEInterface::writeFrame(const uint8_t src[], size_t len) {
|
|
if (len > MAX_FRAME_SIZE) {
|
|
BLE_DEBUG_PRINTLN("writeFrame(), frame too big, len=%d", len);
|
|
return 0;
|
|
}
|
|
|
|
if (deviceConnected && len > 0) {
|
|
if (send_queue_len >= FRAME_QUEUE_SIZE) {
|
|
BLE_DEBUG_PRINTLN("writeFrame(), send_queue is full!");
|
|
return 0;
|
|
}
|
|
|
|
send_queue[send_queue_len].len = len; // add to send queue
|
|
memcpy(send_queue[send_queue_len].buf, src, len);
|
|
send_queue_len++;
|
|
|
|
return len;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
#define BLE_WRITE_MIN_INTERVAL 60
|
|
|
|
bool SerialBLEInterface::isWriteBusy() const {
|
|
return millis() < _last_write + BLE_WRITE_MIN_INTERVAL; // still too soon to start another write?
|
|
}
|
|
|
|
size_t SerialBLEInterface::checkRecvFrame(uint8_t dest[]) {
|
|
if (send_queue_len > 0 // first, check send queue
|
|
&& millis() >= _last_write + BLE_WRITE_MIN_INTERVAL // space the writes apart
|
|
) {
|
|
_last_write = millis();
|
|
pTxCharacteristic->setValue(send_queue[0].buf, send_queue[0].len);
|
|
pTxCharacteristic->notify();
|
|
|
|
BLE_DEBUG_PRINTLN("writeBytes: sz=%d, hdr=%d", (uint32_t)send_queue[0].len, (uint32_t) send_queue[0].buf[0]);
|
|
|
|
send_queue_len--;
|
|
for (int i = 0; i < send_queue_len; i++) { // delete top item from queue
|
|
send_queue[i] = send_queue[i + 1];
|
|
}
|
|
}
|
|
|
|
if (recv_queue_len > 0) { // check recv queue
|
|
size_t len = recv_queue[0].len; // take from top of queue
|
|
memcpy(dest, recv_queue[0].buf, len);
|
|
|
|
BLE_DEBUG_PRINTLN("readBytes: sz=%d, hdr=%d", len, (uint32_t) dest[0]);
|
|
|
|
recv_queue_len--;
|
|
for (int i = 0; i < recv_queue_len; i++) { // delete top item from queue
|
|
recv_queue[i] = recv_queue[i + 1];
|
|
}
|
|
return len;
|
|
}
|
|
|
|
if (pServer->getConnectedCount() == 0) deviceConnected = false;
|
|
|
|
if (deviceConnected != oldDeviceConnected) {
|
|
if (!deviceConnected) { // disconnecting
|
|
clearBuffers();
|
|
|
|
BLE_DEBUG_PRINTLN("SerialBLEInterface -> disconnecting...");
|
|
|
|
//pServer->getAdvertising()->setMinInterval(500);
|
|
//pServer->getAdvertising()->setMaxInterval(1000);
|
|
|
|
adv_restart_time = millis() + ADVERT_RESTART_DELAY;
|
|
} else {
|
|
BLE_DEBUG_PRINTLN("SerialBLEInterface -> stopping advertising");
|
|
BLE_DEBUG_PRINTLN("SerialBLEInterface -> connecting...");
|
|
// connecting
|
|
// do stuff here on connecting
|
|
pServer->getAdvertising()->stop();
|
|
adv_restart_time = 0;
|
|
}
|
|
oldDeviceConnected = deviceConnected;
|
|
}
|
|
|
|
if (adv_restart_time && millis() >= adv_restart_time) {
|
|
if (pServer->getConnectedCount() == 0) {
|
|
BLE_DEBUG_PRINTLN("SerialBLEInterface -> re-starting advertising");
|
|
pServer->getAdvertising()->start(); // re-Start advertising
|
|
}
|
|
adv_restart_time = 0;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
bool SerialBLEInterface::isConnected() const {
|
|
return deviceConnected; //pServer != NULL && pServer->getConnectedCount() > 0;
|
|
}
|