TinyCTSClientArduinoBLE.h

Go to the documentation of this file.

 
#pragma once
#include "TinyCTSArduinoBLE.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 (!ctsArduinoBleBegin()) return false;
    return update();
  }

  bool update() {
    BLEDevice peripheral;
    if (!connect(peripheral)) return false;
    uint8_t data[16];
    size_t len;
    if (read(peripheral, "2a0f", data, len)) storeLocalInfo(data, len);
    if (read(peripheral, "2a14", data, len)) storeReferenceInfo(data, len);
    uint32_t t0 = TINY_CTS_MILLIS();
    bool ok = read(peripheral, "2a2b", data, len) &&
              storeCurrentTime(data, len, t0, TINY_CTS_MILLIS());
    peripheral.disconnect();
    return ok;
  }

  bool setTimeMs(uint64_t unixMs) override {
    BLEDevice peripheral;
    if (!connect(peripheral)) return false;
    bool ok = false;
    BLECharacteristic chr = peripheral.characteristic("2a2b");
    if (chr && chr.canWrite()) {
      uint8_t data[TinyCTSCurrentTime::Size];
      ok = chr.writeValue(data, static_cast<int>(timeToWrite(unixMs, data))) != 0;
    }
    peripheral.disconnect();
    return ok;
  }
 
 protected:
  static bool offersService(BLEDevice& d) {
    for (int i = 0; i < d.advertisedServiceUuidCount(); i++) {
      if (d.advertisedServiceUuid(i).equalsIgnoreCase("1805")) return true;
    }
    return false;
  }
 
  bool connect(BLEDevice& peripheral) {
    BLE.scan();
    uint32_t start = millis();
    bool found = false;
    while (!found && static_cast<uint32_t>(millis() - start) < _scanMs) {
      BLEDevice d = BLE.available();
      if (!d) continue;
      std::string address = d.address().c_str();
      std::string name = d.hasLocalName() ? d.localName().c_str() : "";
      if (_device.empty() ? offersService(d) : isWanted(address, name)) {
        peripheral = d;
        _address = address;
        _name = name;
        found = true;
      }
    }
    BLE.stopScan();
    if (!found || !peripheral.connect()) return false;
    if (!peripheral.discoverAttributes()) {
      peripheral.disconnect();
      return false;
    }
    return true;
  }
 
  static bool read(BLEDevice& peripheral, const char* uuid, uint8_t* out, size_t& len) {
    BLECharacteristic chr = peripheral.characteristic(uuid);
    if (!chr || !chr.canRead() || !chr.read()) return false;
    len = static_cast<size_t>(chr.valueLength());
    if (len == 0) return false;
    if (len > 16) len = 16;
    memcpy(out, chr.value(), len);
    return true;
  }
 
  uint32_t _scanMs;
};
 
}  // namespace tiny_cts