NRF_52 Development Kit notification events don't fire on the central, when peripheral data changes about ble HOT 24 CLOSED

struct EnableNotificationParams { 
    const DiscoveredCharacteristic& characteristic;
    bool success;
}; 

typedef FunctionPointerWithContext<const EnableNotificationParams&> EnableNotificationCallback_t;

struct EnableNotificationProcedure { 
    static bool launch(
        const DiscoveredCharacteristic& characteristic, 
        const EnableNotificationCallback_t& cb) { 
        EnableNotificationProcedure* proc = new EnableNotificationProcedure( 
            characteristic, cb
        );

        return proc->start();
    }

private:
    EnableNotificationProcedure(
        const DiscoveredCharacteristic& characteristic, 
        const EnableNotificationCallback_t& cb) : 
        _char(characteristic), _cb(cb), _CCCD(0) { 
    }

    bool start() { 
        if (!_char.notify()) { 
            delete this;
            return false;
        }

        ble_error_t err = discoverCharacteristicDescriptors( 
            _char, 
            asFunction(&EnableNotificationProcedure::whenDescriptorDiscovered),
            asFunction(&EnableNotificationProcedure::whenDiscoveryEnd)
        )

        if (err) { 
            delete this;
            return false;
        }

        return true;
    }

    void whenDescriptorDiscovered(CharacteristicDescriptorDiscovery::DiscoveryCallbackParams_t& p) { 
        if (p.descriptor.getUUID() == BLE_UUID_DESCRIPTOR_CLIENT_CHAR_CONFIG) { 
            _CCCD = p.descriptor.getAttributeHandle();
            client()->terminateCharacteristicDescriptorDiscovery(_char);
        }
    }

    void whenDiscoveryEnd(CharacteristicDescriptorDiscovery::TerminationCallbackParams_t& p) { 
        // if an error occur report the error and terminate the procedure.
        if (p.status) { 
            EnableNotificationParams res = { _char, false };
            _cb(res);
            delete this;
            return;
        }

        // otherwise launch write the descriptor
        // first register the write callback 
        client()->onDataWritten(
            asFunction(&EnableNotificationProcedure::whenDataWritten)
        );

        uint16_t notification_enabled = 1; 
        ble_error_t err = client()->write( 
            GattClient::GATT_OP_WRITE_REQ,
            _char.getConnectionHandle(),
            _CCCD,
            sizeof(notification_enabled),
            reinterpret_cast<const uint8_t*>(&notification_enabled)
        );

        // if an error occur, notify the client and terminate
        if (err) { 
            EnableNotificationParams res = { _char, false };
            _cb(res);
            // remove the callback registered for data write 
            client()->onDataWritten().detach(
                asFunction(&EnableNotificationProcedure::whenDataWritten)
            );
            delete this;
            return;
        }
    }

    void whenDataWritten(const GattWriteCallbackParams* p) { 
        // filter other write 
        if (p.connHandle != _char.getConnectionHandle() || p.handle != _CCCD) { 
            return;
        }

        // TODO: test write status when properly implemented by BLE API!
        // for now, it always succeed :(
        EnableNotificationParams res = { _char, true };
        _cb(res);
        client()->onDataWritten().detach(
            asFunction(&EnableNotificationProcedure::whenDataWritten)
        );
        delete this;
    }

    // client accessor
    GattClient* client() { 
        return _char.getGattClient();
    }

    // transform a member function of this class into a FunctionPointerWithContext 
    // for a the instance of this.
    template<typename ContextType>
    FunctionPointerWithContext<ContextType> asFunction(
        void (EnableNotificationProcedure::*member)(ContextType context)) {
        return FunctionPointerWithContext<ContextType>(this, member);
    }

    DiscoveredCharacteristic _char;
    EnableNotificationCallback_t _cb;
    GattAttribute::Handle_t _CCCD;
}


/**
 * Enable the notification on a discovered characteristic. 
 * This is an asynchronous process, the result of the operation will be known via a callback.
 */
bool enableNotification(
    const DiscoveredCharacteristic& characteristic, 
    const EnableNotificationCallback_t& cb) { 
    return EnableNotificationProcedure::launch(characteristic, cb);
}

#ifndef BLEPERIPHERAL_H
#define BLEPERIPHERAL_H

#include <mbed.h>
#include "ble/BLE.h"
#include "ble/DiscoveredCharacteristic.h"
#include "ble/DiscoveredService.h"

namespace BleCentralApp
{   
    struct BlePeripheral 
    { 
        BlePeripheral() {
			_CCCD = 0; 
			_enabledNotification = false;
        }
          
        void setDiscoveredCharacteristic(const DiscoveredCharacteristic* pDiscoveredCharacteristic) {
            if(pDiscoveredCharacteristic != NULL) {
               _discoveredCharacteristic = *pDiscoveredCharacteristic; 
	        }
			else {
				_enabledNotification = false;
			}
        }
        
        const DiscoveredCharacteristic* getDiscoveredCharacteristic() const {
            return &_discoveredCharacteristic;
		}      
        
        bool isNotificationEnabled() {
            return _enabledNotification;  
        }

		void discoverCharacteristicDescriptors() { 
			//notification already enabled.
			if(_enabledNotification)
				return;

			if (!_discoveredCharacteristic.getProperties().notify()) { 
			    logError("Notifications are not enabled for the Discovered Characteristic.");
                return;
            }
    
            ble_error_t err = client()->discoverCharacteristicDescriptors( 
                _discoveredCharacteristic, 
                asFunction(&BlePeripheral::whenDescriptorDiscovered),
                asFunction(&BlePeripheral::whenDiscoveryEnd)
            );
    
            if (err) { 
               logError("discoverCharacteristicDescriptors call failed with Ble error: %d" , err);
            }
        }

        
    private:
        void whenDescriptorDiscovered(const CharacteristicDescriptorDiscovery::DiscoveryCallbackParams_t* p) { 
            if (p->descriptor.getUUID() == BLE_UUID_DESCRIPTOR_CLIENT_CHAR_CONFIG) { 
                _CCCD = p->descriptor.getAttributeHandle();
                client()->terminateCharacteristicDescriptorDiscovery(_discoveredCharacteristic);
            }
        }
    
        void whenDiscoveryEnd(const CharacteristicDescriptorDiscovery::TerminationCallbackParams_t* p) { 
            if (p->status) { 
                _enabledNotification = false;
                return;
            }
    
            // otherwise launch write the descriptor
            // first register the write callback 
            client()->onDataWritten(
                asFunction(&BlePeripheral::whenDataWritten)
            );
    
            uint16_t notification_enabled = 1; 
            ble_error_t err = client()->write( 
                GattClient::GATT_OP_WRITE_REQ,
                _discoveredCharacteristic.getConnectionHandle(),
                _CCCD,
                sizeof(notification_enabled),
                reinterpret_cast<const uint8_t*>(&notification_enabled)
            );
    
            if (err) { 
                _enabledNotification = false;
                
                // remove the callback registered for data write 
                client()->onDataWritten().detach(
                    asFunction(&BlePeripheral::whenDataWritten)
                );
                return;
            }

			_enabledNotification = true;
        }
    
        void whenDataWritten(const GattWriteCallbackParams* p) { 
            // filter other write 
            if (p->connHandle != _discoveredCharacteristic.getConnectionHandle() || p->handle != _CCCD) { 
                return;
            }
    		
            _enabledNotification = true;
         
            client()->onDataWritten().detach(
                asFunction(&BlePeripheral::whenDataWritten)
            );
        }
    
        // client accessor
        GattClient* client() { 
            return _discoveredCharacteristic.getGattClient();
        }
    
        // transform a member function of this class into a FunctionPointerWithContext 
        // for a the instance of this.
        template<typename ContextType>
        FunctionPointerWithContext<ContextType> asFunction(
            void (BlePeripheral::*member)(ContextType context)) {
            return FunctionPointerWithContext<ContextType>(this, member);
        }
        
        //ble related handles and characteristics
        GattAttribute::Handle_t _CCCD;
        DiscoveredCharacteristic _discoveredCharacteristic;
		
        //flags to enable notifications.
        bool  _enabledNotification;
    };
}
#endif /* BLEPERIPHERAL_H */

/* 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.
 */

#include <events/mbed_events.h>
#include <mbed.h>
#include "ble/BLE.h"
#include "ble/DiscoveredCharacteristic.h"
#include "ble/DiscoveredService.h"

#define UUID_HRM_SERVICE                0x180d
#define UUID_HRM_CHARACTERISTIC         0x2a37
#define UUID_HRM_DESCRIPTOR             0x2902

DigitalOut alivenessLED(LED1, 1);
static DiscoveredCharacteristic hrmCharacteristic;
static const char PEER_NAME[] = "RBL-BLE";

uint16_t _discovered_UUID = 0x0000;
GattAttribute::Handle_t _CCCD_handle(0);
uint8_t reed_state;

void look_for_Descriptors();
void stop();
void triggerRead(const GattWriteCallbackParams *response);
void onUpdatesCallback(const GattHVXCallbackParams *updates);
void read_characteristic(const DiscoveredCharacteristic &characteristic);
void ReadCompletitionCallback(const GattReadCallbackParams *params);

static bool flag_connected = false;
static bool flag_hrm_char_found = false;


static EventQueue eventQueue(/* event count */ 16 * EVENTS_EVENT_SIZE);

void periodicCallback(void) {
    if(flag_connected){
            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
    uint32_t err_code;
    for (uint8_t i = 0; i < params->advertisingDataLen; ++i) {

        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;

        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],                 //peerAddr: BLE address of the device that has advertised the packet.
                    params->peerAddr[1], params->peerAddr[0], params->rssi, params->isScanResponse, params->type
                );
                err_code = BLE::Instance().gap().connect(params->peerAddr, Gap::ADDR_TYPE_RANDOM_STATIC, NULL, NULL);
                if(err_code == BLE_ERROR_NOT_IMPLEMENTED){
                      printf("BLE_ERROR_NOT_IMPLEMENTED\n");
                }else if(err_code == 0){
                  wait_ms(100);
                  printf("success\n");
                }
                break;
            }
        }
        i += record_length;
    }
}

void serviceDiscoveryCallback(const DiscoveredService *service) {
    printf("Service Discovery Callback\n");
    if (service->getUUID().shortOrLong() == UUID::UUID_TYPE_SHORT) {
        printf("Service UUID-%x attrs[%u %u]\r\n", service->getUUID().getShortUUID(), service->getStartHandle(), service->getEndHandle());
    } else {
        printf("Service UUID-");
        const uint8_t *longUUIDBytes = service->getUUID().getBaseUUID();
        for (unsigned i = 0; i < UUID::LENGTH_OF_LONG_UUID; i++) {
            printf("%02x", longUUIDBytes[i]);
        }
        printf(" attrs[%u %u]\r\n", service->getStartHandle(), service->getEndHandle());
    }
}
void onDataWrittenCallback(const GattWriteCallbackParams* params){
            printf("onDataWritten Callback. attribute handle: %u, length:%u, data:%u \n", params->handle, params->len, params->data);
            printf("hrmChar read: %u\n", hrmCharacteristic.read());
}

void write_cccd(){
        uint16_t notification_enabled = BLE_HVX_NOTIFICATION;
        BLE &ble = BLE::Instance();


        ble_error_t err =  BLE::Instance(BLE::DEFAULT_INSTANCE).gattClient().write(

            GattClient::GATT_OP_WRITE_REQ,
            hrmCharacteristic.getConnectionHandle(),
            _CCCD_handle,
            sizeof(notification_enabled),
            reinterpret_cast<const uint8_t *>(&notification_enabled)

        );
        /*
        ble_error_t err = GattServer::write(
            _CCCD_handle,
            notification_enabled,
            sizeof(notification_enabled),
            false
            );*/
        if(err == BLE_ERROR_NONE){
            printf("cccd update sent successful\n");
            //ble.gattClient().onHVX(onUpdatesCallback);
        }else{
            printf("error updating: error_code [%u]\n", err);
        }
}

void characteristicDescriptorDiscoveryCallback(const CharacteristicDescriptorDiscovery::DiscoveryCallbackParams_t *charParams){

            printf("descriptor found with:\n");
            printf("connection_handle[%u] UUID[%X] attribute_Handle[%u]\r\n",
            charParams->descriptor.getConnectionHandle(),
            _discovered_UUID = charParams->descriptor.getUUID().getShortUUID(),
            _CCCD_handle = charParams->descriptor.getAttributeHandle()
            );

}

void descriptorDiscoveryTerminationCallback(const CharacteristicDescriptorDiscovery::TerminationCallbackParams_t *termParams){
BLE &ble = BLE::Instance();
            if(termParams->error_code == 0 && _discovered_UUID == BLE_UUID_DESCRIPTOR_CLIENT_CHAR_CONFIG){  // && !BLE::Instance().gattClient().isServiceDiscoveryActive()
                    printf("descriptorDiscovery terminated without errors\n");
                    printf("sending notification request now..\n");
                    write_cccd();
                    ble.gattClient().terminateServiceDiscovery();
            }else{
                    printf("no cccd found yet..\n");
                    printf("try again\n");
                    look_for_Descriptors();
            }

}

void updatehrmCharacteristic(void) {
    uint32_t err_code;
    if (!BLE::Instance().gattClient().isServiceDiscoveryActive()) {

        //hrmCharacteristic.read();
    }
}

void characteristicDiscoveryCallback(const DiscoveredCharacteristic *characteristicP) {
        BLE &ble = BLE::Instance();
        printf("    \n");
        printf("Characteristic Discovery Callback\n");
        printf("Char UUID[%x] valueAttr_Handle[%u] broadcast[%x] notification[%u] readable[%u]\r\n",
        characteristicP->getUUID().getShortUUID(),
        characteristicP->getValueHandle(),
        (uint8_t)characteristicP->getProperties().broadcast(),
        (uint8_t)characteristicP->getProperties().notify(),
        (uint8_t)characteristicP->getProperties().read());

    if (characteristicP->getUUID().getShortUUID() == UUID_HRM_CHARACTERISTIC ) { /* !ALERT! Alter this filter to suit your device. */
        hrmCharacteristic        = *characteristicP;
        flag_hrm_char_found = true;     //flag true so look_for_Descriptors gets invoked
    }
}

void look_for_Descriptors(){
    printf("    \n");
    BLE &ble = BLE::Instance();
    if(_discovered_UUID == UUID_HRM_DESCRIPTOR && !BLE::Instance().gattClient().isServiceDiscoveryActive()){
            printf("discovered UUID[%X] == cccd UUID[%X]\r\n",
                _discovered_UUID,
                UUID_HRM_DESCRIPTOR
                );
            printf("cccd with handle [%u] found!\n", _CCCD_handle);
            eventQueue.call(write_cccd);
    }else{
            printf("start looking for Descriptors now\n");
                ble.gattClient().discoverCharacteristicDescriptors(
                hrmCharacteristic,
                characteristicDescriptorDiscoveryCallback,
                descriptorDiscoveryTerminationCallback
            );
    }

}

void discoveryTerminationCallback(Gap::Handle_t connectionHandle) {
    printf("terminated Service Discovery for handle %u\r\n", connectionHandle);
        //printf("trigger update\n");
        if(flag_hrm_char_found == true && hrmCharacteristic.getProperties().notify()){
            printf("hrm Char found with notifications enabled\n");
            eventQueue.call(look_for_Descriptors);
        }else if(flag_hrm_char_found == true && !hrmCharacteristic.getProperties().notify()){
            printf("hrm Char found with notifications disabled\n");
        }
}

void connectionCallback(const Gap::ConnectionCallbackParams_t *params) {
    flag_connected = true;
    printf("connected to Peripheral with peerAddr:   0x%X\n", params->peerAddr);
    printf("connection handle: %d\n", params->handle);
    if (params->role == Gap::CENTRAL) {
        BLE &ble = BLE::Instance();
        ble.gattClient().onServiceDiscoveryTermination(discoveryTerminationCallback);
        ble.gattClient().launchServiceDiscovery(params->handle, serviceDiscoveryCallback, characteristicDiscoveryCallback);
    }
}

void triggerToggledWrite(const GattReadCallbackParams *response) {
    printf("onDataRead Callback\n");
    /*
    printf("server has updated characterisitc value attribute\n");
    if (response->handle == hrmCharacteristic.getValueHandle()) {
        printf("update at: 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];
        printf("toggle value %u\n", toggledValue);
    }*/
}

void onUpdatesCallback(const GattHVXCallbackParams *updates){
    ble_error_t err;
    printf("update received: handle %u, type %u, len %u, data %u, %u, %u\r\n", updates->handle, updates->type, updates->len, updates->data[0],updates->data[1],updates->data[2]);
    //err = hrmCharacteristic.read(0, ReadCompletitionCallback);
   // printf("error_code reading char: %u\n",err);
    /*
    if(updates->handle == _CCCD_handle){
                const uint8_t *p_data = updates->data;
        printf("updates received: connHandle[%u]    attrHandle[%u]  Data[%u] Type[%x] Len[%u]\n",
                updates->connHandle,
                updates->handle,
                p_data,
                updates->type,
                updates->len
        );
        for (unsigned index = 0; index < updates->len; index++) {
            printf("[%02x]", updates->data[index]);
        }
        printf("\r\n");
    }*/
    //read_characteristic(hrmCharacteristic);

}
void ReadCompletitionCallback(const GattReadCallbackParams *params){
    printf("Read attr: connHandle [%u], attributeHandle [%u], offset [%u], len [%u], value [%u], status [%u]\n\r",
    params->connHandle,
    params->handle,
    params->offset,
    params->len,
    params->data[0],
    params->status
    );
    for (size_t i = 0; i <  params->len; ++i) {
            printf("0x%02X ", params->data[i]);
        }
    printf(".\r\n");
}
void read_characteristic(const DiscoveredCharacteristic &characteristic){
    ble_error_t err;
    printf("Initiating read at %u.\r\n", characteristic.getValueHandle());
    err = hrmCharacteristic.read(0, ReadCompletitionCallback);
    printf("error_code reading char: %u\n",err);
    printf("value: %u\n\r", characteristic.read());
   /* for(int i=0; i<8; i++){
        printf("value: %u, value %u\n\r", characteristic.read(i), hrmCharacteristic.read(i));
    }*/
}

void triggerRead(const GattWriteCallbackParams *response) {
    printf("onDataWrite Callback. attribute handle: %u, length:%u, data:%u \n", response->handle, response->len, response->data);
    printf("hrmChar read: %u\n", hrmCharacteristic.read());
    /*
    BLE &ble = BLE::Instance();

    printf("server has updated characterisitc attribute with handle [%u]; type of operation = %u\n", response->handle, response->writeOp);

    if(response->handle == _CCCD_handle){
        printf("handle: [%u], length: [%u]]\n",response->handle, response->len);
        for(int index = 0; index <=response->len; index++){
            printf("data(%u):[%u]\n",index,response->data[index]);
        }
        read_characteristic(hrmCharacteristic);
    }else{

    }
*/
}

void disconnectionCallback(const Gap::DisconnectionCallbackParams_t *) {
    flag_connected = false;
    printf("disconnected\r\n");
    stop(); //detach hvx callback handler and reset flags
    /* Start scanning and try to connect again */
    BLE::Instance().gap().startScan(advertisementCallback);
}

void onBleInitError(BLE &ble, ble_error_t error)
{
    /* Initialization error handling should go here */
    printf("    \n");
    printf("ble init error\n");
    printf("    \n");
}

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]);
    }
    printf("%02x\r\n", address[0]);
}

void bleInitComplete(BLE::InitializationCompleteCallbackContext *params)
{
    BLE&        ble   = params->ble;
    ble_error_t error = params->error;

    if (error != BLE_ERROR_NONE) {
        /* In case of error, forward the error handling to onBleInitError */
        onBleInitError(ble, error);
        return;
    }

    /* Ensure that it is the default instance of BLE */
    if (ble.getInstanceID() != BLE::DEFAULT_INSTANCE) {
        return;
    }

    ble.gap().onDisconnection(disconnectionCallback);
    ble.gap().onConnection(connectionCallback);

    //ble.gattClient().onDataRead(triggerToggledWrite);
    //ble.gattClient().onDataWrite(triggerRead);
    ble.gattClient().onDataWrite(triggerRead);
    ble.gattClient().onHVX(onUpdatesCallback);
    ble.gattClient().onDataWritten(onDataWrittenCallback);

    // 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);

    printMacAddress();
}

void scheduleBleEventsProcessing(BLE::OnEventsToProcessCallbackContext* context) {
    BLE &ble = BLE::Instance();
    eventQueue.call(Callback<void()>(&ble, &BLE::processEvents));
}

void stop(){
    printf("stopp\n");
    BLE &ble = BLE::Instance();
    //ble.gattClient().onHVX().detach(onUpdatesCallback);
    //ble.gattClient().onDataWritten().detach(triggerRead);
    flag_hrm_char_found = false;
    flag_connected = false;
    _discovered_UUID = 0;
    _CCCD_handle = 0;

}

int main()
{
    eventQueue.call_every(500, periodicCallback);   //Calls an event on the queue periodically

    BLE &ble = BLE::Instance();
    ble.onEventsToProcess(scheduleBleEventsProcessing);
    ble.init(bleInitComplete);

    eventQueue.dispatch_forever();

    return 0;
}

```cpp
your workflow (or flow of events) is understood.
But maybe someone can take a look on my example and figure it out within a couple of minutes.
I spent hours trying and trying, and dont seem to come to an end here.
Thank you very much for your help Yogesh! :)
Yours,
Philipp

edit:
I tried to figure it out what may cause the problem. I just refreshed the code above, what shall be concentrated on is the weird output returned by the onUpdatesCallback function.
Watching my serial monitor, it says:

update received: handle 15384, type 0, len 15384, data 4, 0, 32
update received: handle 15384, type 0, len 15384, data 4, 0, 32
update received: handle 15384, type 0, len 15384, data 4, 0, 32
update received: handle 15384, type 0, len 15384, data 4, 0, 32
update received: handle 15384, type 0, len 15384, data 4, 0, 32
...

Shouldnt the handle be 14 (for the characteristic value attribute)?
And the length seems also pretty weird...