EXPERIMENTAL: Ble read/write characteristics over MQTT.

Uses 1technophile#979

This allows reading and writing BLE characteristics from an MQTT message.

Example format:
mosquitto_pub -t home/OpenMQTTGateway/commands/MQTTtoBT/config -m '{"ble_write_address":"AA:BB:CC:DD:EE:FF", "ble_write_service":"cba20d00-224d-11e6-9fb8-0002a5d5c51b", "ble_write_char":"cba20002-224d-11e6-9fb8-0002a5d5c51b", "ble_write_value":"TEST", "ttl":4 }'
mosquitto_pub -t home/OpenMQTTGateway/commands/MQTTtoBT/config -m '{"ble_read_address":"30:AE:A4:7C:3C:A6", "ble_read_service":"cba20d00-224d-11e6-9fb8-0002a5d5c51b", "ble_read_char":"cba20002-224d-11e6-9fb8-0002a5d5c51b", "ttl": 2 }'
The ttl parameter is the number of calls to connect (defaults to 1), which occur after the BLE scan completes.

A response is provided over MQTT in the format:
write : {"id":"30:AE:A4:7C:3C:A6","service":"cba20d00-224d-11e6-9fb8-0002a5d5c51b","characteristic":"cba20002-224d-11e6-9fb8-0002a5d5c51b","write":"TEST","success":true}
read : {"id":"30:AE:A4:7C:3C:A6","service":"cba20d00-224d-11e6-9fb8-0002a5d5c51b","characteristic":"cba20002-224d-11e6-9fb8-0002a5d5c51b","read":"TEST","success":true}

Author: h2zero

main/ZgatewayBLEConnect.h

@@ -4,6 +4,7 @@
 #ifdef ESP32
 #  include "ArduinoJson.h"
 #  include "NimBLEDevice.h"
+#  include "config_BT.h"
 
 extern void pubBT(JsonObject& data);
 
@@ -13,6 +14,9 @@ class zBLEConnect {
   TaskHandle_t m_taskHandle = nullptr;
   zBLEConnect(NimBLEAddress& addr) { m_pClient = NimBLEDevice::createClient(addr); }
   virtual ~zBLEConnect() { NimBLEDevice::deleteClient(m_pClient); }
+  virtual bool writeData(BLEAction* action);
+  virtual bool readData(BLEAction* action);
+  virtual bool processActions(std::vector<BLEAction>& actions);
   virtual void publishData() {}
   virtual NimBLERemoteCharacteristic* getCharacteristic(const NimBLEUUID& service, const NimBLEUUID& characteristic);
 };

main/ZgatewayBLEConnect.ino

@@ -4,7 +4,6 @@
 #    include "ArduinoJson.h"
 #    include "ArduinoLog.h"
 #    include "ZgatewayBLEConnect.h"
-#    include "config_BT.h"
 
 #    define convertTemp_CtoF(c) ((c * 1.8) + 32)
 
@@ -35,6 +34,57 @@ NimBLERemoteCharacteristic* zBLEConnect::getCharacteristic(const NimBLEUUID& ser
   return pRemoteCharacteristic;
 }
 
+bool zBLEConnect::writeData(BLEAction* action) {
+  NimBLERemoteCharacteristic* pChar = getCharacteristic(action->service, action->characteristic);
+
+  if (pChar && pChar->canWrite()) {
+    return pChar->writeValue(action->value);
+  }
+  return false;
+}
+
+bool zBLEConnect::readData(BLEAction* action) {
+  NimBLERemoteCharacteristic* pChar = getCharacteristic(action->service, action->characteristic);
+
+  if (pChar && pChar->canRead()) {
+    action->value = pChar->readValue();
+    if (action->value != "") {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool zBLEConnect::processActions(std::vector<BLEAction>& actions) {
+  bool result = false;
+  if (actions.size() > 0) {
+    for (auto& it : actions) {
+      if (NimBLEAddress(it.addr) == m_pClient->getPeerAddress()) {
+        JsonObject& BLEresult = getBTJsonObject();
+        BLEresult.set("id", it.addr);
+        BLEresult.set("service", (char*)it.service.toString().c_str());
+        BLEresult.set("characteristic", (char*)it.characteristic.toString().c_str());
+
+        if (it.write) {
+          Log.trace(F("processing BLE write" CR));
+          BLEresult.set("write", it.value.c_str());
+          result = writeData(&it);
+        } else {
+          Log.trace(F("processing BLE read" CR));
+          result = readData(&it);
+          BLEresult.set("read", it.value.c_str());
+        }
+
+        it.complete = true;
+        BLEresult.set("success", result);
+        pubBT(BLEresult);
+      }
+    }
+  }
+
+  return result;
+}
+
 /*-----------------------LYWSD03MMC && MHO_C401 HANDLING-----------------------*/
 void LYWSD03MMC_connect::notifyCB(NimBLERemoteCharacteristic* pChar, uint8_t* pData, size_t length, bool isNotify) {
   if (m_taskHandle == nullptr) {
@@ -158,5 +208,6 @@ void DT24_connect::publishData() {
     }
   }
 }
+
 #  endif //ZgatewayBT
 #endif //ESP32

main/ZgatewayBT.ino

@@ -71,6 +71,10 @@ struct decompose {
   bool reverse;
 };
 
+#  ifdef ESP32
+vector<BLEAction> BLEactions;
+#  endif
+
 vector<BLEdevice*> devices;
 int newDevices = 0;
 
@@ -727,21 +731,33 @@ void BLEconnect() {
     if (p->connect) {
       Log.trace(F("Model to connect found: %s" CR), p->macAdr);
       NimBLEAddress addr(std::string(p->macAdr));
+
       switch (p->sensorModel) {
         case LYWSD03MMC:
         case MHO_C401: {
           LYWSD03MMC_connect BLEclient(addr);
+          BLEclient.processActions(BLEactions);
           BLEclient.publishData();
           break;
         }
         case DT24: {
           DT24_connect BLEclient(addr);
+          BLEclient.processActions(BLEactions);
           BLEclient.publishData();
           break;
         }
         default:
           break;
       }
+      if (BLEactions.size() > 0) {
+        std::vector<BLEAction> swap;
+        for (auto& it : BLEactions) {
+          if (!it.complete && --it.ttl) {
+            swap.push_back(it);
+          }
+        }
+        std::swap(BLEactions, swap);
+      }
     }
   }
   Log.notice(F("BLE Connect end" CR));
@@ -1661,6 +1677,36 @@ void BTforceScan() {
   }
 }
 
+void MQTTtoBTAction(JsonObject& BTdata) {
+#  ifdef ESP32
+  BLEAction action;
+  action.ttl = BTdata.containsKey("ttl") ? (uint8_t)BTdata["ttl"] : 1;
+  Log.trace(F("BLE ACTION TTL = %u" CR), action.ttl);
+  action.complete = false;
+  if (BTdata.containsKey("ble_write_address") &&
+      BTdata.containsKey("ble_write_service") &&
+      BTdata.containsKey("ble_write_char") &&
+      BTdata.containsKey("ble_write_value")) {
+    strcpy(action.addr, (const char*)BTdata["ble_write_address"]);
+    action.service = NimBLEUUID((const char*)BTdata["ble_write_service"]);
+    action.characteristic = NimBLEUUID((const char*)BTdata["ble_write_char"]);
+    action.value = std::string((const char*)BTdata["ble_write_value"]);
+    action.write = true;
+  } else if (BTdata.containsKey("ble_read_address") &&
+             BTdata.containsKey("ble_read_service") &&
+             BTdata.containsKey("ble_read_char")) {
+    strcpy(action.addr, (const char*)BTdata["ble_read_address"]);
+    action.service = NimBLEUUID((const char*)BTdata["ble_read_service"]);
+    action.characteristic = NimBLEUUID((const char*)BTdata["ble_read_char"]);
+    action.write = false;
+  } else {
+    return;
+  }
+
+  BLEactions.push_back(action);
+#  endif
+}
+
 void MQTTtoBT(char* topicOri, JsonObject& BTdata) { // json object decoding
   if (cmpToMainTopic(topicOri, subjectMQTTtoBTset)) {
     Log.trace(F("MQTTtoBT json set" CR));
@@ -1722,6 +1768,8 @@ void MQTTtoBT(char* topicOri, JsonObject& BTdata) { // json object decoding
     if (BTdata.containsKey("lowpowermode")) {
       changelowpowermode((int)BTdata["lowpowermode"]);
     }
+
+    MQTTtoBTAction(BTdata);
 #  endif
     // MinRSSI set
     if (BTdata.containsKey("minrssi")) {

main/config_BT.h

@@ -46,6 +46,7 @@ bool bleConnect = AttemptBLECOnnect;
 #  ifndef BLE_FILTER_CONNECTABLE
 #    define BLE_FILTER_CONNECTABLE 1
 #  endif
+#  include "NimBLEDevice.h"
 #endif
 
 /*----------------------BT topics & parameters-------------------------*/
@@ -168,6 +169,18 @@ enum ble_sensor_model {
 #endif
 
 /*---------------INTERNAL USE: DO NOT MODIFY--------------*/
+#ifdef ESP32
+struct BLEAction {
+  std::string value;
+  char addr[18];
+  NimBLEUUID service;
+  NimBLEUUID characteristic;
+  bool write;
+  bool complete;
+  uint8_t ttl;
+};
+#endif
+
 struct BLEdevice {
   char macAdr[18];
   bool isDisc;