nimble software update WIP builds

src/nimble/BluetoothUtil.cpp

@@ -365,6 +365,10 @@ void gatt_svr_register_cb(struct ble_gatt_register_ctxt *ctxt, void *arg)
             fromNumValHandle = ctxt->chr.val_handle;
             DEBUG_MSG("FromNum handle %d\n", fromNumValHandle);
         }
+        if (ctxt->chr.chr_def->uuid == &update_result_uuid.u) {
+            updateResultHandle = ctxt->chr.val_handle;
+            DEBUG_MSG("update result handle %d\n", updateResultHandle);
+        }
         break;
 
     case BLE_GATT_REGISTER_OP_DSC:
@@ -377,6 +381,68 @@ void gatt_svr_register_cb(struct ble_gatt_register_ctxt *ctxt, void *arg)
     }
 }
 
+/**
+ * A helper function that implements simple read and write handling for a uint32_t
+ *
+ * If a read, the provided value will be returned over bluetooth.  If a write, the value from the received packet
+ * will be written into the variable.
+ */
+int chr_readwrite32le(uint32_t *v, struct ble_gatt_access_ctxt *ctxt, void *arg)
+{
+    uint8_t le[4];
+
+    if (ctxt->op == BLE_GATT_ACCESS_OP_READ_CHR) {
+        DEBUG_MSG("BLE reading a uint32\n");
+        put_le32(le, *v);
+        auto rc = os_mbuf_append(ctxt->om, le, sizeof(le));
+        assert(rc == 0);
+    } else if (ctxt->op == BLE_GATT_ACCESS_OP_WRITE_CHR) {
+        uint16_t len = 0;
+
+        auto rc = ble_hs_mbuf_to_flat(ctxt->om, le, sizeof(le), &len);
+        assert(rc == 0);
+        if (len < sizeof(le)) {
+            DEBUG_MSG("Error: wrongsized write32\n");
+            *v = 0;
+        } else {
+            *v = get_le32(le);
+            DEBUG_MSG("BLE writing a uint32\n");
+        }
+    } else {
+        DEBUG_MSG("Unexpected readwrite32 op\n");
+        return BLE_ATT_ERR_UNLIKELY;
+    }
+
+    return 0; // success
+}
+
+/**
+ * A helper for readwrite access to an array of bytes (with no endian conversion)
+ */
+int chr_readwrite8(uint8_t *v, size_t vlen, struct ble_gatt_access_ctxt *ctxt, void *arg)
+{
+    if (ctxt->op == BLE_GATT_ACCESS_OP_READ_CHR) {
+        DEBUG_MSG("BLE reading bytes\n");
+        auto rc = os_mbuf_append(ctxt->om, v, vlen);
+        assert(rc == 0);
+    } else if (ctxt->op == BLE_GATT_ACCESS_OP_WRITE_CHR) {
+        uint16_t len = 0;
+
+        auto rc = ble_hs_mbuf_to_flat(ctxt->om, v, vlen, &len);
+        assert(rc == 0);
+        if (len < vlen)
+            DEBUG_MSG("Error: wrongsized write\n");
+        else {
+            DEBUG_MSG("BLE writing bytes\n");
+        }
+    } else {
+        DEBUG_MSG("Unexpected readwrite8 op\n");
+        return BLE_ATT_ERR_UNLIKELY;
+    }
+
+    return 0; // success
+}
+
 // This routine is called multiple times, once each time we come back from sleep
 void reinitBluetooth()
 {

src/nimble/BluetoothUtil.h

@@ -1,36 +1,10 @@
 #pragma once
 
+#include <Arduino.h>
 #include <functional>
 
-#include "SimpleAllocator.h"
-#include <Arduino.h>
-#include <BLEDevice.h>
-#include <BLEServer.h>
-#include <BLEUtils.h>
-
-#ifdef CONFIG_BLUEDROID_ENABLED
-
-// Help routine to add a description to any BLECharacteristic and add it to the service
-void addWithDesc(BLEService *service, BLECharacteristic *c, const char *description);
-
-void dumpCharacteristic(BLECharacteristic *c);
-
-/** converting endianness pull out a 32 bit value */
-uint32_t getValue32(BLECharacteristic *c, uint32_t defaultValue);
-
-BLEServer *initBLE(StartBluetoothPinScreenCallback startBtPinScreen, StopBluetoothPinScreenCallback stopBtPinScreen,
-                   std::string devName, std::string hwVendor, std::string swVersion, std::string hwVersion = "");
-
-/// Add a characteristic that we will delete when we restart
-BLECharacteristic *addBLECharacteristic(BLECharacteristic *c);
-
-/// Add a characteristic that we will delete when we restart
-BLEDescriptor *addBLEDescriptor(BLEDescriptor *c);
-
-/// Any bluetooth objects you allocate _must_ come from this pool if you want to be able to call deinitBLE()
-extern SimpleAllocator btPool;
-
-#endif
+/// We only allow one BLE connection at a time
+extern int16_t curConnectionHandle;
 
 // TODO(girts): create a class for the bluetooth utils helpers?
 using StartBluetoothPinScreenCallback = std::function<void(uint32_t pass_key)>;
@@ -40,4 +14,17 @@ using StopBluetoothPinScreenCallback = std::function<void(void)>;
 void updateBatteryLevel(uint8_t level);
 void deinitBLE();
 void loopBLE();
-void reinitBluetooth();
+void reinitBluetooth();
+
+/**
+ * A helper function that implements simple read and write handling for a uint32_t
+ *
+ * If a read, the provided value will be returned over bluetooth.  If a write, the value from the received packet
+ * will be written into the variable.
+ */
+int chr_readwrite32le(uint32_t *v, struct ble_gatt_access_ctxt *ctxt, void *arg);
+
+/**
+ * A helper for readwrite access to an array of bytes (with no endian conversion)
+ */
+int chr_readwrite8(uint8_t *v, size_t vlen, struct ble_gatt_access_ctxt *ctxt, void *arg);

src/nimble/NimbleBluetoothAPI.cpp

@@ -1,11 +1,13 @@
 #include "NimbleBluetoothAPI.h"
 #include "PhoneAPI.h"
 #include "configuration.h"
+#include "nimble/BluetoothUtil.h"
 #include "nimble/NimbleDefs.h"
+#include <Arduino.h>
 
 // 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(FromRadio_size, ToRadio_size)];
+static uint8_t trBytes[FromRadio_size < ToRadio_size ? ToRadio_size : FromRadio_size];
 static uint32_t fromNum;
 
 uint16_t fromNumValHandle;
@@ -60,10 +62,5 @@ int fromradio_callback(uint16_t conn_handle, uint16_t attr_handle, struct ble_ga
 
 int fromnum_callback(uint16_t conn_handle, uint16_t attr_handle, struct ble_gatt_access_ctxt *ctxt, void *arg)
 {
-    // DEBUG_MSG("BLE fromNum called\n");
-    auto rc = os_mbuf_append(ctxt->om, &fromNum,
-                             sizeof(fromNum)); // FIXME - once we report real numbers we will need to consider endianness
-    assert(rc == 0);
-
-    return 0; // success
+    return chr_readwrite32le(&fromNum, ctxt, arg);
 }

src/nimble/NimbleBluetoothAPI.h

@@ -4,9 +4,6 @@
 
 extern uint16_t fromNumValHandle;
 
-/// We only allow one BLE connection at a time
-extern int16_t curConnectionHandle;
-
 class BluetoothPhoneAPI : public PhoneAPI
 {
     /**

src/nimble/NimbleDefs.h

@@ -1,10 +1,17 @@
 #pragma once
 
+// Keep nimble #defs from messing up the build
+#ifndef max
+#define max max
+#define min min
+#endif
+
 #include "esp_nimble_hci.h"
 #include "host/ble_hs.h"
 #include "host/ble_uuid.h"
 #include "nimble/nimble_port.h"
 #include "nimble/nimble_port_freertos.h"
+#include <Arduino.h>
 
 #ifdef __cplusplus
 extern "C" {