Diff: source/main.cpp

Revision:

75:1a8d19363522

Parent:

45:9fe6d1e21b8a

Child:

77:85a0d3cdd896

--- a/source/main.cpp	Fri Dec 14 13:15:46 2018 +0000
+++ b/source/main.cpp	Mon Jan 14 10:45:54 2019 +0000
@@ -19,50 +19,18 @@
 #include "ble/BLE.h"
 #include "ble/DiscoveredCharacteristic.h"
 #include "ble/DiscoveredService.h"
-
-DigitalOut alivenessLED(LED1, 1);
-static DiscoveredCharacteristic ledCharacteristic;
-static bool triggerLedCharacteristic;
-static const char PEER_NAME[] = "LED";
-
-static EventQueue eventQueue(/* event count */ 16 * EVENTS_EVENT_SIZE);
+#include "ble/gap/Gap.h"
+#include "ble/gap/AdvertisingDataParser.h"
+#include "pretty_printer.h"
 
-void periodicCallback(void) {
-    alivenessLED = !alivenessLED; /* Do blinky on LED1 while we're waiting for BLE events */
-}
-
-void advertisementCallback(const Gap::AdvertisementCallbackParams_t *params) {
-    // parse the advertising payload, looking for data type COMPLETE_LOCAL_NAME
-    // The advertising payload is a collection of key/value records where
-    // byte 0: length of the record excluding this byte
-    // byte 1: The key, it is the type of the data
-    // byte [2..N] The value. N is equal to byte0 - 1
-    for (uint8_t i = 0; i < params->advertisingDataLen; ++i) {
+const static char PEER_NAME[] = "LED";
 
-        const uint8_t record_length = params->advertisingData[i];
-        if (record_length == 0) {
-            continue;
-        }
-        const uint8_t type = params->advertisingData[i + 1];
-        const uint8_t* value = params->advertisingData + i + 2;
-        const uint8_t value_length = record_length - 1;
+static EventQueue event_queue(/* event count */ 10 * EVENTS_EVENT_SIZE);
 
-        if(type == GapAdvertisingData::COMPLETE_LOCAL_NAME) {
-            if ((value_length == sizeof(PEER_NAME)) && (memcmp(value, PEER_NAME, value_length) == 0)) {
-                printf(
-                    "adv peerAddr[%02x %02x %02x %02x %02x %02x] rssi %d, isScanResponse %u, AdvertisementType %u\r\n",
-                    params->peerAddr[5], params->peerAddr[4], params->peerAddr[3], params->peerAddr[2],
-                    params->peerAddr[1], params->peerAddr[0], params->rssi, params->isScanResponse, params->type
-                );
-                BLE::Instance().gap().connect(params->peerAddr, Gap::ADDR_TYPE_RANDOM_STATIC, NULL, NULL);
-                break;
-            }
-        }
-        i += record_length;
-    }
-}
+static DiscoveredCharacteristic led_characteristic;
+static bool trigger_led_characteristic = false;
 
-void serviceDiscoveryCallback(const DiscoveredService *service) {
+void service_discovery(const DiscoveredService *service) {
     if (service->getUUID().shortOrLong() == UUID::UUID_TYPE_SHORT) {
         printf("S UUID-%x attrs[%u %u]\r\n", service->getUUID().getShortUUID(), service->getStartHandle(), service->getEndHandle());
     } else {
@@ -75,125 +43,186 @@
     }
 }
 
-void updateLedCharacteristic(void) {
+void update_led_characteristic(void) {
     if (!BLE::Instance().gattClient().isServiceDiscoveryActive()) {
-        ledCharacteristic.read();
-    }
-}
-
-void characteristicDiscoveryCallback(const DiscoveredCharacteristic *characteristicP) {
-    printf("  C UUID-%x valueAttr[%u] props[%x]\r\n", characteristicP->getUUID().getShortUUID(), characteristicP->getValueHandle(), (uint8_t)characteristicP->getProperties().broadcast());
-    if (characteristicP->getUUID().getShortUUID() == 0xa001) { /* !ALERT! Alter this filter to suit your device. */
-        ledCharacteristic        = *characteristicP;
-        triggerLedCharacteristic = true;
+        led_characteristic.read();
     }
 }
 
-void discoveryTerminationCallback(Gap::Handle_t connectionHandle) {
-    printf("terminated SD for handle %u\r\n", connectionHandle);
-    if (triggerLedCharacteristic) {
-        triggerLedCharacteristic = false;
-        eventQueue.call(updateLedCharacteristic);
+void characteristic_discovery(const DiscoveredCharacteristic *characteristicP) {
+    printf("  C UUID-%x valueAttr[%u] props[%x]\r\n", characteristicP->getUUID().getShortUUID(), characteristicP->getValueHandle(), (uint8_t)characteristicP->getProperties().broadcast());
+    if (characteristicP->getUUID().getShortUUID() == 0xa001) { /* !ALERT! Alter this filter to suit your device. */
+        led_characteristic        = *characteristicP;
+        trigger_led_characteristic = true;
     }
 }
 
-void connectionCallback(const Gap::ConnectionCallbackParams_t *params) {
-    if (params->role == Gap::CENTRAL) {
-        BLE &ble = BLE::Instance();
-        ble.gattClient().onServiceDiscoveryTermination(discoveryTerminationCallback);
-        ble.gattClient().launchServiceDiscovery(params->handle, serviceDiscoveryCallback, characteristicDiscoveryCallback, 0xa000, 0xa001);
+void discovery_termination(Gap::Handle_t connectionHandle) {
+    printf("terminated SD for handle %u\r\n", connectionHandle);
+    if (trigger_led_characteristic) {
+        trigger_led_characteristic = false;
+        event_queue.call(update_led_characteristic);
     }
 }
 
-void triggerToggledWrite(const GattReadCallbackParams *response) {
-    if (response->handle == ledCharacteristic.getValueHandle()) {
-        printf("triggerToggledWrite: handle %u, offset %u, len %u\r\n", response->handle, response->offset, response->len);
+void trigger_toggled_write(const GattReadCallbackParams *response) {
+    if (response->handle == led_characteristic.getValueHandle()) {
+        printf("trigger_toggled_write: handle %u, offset %u, len %u\r\n", response->handle, response->offset, response->len);
         for (unsigned index = 0; index < response->len; index++) {
             printf("%c[%02x]", response->data[index], response->data[index]);
         }
         printf("\r\n");
 
         uint8_t toggledValue = response->data[0] ^ 0x1;
-        ledCharacteristic.write(1, &toggledValue);
+        led_characteristic.write(1, &toggledValue);
     }
 }
 
-void triggerRead(const GattWriteCallbackParams *response) {
-    if (response->handle == ledCharacteristic.getValueHandle()) {
-        ledCharacteristic.read();
+void trigger_read(const GattWriteCallbackParams *response) {
+    if (response->handle == led_characteristic.getValueHandle()) {
+        led_characteristic.read();
     }
 }
 
-void disconnectionCallback(const Gap::DisconnectionCallbackParams_t *) {
-    printf("disconnected\r\n");
-    /* Start scanning and try to connect again */
-    BLE::Instance().gap().startScan(advertisementCallback);
-}
+class LEDBlinkerDemo : ble::Gap::EventHandler {
+public:
+    LEDBlinkerDemo(BLE &ble, events::EventQueue &event_queue) :
+        _ble(ble),
+        _event_queue(event_queue),
+        _alive_led(LED1, 1),
+        _actuated_led(LED2, 0),
+        _is_connecting(false) { }
 
-void onBleInitError(BLE &ble, ble_error_t error)
-{
-   /* Initialization error handling should go here */
-}
+    ~LEDBlinkerDemo() { }
+
+    void start() {
+        _ble.gap().setEventHandler(this);
+
+        _ble.init(this, &LEDBlinkerDemo::on_init_complete);
+
+        _event_queue.call_every(500, this, &LEDBlinkerDemo::blink);
+
+        _event_queue.dispatch_forever();
+    }
 
-void printMacAddress()
-{
-    /* Print out device MAC address to the console*/
-    Gap::AddressType_t addr_type;
-    Gap::Address_t address;
-    BLE::Instance().gap().getAddress(&addr_type, address);
-    printf("DEVICE MAC ADDRESS: ");
-    for (int i = 5; i >= 1; i--){
-        printf("%02x:", address[i]);
+private:
+    /** 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();
+
+        _ble.gattClient().onDataRead(trigger_toggled_write);
+        _ble.gattClient().onDataWritten(trigger_read);
+
+        ble::ScanParameters scan_params;
+        _ble.gap().setScanParameters(scan_params);
+        _ble.gap().startScan();
     }
-    printf("%02x\r\n", address[0]);
-}
+
+    void blink() {
+        _alive_led = !_alive_led;
+    }
 
-void bleInitComplete(BLE::InitializationCompleteCallbackContext *params)
-{
-    BLE&        ble   = params->ble;
-    ble_error_t error = params->error;
+private:
+    /* Event handler */
 
-    if (error != BLE_ERROR_NONE) {
-        /* In case of error, forward the error handling to onBleInitError */
-        onBleInitError(ble, error);
-        return;
+    void onDisconnectionComplete(const ble::DisconnectionCompleteEvent&) {
+        _ble.gap().startScan();
+        _is_connecting = false;
     }
 
-    /* Ensure that it is the default instance of BLE */
-    if (ble.getInstanceID() != BLE::DEFAULT_INSTANCE) {
-        return;
+    void onConnectionComplete(const ble::ConnectionCompleteEvent& event) {
+        if (event.getOwnRole() == Gap::CENTRAL) {
+            _ble.gattClient().onServiceDiscoveryTermination(discovery_termination);
+            _ble.gattClient().launchServiceDiscovery(
+                event.getConnectionHandle(),
+                service_discovery,
+                characteristic_discovery,
+                0xa000,
+                0xa001
+            );
+        } else {
+            _ble.gap().startScan();
+        }
+        _is_connecting = false;
     }
 
-    ble.gap().onDisconnection(disconnectionCallback);
-    ble.gap().onConnection(connectionCallback);
+    void onAdvertisingReport(const ble::AdvertisingReportEvent &event) {
+        /* don't bother with analysing scan result if we're already connecting */
+        if (_is_connecting) {
+            return;
+        }
+
+        ble::AdvertisingDataParser adv_data(event.getPayload());
+
+        /* parse the advertising payload, looking for a discoverable device */
+        while (adv_data.hasNext()) {
+            ble::AdvertisingDataParser::element_t field = adv_data.next();
 
-    ble.gattClient().onDataRead(triggerToggledWrite);
-    ble.gattClient().onDataWrite(triggerRead);
+            /* connect to a discoverable device */
+            if (field.type == ble::adv_data_type_t::COMPLETE_LOCAL_NAME &&
+                field.value.size() == strlen(PEER_NAME) &&
+                (memcmp(field.value.data(), PEER_NAME, field.value.size()) == 0)) {
+
+                printf("Adv from: ");
+                print_address(event.getPeerAddress().data());
+                printf(" rssi: %d, scan response: %u, connectable: %u\r\n",
+                       event.getRssi(), event.getType().scan_response(), event.getType().connectable());
+
+                ble_error_t error = _ble.gap().stopScan();
+
+                if (error) {
+                    print_error(error, "Error caused by Gap::stopScan");
+                    return;
+                }
+
+                const ble::ConnectionParameters connection_params;
 
-    // scan interval: 400ms and scan window: 400ms.
-    // Every 400ms the device will scan for 400ms
-    // This means that the device will scan continuously.
-    ble.gap().setScanParams(400, 400);
-    ble.gap().startScan(advertisementCallback);
+                error = _ble.gap().connect(
+                    event.getPeerAddressType(),
+                    event.getPeerAddress(),
+                    connection_params
+                );
+
+                if (error) {
+                    _ble.gap().startScan();
+                    return;
+                }
+
+                /* we may have already scan events waiting
+                 * to be processed so we need to remember
+                 * that we are already connecting and ignore them */
+                _is_connecting = true;
 
-    printMacAddress();
-}
+                return;
+            }
+        }
+    }
 
-void scheduleBleEventsProcessing(BLE::OnEventsToProcessCallbackContext* context) {
-    BLE &ble = BLE::Instance();
-    eventQueue.call(Callback<void()>(&ble, &BLE::processEvents));
+private:
+    BLE &_ble;
+    events::EventQueue &_event_queue;
+    DigitalOut _alive_led;
+    DigitalOut _actuated_led;
+    bool _is_connecting;
+};
+
+/** 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()
 {
-    triggerLedCharacteristic = false;
-    eventQueue.call_every(500, periodicCallback);
+    BLE &ble = BLE::Instance();
+    ble.onEventsToProcess(schedule_ble_events);
 
-    BLE &ble = BLE::Instance();
-    ble.onEventsToProcess(scheduleBleEventsProcessing);
-    ble.init(bleInitComplete);
-
-    eventQueue.dispatch_forever();
+    LEDBlinkerDemo demo(ble, event_queue);
+    demo.start();
 
     return 0;
 }