TinyCTSServerPico.h

Go to the documentation of this file.

 
#pragma once
#include <BluetoothLock.h>
 
#include <cstdlib>
#include <cstring>
 
#include "TinyCTSPicoBLE.h"
#include "../TinyCTSServerBase.h"
 
namespace tiny_cts {

class TinyCTSServer : public TinyCTSServerBase, public BLECharacteristicCallbacks {
 public:
  TinyCTSServer() = default;

  bool begin(TinyCTSTimeSource& source, const char* deviceName = "TinyCTS") {
    _source = &source;
    bool pairing = _settable && _encrypted;
    if (!ctsPicoBegin(deviceName, pairing)) return false;
 
    // writing needs an encrypted connection (ATT_SECURITY_ENCRYPTED = 1)
    uint8_t writePerm = pairing ? 1 : 0;
    uint16_t write = _settable ? BLEWrite : 0;
    _service = new BLEService(BLEUUID(CTS_SERVICE_UUID));
    _current = new Value(BLEUUID(CTS_CURRENT_TIME_UUID), BLERead | BLENotify | write, writePerm);
    _local = new Value(BLEUUID(CTS_LOCAL_TIME_INFO_UUID), BLERead | write, writePerm);
    _reference = new Value(BLEUUID(CTS_REFERENCE_TIME_INFO_UUID), BLERead, 0);
    _current->setCallbacks(this);
    _local->setCallbacks(this);
    _reference->setCallbacks(this);
    updateCurrent(0, false);
    updateLocal();
    updateReference();
    _service->addCharacteristic(_current);
    _service->addCharacteristic(_local);
    _service->addCharacteristic(_reference);
    BLE.server()->addService(_service);
    BLE.startAdvertising();
    return true;
  }

  void end() {
    BLE.stopAdvertising();
    _source = nullptr;
  }

  bool process() {
    if (_current == nullptr || !notifyDue()) return false;
    return notifyTime(0);
  }

  bool notifyTime(uint8_t adjustReason = 0) {
    if (_current == nullptr) return false;
    BluetoothLock lock;  // the callbacks of the stack use the time source too
    updateCurrent(adjustReason, true);
    return true;
  }
 
 protected:
  class Value : public BLECharacteristic {
   public:
    Value(BLEUUID uuid, uint16_t flags, uint8_t writePerm)
        : BLECharacteristic(uuid, flags, nullptr, 0, writePerm) {}
 
    void set(const uint8_t* data, size_t len, bool notify) {
      _charData = realloc(_charData, len);
      memcpy(_charData, data, len);
      _charLen = len;
      if (notify) requestNotify();
    }
  };
 
  void onTimeZoneChanged() override {
    if (_local == nullptr) return;
    BluetoothLock lock;
    updateLocal();
    updateCurrent(TinyCTSCurrentTime::TimeZoneChange, true);
  }
 
  void onReferenceChanged() override {
    if (_reference == nullptr) return;
    BluetoothLock lock;
    updateReference();
  }
 
  // (runs in the context of the Bluetooth stack)
  void onRead(BLECharacteristic* chr) override {
    if (chr == _current) updateCurrent(0, false);
  }
 
  void onWrite(BLECharacteristic* chr) override {
    const uint8_t* data = static_cast<const uint8_t*>(chr->valueData());
    size_t len = chr->valueLen();
    if (chr == _current) {
      if (setTimeFromWrite(data, len)) {
        updateCurrent(TinyCTSCurrentTime::ManualUpdate, true);
      } else {
        updateCurrent(0, false);  // refused: show the real time again
      }
    } else if (chr == _local) {
      setTimeZoneFromWrite(data, len);
      updateLocal();
      updateCurrent(TinyCTSCurrentTime::TimeZoneChange, true);
    }
  }
 
  void updateCurrent(uint8_t reason, bool notify) {
    uint8_t data[TinyCTSCurrentTime::Size];
    _current->set(data, currentTimeValue(reason, data), notify);
  }
 
  void updateLocal() {
    uint8_t data[TinyCTSLocalTimeInfo::Size];
    _local->set(data, localTimeValue(data), false);
  }
 
  void updateReference() {
    uint8_t data[TinyCTSReferenceTimeInfo::Size];
    _reference->set(data, referenceTimeValue(data), false);
  }
 
  BLEService* _service = nullptr;
  Value* _current = nullptr;
  Value* _local = nullptr;
  Value* _reference = nullptr;
};
 
}  // namespace tiny_cts