Diff: source/BleManager.cpp

Revision:

75:08eff6258e1b

Parent:

74:f26e846adfe9

Child:

76:6afda865fbf8

--- a/source/BleManager.cpp	Sun Mar 10 09:46:06 2019 +0000
+++ b/source/BleManager.cpp	Thu Mar 14 21:34:06 2019 +0000
@@ -13,11 +13,515 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#ifdef BLE_SECURITY_ENABLED
+
 #include <events/mbed_events.h>
 #include <mbed.h>
 #include "ble/BLE.h"
 #include "SecurityManager.h"
+#include "BleManager.h"
+#if MBED_CONF_APP_FILESYSTEM_SUPPORT
+#include "LittleFileSystem.h"
+#include "HeapBlockDevice.h"
+#endif //MBED_CONF_APP_FILESYSTEM_SUPPORT
+
+
+static const uint8_t DEVICE_NAME[] = "SM_device";
+
+/** This example demonstrates all the basic setup required
+ *  for pairing and setting up link security both as a central and peripheral
+ *
+ *  The example is implemented as two classes, one for the peripheral and one
+ *  for central inheriting from a common base. They are run in sequence and
+ *  require a peer device to connect to. During the peripheral device demonstration
+ *  a peer device is required to connect. In the central device demonstration
+ *  this peer device will be scanned for and connected to - therefore it should
+ *  be advertising with the same address as when it connected.
+ *
+ *  During the test output is written on the serial connection to monitor its
+ *  progress.
+ */
+
+//static const uint8_t DEVICE_NAME[] = "SM_device";
+
+/* for demonstration purposes we will store the peer device address
+ * of the device that connects to us in the first demonstration
+ * so we can use its address to reconnect to it later */
+//static BLEProtocol::AddressBytes_t peer_address;
+
+/** Base class for both peripheral and central. The same class that provides
+ *  the logic for the application also implements the SecurityManagerEventHandler
+ *  which is the interface used by the Security Manager to communicate events
+ *  back to the applications. You can provide overrides for a selection of events
+ *  your application is interested in.
+ */
+SMDevice::SMDevice(BLE &ble, events::EventQueue &event_queue, BLEProtocol::AddressBytes_t &peer_address) :
+        _led1(LED1, 0),
+        _ble(ble),
+        _event_queue(event_queue),
+        _peer_address(peer_address),
+        _handle(0),
+        _is_connecting(false) { }
+
+SMDevice::~SMDevice()
+{
+    if (_ble.hasInitialized()) {
+        _ble.shutdown();
+    }
+}
+
+/** Start BLE interface initialisation */
+void SMDevice::run()
+{
+    ble_error_t error;
+
+    /* to show we're running we'll blink every 500ms */
+    _event_queue.call_every(500, this, &SMDevice::blink);
+
+    if (_ble.hasInitialized()) {
+        printf("Ble instance already initialised.\r\n");
+        return;
+    }
+
+    /* this will inform us off all events so we can schedule their handling
+     * using our event queue */
+    _ble.onEventsToProcess(
+        makeFunctionPointer(this, &SMDevice::schedule_ble_events)
+    );
+
+    /* handle timeouts, for example when connection attempts fail */
+    _ble.gap().onTimeout(
+        makeFunctionPointer(this, &SMDevice::on_timeout)
+    );
+
+    error = _ble.init(this, &SMDevice::on_init_complete);
+
+    if (error) {
+        printf("Error returned by BLE::init.\r\n");
+        return;
+    }
+
+    /* this will not return until shutdown */
+    _event_queue.dispatch_forever();
+}
+
+/* event handler functions */
+
+/** Respond to a pairing request. This will be called by the stack
+ * when a pairing request arrives and expects the application to
+ * call acceptPairingRequest or cancelPairingRequest */
+void SMDevice::pairingRequest(
+    ble::connection_handle_t connectionHandle
+) {
+    printf("Pairing requested - authorising\r\n");
+    _ble.securityManager().acceptPairingRequest(connectionHandle);
+}
+
+/** Inform the application of a successful pairing. Terminate the demonstration. */
+void SMDevice::pairingResult(
+    ble::connection_handle_t connectionHandle,
+    SecurityManager::SecurityCompletionStatus_t result
+) {
+    if (result == SecurityManager::SEC_STATUS_SUCCESS) {
+        printf("Pairing successful\r\n");
+    } else {
+        printf("Pairing failed\r\n");
+    }
+}
+
+/** Inform the application of change in encryption status. This will be
+ * communicated through the serial port */
+void SMDevice::linkEncryptionResult(
+    ble::connection_handle_t connectionHandle,
+    ble::link_encryption_t result
+) {
+    if (result == ble::link_encryption_t::ENCRYPTED) {
+        printf("Link ENCRYPTED\r\n");
+    } else if (result == ble::link_encryption_t::ENCRYPTED_WITH_MITM) {
+        printf("Link ENCRYPTED_WITH_MITM\r\n");
+    } else if (result == ble::link_encryption_t::NOT_ENCRYPTED) {
+        printf("Link NOT_ENCRYPTED\r\n");
+    }
+
+    /* disconnect in 2 s */
+    _event_queue.call_in(
+        2000, &_ble.gap(),
+        &Gap::disconnect, _handle, Gap::REMOTE_USER_TERMINATED_CONNECTION
+    );
+}
+
+/** Override to start chosen activity when initialisation completes */
+//void SMDevice::start() = 0;
+
+/** This is called when BLE interface is initialised and starts the demonstration */
+void SMDevice::on_init_complete(BLE::InitializationCompleteCallbackContext *event)
+{
+    ble_error_t error;
+
+    if (event->error) {
+        printf("Error during the initialisation\r\n");
+        return;
+    }
+
+    /* This path will be used to store bonding information but will fallback
+     * to storing in memory if file access fails (for example due to lack of a filesystem) */
+    const char* db_path = "/fs/bt_sec_db";
+    /* If the security manager is required this needs to be called before any
+     * calls to the Security manager happen. */
+    error = _ble.securityManager().init(
+        true,
+        false,
+        SecurityManager::IO_CAPS_NONE,
+        NULL,
+        false,
+        db_path
+    );
+
+    if (error) {
+        printf("Error during init %d\r\n", error);
+        return;
+    }
+
+    error = _ble.securityManager().preserveBondingStateOnReset(true);
+
+    if (error) {
+        printf("Error during preserveBondingStateOnReset %d\r\n", error);
+    }
+
+#if MBED_CONF_APP_FILESYSTEM_SUPPORT
+    /* Enable privacy so we can find the keys */
+    error = _ble.gap().enablePrivacy(true);
+
+    if (error) {
+        printf("Error enabling privacy\r\n");
+    }
+
+    Gap::PeripheralPrivacyConfiguration_t configuration_p = {
+        /* use_non_resolvable_random_address */ false,
+        Gap::PeripheralPrivacyConfiguration_t::REJECT_NON_RESOLVED_ADDRESS
+    };
+    _ble.gap().setPeripheralPrivacyConfiguration(&configuration_p);
+
+    Gap::CentralPrivacyConfiguration_t configuration_c = {
+        /* use_non_resolvable_random_address */ false,
+        Gap::CentralPrivacyConfiguration_t::RESOLVE_AND_FORWARD
+    };
+    _ble.gap().setCentralPrivacyConfiguration(&configuration_c);
+
+    /* this demo switches between being master and slave */
+    _ble.securityManager().setHintFutureRoleReversal(true);
+#endif
+
+    /* Tell the security manager to use methods in this class to inform us
+     * of any events. Class needs to implement SecurityManagerEventHandler. */
+    _ble.securityManager().setSecurityManagerEventHandler(this);
+
+    /* print device address */
+    Gap::AddressType_t addr_type;
+    Gap::Address_t addr;
+    _ble.gap().getAddress(&addr_type, addr);
+    printf("Device address: %02x:%02x:%02x:%02x:%02x:%02x\r\n",
+           addr[5], addr[4], addr[3], addr[2], addr[1], addr[0]);
+
+    /* when scanning we want to connect to a peer device so we need to
+     * attach callbacks that are used by Gap to notify us of events */
+    _ble.gap().onConnection(this, &SMDevice::on_connect);
+    _ble.gap().onDisconnection(this, &SMDevice::on_disconnect);
+
+    /* start test in 500 ms */
+    _event_queue.call_in(500, this, &SMDevice::start);
+}
+
+/** This is called by Gap to notify the application we connected */
+//void SMDevice::on_connect(const Gap::ConnectionCallbackParams_t *connection_event);
+
+/** This is called by Gap to notify the application we disconnected,
+ *  in our case it ends the demonstration. */
+void SMDevice::on_disconnect(const Gap::DisconnectionCallbackParams_t *event)
+{
+    printf("Disconnected\r\n");
+    _event_queue.break_dispatch();
+}
+
+/** End demonstration unexpectedly. Called if timeout is reached during advertising,
+ * scanning or connection initiation */
+void SMDevice::on_timeout(const Gap::TimeoutSource_t source)
+{
+    printf("Unexpected timeout - aborting\r\n");
+    _event_queue.break_dispatch();
+}
+
+/** Schedule processing of events from the BLE in the event queue. */
+void SMDevice::schedule_ble_events(BLE::OnEventsToProcessCallbackContext *context)
+{
+    _event_queue.call(mbed::callback(&context->ble, &BLE::processEvents));
+};
+
+/** Blink LED to show we're running */
+void SMDevice::blink(void)
+{
+    _led1 = !_led1;
+}
+
+
+/** A peripheral device will advertise, accept the connection and request
+ * a change in link security. */
+SMDevicePeripheral::SMDevicePeripheral(BLE &ble, events::EventQueue &event_queue, BLEProtocol::AddressBytes_t &peer_address)
+        : SMDevice(ble, event_queue, peer_address) { }
+
+void SMDevicePeripheral::start()
+{
+    /* Set up and start advertising */
+
+    ble_error_t error;
+    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)
+    );
+
+    error = _ble.gap().setAdvertisingPayload(advertising_data);
+
+    if (error) {
+        printf("Error during Gap::setAdvertisingPayload\r\n");
+        return;
+    }
+
+    /* advertise to everyone */
+    _ble.gap().setAdvertisingType(GapAdvertisingParams::ADV_CONNECTABLE_UNDIRECTED);
+    /* how many milliseconds between advertisements, lower interval
+     * increases the chances of being seen at the cost of more power */
+    _ble.gap().setAdvertisingInterval(20);
+    _ble.gap().setAdvertisingTimeout(0);
+
+    error = _ble.gap().startAdvertising();
+
+    if (error) {
+        printf("Error during Gap::startAdvertising.\r\n");
+        return;
+    }
+
+    printf("Please connect to device\r\n");
+
+    /** This tells the stack to generate a pairingRequest event
+     * which will require this application to respond before pairing
+     * can proceed. Setting it to false will automatically accept
+     * pairing. */
+    _ble.securityManager().setPairingRequestAuthorisation(true);
+}
+
+/** This is called by Gap to notify the application we connected,
+ *  in our case it immediately requests a change in link security */
+void SMDevicePeripheral::on_connect(const Gap::ConnectionCallbackParams_t *connection_event)
+{
+    ble_error_t error;
+
+    /* remember the device that connects to us now so we can connect to it
+     * during the next demonstration */
+    memcpy(_peer_address, connection_event->peerAddr, sizeof(_peer_address));
+
+    printf("Connected to: %02x:%02x:%02x:%02x:%02x:%02x\r\n",
+            _peer_address[5], _peer_address[4], _peer_address[3],
+            _peer_address[2], _peer_address[1], _peer_address[0]);
+
+    /* store the handle for future Security Manager requests */
+    _handle = connection_event->handle;
+
+    /* Request a change in link security. This will be done
+     * indirectly by asking the master of the connection to
+     * change it. Depending on circumstances different actions
+     * may be taken by the master which will trigger events
+     * which the applications should deal with. */
+    error = _ble.securityManager().setLinkSecurity(
+        _handle,
+        SecurityManager::SECURITY_MODE_ENCRYPTION_NO_MITM
+    );
+
+    if (error) {
+        printf("Error during SM::setLinkSecurity %d\r\n", error);
+        return;
+    }
+}
+
+/** A central device will scan, connect to a peer and request pairing. */
+
+SMDeviceCentral::SMDeviceCentral(BLE &ble, events::EventQueue &event_queue, BLEProtocol::AddressBytes_t &peer_address)
+    : SMDevice(ble, event_queue, peer_address) { };
+
+void SMDeviceCentral::start()
+{
+    /* start scanning and attach a callback that will handle advertisements
+     * and scan requests responses */
+    ble_error_t error = _ble.gap().startScan(this, &SMDeviceCentral::on_scan);
+
+    printf("Please advertise\r\n");
+
+    printf("Scanning for: %02x:%02x:%02x:%02x:%02x:%02x\r\n",
+           _peer_address[5], _peer_address[4], _peer_address[3],
+           _peer_address[2], _peer_address[1], _peer_address[0]);
+
+    if (error) {
+        printf("Error during Gap::startScan %d\r\n", error);
+        return;
+    }
+}
+
+/** Look at scan payload to find a peer device and connect to it */
+void SMDeviceCentral::on_scan(const Gap::AdvertisementCallbackParams_t *params)
+{
+    /* don't bother with analysing scan result if we're already connecting */
+    if (_is_connecting) {
+        return;
+    }
+
+    /* connect to the same device that connected to us */
+    if (memcmp(params->peerAddr, _peer_address, sizeof(_peer_address)) == 0) {
+
+        ble_error_t error = _ble.gap().connect(
+            params->peerAddr, params->peerAddrType,
+            NULL, NULL
+        );
+
+        if (error) {
+            printf("Error during Gap::connect %d\r\n", error);
+            return;
+        }
+
+        printf("Connecting... ");
+
+        /* 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;
+
+        return;
+    }
+}
+
+/** This is called by Gap to notify the application we connected,
+ *  in our case it immediately request pairing */
+void SMDeviceCentral::on_connect(const Gap::ConnectionCallbackParams_t *connection_event)
+{
+    ble_error_t error;
+
+    /* store the handle for future Security Manager requests */
+    _handle = connection_event->handle;
+
+    /* in this example the local device is the master so we request pairing */
+    error = _ble.securityManager().requestPairing(_handle);
+
+    printf("Connected\r\n");
+
+    if (error) {
+        printf("Error during SM::requestPairing %d\r\n", error);
+        return;
+    }
+
+    /* upon pairing success the application will disconnect */
+}
+
+
+
+#if MBED_CONF_APP_FILESYSTEM_SUPPORT
+bool create_filesystem()
+{
+    static LittleFileSystem fs("fs");
+
+    /* replace this with any physical block device your board supports (like an SD card) */
+    static HeapBlockDevice bd(4096, 256);
+
+    int err = bd.init();
+
+    if (err) {
+        return false;
+    }
+
+    err = bd.erase(0, bd.size());
+
+    if (err) {
+        return false;
+    }
+
+    err = fs.mount(&bd);
+
+    if (err) {
+        /* Reformat if we can't mount the filesystem */
+        printf("No filesystem found, formatting...\r\n");
+
+        err = fs.reformat(&bd);
+
+        if (err) {
+            return false;
+        }
+    }
+
+    return true;
+}
+#endif //MBED_CONF_APP_FILESYSTEM_SUPPORT
+#ifdef BLE_SECURITY_MAIN
+int main()
+{
+    BLE& ble = BLE::Instance();
+    events::EventQueue queue;
+
+#if MBED_CONF_APP_FILESYSTEM_SUPPORT
+    /* if filesystem creation fails or there is no filesystem the security manager
+     * will fallback to storing the security database in memory */
+    if (!create_filesystem()) {
+        printf("Filesystem creation failed, will use memory storage\r\n");
+    }
+#endif
+
+    while(1) {
+        {
+            printf("\r\n PERIPHERAL \r\n\r\n");
+            SMDevicePeripheral peripheral(ble, queue, peer_address);
+            peripheral.run();
+        }
+
+        {
+            printf("\r\n CENTRAL \r\n\r\n");
+            SMDeviceCentral central(ble, queue, peer_address);
+            central.run();
+        }
+    }
+
+    return 0;
+}
+#endif
+
+#ifdef OLD_BLE_SECURITY
+/* mbed Microcontroller Library
+ * Copyright (c) 2006-2013 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.
+ */
+//#ifdef BLE_SECURITY_ENABLED
+#include <events/mbed_events.h>
+#include <mbed.h>
+#include "ble/BLE.h"
+#include "ble/Gap.h"
+#include "Types.h"
+#include "ble/services/UARTService.h"
+
+//#include "ble/gap/Types.h"
+#include "SecurityManager.h"
 #include "pretty_printer.h"
 
 #if MBED_CONF_APP_FILESYSTEM_SUPPORT
@@ -42,8 +546,10 @@
 static const char DEVICE_NAME[] = "SM_device";
 
 /* we have to specify the disconnect call because of ambiguous overloads */
-typedef ble_error_t (Gap::*disconnect_call_t)(ble::connection_handle_t, ble::local_disconnection_reason_t);
-const static disconnect_call_t disconnect_call = &Gap::disconnect;
+//typedef ble_error_t (Gap::*disconnect_call_t)(ble::connection_handle_t, ble::local_disconnection_reason_t);
+//const static disconnect_call_t disconnect_call = &Gap::disconnect;
+//typedef ble_error_t (Gap::*disconnect_call_t)(ble::connection_handle_t, ble::local_disconnection_reason_t);
+//const static (Gap::*disconnect_call_t) disconnect_call = &Gap::disconnect;
 
 /* for demonstration purposes we will store the peer device address
  * of the device that connects to us in the first demonstration
@@ -58,7 +564,7 @@
  */
 class SMDevice : private mbed::NonCopyable<SMDevice>,
                  public SecurityManager::EventHandler,
-                 public ble::Gap::EventHandler
+                 public Gap::EventHandler
 {
 public:
     SMDevice(BLE &ble, events::EventQueue &event_queue, BLEProtocol::AddressBytes_t &peer_address) :
@@ -244,31 +750,37 @@
         _event_queue.call_in(
             2000,
             &_ble.gap(),
-            disconnect_call,
+            &Gap::disconnect, //disconnect_call,
             _handle,
-            ble::local_disconnection_reason_t(ble::local_disconnection_reason_t::USER_TERMINATION)
+             (Gap::DisconnectionReason_t)0x13
+             //Gap::DisconnectionReason_t::REMOTE_USER_TERMINATED_CONNECTION)
+            //ble::local_disconnection_reason_t(ble::local_disconnection_reason_t::USER_TERMINATION)
         );
     }
+    
+    
 
     /** This is called by Gap to notify the application we disconnected,
      *  in our case it ends the demonstration. */
-    virtual void onDisconnectionComplete(const ble::DisconnectionCompleteEvent &)
+    //virtual void onDisconnectionComplete(const Gap::DisconnectionCompleteEvent &)
+    virtual void onDisconnectionComplete(const Gap::DisconnectionCallbackParams_t *params)
     {
-        printf("Diconnected\r\n");
+        printf("Disconnected\r\n");
         _event_queue.break_dispatch();
     };
 
-    virtual void onAdvertisingEnd(const ble::AdvertisingEndEvent &)
-    {
-        printf("Advertising timed out - aborting\r\n");
-        _event_queue.break_dispatch();
-    }
+    //virtual void onAdvertisingEnd(const ble::AdvertisingEndEvent &)
+    //void onAdvertisingEnd(const ble::AdvertisingEndEvent &)
+    //{
+    //    printf("Advertising timed out - aborting\r\n");
+    //    _event_queue.break_dispatch();
+    //}
 
-    virtual void onScanTimeout(const ble::ScanTimeoutEvent &)
-    {
-        printf("Scan timed out - aborting\r\n");
-        _event_queue.break_dispatch();
-    }
+    //virtual void onScanTimeout(const ble::ScanTimeoutEvent &)
+    //{
+    //    printf("Scan timed out - aborting\r\n");
+    //    _event_queue.break_dispatch();
+    //}
 
 private:
     DigitalOut _led1;
@@ -291,10 +803,12 @@
     virtual void start()
     {
         /* Set up and start advertising */
-        uint8_t adv_buffer[ble::LEGACY_ADVERTISING_MAX_SIZE];
+#ifdef NEW_BLE5_API        
+        //uint8_t adv_buffer[Gap::LEGACY_ADVERTISING_MAX_SIZE];
+        uint8_t adv_buffer[32];
         /* use the helper to build the payload */
-        ble::AdvertisingDataBuilder adv_data_builder(
-            adv_buffer
+        ble::Gap::AdvertisingDataBuilder adv_data_builder(
+            adv_buffer, 32
         );
 
         adv_data_builder.setFlags();
@@ -312,7 +826,7 @@
             return;
         }
 
-        ble::AdvertisingParameters adv_parameters(
+        ble::gap::AdvertisingParameters adv_parameters(
             ble::advertising_type_t::CONNECTABLE_UNDIRECTED
         );
 
@@ -332,7 +846,19 @@
             print_error(error, "Gap::startAdvertising() failed");
             return;
         }
+#else
+    /* setup advertising */
+    _ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::BREDR_NOT_SUPPORTED | GapAdvertisingData::LE_GENERAL_DISCOVERABLE);
+    //_ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LIST_16BIT_SERVICE_IDS, (uint8_t *)uuid16_list, sizeof(uuid16_list));
+    _ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LOCAL_NAME, (uint8_t *)DEVICE_NAME, sizeof(DEVICE_NAME));
+    /* set up the services that can be discovered */
+    _ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LIST_128BIT_SERVICE_IDS,(const uint8_t *)UARTServiceUUID_reversed, sizeof(UARTServiceUUID_reversed));
+    _ble.gap().setAdvertisingType(GapAdvertisingParams::ADV_CONNECTABLE_UNDIRECTED);
+    _ble.gap().setAdvertisingInterval(1000); /* 1000ms. */
+    _ble.gap().setAdvertisingTimeout(300); /* 16 * 1000ms. */
+    _ble.gap().startAdvertising();
 
+#endif
         printf("Please connect to device\r\n");
 
         /** This tells the stack to generate a pairingRequest event
@@ -344,18 +870,19 @@
 
     /** This is called by Gap to notify the application we connected,
      *  in our case it immediately requests a change in link security */
-    virtual void onConnectionComplete(const ble::ConnectionCompleteEvent &event)
+    //virtual void onConnectionComplete(const ble::ConnectionCompleteEvent_t &event)
+    virtual void onConnectionComplete(const Gap::ConnectionCallbackParams_t &event)
     {
         ble_error_t error;
 
         /* remember the device that connects to us now so we can connect to it
          * during the next demonstration */
-        memcpy(_peer_address, event.getPeerAddress().data(), sizeof(_peer_address));
+        memcpy(_peer_address, event.peerAddr, 6);
 
         printf("Connected to peer: ");
-        print_address(event.getPeerAddress().data());
+        print_address(event.peerAddr);
 
-        _handle = event.getConnectionHandle();
+        _handle = event.handle;
 
         /* Request a change in link security. This will be done
          * indirectly by asking the master of the connection to
@@ -408,7 +935,7 @@
     /* Gap::EventHandler */
 
     /** Look at scan payload to find a peer device and connect to it */
-    virtual void onAdvertisingReport(const ble::AdvertisingReportEvent &event)
+    virtual void onAdvertisingReport(const Gap::AdvertisementCallbackParams_t &event)
     {
         /* don't bother with analysing scan result if we're already connecting */
         if (_is_connecting) {
@@ -416,7 +943,7 @@
         }
 
         /* parse the advertising payload, looking for a discoverable device */
-        if (memcmp(event.getPeerAddress().data(), _peer_address, sizeof(_peer_address)) == 0) {
+        if (memcmp(event.peerAddr, _peer_address, sizeof(_peer_address)) == 0) {
             ble_error_t error = _ble.gap().stopScan();
 
             if (error) {
@@ -457,7 +984,7 @@
 
     /** This is called by Gap to notify the application we connected,
      *  in our case it immediately request pairing */
-    virtual void onConnectionComplete(const ble::ConnectionCompleteEvent &event)
+    virtual void onConnectionComplete(const Gap::ConnectionCallbackParams_t &event)
     {
         if (event.getStatus() == BLE_ERROR_NONE) {
             /* store the handle for future Security Manager requests */
@@ -523,7 +1050,7 @@
     return true;
 }
 #endif //MBED_CONF_APP_FILESYSTEM_SUPPORT
-
+#ifdef BLE_MAIN
 int main()
 {
     BLE& ble = BLE::Instance();
@@ -554,4 +1081,6 @@
     return 0;
 }
 
+#endif
+
 #endif
\ No newline at end of file