Make remote ad hoc protocol work over BLE

Author: max-arnold

ats-mini/Ble.cpp

@@ -1,9 +1,8 @@
 #include "Common.h"
 #include "Themes.h"
+#include "Remote.h"
 #include "Ble.h"
 
-NordicUART BLESerial = NordicUART(RECEIVER_NAME);
-
 //
 // Get current connection status
 // (-1 - not connected, 0 - disabled, 1 - connected)
@@ -31,15 +30,21 @@ void bleInit(uint8_t bleMode)
   BLESerial.start();
 }
 
-int bleDoCommand(uint8_t bleMode)
+int bleDoCommand(Stream* stream, RemoteState* state, uint8_t bleMode)
 {
   if(bleMode == BLE_OFF) return 0;
 
   if (BLEDevice::getServer()->getConnectedCount() > 0) {
-    if (BLESerial.available()) {
-      char bleChar = BLESerial.read();
-      BLESerial.write(bleChar);
-    }
+    if (BLESerial.available())
+      return remoteDoCommand(stream, state, BLESerial.read());
   }
   return 0;
 }
+
+void remoteBLETickTime(Stream* stream, RemoteState* state, uint8_t bleMode)
+{
+  if(bleMode == BLE_OFF) return;
+
+  if (BLEDevice::getServer()->getConnectedCount() > 0)
+    remoteTickTime(stream, state);
+}

ats-mini/Ble.h

@@ -7,11 +7,13 @@
 #include <BLE2902.h>
 #include <semaphore>
 
+#include "Remote.h"
+
 #define NORDIC_UART_SERVICE_UUID           "6E400001-B5A3-F393-E0A9-E50E24DCCA9E"
 #define NORDIC_UART_CHARACTERISTIC_UUID_RX "6E400002-B5A3-F393-E0A9-E50E24DCCA9E"
 #define NORDIC_UART_CHARACTERISTIC_UUID_TX "6E400003-B5A3-F393-E0A9-E50E24DCCA9E"
 
-class NordicUART : public BLEServerCallbacks, public BLECharacteristicCallbacks {
+class NordicUART : public Stream, public BLEServerCallbacks, public BLECharacteristicCallbacks {
 private:
   // BLE components
   BLEServer* pServer;
@@ -53,7 +55,7 @@ class NordicUART : public BLEServerCallbacks, public BLECharacteristicCallbacks
     pServer->getAdvertising()->addServiceUUID(NORDIC_UART_SERVICE_UUID);
     pService = pServer->createService(NORDIC_UART_SERVICE_UUID);
     pTxCharacteristic = pService->createCharacteristic(NORDIC_UART_CHARACTERISTIC_UUID_TX, BLECharacteristic::PROPERTY_NOTIFY);
-    pTxCharacteristic->setCallbacks(this); // onSubscribe
+    pTxCharacteristic->setCallbacks(this); // onSubscribe/onStatus
     pRxCharacteristic = pService->createCharacteristic(NORDIC_UART_CHARACTERISTIC_UUID_RX, BLECharacteristic::PROPERTY_WRITE);
     pRxCharacteristic->setCallbacks(this); // onWrite
     pService->start();
@@ -109,11 +111,26 @@ class NordicUART : public BLEServerCallbacks, public BLECharacteristicCallbacks
     }
   }
 
+  void onStatus(BLECharacteristic *pCharacteristic, Status s, uint32_t code)
+  {
+    // if(code) Serial.println(code);
+  }
+
   int available()
   {
     return unreadByteCount;
   }
 
+  int peek()
+  {
+    if (unreadByteCount > 0)
+    {
+        size_t index = incomingPacket.length() - unreadByteCount;
+        return incomingPacket[index];
+    }
+    return -1;
+  }
+
   int read()
   {
     if (unreadByteCount > 0)
@@ -128,22 +145,90 @@ class NordicUART : public BLEServerCallbacks, public BLECharacteristicCallbacks
     return -1;
   }
 
-  size_t write(uint8_t *data, size_t size)
+  // It is hard to achieve max throughput witout using delays...
+  //
+  // https://github.com/nkolban/esp32-snippets/issues/773
+  // https://github.com/espressif/arduino-esp32/issues/8413
+  // https://github.com/espressif/esp-idf/issues/9097
+  // https://github.com/espressif/esp-idf/issues/16889
+  // https://github.com/espressif/esp-nimble/issues/75
+  // https://github.com/espressif/esp-nimble/issues/106
+  // https://github.com/h2zero/esp-nimble-cpp/issues/347
+  size_t write(const uint8_t *data, size_t size)
   {
-   if (pTxCharacteristic)
-   {
-     pTxCharacteristic->setValue(data, size);
-     pTxCharacteristic->notify();
-     return size;
-   }
-   else
+    if (pTxCharacteristic)
+    {
+      // Data is sent in chunks of MTU size to avoid data loss
+      // as each chunk is notified separately
+      size_t chunkSize = BLEDevice::getMTU();
+      size_t remainingByteCount = size;
+      while (remainingByteCount >= chunkSize)
+      {
+        delay(20);
+        pTxCharacteristic->setValue(data, chunkSize);
+        pTxCharacteristic->notify();
+        data += chunkSize;
+        remainingByteCount -= chunkSize;
+      }
+      if (remainingByteCount > 0)
+      {
+        delay(20);
+        pTxCharacteristic->setValue(data, remainingByteCount);
+        pTxCharacteristic->notify();
+      }
+      return size;
+    }
+    else
       return 0;
   }
 
   size_t write(uint8_t byte)
   {
     return write(&byte, 1);
-  };
+  }
+
+  size_t print(std::string str)
+  {
+    return write((const uint8_t *)str.data(), str.length());
+  }
+
+  size_t printf(const char *format, ...)
+  {
+    char dummy;
+    va_list args;
+    va_start(args, format);
+    int requiredSize = vsnprintf(&dummy, 1, format, args);
+    va_end(args);
+    if (requiredSize == 0)
+    {
+      return write((uint8_t *)&dummy, 1);
+    }
+    else if (requiredSize > 0)
+    {
+      char *buffer = (char *)malloc(requiredSize + 1);
+      if (buffer)
+      {
+        va_start(args, format);
+        int result = vsnprintf(buffer, requiredSize + 1, format, args);
+        va_end(args);
+        if ((result >= 0) && (result <= requiredSize))
+        {
+          size_t writtenBytesCount = write((uint8_t *)buffer, result + 1);
+          free(buffer);
+          return writtenBytesCount;
+        }
+        free(buffer);
+      }
+    }
+    return 0;
+  }
 };
 
+void bleInit(uint8_t bleMode);
+void bleStop();
+int8_t getBleStatus();
+void remoteBLETickTime(Stream* stream, RemoteState* state, uint8_t bleMode);
+int bleDoCommand(Stream* stream, RemoteState* state, uint8_t bleMode);
+extern NordicUART BLESerial;
+
 #endif

ats-mini/Common.h

@@ -206,12 +206,6 @@ bool ntpSyncTime();
 void netRequestConnect();
 void netTickTime();
 
-// Ble.cpp
-int bleDoCommand(uint8_t bleModeIdx);
-void bleInit(uint8_t bleMode);
-void bleStop();
-int8_t getBleStatus();
-
 // Remote.c
 #define REMOTE_CHANGED   1
 #define REMOTE_CLICK     2

ats-mini/Draw.cpp

@@ -3,6 +3,7 @@
 #include "Storage.h"
 #include "Utils.h"
 #include "Menu.h"
+#include "Ble.h"
 #include "Draw.h"
 
 //

ats-mini/Menu.cpp

@@ -2,9 +2,10 @@
 #include "Common.h"
 #include "Themes.h"
 #include "Utils.h"
-#include "Menu.h"
 #include "Draw.h"
 #include "EIBI.h"
+#include "Ble.h"
+#include "Menu.h"
 
 //
 // Bands Menu
@@ -121,9 +122,9 @@ static const char *menu[] =
 #define MENU_SLEEP        9
 #define MENU_SLEEPMODE    10
 #define MENU_LOADEIBI     11
-#define MENU_BLEMODE      14
-#define MENU_WIFIMODE     12
-#define MENU_ABOUT        13
+#define MENU_BLEMODE      12
+#define MENU_WIFIMODE     13
+#define MENU_ABOUT        14
 
 
 int8_t settingsIdx = MENU_BRIGHTNESS;
@@ -142,7 +143,7 @@ static const char *settings[] =
   "Sleep",
   "Sleep Mode",
   "Load EiBi",
-  //  "Bluetooth",
+  "Bluetooth",
   "Wi-Fi",
   "About",
 };
@@ -249,7 +250,7 @@ static const char *uiLayoutDesc[] =
 
 uint8_t bleModeIdx = BLE_OFF;
 static const char *bleModeDesc[] =
-{ "Off", "DummyEcho" };
+{ "Off", "Ad hoc" };
 
 int getTotalBleModes() { return(ITEM_COUNT(bleModeDesc)); }
 

ats-mini/Remote.h

@@ -1,3 +1,6 @@
+#ifndef REMOTE_H
+#define REMOTE_H
+
 typedef struct {
   uint32_t remoteTimer = millis();
   uint8_t remoteSeqnum = 0;
@@ -6,3 +9,5 @@ typedef struct {
 
 void remoteTickTime(Stream* stream, RemoteState* state);
 int remoteDoCommand(Stream* stream, RemoteState* state, char key);
+
+#endif

ats-mini/ats-mini.ino

@@ -13,14 +13,14 @@
 #include "Utils.h"
 #include "EIBI.h"
 #include "Remote.h"
+#include "Ble.h"
 
 // SI473/5 and UI
 #define MIN_ELAPSED_TIME         5  // 300
 #define MIN_ELAPSED_RSSI_TIME  200  // RSSI check uses IN_ELAPSED_RSSI_TIME * 6 = 1.2s
 #define ELAPSED_COMMAND      10000  // time to turn off the last command controlled by encoder. Time to goes back to the VFO control // G8PTN: Increased time and corrected comment
 #define DEFAULT_VOLUME          35  // change it for your favorite sound volume
 #define DEFAULT_SLEEP            0  // Default sleep interval, range = 0 (off) to 255 in steps of 5
-#define STRENGTH_CHECK_TIME   1500  // Not used
 #define RDS_CHECK_TIME         250  // Increased from 90
 #define SEEK_TIMEOUT        600000  // Max seek timeout (ms)
 #define NTP_CHECK_TIME       60000  // NTP time refresh period (ms)
@@ -93,6 +93,7 @@ uint8_t  snr  = 0;
 // Remotes
 //
 RemoteState remoteSerialState;
+RemoteState remoteBLEState;
 
 //
 // Devices
@@ -102,7 +103,7 @@ ButtonTracker pb1 = ButtonTracker();
 TFT_eSPI tft    = TFT_eSPI();
 TFT_eSprite spr = TFT_eSprite(&tft);
 SI4735_fixed rx;
-
+NordicUART BLESerial = NordicUART(RECEIVER_NAME);
 
 //
 // Hardware initialization and setup
@@ -752,8 +753,9 @@ void loop()
 
   ButtonTracker::State pb1st = pb1.update(digitalRead(ENCODER_PUSH_BUTTON) == LOW);
 
-  // Periodically print status to serial
+  // Periodically print status to remote interfaces
   remoteTickTime(&Serial, &remoteSerialState);
+  remoteBLETickTime(&BLESerial, &remoteBLEState, bleModeIdx);
 
   // if(encCount && getCpuFrequencyMhz()!=240) setCpuFrequencyMhz(240);
 
@@ -769,7 +771,14 @@ void loop()
     if(revent & REMOTE_PREFS) prefsRequestSave(SAVE_ALL);
   }
 
-  int ble_event = bleDoCommand(bleModeIdx);
+  // Receive and execute BLE command
+  int ble_event = bleDoCommand(&BLESerial, &remoteBLEState, bleModeIdx);
+  needRedraw |= !!(ble_event & REMOTE_CHANGED);
+  pb1st.wasClicked |= !!(ble_event & REMOTE_CLICK);
+  int direction = ble_event >> REMOTE_DIRECTION;
+  encCount = direction? direction : encCount;
+  encCountAccel = direction? direction : encCountAccel;
+  if(ble_event & REMOTE_PREFS) prefsRequestSave(SAVE_ALL);
 
   // Block encoder rotation when in the locked sleep mode
   if(encCount && sleepOn() && sleepModeIdx==SLEEP_LOCKED) encCount = encCountAccel = 0;