Fabio Dal Forno
Gestione Bluetooth per il progetto Tarallo
Revision 82:443323e7d4c9, committed 2020-01-16
- Comitter:
- fdalforno
- Date:
- Thu Jan 16 14:48:30 2020 +0000
- Parent:
- 81:796f36bfa718
- Commit message:
- Gestione client Bluetooth per scheda F401RE
Changed in this revision
| source/BLEProcess.h | Show annotated file Show diff for this revision Revisions of this file |
| source/main.cpp | Show annotated file Show diff for this revision Revisions of this file |
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/source/BLEProcess.h Thu Jan 16 14:48:30 2020 +0000
@@ -0,0 +1,231 @@
+/* mbed Microcontroller Library
+ * Copyright (c) 2006-2015 ARM Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef GATT_EXAMPLE_BLE_PROCESS_H_
+#define GATT_EXAMPLE_BLE_PROCESS_H_
+
+#include <stdint.h>
+#include <stdio.h>
+
+#include "events/EventQueue.h"
+#include "platform/Callback.h"
+#include "platform/NonCopyable.h"
+
+#include "ble/BLE.h"
+#include "ble/Gap.h"
+#include "ble/GapAdvertisingParams.h"
+#include "ble/GapAdvertisingData.h"
+#include "ble/FunctionPointerWithContext.h"
+
+/**
+ * Handle initialization and shutdown of the BLE Instance.
+ *
+ * Setup advertising payload and manage advertising state.
+ * Delegate to GattClientProcess once the connection is established.
+ */
+class BLEProcess : private mbed::NonCopyable<BLEProcess> {
+public:
+ /**
+ * Construct a BLEProcess from an event queue and a ble interface.
+ *
+ * Call start() to initiate ble processing.
+ */
+ BLEProcess(events::EventQueue &event_queue, BLE &ble_interface) :
+ _event_queue(event_queue),
+ _ble_interface(ble_interface),
+ _post_init_cb() {
+ }
+
+ ~BLEProcess()
+ {
+ stop();
+ }
+
+ /**
+ * Initialize the ble interface, configure it and start advertising.
+ */
+ bool start()
+ {
+ printf("Ble process started.\r\n");
+
+ if (_ble_interface.hasInitialized()) {
+ printf("Error: the ble instance has already been initialized.\r\n");
+ return false;
+ }
+
+ _ble_interface.onEventsToProcess(
+ makeFunctionPointer(this, &BLEProcess::schedule_ble_events)
+ );
+
+ ble_error_t error = _ble_interface.init(
+ this, &BLEProcess::when_init_complete
+ );
+
+ if (error) {
+ printf("Error: %u returned by BLE::init.\r\n", error);
+ return false;
+ }
+
+ return true;
+ }
+
+ /**
+ * Close existing connections and stop the process.
+ */
+ void stop()
+ {
+ if (_ble_interface.hasInitialized()) {
+ _ble_interface.shutdown();
+ printf("Ble process stopped.");
+ }
+ }
+
+ /**
+ * Subscription to the ble interface initialization event.
+ *
+ * @param[in] cb The callback object that will be called when the ble
+ * interface is initialized.
+ */
+ void on_init(mbed::Callback<void(BLE&, events::EventQueue&)> cb)
+ {
+ _post_init_cb = cb;
+ }
+
+private:
+ /**
+ * Sets up adverting payload and start advertising.
+ *
+ * This function is invoked when the ble interface is initialized.
+ */
+ void when_init_complete(BLE::InitializationCompleteCallbackContext *event)
+ {
+ if (event->error) {
+ printf("Error %u during the initialization\r\n", event->error);
+ return;
+ }
+ printf("Ble instance initialized\r\n");
+
+ Gap &gap = _ble_interface.gap();
+ ble_error_t error = gap.setAdvertisingPayload(make_advertising_data());
+ if (error) {
+ printf("Error %u during gap.setAdvertisingPayload\r\n", error);
+ return;
+ }
+
+ gap.setAdvertisingParams(make_advertising_params());
+
+ gap.onConnection(this, &BLEProcess::when_connection);
+ gap.onDisconnection(this, &BLEProcess::when_disconnection);
+
+ start_advertising();
+
+ if (_post_init_cb) {
+ _post_init_cb(_ble_interface, _event_queue);
+ }
+ }
+
+ /**
+ * Start the gatt client process when a connection event is received.
+ */
+ void when_connection(const Gap::ConnectionCallbackParams_t *connection_event)
+ {
+ printf("Connected.\r\n");
+ }
+
+ /**
+ * Stop the gatt client process when the device is disconnected then restart
+ * advertising.
+ */
+ void when_disconnection(const Gap::DisconnectionCallbackParams_t *event)
+ {
+ printf("Disconnected.\r\n");
+ start_advertising();
+ }
+
+ /**
+ * Setup the advertising parameters.
+ */
+ void setup_advertising()
+ {
+ Gap &gap = _ble_interface.gap();
+ gap.setAdvertisingPayload(make_advertising_data());
+ gap.setAdvertisingParams(make_advertising_params());
+ }
+
+ /**
+ * Start the advertising process; it ends when a device connects.
+ */
+ void start_advertising()
+ {
+ ble_error_t error = _ble_interface.gap().startAdvertising();
+ if (error) {
+ printf("Error %u during gap.startAdvertising.\r\n", error);
+ } else {
+ printf("Advertising started.\r\n");
+ }
+ }
+
+ /**
+ * Schedule processing of events from the BLE middleware in the event queue.
+ */
+ void schedule_ble_events(BLE::OnEventsToProcessCallbackContext *event)
+ {
+ _event_queue.call(mbed::callback(&event->ble, &BLE::processEvents));
+ }
+
+ /**
+ * Build data advertised by the BLE interface.
+ */
+ static GapAdvertisingData make_advertising_data(void)
+ {
+ static const uint8_t device_name[] = "GattClient";
+ GapAdvertisingData advertising_data;
+
+ // add advertising flags
+ advertising_data.addFlags(
+ GapAdvertisingData::LE_GENERAL_DISCOVERABLE |
+ GapAdvertisingData::BREDR_NOT_SUPPORTED
+ );
+
+ // add device name
+ advertising_data.addData(
+ GapAdvertisingData::COMPLETE_LOCAL_NAME,
+ device_name,
+ sizeof(device_name)
+ );
+
+ return advertising_data;
+ }
+
+ /**
+ * Build advertising parameters used by the BLE interface.
+ */
+ static GapAdvertisingParams make_advertising_params(void)
+ {
+ return GapAdvertisingParams(
+ /* type */ GapAdvertisingParams::ADV_CONNECTABLE_UNDIRECTED,
+ /* interval */ GapAdvertisingParams::MSEC_TO_ADVERTISEMENT_DURATION_UNITS(500),
+ /* timeout */ 0
+ );
+ }
+
+ events::EventQueue &_event_queue;
+ BLE &_ble_interface;
+ mbed::Callback<void(BLE&, events::EventQueue&)> _post_init_cb;
+};
+
+
+#endif /* GATT_EXAMPLE_BLE_PROCESS_H_ */
\ No newline at end of file
--- a/source/main.cpp Thu Aug 15 17:00:47 2019 +0100
+++ b/source/main.cpp Thu Jan 16 14:48:30 2020 +0000
@@ -1,5 +1,5 @@
/* mbed Microcontroller Library
- * Copyright (c) 2006-2015 ARM Limited
+ * Copyright (c) 2006-2018 ARM Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -14,221 +14,566 @@
* limitations under the License.
*/
-#include <events/mbed_events.h>
-#include <mbed.h>
+#include <memory>
+#include <new>
+#include <stdio.h>
+
+#include "events/EventQueue.h"
+#include "platform/NonCopyable.h"
+
#include "ble/BLE.h"
-#include "pretty_printer.h"
+#include "ble/Gap.h"
+#include "ble/GattClient.h"
+#include "ble/GapAdvertisingParams.h"
+#include "ble/GapAdvertisingData.h"
+#include "ble/GattClient.h"
+#include "ble/DiscoveredService.h"
+#include "ble/DiscoveredCharacteristic.h"
+#include "ble/CharacteristicDescriptorDiscovery.h"
-static events::EventQueue event_queue(/* event count */ 16 * EVENTS_EVENT_SIZE);
+#include "BLEProcess.h"
-/** @deprecated This demo is deprecated and no replacement is currently available.
+/**
+ * Handle discovery of the GATT server.
+ *
+ * First the GATT server is discovered in its entirety then each readable
+ * characteristic is read and the client register to characteristic
+ * notifications or indication when available. The client report server
+ * indications and notification until the connection end.
*/
-MBED_DEPRECATED_SINCE(
- "mbed-os-5.11",
- "This demo is deprecated and no replacement is currently available."
-)
-class BeaconDemo : ble::Gap::EventHandler {
+class GattClientProcess : private mbed::NonCopyable<GattClientProcess>,
+ public ble::Gap::EventHandler {
+
+ // Internal typedef to this class type.
+ // It is used as a shorthand to pass member function as callbacks.
+ typedef GattClientProcess Self;
+
+ typedef CharacteristicDescriptorDiscovery::DiscoveryCallbackParams_t
+ DiscoveryCallbackParams_t;
+
+ typedef CharacteristicDescriptorDiscovery::TerminationCallbackParams_t
+ TerminationCallbackParams_t;
+
+ typedef DiscoveredCharacteristic::Properties_t Properties_t;
+
public:
- BeaconDemo(BLE &ble, events::EventQueue &event_queue) :
- _ble(ble),
- _event_queue(event_queue),
- _adv_data_builder(_adv_buffer) { }
+
+ /**
+ * Construct an empty client process.
+ *
+ * The function start() shall be called to initiate the discovery process.
+ */
+ GattClientProcess() :
+ _client(NULL),
+ _connection_handle(),
+ _characteristics(NULL),
+ _it(NULL),
+ _descriptor_handle(0),
+ _ble_interface(NULL),
+ _event_queue(NULL) {
+ }
+
+ ~GattClientProcess()
+ {
+ stop();
+ }
+
+ void init(BLE &ble_interface, events::EventQueue &event_queue)
+ {
+ _ble_interface = &ble_interface;
+ _event_queue = &event_queue;
+ _client = &_ble_interface->gattClient();
+
+ _ble_interface->gap().setEventHandler(this);
+ }
+
+ /**
+ * Start the discovery process.
+ *
+ * @param[in] client The GattClient instance which will discover the distant
+ * GATT server.
+ * @param[in] connection_handle Reference of the connection to the GATT
+ * server which will be discovered.
+ */
+ void start()
+ {
+ // setup the event handlers called during the process
+ _client->onDataWritten().add(as_cb(&Self::when_descriptor_written));
+ _client->onHVX().add(as_cb(&Self::when_characteristic_changed));
- void start() {
- _ble.gap().setEventHandler(this);
+ // The discovery process will invoke when_service_discovered when a
+ // service is discovered, when_characteristic_discovered when a
+ // characteristic is discovered and when_service_discovery_ends once the
+ // discovery process has ended.
+ _client->onServiceDiscoveryTermination(as_cb(&Self::when_service_discovery_ends));
+ ble_error_t error = _client->launchServiceDiscovery(
+ _connection_handle,
+ as_cb(&Self::when_service_discovered),
+ as_cb(&Self::when_characteristic_discovered)
+ );
+
+ if (error) {
+ printf("Error %u returned by _client->launchServiceDiscovery.\r\n", error);
+ return;
+ }
+
+ printf("Client process started: initiate service discovery.\r\n");
+ }
- _ble.init(this, &BeaconDemo::on_init_complete);
+ /**
+ * Stop the discovery process and clean the instance.
+ */
+ void stop()
+ {
+ if (!_client) {
+ return;
+ }
- _event_queue.dispatch_forever();
+ // unregister event handlers
+ _client->onDataWritten().detach(as_cb(&Self::when_descriptor_written));
+ _client->onHVX().detach(as_cb(&Self::when_characteristic_changed));
+ _client->onServiceDiscoveryTermination(NULL);
+
+ // remove discovered characteristics
+ clear_characteristics();
+
+ // clean up the instance
+ _connection_handle = 0;
+ _characteristics = NULL;
+ _it = NULL;
+ _descriptor_handle = 0;
+
+ printf("Client process stopped.\r\n");
}
private:
/**
- * iBeacon payload builder.
+ * Event handler invoked when a connection is established.
*
- * This data structure contains the payload of an iBeacon. The payload is
- * built at construction time and application code can set up an iBeacon by
- * injecting the raw field into the GAP advertising payload as a
- * GapAdvertisingData::MANUFACTURER_SPECIFIC_DATA.
+ * This function setup the connection handle to operate on then start the
+ * discovery process.
*/
- union Payload {
- /**
- * Raw data of the payload.
- */
- uint8_t raw[25];
- struct {
- /**
- * Beacon manufacturer identifier.
- */
- uint16_t companyID;
-
- /**
- * Packet ID; Equal to 2 for an iBeacon.
- */
- uint8_t ID;
-
- /**
- * Length of the remaining data presents in the payload.
- */
- uint8_t len;
-
- /**
- * Beacon UUID.
- */
- uint8_t proximityUUID[16];
-
- /**
- * Beacon Major group ID.
- */
- uint16_t majorNumber;
-
- /**
- * Beacon minor ID.
- */
- uint16_t minorNumber;
+ virtual void onConnectionComplete(const ble::ConnectionCompleteEvent &event)
+ {
+ _connection_handle = event.getConnectionHandle();
+ _event_queue->call(mbed::callback(this, &Self::start));
+ }
- /**
- * Tx power received at 1 meter; in dBm.
- */
- uint8_t txPower;
- };
-
- /**
- * Assemble an iBeacon payload.
- *
- * @param[in] uuid Beacon network ID. iBeacon operators use this value
- * to group their iBeacons into a single network, a single region and
- * identify their organization among others.
- *
- * @param[in] majNum Beacon major group ID. iBeacon exploitants may use
- * this field to divide the region into subregions, their network into
- * subnetworks.
- *
- * @param[in] minNum Identifier of the Beacon in its subregion.
- *
- * @param[in] transmitPower Measured transmit power of the beacon at 1
- * meter. Scanners use this parameter to approximate the distance
- * to the beacon.
- *
- * @param[in] companyIDIn ID of the beacon manufacturer.
- */
- Payload(
- const uint8_t *uuid,
- uint16_t majNum,
- uint16_t minNum,
- uint8_t transmitPower,
- uint16_t companyIDIn
- ) : companyID(companyIDIn),
- ID(0x02),
- len(0x15),
- majorNumber(__REV16(majNum)),
- minorNumber(__REV16(minNum)),
- txPower(transmitPower)
- {
- memcpy(proximityUUID, uuid, 16);
+ /**
+ * Stop the discovery process and clean the instance.
+ */
+ virtual void onDisconnectionComplete(const ble::DisconnectionCompleteEvent &event)
+ {
+ if (_client && event.getConnectionHandle() == _connection_handle) {
+ stop();
}
- };
-
- /** Callback triggered when the ble initialization process has finished */
- void on_init_complete(BLE::InitializationCompleteCallbackContext *params) {
- if (params->error != BLE_ERROR_NONE) {
- printf("Ble initialization failed.");
- return;
- }
-
- print_mac_address();
-
- start_advertising();
}
- void start_advertising() {
- /* Create advertising parameters and payload */
+private:
+////////////////////////////////////////////////////////////////////////////////
+// Service and characteristic discovery process.
- ble::AdvertisingParameters adv_parameters(
- ble::advertising_type_t::CONNECTABLE_UNDIRECTED,
- ble::adv_interval_t(ble::millisecond_t(1000))
+ /**
+ * Handle services discovered.
+ *
+ * The GattClient invokes this function when a service has been discovered.
+ *
+ * @see GattClient::launchServiceDiscovery
+ */
+ void when_service_discovered(const DiscoveredService *discovered_service)
+ {
+ // print information of the service discovered
+ printf("Service discovered: value = ");
+ print_uuid(discovered_service->getUUID());
+ printf(", start = %u, end = %u.\r\n",
+ discovered_service->getStartHandle(),
+ discovered_service->getEndHandle()
+ );
+ }
+
+ /**
+ * Handle characteristics discovered.
+ *
+ * The GattClient invoke this function when a characteristic has been
+ * discovered.
+ *
+ * @see GattClient::launchServiceDiscovery
+ */
+ void when_characteristic_discovered(const DiscoveredCharacteristic *discovered_characteristic)
+ {
+ // print characteristics properties
+ printf("\tCharacteristic discovered: uuid = ");
+ print_uuid(discovered_characteristic->getUUID());
+ printf(", properties = ");
+ print_properties(discovered_characteristic->getProperties());
+ printf(
+ ", decl handle = %u, value handle = %u, last handle = %u.\r\n",
+ discovered_characteristic->getDeclHandle(),
+ discovered_characteristic->getValueHandle(),
+ discovered_characteristic->getLastHandle()
);
- _adv_data_builder.setFlags();
-
- /**
- * The Beacon payload has the following composition:
- * 128-Bit / 16byte UUID = E2 0A 39 F4 73 F5 4B C4 A1 2F 17 D1 AD 07 A9 61
- * Major/Minor = 0x1122 / 0x3344
- * Tx Power = 0xC8 = 200, 2's compliment is 256-200 = (-56dB)
- *
- * Note: please remember to calibrate your beacons TX Power for more accurate results.
- */
- static const uint8_t uuid[] = { 0xE2, 0x0A, 0x39, 0xF4, 0x73, 0xF5, 0x4B, 0xC4,
- 0xA1, 0x2F, 0x17, 0xD1, 0xAD, 0x07, 0xA9, 0x61 };
- uint16_t major_number = 1122;
- uint16_t minor_number = 3344;
- uint16_t tx_power = 0xC8;
- uint16_t comp_id = 0x004C;
-
- Payload ibeacon(uuid, major_number, minor_number, tx_power, comp_id);
-
- _adv_data_builder.setManufacturerSpecificData(ibeacon.raw);
-
- /* Setup advertising */
-
- ble_error_t error = _ble.gap().setAdvertisingParameters(
- ble::LEGACY_ADVERTISING_HANDLE,
- adv_parameters
- );
-
- if (error) {
- print_error(error, "_ble.gap().setAdvertisingParameters() failed");
- return;
- }
-
- error = _ble.gap().setAdvertisingPayload(
- ble::LEGACY_ADVERTISING_HANDLE,
- _adv_data_builder.getAdvertisingData()
- );
-
- if (error) {
- print_error(error, "_ble.gap().setAdvertisingPayload() failed");
- return;
- }
-
- /* Start advertising */
-
- error = _ble.gap().startAdvertising(ble::LEGACY_ADVERTISING_HANDLE);
-
- if (error) {
- print_error(error, "_ble.gap().startAdvertising() failed");
+ // add the characteristic into the list of discovered characteristics
+ bool success = add_characteristic(discovered_characteristic);
+ if (!success) {
+ printf("Error: memory allocation failure while adding the discovered characteristic.\r\n");
+ _client->terminateServiceDiscovery();
+ stop();
return;
}
}
-private:
- /* Event handler */
+ /**
+ * Handle termination of the service and characteristic discovery process.
+ *
+ * The GattClient invokes this function when the service and characteristic
+ * discovery process ends.
+ *
+ * @see GattClient::onServiceDiscoveryTermination
+ */
+ void when_service_discovery_ends(Gap::Handle_t connection_handle)
+ {
+ if (!_characteristics) {
+ printf("No characteristics discovered, end of the process.\r\n");
+ return;
+ }
+
+ printf("All services and characteristics discovered, process them.\r\n");
+
+ // reset iterator and start processing characteristics in order
+ _it = NULL;
+ _event_queue->call(mbed::callback(this, &Self::process_next_characteristic));
+ }
+
+////////////////////////////////////////////////////////////////////////////////
+// Processing of characteristics based on their properties.
+
+ /**
+ * Process the characteristics discovered.
+ *
+ * - If the characteristic is readable then read its value and print it. Then
+ * - If the characteristic can emit notification or indication then discover
+ * the characteristic CCCD and subscribe to the server initiated event.
+ * - Otherwise skip the characteristic processing.
+ */
+ void process_next_characteristic(void)
+ {
+ if (!_it) {
+ _it = _characteristics;
+ } else {
+ _it = _it->next;
+ }
+
+ while (_it) {
+ Properties_t properties = _it->value.getProperties();
+
+ if (properties.read()) {
+ read_characteristic(_it->value);
+ return;
+ } else if(properties.notify() || properties.indicate()) {
+ discover_descriptors(_it->value);
+ return;
+ } else {
+ printf(
+ "Skip processing of characteristic %u\r\n",
+ _it->value.getValueHandle()
+ );
+ _it = _it->next;
+ }
+ }
+
+ printf("All characteristics discovered have been processed.\r\n");
+ }
+
+ /**
+ * Initate the read of the characteristic in input.
+ *
+ * The completion of the operation will happens in when_characteristic_read()
+ */
+ void read_characteristic(const DiscoveredCharacteristic &characteristic)
+ {
+ printf("Initiating read at %u.\r\n", characteristic.getValueHandle());
+ ble_error_t error = characteristic.read(
+ 0, as_cb(&Self::when_characteristic_read)
+ );
- void onDisconnectionComplete(const ble::DisconnectionCompleteEvent&) {
- _ble.gap().startAdvertising(ble::LEGACY_ADVERTISING_HANDLE);
+ if (error) {
+ printf(
+ "Error: cannot initiate read at %u due to %u\r\n",
+ characteristic.getValueHandle(), error
+ );
+ stop();
+ }
+ }
+
+ /**
+ * Handle the reception of a read response.
+ *
+ * If the characteristic can emit notification or indication then start the
+ * discovery of the the characteristic descriptors then subscribe to the
+ * server initiated event by writing the CCCD discovered. Otherwise start
+ * the processing of the next characteristic discovered in the server.
+ */
+ void when_characteristic_read(const GattReadCallbackParams *read_event)
+ {
+ printf("\tCharacteristic value at %u equal to: ", read_event->handle);
+ for (size_t i = 0; i < read_event->len; ++i) {
+ printf("0x%02X ", read_event->data[i]);
+ }
+ printf(".\r\n");
+
+ Properties_t properties = _it->value.getProperties();
+
+ if(properties.notify() || properties.indicate()) {
+ discover_descriptors(_it->value);
+ } else {
+ process_next_characteristic();
+ }
+ }
+
+ /**
+ * Initiate the discovery of the descriptors of the characteristic in input.
+ *
+ * When a descriptor is discovered, the function when_descriptor_discovered
+ * is invoked.
+ */
+ void discover_descriptors(const DiscoveredCharacteristic &characteristic)
+ {
+ printf("Initiating descriptor discovery of %u.\r\n", characteristic.getValueHandle());
+
+ _descriptor_handle = 0;
+ ble_error_t error = characteristic.discoverDescriptors(
+ as_cb(&Self::when_descriptor_discovered),
+ as_cb(&Self::when_descriptor_discovery_ends)
+ );
+
+ if (error) {
+ printf(
+ "Error: cannot initiate discovery of %04X due to %u.\r\n",
+ characteristic.getValueHandle(), error
+ );
+ stop();
+ }
+ }
+
+ /**
+ * Handle the discovery of the characteristic descriptors.
+ *
+ * If the descriptor found is a CCCD then stop the discovery. Once the
+ * process has ended subscribe to server initiated events by writing the
+ * value of the CCCD.
+ */
+ void when_descriptor_discovered(const DiscoveryCallbackParams_t* event)
+ {
+ printf("\tDescriptor discovered at %u, UUID: ", event->descriptor.getAttributeHandle());
+ print_uuid(event->descriptor.getUUID());
+ printf(".\r\n");
+
+ if (event->descriptor.getUUID() == BLE_UUID_DESCRIPTOR_CLIENT_CHAR_CONFIG) {
+ _descriptor_handle = event->descriptor.getAttributeHandle();
+ _client->terminateCharacteristicDescriptorDiscovery(
+ event->characteristic
+ );
+ }
}
-private:
- BLE &_ble;
- events::EventQueue &_event_queue;
+ /**
+ * If a CCCD has been found subscribe to server initiated events by writing
+ * its value.
+ */
+ void when_descriptor_discovery_ends(const TerminationCallbackParams_t *event) {
+ // shall never happen but happen with android devices ...
+ // process the next charateristic
+ if (!_descriptor_handle) {
+ printf("\tWarning: characteristic with notify or indicate attribute without CCCD.\r\n");
+ process_next_characteristic();
+ return;
+ }
+
+ Properties_t properties = _it->value.getProperties();
+
+ uint16_t cccd_value =
+ (properties.notify() << 0) | (properties.indicate() << 1);
+
+ ble_error_t error = _client->write(
+ GattClient::GATT_OP_WRITE_REQ,
+ _connection_handle,
+ _descriptor_handle,
+ sizeof(cccd_value),
+ reinterpret_cast<uint8_t*>(&cccd_value)
+ );
+
+ if (error) {
+ printf(
+ "Error: cannot initiate write of CCCD %u due to %u.\r\n",
+ _descriptor_handle, error
+ );
+ stop();
+ }
+ }
+
+ /**
+ * Called when the CCCD has been written.
+ */
+ void when_descriptor_written(const GattWriteCallbackParams* event)
+ {
+ // should never happen
+ if (!_descriptor_handle) {
+ printf("\tError: received write response to unsolicited request.\r\n");
+ stop();
+ return;
+ }
+
+ printf("\tCCCD at %u written.\r\n", _descriptor_handle);
+ _descriptor_handle = 0;
+ process_next_characteristic();
+ }
+
+ /**
+ * Print the updated value of the characteristic.
+ *
+ * This function is called when the server emits a notification or an
+ * indication of a characteristic value the client has subscribed to.
+ *
+ * @see GattClient::onHVX()
+ */
+ void when_characteristic_changed(const GattHVXCallbackParams* event)
+ {
+ printf("Change on attribute %u: new value = ", event->handle);
+ for (size_t i = 0; i < event->len; ++i) {
+ printf("0x%02X ", event->data[i]);
+ }
+ printf(".\r\n");
+ }
+
+ struct DiscoveredCharacteristicNode {
+ DiscoveredCharacteristicNode(const DiscoveredCharacteristic &c) :
+ value(c), next(NULL) { }
+
+ DiscoveredCharacteristic value;
+ DiscoveredCharacteristicNode *next;
+ };
+
+ /**
+ * Add a discovered characteristic into the list of discovered characteristics.
+ */
+ bool add_characteristic(const DiscoveredCharacteristic *characteristic)
+ {
+ DiscoveredCharacteristicNode* new_node =
+ new(std::nothrow) DiscoveredCharacteristicNode(*characteristic);
- uint8_t _adv_buffer[ble::LEGACY_ADVERTISING_MAX_SIZE];
- ble::AdvertisingDataBuilder _adv_data_builder;
+ if (new_node == NULL) {
+ printf("Error while allocating a new characteristic.\r\n");
+ return false;
+ }
+
+ if (_characteristics == NULL) {
+ _characteristics = new_node;
+ } else {
+ DiscoveredCharacteristicNode* c = _characteristics;
+ while(c->next) {
+ c = c->next;
+ }
+ c->next = new_node;
+ }
+
+ return true;
+ }
+
+ /**
+ * Clear the list of discovered characteristics.
+ */
+ void clear_characteristics(void)
+ {
+ DiscoveredCharacteristicNode *c= _characteristics;
+
+ while (c) {
+ DiscoveredCharacteristicNode *n = c->next;
+ delete c;
+ c = n;
+ }
+ }
+
+ /**
+ * Helper to construct an event handler from a member function of this
+ * instance.
+ */
+ template<typename ContextType>
+ FunctionPointerWithContext<ContextType> as_cb(
+ void (Self::*member)(ContextType context)
+ ) {
+ return makeFunctionPointer(this, member);
+ }
+
+ /**
+ * Print the value of a UUID.
+ */
+ static void print_uuid(const UUID &uuid)
+ {
+ const uint8_t *uuid_value = uuid.getBaseUUID();
+
+ // UUIDs are in little endian, print them in big endian
+ for (size_t i = 0; i < uuid.getLen(); ++i) {
+ printf("%02X", uuid_value[(uuid.getLen() - 1) - i]);
+ }
+ }
+
+ /**
+ * Print the value of a characteristic properties.
+ */
+ static void print_properties(const Properties_t &properties)
+ {
+ const struct {
+ bool (Properties_t::*fn)() const;
+ const char* str;
+ } prop_to_str[] = {
+ { &Properties_t::broadcast, "broadcast" },
+ { &Properties_t::read, "read" },
+ { &Properties_t::writeWoResp, "writeWoResp" },
+ { &Properties_t::write, "write" },
+ { &Properties_t::notify, "notify" },
+ { &Properties_t::indicate, "indicate" },
+ { &Properties_t::authSignedWrite, "authSignedWrite" }
+ };
+
+ printf("[");
+ for (size_t i = 0; i < (sizeof(prop_to_str) / sizeof(prop_to_str[0])); ++i) {
+ if ((properties.*(prop_to_str[i].fn))()) {
+ printf(" %s", prop_to_str[i].str);
+ }
+ }
+ printf(" ]");
+ }
+
+ GattClient *_client;
+ Gap::Handle_t _connection_handle;
+ DiscoveredCharacteristicNode *_characteristics;
+ DiscoveredCharacteristicNode *_it;
+ GattAttribute::Handle_t _descriptor_handle;
+ BLE *_ble_interface;
+ events::EventQueue *_event_queue;
};
-/** Schedule processing of events from the BLE middleware in the event queue. */
-void schedule_ble_events(BLE::OnEventsToProcessCallbackContext *context) {
- event_queue.call(Callback<void()>(&context->ble, &BLE::processEvents));
-}
+
+int main() {
+
+ BLE &ble_interface = BLE::Instance();
+ events::EventQueue event_queue;
+ BLEProcess ble_process(event_queue, ble_interface);
+ GattClientProcess gatt_client_process;
-int main()
-{
- BLE &ble = BLE::Instance();
- ble.onEventsToProcess(schedule_ble_events);
+ // Register GattClientProcess::init in the ble_process; this function will
+ // be called once the ble_interface is initialized.
+ ble_process.on_init(
+ mbed::callback(&gatt_client_process, &GattClientProcess::init)
+ );
- BeaconDemo demo(ble, event_queue);
- demo.start();
+ // bind the event queue to the ble interface, initialize the interface
+ // and start advertising
+ ble_process.start();
+
+ // Process the event queue.
+ event_queue.dispatch_forever();
return 0;
-}
+}
\ No newline at end of file