Seeed nRF52 will not connect with BLE to Seeed ESP32C3

[Timwxc]

I am trying to connect nRF with ESP. In the moment it looks like the nRF do not let the ESP connect. The reason is unclear for me.
The ESP can find the nRF.
I think somthing is missing in the code for the nRF.
Hope someone can help.

Code for the ESP32C3 as receiver:

#include <Servo.h>


  // Vorheriger Wert von notificationValue
uint8_t previousValue = 0;

//sevo

Servo myservo = Servo();

int servoPin = 10, ch = 0;

//BLE

#define DEVICE_MAC_ADDRESS "f1:d1:d7:76:38:fb"  // 34:85:18:03:d6:d2
static BLEUUID serviceUUID("8bd46fae-11d3-4fb5-acaa-16d38ab53579");
static BLEUUID charUUID("c3a5f5ea-9167-4fda-9447-412be6130fca");

static BLEClient* pClient;
static BLERemoteCharacteristic* pRemoteCharacteristic;

bool bluetoothEnabled = true;

class MyBLEScanCallback : public BLEAdvertisedDeviceCallbacks {
public:
  void onResult(BLEAdvertisedDevice advertisedDevice) {
    Serial.print("Found BLE device: ");
    Serial.println(advertisedDevice.toString().c_str());
    BLEAddress address = advertisedDevice.getAddress();
    Serial.print("Address: ");
    Serial.println(address.toString().c_str());
    Serial.print("RSSI: ");
    Serial.println(advertisedDevice.getRSSI());
    Serial.println("-------------");
  }
};

class MyBLEClientCallback : public BLEClientCallbacks {
public:
  void onConnect(BLEClient* pClient) {
    Serial.println("Connected to BLE device");
  }

  void onDisconnect(BLEClient* pClient) {
    Serial.println("Disconnected from BLE device");
     if (bluetoothEnabled) {
      BLEDevice::deinit(true); // Bluetooth deaktivieren
      bluetoothEnabled = false;
      Serial.println("Bluetooth Aus");
    }
  }
};

void setup() {
  

  
  Serial.begin(115200);
  Serial.println("Starting...");
//servo
  //myservo.attach(servoPin, 6, 440, 2550, true);  // attach to ch 6, minUs=500 maxUs=2500, inverted pwm 
  //myservo.printDebug();

  BLEDevice::init("Empfänger");
Serial.println("Empfänger gesetzt");
  BLEScan* pBLEScan = BLEDevice::getScan();
  pBLEScan->setAdvertisedDeviceCallbacks(new MyBLEScanCallback());
Serial.println("get scan");
  pBLEScan->setActiveScan(true);
  pBLEScan->start(10);

  pBLEScan->clearResults();
Serial.println("clean results");
  pClient = BLEDevice::createClient();
  Serial.println("created client");
  pClient->setClientCallbacks(new MyBLEClientCallback());
  BLEAddress deviceAddress(DEVICE_MAC_ADDRESS);
  Serial.println("Mac finden");
  pClient->connect(deviceAddress);
  
 if (pClient->connect(deviceAddress)) {
  Serial.println("Connected to BLE device");
} else {
  Serial.println("Failed to connect to BLE device");
 
}
  if (pClient->isConnected()) {
    Serial.println("Connected to BLE device");
    
    BLERemoteService* pRemoteService = pClient->getService(serviceUUID);
    if (pRemoteService == nullptr) {
      Serial.println("Failed to find the remote service");
      return;
    }
    Serial.println("Found remote service");

    pRemoteCharacteristic = pRemoteService->getCharacteristic(charUUID);
    if (pRemoteCharacteristic == nullptr) {
      Serial.println("Failed to find the remote characteristic");
      return;
    }
      
    Serial.println("Found remote characteristic");

    if (pRemoteCharacteristic->canNotify()) {
      pRemoteCharacteristic->registerForNotify([](BLERemoteCharacteristic* pBLERemoteCharacteristic, uint8_t* pData, size_t length, bool isNotify) {
        Serial.print("Received notification: ");
        
        for (int i = 0; i < length; i++) {
          Serial.print((char)pData[i]);
        }
        Serial.println();
      });
    } else {
      Serial.println("Notification is not supported for this characteristic.");
    }

    pRemoteCharacteristic->getDescriptors();
    BLERemoteDescriptor* pRemoteDescriptor = pRemoteCharacteristic->getDescriptor(BLEUUID((uint16_t)0x2902));
    if (pRemoteDescriptor == nullptr) {
      Serial.println("Failed to get descriptor");
      return;
    }
    uint8_t notificationOn[] = {0x01, 0x00};
    pRemoteDescriptor->writeValue(notificationOn, sizeof(notificationOn));

  }


}


void loop() {
  /*if (pRemoteCharacteristic->canNotify()) {
    pRemoteCharacteristic->canNotify();

    std::string value = pRemoteCharacteristic->readValue();

    if (value.length() > 0) {
      uint8_t notificationValue = value[0];
      
      if (notificationValue != previousValue) {
      
        if (notificationValue == 0x01 && previousValue == 0x00) {
         
        
          for (int pos = 0; pos <= 190; pos++) {
            myservo.write(servoPin, pos);
           
         } 
         
        } 
        else if (notificationValue == 0x00 && previousValue == 0x01) {
         
         
          for (int pos = 190; pos >= 0; pos--) {
          
            myservo.write(servoPin, pos);
            
          } 
        
        }
        
        // Aktualisiere den vorherigen Wert
        previousValue = notificationValue;
      }
    }
    
    delay(50);
  }*/
}```



Code for ESP32C3 as transmitter:

```#include <BLEDevice.h>
#include <BLEUtils.h>
#include <BLEServer.h>
#include <BLE2902.h>
#include <esp_bt.h>

BLECharacteristic *pCharacteristic;


#define BUTTON_PIN 10
#define SERVICE_UUID "4fafc201-1fb5-459e-8fcc-c5c9c331914b"
#define CHARACTERISTIC_UUID "beb5483e-36e1-4688-b7f5-ea07361b26a8"

BLEServer *pServer = NULL;
bool previousButtonState = HIGH;

class MyServerCallbacks: public BLEServerCallbacks {
    void onConnect(BLEServer* pServer) {
        //Serial.println("Connected");
    }

    void onDisconnect(BLEServer* pServer) {
       // Serial.println("Disconnected");
    }
};


int buttonPressCount = 0;
unsigned long previousMillis = 0;
const unsigned long interval = 850; // Zeitintervall zwischen den Aktionen

void setup() {
    //Serial.begin(115200);
    //Serial.print("start");

    pinMode(BUTTON_PIN, INPUT_PULLUP);

    
    BLEDevice::init("Sender");
    pServer = BLEDevice::createServer();
    pServer->setCallbacks(new MyServerCallbacks());

    BLEService *pService = pServer->createService(BLEUUID(SERVICE_UUID));
    pCharacteristic = pService->createCharacteristic(
                        BLEUUID(CHARACTERISTIC_UUID),
                        BLECharacteristic::PROPERTY_NOTIFY
                      );
    pCharacteristic->addDescriptor(new BLE2902());

    pService->start();

    BLEAdvertising *pAdvertising = BLEDevice::getAdvertising();
    pAdvertising->addServiceUUID(BLEUUID(SERVICE_UUID));

    pAdvertising->setScanResponse(true);
    pAdvertising->setMinPreferred(0x000000002);  // set value to 0x00 to not advertise this parameter
    BLEDevice::startAdvertising();


 
   
}

void loop() {


  
    int buttonState = digitalRead(BUTTON_PIN);
    unsigned long currentMillis = millis();

    if (buttonState != previousButtonState) {
        if (buttonState == LOW) {
            if (currentMillis - previousMillis >= interval) {
                buttonPressCount++;
                
                if (buttonPressCount % 2 == 1) {
                    uint8_t value = 1;
                    pCharacteristic->setValue(&value, 1);
                    pCharacteristic->notify();
                   // Serial.println("Button pressed, LED on");
                } else {
                    uint8_t value = 0;
                    pCharacteristic->setValue(&value, 1);
                    pCharacteristic->notify();
                   // Serial.println("Button pressed, LED off");
                }
                
                previousMillis = currentMillis;
            }
        }
    }

    previousButtonState = buttonState;

    
  }```


And code for the nRF52 that should work like the transmitter:

```#include <bluefruit.h>
#define BUTTON_PIN 10

const char* customServiceUUID = "4fafc201-1fb5-459e-8fcc-c5c9c331914b";
const char* customCharacteristicUUID = "beb5483e-36e1-4688-b7f5-ea07361b26a8";

BLEService LockControl = BLEService(customServiceUUID);
BLECharacteristic LockControl1 = BLECharacteristic(customCharacteristicUUID);

//BLEDis bledis;    // DIS (Device Information Service) helper class instance


int buttonPressCount = 0;
int buttonState = HIGH;
int previousButtonState = HIGH;
unsigned long previousMillis = 0;
const unsigned long interval = 850; // Zeitintervall zwischen den Aktionen

void setup()
{
  pinMode(BUTTON_PIN, INPUT_PULLUP);

  Serial.begin(115200);
while ( !Serial ) delay(10);  
  
  Bluefruit.begin(1, 1);

  Bluefruit.Periph.setConnectCallback(connect_callback);
  Bluefruit.Periph.setDisconnectCallback(disconnect_callback);

  
 /*bledi.setManufacturer("Lockop");
  bledis.setModel("Seed");
  bledis.begin();*/

  
  setupLockControl();

 
  startAdv();

  
}

void startAdv(void)
{
  Bluefruit.Advertising.addFlags(BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE);
  Bluefruit.Advertising.addTxPower();
  Bluefruit.Advertising.addService(LockControl);
  Bluefruit.Advertising.addName();

  Bluefruit.Advertising.restartOnDisconnect(true);
  Bluefruit.Advertising.setInterval(32, 200);
  Bluefruit.Advertising.setFastTimeout(30);
  Bluefruit.Advertising.start(500);
}

void setupLockControl(void)
{
  LockControl.begin();

  LockControl1.setProperties(CHR_PROPS_NOTIFY);
  LockControl1.setPermission(SECMODE_OPEN, SECMODE_OPEN);
  LockControl1.setFixedLen(0);
  LockControl1.setCccdWriteCallback(cccd_callback);
  LockControl1.begin();
 
}

void connect_callback(uint16_t conn_handle)
{
  BLEConnection* connection = Bluefruit.Connection(conn_handle);

  char central_name[32] = {0};
  connection->getPeerName(central_name, sizeof(central_name));

  Serial.print("Connected to ");
  Serial.println(central_name);
}

void disconnect_callback(uint16_t conn_handle, uint8_t reason)
{
  (void)conn_handle;
  (void)reason;

  Serial.print("Disconnected, reason = 0x");
  Serial.println(reason, HEX);
  Serial.println("Advertising!");
}

void cccd_callback(uint16_t conn_hdl, BLECharacteristic* chr, uint16_t cccd_value)
{
  Serial.print("CCCD Updated: ");
  Serial.print(cccd_value);
  Serial.println("");

  if (chr->uuid == LockControl.uuid)
  {
    if (chr->notifyEnabled(conn_hdl))
    {
      Serial.println("LockControl 'Notify' enabled");
    }
    else
    {
      Serial.println("LockControl 'Notify' disabled");
    }
  }
}

void loop()
{
  digitalToggle(LED_GREEN);
  
  int buttonState = digitalRead(BUTTON_PIN);
  unsigned long currentMillis = millis();

   if (buttonState != previousButtonState) {
        if (buttonState == LOW) {
            if (currentMillis - previousMillis >= interval) {
                buttonPressCount++;
                   if (buttonPressCount % 2 == 1) {
                    uint8_t value = 1;
       
        LockControl1.write(&value, 1);
        LockControl1.notify(&value, sizeof(value));
       } else {
                    uint8_t value = 0;
                    LockControl1.write(&value, 1);
                    LockControl1.notify(&value, sizeof(value));
                  
                }
        previousMillis = currentMillis;
      }
    }

    previousButtonState = buttonState;
  }

  delay(1);
}```

[Timwxc]

Debug output

[ 16599][I][BLEDevice.cpp:622] addPeerDevice(): add conn_id: 0, GATT role: client
[ 16607][V][FreeRTOS.cpp:189] take(): Semaphore taking: name: RegEvt (0x3fcaf108), owner: <N/A> for connect
[ 16616][V][FreeRTOS.cpp:198] take(): Semaphore taken:  name: RegEvt (0x3fcaf108), owner: connect
[ 16625][D][BLEDevice.cpp:148] gattClientEventHandler(): gattClientEventHandler [esp_gatt_if: 3] ... ESP_GATTC_REG_EVT
[ 16635][V][BLEUtils.cpp:1283] dumpGattClientEvent(): GATT Event: ESP_GATTC_REG_EVT
[ 16642][V][BLEUtils.cpp:1444] dumpGattClientEvent(): [status: ESP_GATT_OK, app_id: 0x0]
[ 16650][D][BLEClient.cpp:178] gattClientEventHandler(): gattClientEventHandler [esp_gatt_if: 3] ... ESP_GATTC_REG_EVT
[ 16661][V][FreeRTOS.cpp:143] give(): Semaphore giving: name: RegEvt (0x3fcaf108), owner: connect
[ 16669][V][FreeRTOS.cpp:63] wait(): >> wait: Semaphore waiting: name: RegEvt (0x3fcaf108), owner: <N/A> for connect
[ 16679][V][FreeRTOS.cpp:77] wait(): << wait: Semaphore released: name: RegEvt (0x3fcaf108), owner: <N/A>
[ 16689][V][FreeRTOS.cpp:189] take(): Semaphore taking: name: OpenEvt (0x3fcaf368), owner: <N/A> for connect
[ 16698][V][FreeRTOS.cpp:198] take(): Semaphore taken:  name: OpenEvt (0x3fcaf368), owner: connect
[ 16709][V][FreeRTOS.cpp:63] wait(): >> wait: Semaphore waiting: name: OpenEvt (0x3fcaf368), owner: connect for connect
[ 46711][D][BLEDevice.cpp:148] gattClientEventHandler(): gattClientEventHandler [esp_gatt_if: 3] ... ESP_GATTC_DISCONNECT_EVT
[ 46712][V][BLEUtils.cpp:1283] dumpGattClientEvent(): GATT Event: ESP_GATTC_DISCONNECT_EVT
[ 46719][V][BLEUtils.cpp:1326] dumpGattClientEvent(): [reason: ESP_GATT_CONN_CONN_CANCEL, conn_id: 0, remote_bda: f1:d1:d7:76:38:fb]
[ 46731][D][BLEClient.cpp:178] gattClientEventHandler(): gattClientEventHandler [esp_gatt_if: 3] ... ESP_GATTC_DISCONNECT_EVT
[ 46742][D][BLEDevice.cpp:148] gattClientEventHandler(): gattClientEventHandler [esp_gatt_if: 3] ... ESP_GATTC_OPEN_EVT
[ 46753][V][BLEUtils.cpp:1283] dumpGattClientEvent(): GATT Event: ESP_GATTC_OPEN_EVT
[ 46760][V][BLEUtils.cpp:1402] dumpGattClientEvent(): [status: ESP_GATT_ERROR, conn_id: 0, remote_bda: f1:d1:d7:76:38:fb, mtu: 0]
[ 46771][D][BLEClient.cpp:178] gattClientEventHandler(): gattClientEventHandler [esp_gatt_if: 3] ... ESP_GATTC_OPEN_EVT
[ 46782][E][BLEClient.cpp:239] gattClientEventHandler(): Failed to connect, status=Unknown ESP_ERR error
[ 46791][V][FreeRTOS.cpp:143] give(): Semaphore giving: name: OpenEvt (0x3fcaf368), owner: connect
[ 46800][V][FreeRTOS.cpp:77] wait(): << wait: Semaphore released: name: OpenEvt (0x3fcaf368), owner: <N/A>
[ 46809][I][BLEDevice.cpp:637] removePeerDevice(): remove: 0, GATT role client
[ 46816][D][BLEDevice.cpp:148] gattClientEventHandler(): gattClientEventHandler [esp_gatt_if: 3] ... ESP_GATTC_UNREG_EVT
[ 46827][V][BLEUtils.cpp:1283] dumpGattClientEvent(): GATT Event: ESP_GATTC_UNREG_EVT
[ 46834][V][BLEClient.cpp:149] connect(): << connect(), rc=0
[ 46840][V][BLEClient.cpp:98] connect(): >> connect(f1:d1:d7:76:38:fb)
[ 46846][I][BLEDevice.cpp:622] addPeerDevice(): add conn_id: 1, GATT role: client
[ 46853][V][FreeRTOS.cpp:189] take(): Semaphore taking: name: RegEvt (0x3fcaf108), owner: <N/A> for connect
[ 46862][V][FreeRTOS.cpp:198] take(): Semaphore taken:  name: RegEvt (0x3fcaf108), owner: connect
[ 46871][D][BLEDevice.cpp:148] gattClientEventHandler(): gattClientEventHandler [esp_gatt_if: 3] ... ESP_GATTC_REG_EVT
[ 46881][V][BLEUtils.cpp:1283] dumpGattClientEvent(): GATT Event: ESP_GATTC_REG_EVT
[ 46889][V][BLEUtils.cpp:1444] dumpGattClientEvent(): [status: ESP_GATT_OK, app_id: 0x1]
[ 46897][D][BLEClient.cpp:178] gattClientEventHandler(): gattClientEventHandler [esp_gatt_if: 3] ... ESP_GATTC_REG_EVT
[ 46907][V][FreeRTOS.cpp:143] give(): Semaphore giving: name: RegEvt (0x3fcaf108), owner: connect
[ 46916][V][FreeRTOS.cpp:63] wait(): >> wait: Semaphore waiting: name: RegEvt (0x3fcaf108), owner: <N/A> for connect
[ 46926][V][FreeRTOS.cpp:77] wait(): << wait: Semaphore released: name: RegEvt (0x3fcaf108), owner: <N/A>
[ 46935][V][FreeRTOS.cpp:189] take(): Semaphore taking: name: OpenEvt (0x3fcaf368), owner: <N/A> for connect
[ 46945][V][FreeRTOS.cpp:198] take(): Semaphore taken:  name: OpenEvt (0x3fcaf368), owner: connect
[ 46956][V][FreeRTOS.cpp:63] wait(): >> wait: Semaphore waiting: name: OpenEvt (0x3fcaf368), owner: connect for connect
[ 76958][D][BLEDevice.cpp:148] gattClientEventHandler(): gattClientEventHandler [esp_gatt_if: 3] ... ESP_GATTC_DISCONNECT_EVT
[ 76958][V][BLEUtils.cpp:1283] dumpGattClientEvent(): GATT Event: ESP_GATTC_DISCONNECT_EVT
[ 76966][V][BLEUtils.cpp:1326] dumpGattClientEvent(): [reason: ESP_GATT_CONN_CONN_CANCEL, conn_id: 0, remote_bda: f1:d1:d7:76:38:fb]
[ 76977][D][BLEClient.cpp:178] gattClientEventHandler(): gattClientEventHandler [esp_gatt_if: 3] ... ESP_GATTC_DISCONNECT_EVT
[ 76988][V][FreeRTOS.cpp:143] give(): Semaphore giving: name: OpenEvt (0x3fcaf368), owner: connect
[ 76997][V][FreeRTOS.cpp:143] give(): Semaphore giving: name: RssiCmplEvt (0x3fcaf430), owner: <N/A>
[ 77006][V][FreeRTOS.cpp:143] give(): Semaphore giving: name: SearchCmplEvt (0x3fcaf3cc), owner: <N/A>
[ 77015][I][BLEDevice.cpp:637] removePeerDevice(): remove: 1, GATT role client
[ 77022][D][BLEDevice.cpp:148] gattClientEventHandler(): gattClientEventHandler [esp_gatt_if: 3] ... ESP_GATTC_OPEN_EVT
[ 77032][V][BLEUtils.cpp:1283] dumpGattClientEvent(): GATT Event: ESP_GATTC_OPEN_EVT
[ 77040][V][BLEUtils.cpp:1402] dumpGattClientEvent(): [status: ESP_GATT_ERROR, conn_id: 0, remote_bda: f1:d1:d7:76:38:fb, mtu: 0]
[ 77051][D][BLEDevice.cpp:148] gattClientEventHandler(): gattClientEventHandler [esp_gatt_if: 3] ... ESP_GATTC_UNREG_EVT
[ 77062][V][BLEUtils.cpp:1283] dumpGattClientEvent(): GATT Event: ESP_GATTC_UNREG_EVT
[ 77069][V][FreeRTOS.cpp:77] wait(): << wait: Semaphore released: name: OpenEvt (0x3fcaf368), owner: <N/A>
[ 77079][I][BLEDevice.cpp:637] removePeerDevice(): remove: 1, GATT role client
E (94001) BT_APPL: Deregister Failed unknown client cif
[ 77091][V][BLEClient.cpp:149] connect(): << connect(), rc=0
Failed to connect to BLE device