Prog pour OBCP Steffen
Diff: SimpleBLE.h
- Revision:
- 0:2ecd71f6ab04
- Child:
- 1:17c8f5afa7bc
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/SimpleBLE.h Wed May 11 12:59:14 2016 +0000 @@ -0,0 +1,385 @@ +/** + * Because BLE_API is too hard + */ +#include <string> +#include <sstream> +#include <vector> +#include <map> +#include "ble/BLE.h" + +using namespace std; + +/** + * Class so we can call onDataWritten on any SimpleCharInternal regardless of <T,U> + */ +class Updatable { +public: + virtual void onDataWritten(const uint8_t* data, size_t len) = 0; +}; + +/** + * Class that we wrap in SimpleChar so we can just implement operators, + * without having to type the full type of U when using this code. + * Whenever we get 'auto' we can get rid of this. + */ +template <class T> +class SimpleCharBase { +public: + virtual void update(T newValue) = 0; + virtual T* getValue(void) = 0; +}; + +/** + * Actual implementation of the char + * T is the underlying type, U is the GattCharacteristic it's wrapping + */ +template <class T, template <typename T2> class U> +class SimpleCharInternal : public Updatable, public SimpleCharBase<T> { +public: + SimpleCharInternal(BLE* aBle, + const UUID &uuid, + GattCharacteristic::Properties_t aGattChar, + T aDefaultValue, + void(*aCallback)(T) = NULL) : + ble(aBle), value(new T(aDefaultValue)), callback(aCallback) + { + state = new U<T>(uuid, value, aGattChar); + } + + ~SimpleCharInternal() { + if (state) { + free(state); + } + if (value) { + free(value); + } + } + + virtual void update(T newValue) { + *value = newValue; + ble->gattServer().write(state->getValueHandle(), (uint8_t *)value, sizeof(T)); + } + + U<T>* getChar(void) { + return state; + } + + virtual T* getValue(void) { + return value; + } + + virtual void onDataWritten(const uint8_t* data, size_t len) { + *value = ((T*)data)[0]; + if (callback) { + callback(*value); + } + } + +private: + BLE* ble; + T* value; + U<T>* state; + void(*callback)(T); +}; + +/** + * This is what the user gets back. it's nice and short so don't have to type much. + * If we get 'auto' we can get rid of this. + */ +template <class T> +class SimpleChar { +public: + SimpleChar(SimpleCharBase<T>* aBase) : base(aBase) { + } + ~SimpleChar() { + if (base) { + delete base; + } + } + + T operator=(const T& newValue) { + base->update(newValue); + return newValue; + }; + operator T() const { + return *(base->getValue()); + }; + +private: + SimpleCharBase<T>* base; +}; + + +class SimpleBLE { +public: + SimpleBLE(const char* aName, uint16_t aInterval = 1000) : name(aName), interval(aInterval) { + ble = &BLE::Instance(); + } + ~SimpleBLE() {} + + void start() { + ble->init(this, &SimpleBLE::bleInitComplete); + + /* SpinWait for initialization to complete. This is necessary because the + * BLE object is used in the main loop below. */ + while (ble->hasInitialized() == false) { /* spin loop */ } + } + + // Start up the BLE service and just run with it! + void waitForEvent() { + ble->waitForEvent(); + } + + // === START READONLY === + + template <typename T> + SimpleChar<T> readOnly(uint16_t serviceUuid, + const UUID& charUuid, + bool enableNotify = true, + T defaultValue = T()) { + GattCharacteristic::Properties_t gattChar = enableNotify ? + GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_NOTIFY : + GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ; + + SimpleCharInternal<T, ReadOnlyGattCharacteristic>* c = + new SimpleCharInternal<T, ReadOnlyGattCharacteristic>(ble, charUuid, gattChar, defaultValue); + + addToServices(serviceUuid, c->getChar()); + + return *(new SimpleChar<T>(c)); + } + + template <typename T> + SimpleChar<T> readOnly(const char* serviceUuid, + const UUID& charUuid, + bool enableNotify = true, + T defaultValue = T()) { + GattCharacteristic::Properties_t gattChar = enableNotify ? + GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_NOTIFY : + GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ; + + SimpleCharInternal<T, ReadOnlyGattCharacteristic>* c = + new SimpleCharInternal<T, ReadOnlyGattCharacteristic>(ble, charUuid, gattChar, defaultValue); + + addToServices(serviceUuid, c->getChar()); + + return *(new SimpleChar<T>(c)); + } + + // === END READONLY === + + // === START READWRITE === + + template <typename T> + SimpleChar<T> readWrite(uint16_t serviceUuid, + const UUID& charUuid, + bool enableNotify = true, + T defaultValue = T(), + void(*callback)(T) = NULL) { + GattCharacteristic::Properties_t gattChar = enableNotify ? + GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_NOTIFY : + GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ; + + SimpleCharInternal<T, ReadWriteGattCharacteristic>* c = + new SimpleCharInternal<T, ReadWriteGattCharacteristic>(ble, charUuid, gattChar, defaultValue, callback); + + addToServices(serviceUuid, c->getChar()); + + writeCallbacks[c->getChar()] = c; + + return *(new SimpleChar<T>(c)); + } + + + + template <typename T> + SimpleChar<T> readWrite(const char* serviceUuid, + const UUID& charUuid, + bool enableNotify = true, + T defaultValue = T(), + void(*callback)(T) = NULL) { + GattCharacteristic::Properties_t gattChar = enableNotify ? + GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_NOTIFY : + GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ; + + SimpleCharInternal<T, ReadWriteGattCharacteristic>* c = + new SimpleCharInternal<T, ReadWriteGattCharacteristic>(ble, charUuid, gattChar, defaultValue, callback); + + addToServices(serviceUuid, c->getChar()); + + writeCallbacks[c->getChar()] = c; + + return *(new SimpleChar<T>(c)); + } + + template <typename T> + SimpleChar<T> readWrite(uint16_t serviceUuid, + const UUID& charUuid, + void(*callback)(T) = NULL) { + return readWrite(serviceUuid, charUuid, true, T(), callback); + } + + template <typename T> + SimpleChar<T> readWrite(const char* serviceUuid, + const UUID& charUuid, + void(*callback)(T) = NULL) { + return readWrite(serviceUuid, charUuid, true, T(), callback); + } + + // === END READWRITE === + + // === START WRITEONLY === + + template <typename T> + SimpleChar<T> writeOnly(uint16_t serviceUuid, + const UUID& charUuid, + void(*callback)(T) = NULL) { + GattCharacteristic::Properties_t gattChar = enableNotify ? + GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_NOTIFY : + GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ; + + SimpleCharInternal<T, WriteOnlyGattCharacteristic>* c = + new SimpleCharInternal<T, WriteOnlyGattCharacteristic>(ble, charUuid, GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_NONE, defaultValue, callback); + + addToServices(serviceUuid, c->getChar()); + + writeCallbacks[c->getChar()] = c; + + return *(new SimpleChar<T>(c)); + } + + template <typename T> + SimpleChar<T> writeOnly(const char* serviceUuid, + const UUID& charUuid, + void(*callback)(T) = NULL) { + + SimpleCharInternal<T, WriteOnlyGattCharacteristic>* c = + new SimpleCharInternal<T, WriteOnlyGattCharacteristic>(ble, charUuid, GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_NONE, defaultValue, callback); + + addToServices(serviceUuid, c->getChar()); + + writeCallbacks[c->getChar()] = c; + + return *(new SimpleChar<T>(c)); + } + + // === END READWRITE === + + + void onDisconnection(Gap::DisconnectionEventCallback_t callback) { + ble->gap().onDisconnection(callback); + } + + void onConnection(Gap::ConnectionEventCallback_t callback) { + ble->gap().onConnection(callback); + } + + BLE* getBle(void) { + return ble; + } + + +private: + void bleInitComplete(BLE::InitializationCompleteCallbackContext *params) + { + printf("bleInitComplete\r\n"); + + BLE& ble = params->ble; + ble_error_t error = params->error; + + if (error != BLE_ERROR_NONE) { + printf("BLE Init error %d\r\n", error); + return; + } + + /* Ensure that it is the default instance of BLE */ + if(ble.getInstanceID() != BLE::DEFAULT_INSTANCE) { + return; + } + + ble.gattServer().onDataWritten(this, &SimpleBLE::onDataWrittenCallback); + + // let's add some services yo (why is there no 'auto' in mbed?) + uint16_t uuid16_list[uint16_services.size()]; + size_t uuid16_counter = 0; + { + typedef std::map<uint16_t, vector<GattCharacteristic*>* >::iterator it_type; + for(it_type it = uint16_services.begin(); it != uint16_services.end(); it++) { + printf("Creating service 0x%x\n", it->first); + uuid16_list[uuid16_counter++] = it->first; + + GattCharacteristic* charTable[it->second->size()]; + for (size_t git = 0; git < it->second->size(); git++) { + charTable[git] = it->second->at(git); + } + + GattService service(it->first, charTable, it->second->size()); + ble.gattServer().addService(service); + } + } + + // 128 Bit services + const char* uuid128_list[uint128_services.size()]; + size_t uuid128_counter = 0; + { + typedef std::map<string, vector<GattCharacteristic*>* >::iterator it_type; + for(it_type it = uint128_services.begin(); it != uint128_services.end(); it++) { + printf("Creating service %s\n", it->first.c_str()); + uuid128_list[uuid128_counter++] = it->first.c_str(); + + GattCharacteristic* charTable[it->second->size()]; + for (size_t git = 0; git < it->second->size(); git++) { + charTable[git] = it->second->at(git); + } + + GattService service(UUID(it->first.c_str()), charTable, it->second->size()); + ble.gattServer().addService(service); + } + } + + ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::BREDR_NOT_SUPPORTED | GapAdvertisingData::LE_GENERAL_DISCOVERABLE); + ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LIST_16BIT_SERVICE_IDS, (uint8_t *)uuid16_list, uuid16_counter); + ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LIST_128BIT_SERVICE_IDS, (uint8_t *)uuid128_list, uuid128_counter); + ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LOCAL_NAME, (uint8_t *)name, strlen(name)); + ble.gap().setAdvertisingType(GapAdvertisingParams::ADV_CONNECTABLE_UNDIRECTED); + ble.gap().setAdvertisingInterval(interval); + ble.gap().startAdvertising(); + + printf("Started advertising\r\n"); + } + + void onDataWrittenCallback(const GattWriteCallbackParams *params) { + // see if we know for which char this message is... + typedef std::map<GattCharacteristic*, Updatable* >::iterator it_type; + for(it_type it = writeCallbacks.begin(); it != writeCallbacks.end(); it++) { + if (it->first->getValueHandle() == params->handle) { + it->second->onDataWritten(params->data, params->len); + } + } + } + + void addToServices(uint16_t uuid, GattCharacteristic* c) { + if (uint16_services.count(uuid) == 0) { + uint16_services[uuid] = new vector<GattCharacteristic*>(); + } + + uint16_services[uuid]->push_back(c); + } + + void addToServices(const char* aUuid, GattCharacteristic* c) { + string uuid(aUuid); + if (uint128_services.count(uuid) == 0) { + uint128_services[uuid] = new vector<GattCharacteristic*>(); + } + + uint128_services[uuid]->push_back(c); + } + + BLE* ble; + const char* name; + uint16_t interval; + map<uint16_t, vector<GattCharacteristic*>* > uint16_services; + map<string, vector<GattCharacteristic*>* > uint128_services; + map<GattCharacteristic*, Updatable*> writeCallbacks; +}; +