Use NimBLE API for ESP32 bluetooth

src/esp32/BluetoothSoftwareUpdate.cpp

@@ -1,3 +1,5 @@
+#ifndef USE_NEW_ESP32_BLUETOOTH
+
 #include <Arduino.h>
 
 #include "../concurrency/LockGuard.h"
@@ -154,3 +156,5 @@ void reinitUpdateService()
     res = ble_gatts_add_svcs(gatt_update_svcs);
     assert(res == 0);
 }
+
+#endif //#ifndef USE_NEW_ESP32_BLUETOOTH

src/esp32/BluetoothSoftwareUpdate.h

@@ -1,3 +1,5 @@
+#ifndef USE_NEW_ESP32_BLUETOOTH
+
 #pragma once
 
 #include "nimble/NimbleDefs.h"
@@ -22,4 +24,6 @@ extern int16_t updateResultHandle;
 
 #ifdef __cplusplus
 };
-#endif
+#endif
+
+#endif //#ifndef USE_NEW_ESP32_BLUETOOTH

src/esp32/ESP32Bluetooth.cpp

@@ -0,0 +1,205 @@
+#ifdef USE_NEW_ESP32_BLUETOOTH
+
+#include "configuration.h"
+#include "ESP32Bluetooth.h"
+#include "BluetoothCommon.h"
+#include "main.h"
+#include "mesh/PhoneAPI.h"
+#include "mesh/mesh-pb-constants.h"
+#include <NimBLEDevice.h>
+
+//static BLEService meshBleService = BLEService(BLEUuid(MESH_SERVICE_UUID_16));
+//static BLECharacteristic fromNum = BLECharacteristic(BLEUuid(FROMNUM_UUID_16));
+//static BLECharacteristic fromRadio = BLECharacteristic(BLEUuid(FROMRADIO_UUID_16));
+//static BLECharacteristic toRadio = BLECharacteristic(BLEUuid(TORADIO_UUID_16));
+
+//static BLEDis bledis; // DIS (Device Information Service) helper class instance
+//static BLEBas blebas; // BAS (Battery Service) helper class instance
+//static BLEDfu bledfu; // DFU software update helper service
+
+// This scratch buffer is used for various bluetooth reads/writes - but it is safe because only one bt operation can be in
+// proccess at once
+// static uint8_t trBytes[_max(_max(_max(_max(ToRadio_size, RadioConfig_size), User_size), MyNodeInfo_size), FromRadio_size)];
+static uint8_t fromRadioBytes[FromRadio_size];
+static uint8_t toRadioBytes[ToRadio_size];
+
+static bool bleConnected;
+
+NimBLECharacteristic *FromNumCharacteristic;
+NimBLEServer *bleServer;
+
+/**
+ * Subclasses can use this as a hook to provide custom notifications for their transport (i.e. bluetooth notifies)
+ */
+void BluetoothPhoneAPI::onNowHasData(uint32_t fromRadioNum)
+{
+    PhoneAPI::onNowHasData(fromRadioNum);
+
+    DEBUG_MSG("BLE notify fromNum\n");
+    //fromNum.notify32(fromRadioNum);
+    
+    uint8_t val[4];
+    put_le32(val, fromRadioNum);
+
+    std::string fromNumByteString(&val[0], &val[0] + sizeof(val));
+
+    FromNumCharacteristic->setValue(fromNumByteString);
+    FromNumCharacteristic->notify();
+}
+
+/// Check the current underlying physical link to see if the client is currently connected
+bool BluetoothPhoneAPI::checkIsConnected() {
+    if (bleServer && bleServer->getConnectedCount() > 0) {
+        return true;
+    }
+    return false;
+}
+
+PhoneAPI *bluetoothPhoneAPI;
+
+class ESP32BluetoothToRadioCallback : public NimBLECharacteristicCallbacks {
+    virtual void onWrite(NimBLECharacteristic *pCharacteristic) {
+        DEBUG_MSG("To Radio onwrite");
+        auto valueString = pCharacteristic->getValue();
+        
+        bluetoothPhoneAPI->handleToRadio(reinterpret_cast<const uint8_t*>(&valueString[0]), pCharacteristic->getDataLength());
+    }
+};
+
+class ESP32BluetoothFromRadioCallback : public NimBLECharacteristicCallbacks {
+    virtual void onRead(NimBLECharacteristic *pCharacteristic) {
+        DEBUG_MSG("From Radio onread");
+        size_t numBytes = bluetoothPhoneAPI->getFromRadio(fromRadioBytes);
+
+        std::string fromRadioByteString(fromRadioBytes, fromRadioBytes + numBytes);
+
+        pCharacteristic->setValue(fromRadioByteString);
+    }
+};
+
+
+
+static ESP32BluetoothToRadioCallback *toRadioCallbacks;
+static ESP32BluetoothFromRadioCallback *fromRadioCallbacks;
+
+void ESP32Bluetooth::shutdown()
+{
+    // Shutdown bluetooth for minimum power draw
+    DEBUG_MSG("Disable NRF52 bluetooth\n");
+    //Bluefruit.Advertising.stop();
+}
+
+void ESP32Bluetooth::setup()
+{
+    // Initialise the Bluefruit module
+    DEBUG_MSG("Initialise the ESP32 bluetooth module\n");
+    //Bluefruit.autoConnLed(false);
+    //Bluefruit.begin();
+
+    // Set the advertised device name (keep it short!)
+    //Bluefruit.setName(getDeviceName());
+
+    // Set the connect/disconnect callback handlers
+    //Bluefruit.Periph.setConnectCallback(connect_callback);
+    //Bluefruit.Periph.setDisconnectCallback(disconnect_callback);
+
+    // Configure and Start the Device Information Service
+    DEBUG_MSG("Configuring the Device Information Service\n");
+    // FIXME, we should set a mfg string based on our HW_VENDOR enum
+    // bledis.setManufacturer(HW_VENDOR);
+    //bledis.setModel(optstr(HW_VERSION));
+    //bledis.setFirmwareRev(optstr(APP_VERSION));
+    //bledis.begin();
+
+    // Start the BLE Battery Service and set it to 100%
+    //DEBUG_MSG("Configuring the Battery Service\n");
+    //blebas.begin();
+    //blebas.write(0); // Unknown battery level for now
+
+    //bledfu.begin(); // Install the DFU helper
+
+    // Setup the Heart Rate Monitor service using
+    // BLEService and BLECharacteristic classes
+    DEBUG_MSG("Configuring the Mesh bluetooth service\n");
+    //setupMeshService();
+
+    // Supposedly debugging works with soft device if you disable advertising
+    //if (isSoftDeviceAllowed) {
+        // Setup the advertising packet(s)
+    //    DEBUG_MSG("Setting up the advertising payload(s)\n");
+    //    startAdv();
+
+    //    DEBUG_MSG("Advertising\n");
+    //}
+
+    //NimBLEDevice::deleteAllBonds();
+
+    NimBLEDevice::init("Meshtastic_1234");
+    NimBLEDevice::setPower(ESP_PWR_LVL_P9);
+
+    NimBLEDevice::setSecurityAuth(true, true, true);
+    NimBLEDevice::setSecurityPasskey(123456);
+    NimBLEDevice::setSecurityIOCap(BLE_HS_IO_DISPLAY_ONLY);
+    bleServer = NimBLEDevice::createServer();
+    NimBLEService *bleService = bleServer->createService(MESH_SERVICE_UUID);
+    //NimBLECharacteristic *pNonSecureCharacteristic = bleService->createCharacteristic("1234", NIMBLE_PROPERTY::READ );
+    //NimBLECharacteristic *pSecureCharacteristic = bleService->createCharacteristic("1235", NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::READ_ENC | NIMBLE_PROPERTY::READ_AUTHEN);
+
+    //define the characteristics that the app is looking for
+    NimBLECharacteristic *ToRadioCharacteristic = bleService->createCharacteristic(TORADIO_UUID, NIMBLE_PROPERTY::WRITE | NIMBLE_PROPERTY::WRITE_AUTHEN | NIMBLE_PROPERTY::WRITE_ENC);
+    NimBLECharacteristic *FromRadioCharacteristic = bleService->createCharacteristic(FROMRADIO_UUID, NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::READ_AUTHEN | NIMBLE_PROPERTY::READ_ENC);
+    FromNumCharacteristic = bleService->createCharacteristic(FROMNUM_UUID, NIMBLE_PROPERTY::NOTIFY | NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::READ_AUTHEN | NIMBLE_PROPERTY::READ_ENC);
+    
+    bluetoothPhoneAPI = new BluetoothPhoneAPI();
+
+    toRadioCallbacks = new ESP32BluetoothToRadioCallback();
+    ToRadioCharacteristic->setCallbacks(toRadioCallbacks);
+
+    fromRadioCallbacks = new ESP32BluetoothFromRadioCallback();
+    FromRadioCharacteristic->setCallbacks(fromRadioCallbacks);
+
+    //uint8_t val[4];
+    //uint32_t zero = 0;
+    //put_le32(val, zero);
+    //std::string fromNumByteString(&val[0], &val[0] + sizeof(val));
+    //FromNumCharacteristic->setValue(fromNumByteString);
+
+    bleService->start();
+    //pNonSecureCharacteristic->setValue("Hello Non Secure BLE");
+    //pSecureCharacteristic->setValue("Hello Secure BLE");
+
+    //FromRadioCharacteristic->setValue("FromRadioString");
+    //ToRadioCharacteristic->setCallbacks()
+
+    NimBLEAdvertising *pAdvertising = NimBLEDevice::getAdvertising();
+    pAdvertising->addServiceUUID(MESH_SERVICE_UUID);
+    pAdvertising->start();
+
+}
+
+
+/// Given a level between 0-100, update the BLE attribute
+void updateBatteryLevel(uint8_t level)
+{
+    //blebas.write(level);
+}
+
+void ESP32Bluetooth::clearBonds()
+{
+    DEBUG_MSG("Clearing bluetooth bonds!\n");
+    //bond_print_list(BLE_GAP_ROLE_PERIPH);
+    //bond_print_list(BLE_GAP_ROLE_CENTRAL);
+
+    //Bluefruit.Periph.clearBonds();
+    //Bluefruit.Central.clearBonds();
+}
+
+void clearNVS() {
+
+}
+
+void disablePin() {
+
+}
+
+#endif

src/esp32/ESP32Bluetooth.h

@@ -0,0 +1,33 @@
+#ifdef USE_NEW_ESP32_BLUETOOTH
+
+#pragma once
+
+extern uint16_t fromNumValHandle;
+
+class BluetoothPhoneAPI : public PhoneAPI
+{
+protected: 
+    /**
+     * Subclasses can use this as a hook to provide custom notifications for their transport (i.e. bluetooth notifies)
+     */
+    virtual void onNowHasData(uint32_t fromRadioNum) override;
+
+    /// Check the current underlying physical link to see if the client is currently connected
+    virtual bool checkIsConnected() override;
+};
+
+extern PhoneAPI *bluetoothPhoneAPI;
+
+class ESP32Bluetooth
+{
+  public:
+    void setup();
+    void shutdown();
+    void clearBonds();
+};
+
+void setBluetoothEnable(bool on);
+void clearNVS();
+void disablePin();
+
+#endif

src/esp32/NimbleSoftwareUpdate.c

@@ -1,3 +1,4 @@
+#ifndef USE_NEW_ESP32_BLUETOOTH
 #include "BluetoothSoftwareUpdate.h"
 
 // NRF52 wants these constants as byte arrays
@@ -68,3 +69,5 @@ const struct ble_gatt_svc_def gatt_update_svcs[] = {
         0, /* No more services. */
     },
 };
+
+#endif //#ifndef USE_NEW_ESP32_BLUETOOTH

src/esp32/main-esp32.cpp

@@ -3,7 +3,13 @@
 #include "configuration.h"
 #include "esp_task_wdt.h"
 #include "main.h"
+
+#ifdef USE_NEW_ESP32_BLUETOOTH
+#include "ESP32Bluetooth.h"
+#else
 #include "nimble/BluetoothUtil.h"
+#endif
+
 #include "sleep.h"
 #include "target_specific.h"
 #include "utils.h"
@@ -12,6 +18,10 @@
 #include <nvs.h>
 #include <nvs_flash.h>
 
+#ifdef USE_NEW_ESP32_BLUETOOTH
+ESP32Bluetooth *esp32Bluetooth;
+#endif
+
 void getMacAddr(uint8_t *dmac)
 {
     assert(esp_efuse_mac_get_default(dmac) == ESP_OK);
@@ -28,6 +38,19 @@ static void printBLEinfo() {
     }
 
 } */
+#ifdef USE_NEW_ESP32_BLUETOOTH
+void setBluetoothEnable(bool on) {
+    
+    if (!esp32Bluetooth) {
+        esp32Bluetooth = new ESP32Bluetooth();
+    }
+    if (on) {
+        esp32Bluetooth->setup();
+    } else {
+        esp32Bluetooth->shutdown();
+    }
+}
+#endif
 
 void esp32Setup()
 {
@@ -92,11 +115,12 @@ uint32_t axpDebugRead()
 Periodic axpDebugOutput(axpDebugRead);
 #endif
 
+
 /// loop code specific to ESP32 targets
 void esp32Loop()
 {
     esp_task_wdt_reset(); // service our app level watchdog
-    loopBLE();
+    //loopBLE();
 
     // for debug printing
     // radio.radioIf.canSleep();