zhangyanjiaoesp
commented
1 year ago @amitabhskrishworks
Have you called the API esp_mesh_allow_root_conflicts(true) ?
Closed amitabhskrishworks closed 3 months ago
zhangyanjiaoesp
commented
1 year ago @amitabhskrishworks
Have you called the API esp_mesh_allow_root_conflicts(true) ?
amitabhskrishworks
commented
1 year ago No i have not used this option .
amitabhskrishworks
commented
1 year ago @amitabhskrishworks Have you called the API
esp_mesh_allow_root_conflicts(true)?
No
zhangyanjiaoesp
commented
1 year ago when the device2 becomes root, the device1 still be root? The log shows that there is 1 node in the network.
I (101018) mesh_main: The Total Nodes in Network are 1
amitabhskrishworks
commented
1 year ago Yes The device 1 shows that it (device 1) is root node and device 2 shows that it (device 2) is root node. The total node count using esp_mesh_get_total_node_num method returns 1 for both devices.
amitabhskrishworks
commented
1 year ago Collaborator
2 mesh network get formed with same Mesh ID
zhangyanjiaoesp
commented
1 year ago @amitabhskrishworks Did you test just with the internal_communication without any changes? If yes, I will test it locally to reproduce this issue.
amitabhskrishworks
commented
1 year ago Yes i did not made any changes except adding some logs
zhangyanjiaoesp
commented
1 year ago @amitabhskrishworks I have tested locally, and I didn't reproduce your issue. And I noticed that your rssi from the router is -83/-85, can you get your devices closer to the router and test it again?
amitabhskrishworks
commented
1 year ago I tested it and got the same result but this time with lesser frequency. Out of 10 4 times both of the node became root
amitabhskrishworks
commented
1 year ago This is my full code which makes 2 root nodes when 2 nodes are switched ON simultaneously I have node used the code relaed to mesh_light
static const char MESH_TAG = "mesh_main"; static const uint8_t MESH_ID[6] = { 0x11, 0x12, 0x13, 0x14, 0x15, 0x16}; static uint8_t tx_buf[TX_SIZE] = { 0, }; static uint8_t rx_buf[RX_SIZE] = { 0, }; static bool is_running = true; static bool is_mesh_connected = false; static mesh_addr_t mesh_parent_addr; static int mesh_layer = -1; static esp_netif_t netif_sta = NULL;
void esp_mesh_p2p_tx_main(void arg) { ESP_LOGI(MESH_TAG, " esp_mesh_p2p_tx_main tasks is about to start "); int i = 0, route_table_size = 0, j = 0; //int send_count = 0; char str="UPSTREAM DATA BY Shubham Kanaujiya"; bool is_running = true; esp_err_t err; mesh_addr_t route_table[CONFIG_MESH_ROUTE_TABLE_SIZE]; mesh_addr_t route_tables[CONFIG_MESH_ROUTE_TABLE_SIZE]; mesh_data_t data; data.data = (uint8_t *) str; data.data = tx_buf; data.size = sizeof(tx_buf); data.proto = MESH_PROTO_BIN; data.tos = MESH_TOS_P2P;
while (is_running)
{
ESP_LOGI(MESH_TAG, "The Total Nodes in Network are %d",esp_mesh_get_total_node_num());
esp_mesh_get_routing_table((mesh_addr_t *)&route_tables, CONFIG_MESH_ROUTE_TABLE_SIZE * 6, &route_table_size);
if (esp_mesh_is_root())
{
ESP_LOGI(MESH_TAG, "This node is Root Node");
for (i = 0; i < route_table_size; i++)
{
ESP_LOGI(MESH_TAG, "This is routing table : " MACSTR " and the current layer is %d", MAC2STR(route_tables[i].addr),
esp_mesh_get_layer());
}
}
else
{
ESP_LOGI(MESH_TAG, "This node is Non-Root node ");
for (i = 0; i < route_table_size; i++)
{
ESP_LOGI(MESH_TAG, "This is routing table : " MACSTR " and the current layer is %d", MAC2STR(route_tables[i].addr),
esp_mesh_get_layer());
}
}
if (esp_mesh_is_root())
{
ESP_LOGI(MESH_TAG, "layer:%d, rtableSize:%d, %s", mesh_layer, esp_mesh_get_routing_table_size(),
(is_mesh_connected && esp_mesh_is_root()) ? "ROOT" : is_mesh_connected ? "NODE" : "DISCONNECT");
vTaskDelay( pdMS_TO_TICKS(5000) );
continue;
}
else
{
esp_mesh_get_routing_table((mesh_addr_t *)&route_table, CONFIG_MESH_ROUTE_TABLE_SIZE * 6, &route_table_size);
vTaskDelay(pdMS_TO_TICKS(100));
err = esp_mesh_send(NULL, &data, MESH_DATA_P2P, NULL, 0);
if (err)
{
ESP_LOGE(MESH_TAG, "There was an error in sending data to root node");
}
vTaskDelay(2000 / portTICK_PERIOD_MS);
}
/* if route_table_size is less than 10, add delay to avoid watchdog in this task. */
if (route_table_size < 10)
{
vTaskDelay(1000 / portTICK_PERIOD_MS);
}
}
vTaskDelete(NULL);}
void esp_mesh_p2p_rx_main(void *arg) { ESP_LOGI(MESH_TAG, " esp_mesh_p2p_rx_main tasks is about to start "); esp_err_t err; mesh_addr_t from; mesh_data_t data; int flag = 0; data.data = rx_buf; data.size = RX_SIZE; is_running = true;
while (is_running)
{
data.size = RX_SIZE;
err = esp_mesh_recv(&from, &data, portMAX_DELAY, &flag, NULL, 0);
ESP_LOGI(MESH_TAG, "Receiving Data in Mesh Network from Node : " MACSTR "", MAC2STR(from.addr));
ESP_LOGI(MESH_TAG, "Data : %s ", data.data);
if (err != ESP_OK || !data.size)
{
ESP_LOGI(MESH_TAG, "err:0x%x, size:%d", err, data.size);
continue;
}
}
vTaskDelete(NULL);}
esp_err_t esp_mesh_comm_p2p_start(void) { static bool is_comm_p2p_started = false; if (!is_comm_p2p_started) { ESP_LOGI(MESH_TAG, " tasks are about to start "); is_comm_p2p_started = true; xTaskCreate(esp_mesh_p2p_tx_main, "MPTX", 8192, NULL, 5, NULL); xTaskCreate(esp_mesh_p2p_rx_main, "MPRX", 8192, NULL, 5, NULL); } return ESP_OK; }
void mesh_event_handler(void arg, esp_event_base_t event_base, int32_t event_id, void event_data) { mesh_addr_t id = {0,}; static uint16_t last_layer = 0;
switch (event_id) {
case MESH_EVENT_STARTED: {
esp_mesh_get_id(&id);
ESP_LOGI(MESH_TAG, "<MESH_EVENT_MESH_STARTED>ID:"MACSTR"", MAC2STR(id.addr));
is_mesh_connected = false;
mesh_layer = esp_mesh_get_layer();
}
break;
case MESH_EVENT_STOPPED: {
ESP_LOGI(MESH_TAG, "<MESH_EVENT_STOPPED>");
is_mesh_connected = false;
mesh_layer = esp_mesh_get_layer();
}
break;
case MESH_EVENT_CHILD_CONNECTED: {
mesh_event_child_connected_t *child_connected = (mesh_event_child_connected_t *)event_data;
ESP_LOGI(MESH_TAG, "<MESH_EVENT_CHILD_CONNECTED>aid:%d, "MACSTR"",
child_connected->aid,
MAC2STR(child_connected->mac));
}
break;
case MESH_EVENT_CHILD_DISCONNECTED: {
mesh_event_child_disconnected_t *child_disconnected = (mesh_event_child_disconnected_t *)event_data;
ESP_LOGI(MESH_TAG, "<MESH_EVENT_CHILD_DISCONNECTED>aid:%d, "MACSTR"",
child_disconnected->aid,
MAC2STR(child_disconnected->mac));
}
break;
case MESH_EVENT_ROUTING_TABLE_ADD: {
mesh_event_routing_table_change_t *routing_table = (mesh_event_routing_table_change_t *)event_data;
ESP_LOGW(MESH_TAG, "<MESH_EVENT_ROUTING_TABLE_ADD>add %d, new:%d, layer:%d",routing_table->rt_size_change,routing_table->rt_size_new, mesh_layer);
}
break;
case MESH_EVENT_ROUTING_TABLE_REMOVE: {
mesh_event_routing_table_change_t *routing_table = (mesh_event_routing_table_change_t *)event_data;
ESP_LOGW(MESH_TAG, "<MESH_EVENT_ROUTING_TABLE_REMOVE>remove %d, new:%d, layer:%d",
routing_table->rt_size_change,
routing_table->rt_size_new, mesh_layer);
}
break;
case MESH_EVENT_NO_PARENT_FOUND: {
mesh_event_no_parent_found_t *no_parent = (mesh_event_no_parent_found_t *)event_data;
ESP_LOGI(MESH_TAG, "<MESH_EVENT_NO_PARENT_FOUND>scan times:%d",
no_parent->scan_times);
}
/* TODO handler for the failure */
break;
case MESH_EVENT_PARENT_CONNECTED: {
mesh_event_connected_t *connected = (mesh_event_connected_t *)event_data;
esp_mesh_get_id(&id);
mesh_layer = connected->self_layer;
memcpy(&mesh_parent_addr.addr, connected->connected.bssid, 6);
ESP_LOGI(MESH_TAG, " MAC ID of Parent is:"MACSTR" ",MAC2STR(mesh_parent_addr.addr));
ESP_LOGI(MESH_TAG, " MAC ID of Parent is:"MACSTR" ",MAC2STR(mesh_parent_addr.addr));
// ESP_LOGI(MESH_TAG, "<MESH_EVENT_PARENT_CONNECTED>layer:%d-->%d, parent:"MACSTR"%s, ID:"MACSTR", duty:%d",last_layer, mesh_layer,
// MAC2STR(mesh_parent_addr.addr),esp_mesh_is_root() ? "<ROOT>" :(mesh_layer == 2) ? "<layer2>" : "", MAC2STR(id.addr), connected->duty);
last_layer = mesh_layer;
is_mesh_connected = true;
if (esp_mesh_is_root()) {
esp_netif_dhcpc_stop(netif_sta);
esp_netif_dhcpc_start(netif_sta);
}
esp_mesh_comm_p2p_start();
}
break;
case MESH_EVENT_PARENT_DISCONNECTED: {
mesh_event_disconnected_t *disconnected = (mesh_event_disconnected_t *)event_data;
ESP_LOGI(MESH_TAG,"<MESH_EVENT_PARENT_DISCONNECTED>reason:%d",disconnected->reason);
is_mesh_connected = false;
mesh_layer = esp_mesh_get_layer();
}
break;
case MESH_EVENT_LAYER_CHANGE: {
mesh_event_layer_change_t *layer_change = (mesh_event_layer_change_t *)event_data;
mesh_layer = layer_change->new_layer;
ESP_LOGI(MESH_TAG, "<MESH_EVENT_LAYER_CHANGE>layer:%d-->%d%s",
last_layer, mesh_layer,
esp_mesh_is_root() ? "<ROOT>" :
(mesh_layer == 2) ? "<layer2>" : "");
last_layer = mesh_layer;
}
break;
case MESH_EVENT_ROOT_ADDRESS: {
mesh_event_root_address_t *root_addr = (mesh_event_root_address_t *)event_data;
ESP_LOGI(MESH_TAG, "<MESH_EVENT_ROOT_ADDRESS>root address:"MACSTR"",
MAC2STR(root_addr->addr));
}
break;
case MESH_EVENT_VOTE_STARTED: {
mesh_event_vote_started_t *vote_started = (mesh_event_vote_started_t *)event_data;
ESP_LOGI(MESH_TAG,
"<MESH_EVENT_VOTE_STARTED>attempts:%d, reason:%d, rc_addr:"MACSTR"",
vote_started->attempts,
vote_started->reason,
MAC2STR(vote_started->rc_addr.addr));
}
break;
case MESH_EVENT_VOTE_STOPPED: {
ESP_LOGI(MESH_TAG, "<MESH_EVENT_VOTE_STOPPED>");
break;
}
case MESH_EVENT_ROOT_SWITCH_REQ: {
mesh_event_root_switch_req_t *switch_req = (mesh_event_root_switch_req_t *)event_data;
ESP_LOGI(MESH_TAG,
"<MESH_EVENT_ROOT_SWITCH_REQ>reason:%d, rc_addr:"MACSTR"",
switch_req->reason,
MAC2STR( switch_req->rc_addr.addr));
}
break;
case MESH_EVENT_ROOT_SWITCH_ACK: {
/* new root */
mesh_layer = esp_mesh_get_layer();
esp_mesh_get_parent_bssid(&mesh_parent_addr);
ESP_LOGI(MESH_TAG, "<MESH_EVENT_ROOT_SWITCH_ACK>layer:%d, parent:"MACSTR"", mesh_layer, MAC2STR(mesh_parent_addr.addr));
}
break;
case MESH_EVENT_TODS_STATE: {
mesh_event_toDS_state_t *toDs_state = (mesh_event_toDS_state_t *)event_data;
ESP_LOGI(MESH_TAG, "<MESH_EVENT_TODS_REACHABLE>state:%d", *toDs_state);
}
break;
case MESH_EVENT_ROOT_FIXED: {
mesh_event_root_fixed_t *root_fixed = (mesh_event_root_fixed_t *)event_data;
ESP_LOGI(MESH_TAG, "<MESH_EVENT_ROOT_FIXED>%s",
root_fixed->is_fixed ? "fixed" : "not fixed");
}
break;
case MESH_EVENT_ROOT_ASKED_YIELD: {
mesh_event_root_conflict_t *root_conflict = (mesh_event_root_conflict_t *)event_data;
ESP_LOGI(MESH_TAG,
"<MESH_EVENT_ROOT_ASKED_YIELD>"MACSTR", rssi:%d, capacity:%d",
MAC2STR(root_conflict->addr),
root_conflict->rssi,
root_conflict->capacity);
}
break;
case MESH_EVENT_CHANNEL_SWITCH: {
mesh_event_channel_switch_t *channel_switch = (mesh_event_channel_switch_t *)event_data;
ESP_LOGI(MESH_TAG, "<MESH_EVENT_CHANNEL_SWITCH>new channel:%d", channel_switch->channel);
}
break;
case MESH_EVENT_SCAN_DONE: {
mesh_event_scan_done_t *scan_done = (mesh_event_scan_done_t *)event_data;
ESP_LOGI(MESH_TAG, "<MESH_EVENT_SCAN_DONE>number:%d",
scan_done->number);
}
break;
case MESH_EVENT_NETWORK_STATE: {
mesh_event_network_state_t *network_state = (mesh_event_network_state_t *)event_data;
ESP_LOGI(MESH_TAG, "<MESH_EVENT_NETWORK_STATE>is_rootless:%d",
network_state->is_rootless);
}
break;
case MESH_EVENT_STOP_RECONNECTION: {
ESP_LOGI(MESH_TAG, "<MESH_EVENT_STOP_RECONNECTION>");
}
break;
case MESH_EVENT_FIND_NETWORK: {
mesh_event_find_network_t *find_network = (mesh_event_find_network_t *)event_data;
ESP_LOGI(MESH_TAG, "<MESH_EVENT_FIND_NETWORK>new channel:%d, router BSSID:"MACSTR"",
find_network->channel, MAC2STR(find_network->router_bssid));
}
break;
case MESH_EVENT_ROUTER_SWITCH: {
mesh_event_router_switch_t *router_switch = (mesh_event_router_switch_t *)event_data;
ESP_LOGI(MESH_TAG, "<MESH_EVENT_ROUTER_SWITCH>new router:%s, channel:%d, "MACSTR"",
router_switch->ssid, router_switch->channel, MAC2STR(router_switch->bssid));
}
break;
case MESH_EVENT_PS_PARENT_DUTY: {
mesh_event_ps_duty_t *ps_duty = (mesh_event_ps_duty_t *)event_data;
ESP_LOGI(MESH_TAG, "<MESH_EVENT_PS_PARENT_DUTY>duty:%d", ps_duty->duty);
}
break;
case MESH_EVENT_PS_CHILD_DUTY: {
mesh_event_ps_duty_t *ps_duty = (mesh_event_ps_duty_t *)event_data;
ESP_LOGI(MESH_TAG, "<MESH_EVENT_PS_CHILD_DUTY>cidx:%d, "MACSTR", duty:%d", ps_duty->child_connected.aid-1,
MAC2STR(ps_duty->child_connected.mac), ps_duty->duty);
}
break;
default:
ESP_LOGI(MESH_TAG, "unknown id:%" PRId32 "", event_id);
break;
}}
void ip_event_handler(void arg, esp_event_base_t event_base, int32_t event_id, void event_data)
{
ip_event_got_ip_t event = (ip_event_got_ip_t ) event_data;
ESP_LOGI(MESH_TAG, "
}
void app_main(void) { ESP_ERROR_CHECK(nvs_flash_init()); / tcpip initialization / ESP_ERROR_CHECK(esp_netif_init()); / event initialization / ESP_ERROR_CHECK(esp_event_loop_create_default()); / create network interfaces for mesh (only station instance saved for further manipulation, soft AP instance ignored / ESP_ERROR_CHECK(esp_netif_create_default_wifi_mesh_netifs(&netif_sta, NULL)); / wifi initialization / wifi_init_config_t config = WIFI_INIT_CONFIG_DEFAULT(); ESP_ERROR_CHECK(esp_wifi_init(&config)); ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, &ip_event_handler, NULL)); ESP_ERROR_CHECK(esp_wifi_set_storage(WIFI_STORAGE_FLASH)); ESP_ERROR_CHECK(esp_wifi_start()); / mesh initialization / ESP_ERROR_CHECK(esp_mesh_init()); ESP_ERROR_CHECK(esp_event_handler_register(MESH_EVENT, ESP_EVENT_ANY_ID, &mesh_event_handler, NULL)); / set mesh topology / ESP_ERROR_CHECK(esp_mesh_set_topology(CONFIG_MESH_TOPOLOGY)); / set mesh max layer according to the topology / ESP_ERROR_CHECK(esp_mesh_set_max_layer(CONFIG_MESH_MAX_LAYER)); ESP_ERROR_CHECK(esp_mesh_set_vote_percentage(1)); ESP_ERROR_CHECK(esp_mesh_set_xon_qsize(128));
/* Enable mesh PS function */
ESP_ERROR_CHECK(esp_mesh_enable_ps());
/* better to increase the associate expired time, if a small duty cycle is set. */
ESP_ERROR_CHECK(esp_mesh_set_ap_assoc_expire(60));
/* better to increase the announce interval to avoid too much management traffic, if a small duty cycle is set. */
ESP_ERROR_CHECK(esp_mesh_set_announce_interval(600, 3300));/* Disable mesh PS function */
ESP_ERROR_CHECK(esp_mesh_disable_ps());
ESP_ERROR_CHECK(esp_mesh_set_ap_assoc_expire(10));mesh_cfg_t cfg = MESH_INIT_CONFIG_DEFAULT();
/* mesh ID */
memcpy((uint8_t *) &cfg.mesh_id, MESH_ID, 6);
/* router */
cfg.channel = CONFIG_MESH_CHANNEL;
cfg.router.ssid_len = strlen(CONFIG_MESH_ROUTER_SSID);
memcpy((uint8_t *) &cfg.router.ssid, CONFIG_MESH_ROUTER_SSID, cfg.router.ssid_len);
memcpy((uint8_t *) &cfg.router.password, CONFIG_MESH_ROUTER_PASSWD,
strlen(CONFIG_MESH_ROUTER_PASSWD));
/* mesh softAP */
ESP_ERROR_CHECK(esp_mesh_set_ap_authmode(CONFIG_MESH_AP_AUTHMODE));
cfg.mesh_ap.max_connection = CONFIG_MESH_AP_CONNECTIONS;
cfg.mesh_ap.nonmesh_max_connection = CONFIG_MESH_NON_MESH_AP_CONNECTIONS;
memcpy((uint8_t *) &cfg.mesh_ap.password, CONFIG_MESH_AP_PASSWD,
strlen(CONFIG_MESH_AP_PASSWD));
ESP_ERROR_CHECK(esp_mesh_set_config(&cfg));
/* mesh start */
ESP_ERROR_CHECK(esp_mesh_start());/* set the device active duty cycle. (default:10, MESH_PS_DEVICE_DUTY_REQUEST) */
ESP_ERROR_CHECK(esp_mesh_set_active_duty_cycle(CONFIG_MESH_PS_DEV_DUTY, CONFIG_MESH_PS_DEV_DUTY_TYPE));
/* set the network active duty cycle. (default:10, -1, MESH_PS_NETWORK_DUTY_APPLIED_ENTIRE) */
ESP_ERROR_CHECK(esp_mesh_set_network_duty_cycle(CONFIG_MESH_PS_NWK_DUTY, CONFIG_MESH_PS_NWK_DUTY_DURATION, CONFIG_MESH_PS_NWK_DUTY_RULE));ESP_LOGI(MESH_TAG, "mesh starts successfully, heap:%" PRId32 ", %s<%d>%s, ps:%d\n", esp_get_minimum_free_heap_size(),
esp_mesh_is_root_fixed() ? "root fixed" : "root not fixed",
esp_mesh_get_topology(), esp_mesh_get_topology() ? "(chain)":"(tree)", esp_mesh_is_ps_enabled());}
zhangyanjiaoesp
commented
1 year ago I just run the above code can reproduce the problem, right?
amitabhskrishworks
commented
1 year ago yes Please note that if you will switch ON nodes one after another then this problem doesn't occurs.
zhangyanjiaoesp
commented
1 year ago please provide the IDF branch commit id you used.
amitabhskrishworks
commented
1 year ago ESP IDF version - v5.0.4 Is IDF branch commit id, other thing ?
zhangyanjiaoesp
commented
1 year ago ESP IDF version - v5.0.4 Is IDF branch commit id, other thing ?
OK, so the commit id is https://github.com/espressif/esp-idf/commit/8fbf4ba6058bcf736317d8a7aa75d0578563c38b, I will test on it.
zhangyanjiaoesp
commented
1 year ago Have tested based on your code for 20 times, still can't reproduce your issue. Can you provide your sdkconfig file?
amitabhskrishworks
commented
1 year ago Here is the sdkconfig file in text format sdk_config.txt
zhangyanjiaoesp
commented
12 months ago @amitabhskrishworks Do you use the ESP32 device with PSRAM?
amitabhskrishworks
commented
12 months ago Yes i used PSRAM. Is that the issue ?
zhangyanjiaoesp
commented
12 months ago I'm not sure, I will test on the PSRAM devices with the same code and sdkconfig with yours and feedback to you.
zhangyanjiaoesp
commented
11 months ago @amitabhskrishworks I can reproduce the problem now ! It's seems not related to PSRAM, and it related to the mesh PS and the router.
When I enable the mesh PS in the menuconfig, and try to connect to a WPA3 router, the problem can be reproduced.
when I disable the mesh PS in menuconfig, and try to connect to a WPA3 router, the problem can't be reproduced. when I enable the mesh PS in the menuconfig, and try to connect to a WPA2 router, the problem can't be reproduced.
My WPA3 router is Xiaomi AX6000, can you provide the type of your router and show me the setting of it ? So I can use the same router with yours to debug, this can ensure the behavior of the router is same.
amitabhskrishworks
commented
11 months ago @zhangyanjiaoesp Thanks for identifying the cause of issue. My router configurations are: SSID: EWS-2ND F Protocol: Wi-Fi 4 (802.11n) Security type: WPA3-Personal Manufacturer: Intel Corporation Description: Intel(R) Wireless-AC 9560 160MHz Driver version: 22.0.1.1 Network band: 2.4 GHz Network channel: 3 Link speed (Receive/Transmit): 144/144 (Mbps)
kdm2223
commented
10 months ago We also encountered a situation with two root nodes and are hoping for a good solution.
zhangyanjiaoesp
commented
7 months ago @amitabhskrishworks Sorry to reply you so late. I was held up by something else. I checked the mesh code and found that the default configuration of esp_mesh_allow_root_conflicts() is true, so the conflict cannot be resolved when there are two roots in the test. After I call esp_mesh_allow_root_conflicts(false) to disable it, the roots conflict can be solved.
Here is my logs using the internal_communication:
device1:
Sherry616
Answers checklist.
IDF version.
v 5.0
Espressif SoC revision.
ESP 32 (chip revision 3.1)
Operating System used.
Windows
How did you build your project?
Command line with Make
If you are using Windows, please specify command line type.
None
Development Kit.
ESP 32 One
Power Supply used.
USB
What is the expected behavior?
One node becoming root node in esp wifi mesh.
What is the actual behavior?
2 nodes are becoming root node .
Steps to reproduce.
Debug Logs.
More Information.
No response