Zigbee: how to get correct endpoint number and short adress

[CLE93]

For my current project, I want to connect several end devices to a coordinator. The coordinator should receive commands from one end device and control the other end devices as needed. Its also my first project where I am using Zigbee.
In my current test setup (to get started with Zigbee), I have an ESP32-H2 DevkitM-1 which acts as the coordinator with one endpoint (switch), and another ESP32-H2 DevkitM-1 which is an end device. On that end device there are three endpoints: two dimmable lights and one flow sensor. After connecting the end device to the coordinator, and binding the endpoints to the coordinator endpoint switch, the coordinator outputs the connected endpoints and their addresses. However, this is not working as intended:
the coordinator ouputs only one endpoint

Bound devices:
Device on endpoint 100, short address: 0x2562, ieee address: 74:4d:bd:ff:fe:63:f5:3a

After restarting the coordinator, it ouputs three endpoints (as expected), but with incorrect endpoint numbers (correct would be 100, 101 and 102) and adresses:

Bound devices:
Device on endpoint 100, short address: 0xffff, ieee address: 74:4d:bd:ff:fe:63:f5:3a
Device on endpoint 100, short address: 0xffff, ieee address: 74:4d:bd:ff:fe:63:f5:3a
Device on endpoint 100, short address: 0xffff, ieee address: 74:4d:bd:ff:fe:63:f5:3a

→My first question is, how can this error occur, and how can it be avoided?
→My second question: Is there a way to output the connected devices and endpoints as well as their short addresses on the coordinator? I need this information to be able to control the endpoints specifically.

I also connected this end device to a Sonoss USB3.0 Zigbee Dongle (connected to a computer running zigbee2mqtt)... on the frontend I can see the connected endpoints and their correct numbers.

Any help would be highly appreciated :)

code for coordinator:

/*
 *test code: coordinator with color dimmer switch
 *(based on Zigbee_Color_Dimmer_Switch)
 */

#ifndef ZIGBEE_MODE_ZCZR
#error "Zigbee coordinator mode is not selected in Tools->Zigbee mode"
#endif

#include "Zigbee.h"

/* Zigbee color dimmer switch configuration */
#define SWITCH_ENDPOINT_NUMBER 10
uint8_t button = BOOT_PIN;
uint8_t led = RGB_BUILTIN;

/* Zigbee switch */
ZigbeeColorDimmerSwitch zbSwitch = ZigbeeColorDimmerSwitch(SWITCH_ENDPOINT_NUMBER);


#define SWDEV_LED1 0
#define SWDEF_BULB 1
#define SWDEV_ALL 2
uint8_t currentSwDev = SWDEV_ALL;
uint16_t switchDevice[][2] = { { 101, 1 }, { 0x2635, 0x8a61 } };

/********************* dimmable LED 1 functions **************************/
void setDimmableLight1(bool state, uint8_t level)
{
  if (!state)
  {
    rgbLedWrite(led, 0, 0, 0);
    return;
  }
  rgbLedWrite(led, 0, level, 0);
  Serial.print(state);
  Serial.print(", ");
  Serial.println(level);
}

/********************* reset Zigbee **************************/
void resetZigbee()
{
  Serial.println(F("Resetting Zigbee to factory and rebooting in 1s."));
  delay(1000);
  Zigbee.factoryReset();
}

/********************* reset ESP **************************/
void resetESP()
{
  Serial.println(F("ESP Reboot"));
  ESP.restart();
}

/********************* Arduino functions **************************/
void setup()
{
  Serial.begin(115200);

  //Init button switch
  pinMode(button, INPUT_PULLUP);

  // Init RMT and leave light OFF
  rgbLedWrite(led, 0, 0, 0);


  //Optional: set Zigbee device name and model
  zbSwitch.setManufacturerAndModel("Espressif", "ZigbeeSwitch");

  //Optional to allow multiple light to bind to the switch
  zbSwitch.allowMultipleBinding(true);

  //Add endpoint to Zigbee Core
  Zigbee.addEndpoint(&zbSwitch);

  //Open network for 180 seconds after boot
  Zigbee.setRebootOpenNetwork(180);

  //When all EPs are registered, start Zigbee with ZIGBEE_COORDINATOR mode
  if (!Zigbee.begin(ZIGBEE_COORDINATOR))
  {
    resetESP();
  }

  /*Serial.println(F("Waiting for Light to bound to the switch"));
  //Wait for switch to bound to a light:
  while (!zbSwitch.bound())
  {
    Serial.printf(F("."));
    delay(500);
    if (digitalRead(button) == LOW)
    {
      resetZigbee();
    }
  }
  Serial.println();*/
}

void loop()
{
  // Handle button switch in loop()
  if (digitalRead(button) == LOW)
  {  // Push button pressed
    // Key debounce handling
    delay(100);
    int startTime = millis();
    while (digitalRead(button) == LOW)
    {
      delay(50);
      if ((millis() - startTime) > 3000)
      {
        // If key pressed for more than 3secs, factory reset Zigbee and reboot
        resetZigbee();
      }
    }
    // Toggle light
    if (currentSwDev < SWDEV_ALL)
    {
      Serial.println(F("eine Lampe wird getoggelt"));
      zbSwitch.lightToggle(switchDevice[0][currentSwDev], switchDevice[1][currentSwDev]);
    }
    else
    {
      Serial.println(F("alle Lampen werden getoggelt"));
      zbSwitch.lightToggle();
    }
  }
  // Handle serial input to control color and level of the light
  if (Serial.available())
  {
    String command = Serial.readString();

    if (command == "on")
    {
      Serial.println(F("Licht an"));
      zbSwitch.lightOn();
    }
    else if (command == "off")
    {
      Serial.println(F("Licht aus"));
      zbSwitch.lightOff();
    }
    else if (command == "toggle")
    {
      Serial.println(F("Licht toggeln"));
      zbSwitch.lightToggle();
    }
    else if (command == "red")
    {
      Serial.println(F("Licht rot"));
      zbSwitch.setLightColor(255, 0, 0);
    }
    else if (command == "green")
    {
      Serial.println(F("Licht gruen"));
      zbSwitch.setLightColor(0, 255, 0);
    }
    else if (command == "blue")
    {
      Serial.println(F("Licht blau"));
      zbSwitch.setLightColor(0, 0, 255);
    }
    else if (command == "white")
    {
      Serial.println(F("Licht weiß"));
      zbSwitch.setLightColor(255, 255, 255);
    }
    else if (command == "color")
    {
      //wait for color value
      Serial.println(F("Farbe rot angeben (0-255):"));
      while (!Serial.available())
      {
        delay(100);
      }
      int red = Serial.parseInt();
      Serial.println(F("Farbe gruen angeben (0-255):"));
      while (!Serial.available())
      {
        delay(100);
      }
      int green = Serial.parseInt();
      Serial.println(F("Farbe blau angeben (0-255):"));
      while (!Serial.available())
      {
        delay(100);
      }
      int blue = Serial.parseInt();
      zbSwitch.setLightColor(red, green, blue);
    }
    else if (command == "level")
    {
      //wait for level value
      Serial.println(F("Helligkeit angeben (0-255):"));
      while (!Serial.available())
      {
        delay(100);
      }
      int level = Serial.parseInt();
      zbSwitch.setLightLevel(level);
    }
    else if (command == "switch")
    {
      Serial.println(F("naechste Lampe ansteuern..."));
      currentSwDev++;
      if (currentSwDev > SWDEV_ALL)
      {
        currentSwDev = SWDEV_LED1;
      }
      Serial.print(F("umgeschaltet auf: "));
      if (currentSwDev < SWDEV_ALL)
      {
        Serial.print(currentSwDev);
        Serial.print(F(" -EP: "));
        Serial.print(switchDevice[0][currentSwDev]);
        Serial.print(F(" -Adr.: 0x"));
        Serial.println(switchDevice[1][currentSwDev], HEX);
      }
      else
      {
        Serial.println(F("All"));
      }
    }
    else if (command == "bound")
    {
      Serial.println(F("Waiting for Light to bound to the switch"));
      //Wait for switch to bound to a light:
      while (!zbSwitch.bound())
      {
        Serial.printf(F("."));
        delay(500);
        if (digitalRead(button) == LOW)
        {
          resetZigbee();
        }
      }
      Serial.println();
    }
    else
    {
      Serial.println(F("Unbekannter Befehl"));
    }
  }

  // print the bound devices (lights) every 30 seconds
  static uint32_t last_print = 100000;
  if (millis() - last_print > 30000)
  {
    last_print = millis();
    zbSwitch.printBoundDevices(Serial);
    Serial.println();
  }
}

code for end device:

/*
 *test code: zigbee end device with dimmable lights and flow sensor
 *(based on Zigbee_Dimmable_Light and Zigbee_Pressure_Flow_Sensor)
 */

//#define SCAN

#ifndef ZIGBEE_MODE_ED
#error "Zigbee end device mode is not selected in Tools->Zigbee mode"
#endif

#include "Zigbee.h"

/* Zigbee color dimmable light configuration */
#define ZIGBEE_RGB_LIGHT_ENDPOINT 100
uint8_t led = RGB_BUILTIN;
uint8_t button = BOOT_PIN;

#ifdef SCAN
int16_t scanState = 0;
#endif

#define FLOW_MAXVAL 100.0

ZigbeeDimmableLight zbDimmableLight1 = ZigbeeDimmableLight(ZIGBEE_RGB_LIGHT_ENDPOINT);
ZigbeeDimmableLight zbDimmableLight2 = ZigbeeDimmableLight(ZIGBEE_RGB_LIGHT_ENDPOINT + 2);
ZigbeeFlowSensor zbFlowSensor = ZigbeeFlowSensor(ZIGBEE_RGB_LIGHT_ENDPOINT + 1);

/********************* RGB LED functions **************************/
void setRGBLight(bool state, uint8_t red, uint8_t green, uint8_t blue, uint8_t level)
{
  if (!state)
  {
    rgbLedWrite(led, 0, 0, 0);
    return;
  }
  float brightness = (float)level / 255;
  rgbLedWrite(led, red * brightness, green * brightness, blue * brightness);
  Serial.print(state);
  Serial.print(", ");
  Serial.print(red);
  Serial.print(", ");
  Serial.print(green);
  Serial.print(", ");
  Serial.print(blue);
  Serial.print(", ");
  Serial.println(level);
}

/********************* dimmable LED 1 functions **************************/
void setDimmableLight1(bool state, uint8_t level)
{
  if (!state)
  {
    rgbLedWrite(led, 0, 0, 0);
    return;
  }
  rgbLedWrite(led, 0, level, 0);
  Serial.print(F("Lampe 1: "));
  Serial.print(state);
  Serial.print(", ");
  Serial.println(level);
}
/********************* dimmable LED 2 functions **************************/
void setDimmableLight2(bool state, uint8_t level)
{
  if (!state)
  {
    rgbLedWrite(led, 0, 0, 0);
    return;
  }
  rgbLedWrite(led, level, 0, 0);
  Serial.print(F("Lampe 2: "));
  Serial.print(state);
  Serial.print(", ");
  Serial.println(level);
}

// Create a task on identify call to handle the identify function
void identify(uint16_t time)
{
  static uint8_t blink = 1;
  log_d("Identify called for %d seconds", time);
  if (time == 0)
  {
    // If identify time is 0, stop blinking and restore light as it was used for identify
    zbDimmableLight1.restoreLight();
    zbDimmableLight2.restoreLight();
    Serial.println(F("identify called"));
    return;
  }
  rgbLedWrite(led, 255 * blink, 255 * blink, 255 * blink);
  blink = !blink;
}


void printScannedNetworks(uint16_t networksFound)
{
  if (networksFound == 0)
  {
    Serial.println("No networks found");
  }
  else
  {
    zigbee_scan_result_t *scan_result = Zigbee.getScanResult();
    Serial.println("\nScan done");
    Serial.print(networksFound);
    Serial.println(" networks found:");
    Serial.println("Nr | PAN ID | CH | Permit Joining | Router Capacity | End Device Capacity | Extended PAN ID");
    for (int i = 0; i < networksFound; ++i)
    {
      // Print all available info for each network found
      Serial.printf("%2d", i + 1);
      Serial.print(" | ");
      Serial.printf("0x%04hx", scan_result[i].short_pan_id);
      Serial.print(" | ");
      Serial.printf("%2d", scan_result[i].logic_channel);
      Serial.print(" | ");
      Serial.printf("%-14.14s", scan_result[i].permit_joining ? "Yes" : "No");
      Serial.print(" | ");
      Serial.printf("%-15.15s", scan_result[i].router_capacity ? "Yes" : "No");
      Serial.print(" | ");
      Serial.printf("%-19.19s", scan_result[i].end_device_capacity ? "Yes" : "No");
      Serial.print(" | ");
      Serial.printf(
        "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x", scan_result[i].extended_pan_id[7], scan_result[i].extended_pan_id[6], scan_result[i].extended_pan_id[5],
        scan_result[i].extended_pan_id[4], scan_result[i].extended_pan_id[3], scan_result[i].extended_pan_id[2], scan_result[i].extended_pan_id[1],
        scan_result[i].extended_pan_id[0]);
      Serial.println();
      delay(10);
    }
    Serial.println("");
    // Delete the scan result to free memory for code below.
    Zigbee.scanDelete();
  }
}

/********************* reset Zigbee **************************/
void resetZigbee()
{
  Serial.println(F("Resetting Zigbee to factory and rebooting in 1s."));
  delay(1000);
  Zigbee.factoryReset();
}

/********************* reset ESP **************************/
void resetESP()
{
  Serial.println(F("ESP Reboot"));
  ESP.restart();
}

/********************* Arduino functions **************************/
void setup()
{
  Serial.begin(115200);
  Serial.println(F("Started"));

  Serial.println(F("Using ESP object:"));
  Serial.println(ESP.getSdkVersion());
  Serial.println(F("Using lower level function:"));
  Serial.println(esp_get_idf_version());

  // Init RMT and leave light OFF
  rgbLedWrite(led, 0, 0, 0);

  // Init button for factory reset
  pinMode(button, INPUT_PULLUP);

  // Set callback function for light change
  zbDimmableLight1.onLightChange(setDimmableLight1);
  zbDimmableLight2.onLightChange(setDimmableLight2);

  // Optional: set Zigbee device name and model
  zbFlowSensor.setManufacturerAndModel("Espressif", "ZigbeeFlowSensor2");
  // Optional: Set Zigbee device name and model
  zbDimmableLight1.setManufacturerAndModel("Espressif", "dimmbares Licht 1a");
  zbDimmableLight2.setManufacturerAndModel("Espressif", "dimmbares Licht 2a");

  // Set minimum and maximum flow measurement value in 0,1 m3/h
  zbFlowSensor.setMinMaxValue(0.0, FLOW_MAXVAL);
  // Optional: Set tolerance for flow measurement in 0,1 m3/h
  zbFlowSensor.setTolerance(1.0);


  // Add endpoint to Zigbee Core
  Serial.println(F("Adding ZigbeeLight endpoint to Zigbee Core"));
  Zigbee.addEndpoint(&zbDimmableLight1);
  Zigbee.addEndpoint(&zbFlowSensor);
  Zigbee.addEndpoint(&zbDimmableLight2);

  Serial.println(F("Starting Zigbee..."));
  // When all EPs are registered, start Zigbee in End Device mode
  if (!Zigbee.begin())
  {
    Serial.println(F("Zigbee failed to start!"));
    if (digitalRead(button) == LOW)
    {  //reset Zigbee data on setup when button is pressed
      resetZigbee();
    }
    resetESP();
  }
  else
  {
    Serial.println(F("Zigbee started successfully!"));
  }
  Serial.println(F("Connecting to network"));
  while (!Zigbee.connected())
  {
    Serial.print(".");
    delay(100);
    if (digitalRead(button) == LOW)
    {
      resetZigbee();
    }
  }
  Serial.println(F("Connected to network"));
  Serial.println(zbDimmableLight1.getEndpoint());
  Serial.println(zbDimmableLight2.getEndpoint());
  Serial.println(zbFlowSensor.getEndpoint());
  zbDimmableLight1.printBoundDevices(Serial);
  zbDimmableLight2.printBoundDevices(Serial);
  zbFlowSensor.printBoundDevices(Serial);
  Serial.println();

#ifdef SCAN
  Zigbee.scanNetworks();
#endif
}

void loop()
{
  // Checking button for factory reset
  if (digitalRead(button) == LOW)
  {  // Push button pressed
    // Key debounce handling
    delay(100);
    int startTime = millis();
    while (digitalRead(button) == LOW)
    {
      delay(50);
      if ((millis() - startTime) > 3000)
      {
        // If key pressed for more than 3secs, factory reset Zigbee and reboot
        resetZigbee();
      }
    }
    // Increase blightness by 50 every time the button is pressed
    zbDimmableLight1.setLightLevel(zbDimmableLight1.getLightLevel() + 50);
    Serial.println(F("kurzer Tastendruck"));
  }
  delay(100);

  //update flow sensor data every second
  static uint32_t lastFlowUpdate = 100000;
  if (millis() - lastFlowUpdate > 1000)
  {
    lastFlowUpdate = millis();
    zbFlowSensor.setFlow((lastFlowUpdate / 1000) % (uint16_t)FLOW_MAXVAL);
  }


  // print the bound devices (lights) every 30 seconds
  static uint32_t last_print = 100000;
  if (millis() - last_print > 30000)
  {
    last_print = millis();
    Serial.println(zbDimmableLight1.getEndpoint());
    Serial.println(zbDimmableLight2.getEndpoint());
    Serial.println(zbFlowSensor.getEndpoint());
    zbDimmableLight1.printBoundDevices(Serial);
    zbDimmableLight2.printBoundDevices(Serial);
    zbFlowSensor.printBoundDevices(Serial);
#ifdef SCAN
    scanState = Zigbee.scanComplete();
    if (scanState != ZB_SCAN_RUNNING)
    {
      if (scanState == ZB_SCAN_FAILED)
      {
        Serial.println(F("Scan failed"));
      }
      else
      {
        printScannedNetworks(scanState);
      }
      Zigbee.scanNetworks();
    }
#endif
  }
}