TinyCTSClientNimBLE.h

Go to the documentation of this file.

 
#pragma once
#include <NimBLEDevice.h>
 
#include "../TinyCTSClientBase.h"
 
namespace tiny_cts {

class TinyCTSClient : public TinyCTSClientBase {
 public:
  explicit TinyCTSClient(const char* device = nullptr, uint32_t scanMs = 5000)
      : _scanMs(scanMs) {
    if (device != nullptr) _device = device;
  }

  bool begin() {
    if (!NimBLEDevice::isInitialized()) NimBLEDevice::init("");
    return update();
  }

  bool update() {
    NimBLEClient* client = connect();
    if (client == nullptr) return false;
    bool ok = false;
    NimBLERemoteService* service = client->getService(NimBLEUUID(CTS_SERVICE_UUID));
    if (service != nullptr) {
      readInfo(service);
      NimBLERemoteCharacteristic* chr =
          service->getCharacteristic(NimBLEUUID(CTS_CURRENT_TIME_UUID));
      if (chr != nullptr && chr->canRead()) {
        uint32_t t0 = TINY_CTS_MILLIS();
        NimBLEAttValue v = chr->readValue();
        uint32_t t1 = TINY_CTS_MILLIS();
        ok = storeCurrentTime(v.data(), v.size(), t0, t1);
      }
    }
    release(client);
    return ok;
  }

  bool setTimeMs(uint64_t unixMs) override {
    NimBLEClient* client = connect();
    if (client == nullptr) return false;
    bool ok = false;
    NimBLERemoteService* service = client->getService(NimBLEUUID(CTS_SERVICE_UUID));
    NimBLERemoteCharacteristic* chr =
        service != nullptr ? service->getCharacteristic(NimBLEUUID(CTS_CURRENT_TIME_UUID))
                           : nullptr;
    if (chr != nullptr && chr->canWrite()) {
      uint8_t data[TinyCTSCurrentTime::Size];
      ok = chr->writeValue(data, timeToWrite(unixMs, data), true);
    }
    release(client);
    return ok;
  }
 
 protected:
  NimBLEClient* connect() {
    NimBLEScan* scan = NimBLEDevice::getScan();
    scan->setActiveScan(true);
    NimBLEScanResults results = scan->getResults(_scanMs, false);
    const NimBLEAdvertisedDevice* found = nullptr;
    for (int i = 0; i < results.getCount() && found == nullptr; i++) {
      const NimBLEAdvertisedDevice* d = results.getDevice(i);
      if (_device.empty()) {
        if (d->isAdvertisingService(NimBLEUUID(CTS_SERVICE_UUID))) found = d;
      } else if (isWanted(d->getAddress().toString(), d->getName())) {
        found = d;
      }
    }
    if (found == nullptr) return nullptr;
    NimBLEClient* client = NimBLEDevice::createClient();
    if (client == nullptr) return nullptr;
    if (!client->connect(found)) {
      NimBLEDevice::deleteClient(client);
      return nullptr;
    }
    _name = found->getName();
    _address = found->getAddress().toString();
    return client;
  }

  static void release(NimBLEClient* client) {
    client->disconnect();
    NimBLEDevice::deleteClient(client);
  }
 
  void readInfo(NimBLERemoteService* service) {
    NimBLERemoteCharacteristic* chr =
        service->getCharacteristic(NimBLEUUID(CTS_LOCAL_TIME_INFO_UUID));
    if (chr != nullptr && chr->canRead()) {
      NimBLEAttValue v = chr->readValue();
      storeLocalInfo(v.data(), v.size());
    }
    chr = service->getCharacteristic(NimBLEUUID(CTS_REFERENCE_TIME_INFO_UUID));
    if (chr != nullptr && chr->canRead()) {
      NimBLEAttValue v = chr->readValue();
      storeReferenceInfo(v.data(), v.size());
    }
  }
 
  uint32_t _scanMs;
};
 
}  // namespace tiny_cts