Problem with data receive on nRF5340

[.....]

Hello,


I want to send data from peripheral devices to central device. My peripheral device code is based on "ble_peripheral_uart" sample and my central device code is based on "Multi NUS" sample.

https://devzone.nordicsemi.com/guides/nrf-connect-sdk-guides/b/software/posts/enter-the-multi-nus-a-simple-wireless-uart-network

https://github.com/NordicMatt/multi-NUS

I am checking difference between timestamps in every data packet (timestamp is from peripheral device, so it is from the sending moment).

When I connect peripheral device with nRF Connect app on android phone everything is OK. Difference between timestamps are 8ms sometimes 9ms.
But when I connect peripheral device to Multi NUS there is problem. Every 5th data packet have bigger difference in timestamp.
Interesting is it, that average difference between data frames is about 12 ms. It doesn't matter if peripheral device is sending data every 8ms or every 10ms average is 12ms, because in 8ms case difference between 4th timestamp and 5th timestamp is bigger than in 10ms case.

Annother interesting thing is it, that when I connect second peripheral device to Multi NUS it's not worse, but this problem happens for two devices.


I am sending data (17 Bytes) every 8ms, but I have problem with receiving it with Multi NUS application.

Below is picture presenting what is in my data:







Below are my codes changes snippets:

Peripheral UART:

// Peripheral UART (code snippets - changes)

...

// --------------======================-----------------------========================--------------------=====================---------------------

struct bt_conn *my_conn = NULL;


void on_le_param_updated(struct bt_conn *conn, uint16_t interval, uint16_t latency, uint16_t timeout)
{
    double connection_interval = interval*1.25;         // in ms
    uint16_t supervision_timeout = timeout*10;          // in ms
    LOG_INF("Connection parameters updated: interval %.2f ms, latency %d intervals, timeout %d ms", connection_interval, latency, supervision_timeout);
}



/* STEP 7.1 - Define the function to update the connection's PHY */
static void update_phy(struct bt_conn *conn) // Preferowany PHY
{
    int err;
    const struct bt_conn_le_phy_param preferred_phy = {
        .options = BT_CONN_LE_PHY_OPT_NONE,
        .pref_rx_phy = BT_GAP_LE_PHY_2M,
        .pref_tx_phy = BT_GAP_LE_PHY_2M,
		// .pref_rx_phy = BT_GAP_LE_PHY_CODED,
        // .pref_tx_phy = BT_GAP_LE_PHY_CODED,
    };
    err = bt_conn_le_phy_update(conn, &preferred_phy);
    if (err) {
        LOG_ERR("bt_conn_le_phy_update() returned %d", err);
    }
}


/* STEP 8.1 - Write a callback function to inform about updates in the PHY */
void on_le_phy_updated(struct bt_conn *conn, struct bt_conn_le_phy_info *param)
{
    // PHY Updated
    if (param->tx_phy == BT_CONN_LE_TX_POWER_PHY_1M) {
        LOG_INF("PHY updated. New PHY: 1M");
    }
    else if (param->tx_phy == BT_CONN_LE_TX_POWER_PHY_2M) {
        LOG_INF("PHY updated. New PHY: 2M");
    }
    else if (param->tx_phy == BT_CONN_LE_TX_POWER_PHY_CODED_S8) {
        LOG_INF("PHY updated. New PHY: Long Range");
    }
}

// --------------======================-----------------------========================--------------------=====================---------------------

...

static void connected(struct bt_conn *conn, uint8_t err)
{
	char addr[BT_ADDR_LE_STR_LEN];

	if (err) {
		LOG_ERR("Connection failed (err %u)", err);
		return;
	}

	bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
	LOG_INF("Connected %s", addr);

		// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	my_conn = bt_conn_ref(conn);
	// dk_set_led(CONNECTION_STATUS_LED, 1);
	/* STEP 1.1 - Declare a structure to store the connection parameters */
	struct bt_conn_info info;
	err = bt_conn_get_info(conn, &info);
	if (err) {
		LOG_ERR("bt_conn_get_info() returned %d", err);
		return;
	}
	/* STEP 7.2 - Update the PHY mode */
	update_phy(my_conn);
	// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	current_conn = bt_conn_ref(conn);

	dk_set_led_on(CON_STATUS_LED);
	is_conn = true; /////////////////////////////////////////////////////////////////

	LOG_INF("BLE address: %s\n", addr);
	LOG_WRN("BLE address: %s\n", addr);
	LOG_ERR("BLE address: %s\n", addr);
	printk("BLE address: %s\n", addr);

}


static void disconnected(struct bt_conn *conn, uint8_t reason)
{
	char addr[BT_ADDR_LE_STR_LEN];

	bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));

	LOG_INF("Disconnected: %s (reason %u)", addr, reason);

	if (auth_conn) {
		bt_conn_unref(auth_conn);
		auth_conn = NULL;
	}

	if (current_conn) {
		bt_conn_unref(current_conn);
		current_conn = NULL;
		dk_set_led_off(CON_STATUS_LED);
		is_conn = false; /////////////////////////////////////////////////////////////////
	}

	// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	bt_conn_unref(my_conn);
	// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

}


#ifdef CONFIG_BT_NUS_SECURITY_ENABLED
static void security_changed(struct bt_conn *conn, bt_security_t level,
			     enum bt_security_err err)
{
	char addr[BT_ADDR_LE_STR_LEN];

	bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));

	if (!err) {
		LOG_INF("Security changed: %s level %u", addr, level);
	} else {
		LOG_WRN("Security failed: %s level %u err %d", addr,
			level, err);
	}
}
#endif

BT_CONN_CB_DEFINE(conn_callbacks) = {
	.connected    = connected,
	.disconnected = disconnected,

	.le_param_updated       = on_le_param_updated,
	/* STEP 8.3 - Add the callback for PHY mode updates */
	.le_phy_updated         = on_le_phy_updated,
#ifdef CONFIG_BT_NUS_SECURITY_ENABLED
	.security_changed = security_changed,
#endif
};



...

uint8_t data_send_table[] = {0xFF, 0xAA, 0xBB, 0xCC, 0x00, 0x00, 0x22, 0x33, 0x00, 0x00, 0x55, 0x5A, 0xAA, 0xBB, 0x00, 0x00, 0x01};


void update_data_send_table(uint32_t variable) {
    data_send_table[0] = (variable >> 24) & 0xFF;
    data_send_table[1] = (variable >> 16) & 0xFF;
    data_send_table[2] = (variable >> 8) & 0xFF;
    data_send_table[3] = variable & 0xFF;
}

void update_data_send_table_iter_counter(uint32_t iter_counter) {
    data_send_table[10] = (iter_counter >> 24) & 0xFF;
    data_send_table[11] = (iter_counter >> 16) & 0xFF;
    data_send_table[12] = (iter_counter >> 8) & 0xFF;
    data_send_table[13] = iter_counter & 0xFF;
}

void update_data_send_table_iter_counter_TEST(uint32_t iter_counter) {
    data_send_table[6] = (iter_counter >> 24) & 0xFF;
    data_send_table[7] = (iter_counter >> 16) & 0xFF;
    data_send_table[8] = (iter_counter >> 8) & 0xFF;
    data_send_table[9] = iter_counter & 0xFF;
}


void print_data_send_table() {
    for (int i = 0; i < sizeof(data_send_table); i++) {
        printf("0x%02X ", data_send_table[i]);
    }
    printf("\n");
}


...

int main(void)
{
	...
}

...


void ble_write_NUM_thread(void){
	k_sem_take(&ble_init_ok, K_FOREVER);

	for (;;) {


		timer_state = k_uptime_get();

		update_data_send_table(timer_state);			// timer state

		update_data_send_table_iter_counter(iter_counter);

		uint8_t *iter_counter_t_d = data_send_table;

		uint16_t size_t_d = sizeof(data_send_table);


LOG_WRN(":%u;\n", iter_counter);
		if (bt_nus_send(my_conn, iter_counter_t_d, size_t_d)) {
			LOG_WRN("Failed to send --TEST-- data over BLE connection");
		}


		iter_counter++;
	
//		k_msleep(10);
		k_msleep(8);

	}
}


K_THREAD_DEFINE(ble_write_NUM_thread_id, STACKSIZE, ble_write_NUM_thread, NULL, NULL, NULL, 1, 0, 0);

Multi NUS:

// Multi NUS (code snippets - changes)


...

// --------------======================-----------------------========================--------------------=====================---------------------

struct bt_conn *my_conn = NULL;


void on_le_param_updated(struct bt_conn *conn, uint16_t interval, uint16_t latency, uint16_t timeout)
{
    double connection_interval = interval*1.25;         // in ms
    uint16_t supervision_timeout = timeout*10;          // in ms
    LOG_INF("Connection parameters updated: interval %.2f ms, latency %d intervals, timeout %d ms", connection_interval, latency, supervision_timeout);
}



/* STEP 7.1 - Define the function to update the connection's PHY */
static void update_phy(struct bt_conn *conn) // Preferowany PHY
{
    int err;
    const struct bt_conn_le_phy_param preferred_phy = {
        .options = BT_CONN_LE_PHY_OPT_NONE,
        .pref_rx_phy = BT_GAP_LE_PHY_2M,
        .pref_tx_phy = BT_GAP_LE_PHY_2M,
		// .pref_rx_phy = BT_GAP_LE_PHY_CODED,
        // .pref_tx_phy = BT_GAP_LE_PHY_CODED,
    };
    err = bt_conn_le_phy_update(conn, &preferred_phy);
    if (err) {
        LOG_ERR("bt_conn_le_phy_update() returned %d", err);
    }
}


/* STEP 8.1 - Write a callback function to inform about updates in the PHY */
void on_le_phy_updated(struct bt_conn *conn, struct bt_conn_le_phy_info *param)
{
    // PHY Updated
    if (param->tx_phy == BT_CONN_LE_TX_POWER_PHY_1M) {
        LOG_INF("PHY updated. New PHY: 1M");
    }
    else if (param->tx_phy == BT_CONN_LE_TX_POWER_PHY_2M) {
        LOG_INF("PHY updated. New PHY: 2M");
    }
    else if (param->tx_phy == BT_CONN_LE_TX_POWER_PHY_CODED_S8) {
        LOG_INF("PHY updated. New PHY: Long Range");
    }
}

// --------------======================-----------------------========================--------------------=====================---------------------


...


	uint32_t timer_state = 0;
	uint32_t timer_recv_data = 0;
static uint8_t ble_data_received(struct bt_nus_client *nus,const uint8_t *const data, uint16_t len)
{
	int err;
	char text_buffer[64];
	// char text_buffer[32];
	char temp_buffer[16];

	for (uint16_t pos = 0; pos != len;) {
		struct uart_data_t *tx = k_malloc(sizeof(*tx));

		if (!tx) {
			LOG_WRN("Not able to allocate UART send data buffer");
			return BT_GATT_ITER_CONTINUE;
		}

		/* Keep the last byte of TX buffer for potential LF char. */
		size_t tx_data_size = sizeof(tx->data) - 1;

		if ((len - pos) > tx_data_size) {
			tx->len = tx_data_size;
		} else {
			tx->len = (len - pos);
		}

//		memcpy(tx->data, &data[pos], tx->len);

		pos += tx->len;

		/* Append the LF character when the CR character triggered
		 * transmission from the peer.
		 */
		if ((pos == len) && (data[len - 1] == '\r')) {
			tx->data[tx->len] = '\n';
			tx->len++;
		}

		/*	Routed messages. See the comments above. 
		*	Check for *, if there's a star, send it over to the multi-nus send function
		*/
		if (( data[0] == '*') || (routedMessage == true) ) {
			multi_nus_send(tx);
		}

//  //  // -------------------------------------------------------------------------------------------------------------------------------
			timer_recv_data = k_uptime_get();
			timer_state = k_uptime_get();
			uint32_t prev = timer_state;
		LOG_INF("Received data: ");
		for (int i = 0; i < len; i++) {
//			printk("%02X ", data[i]);
///*
			if(i == 0) {
				snprintf(text_buffer, sizeof(text_buffer), "%02X", data[i]); // Writes a number in hexadecimal format
			}
			else {
				snprintf(temp_buffer, sizeof(temp_buffer), "%02X", data[i]); // Writes a number in hexadecimal format
				strcat(text_buffer, temp_buffer);
			}

		}
//		printk("\n");

//		strcat(text_buffer, ";\r\n");
		strcat(text_buffer, ";"); 

		char tmp_index[16];
		snprintf(tmp_index, sizeof(tmp_index), "%d", bt_conn_get_dst(nus->conn));
		strcat(text_buffer, tmp_index); 
		strcat(text_buffer, "\r\n");

//		printk("text_buffer = %s\n", text_buffer);
		printk("\n\tTimer_recv_data: %u \t %s\n", timer_recv_data, text_buffer);

			timer_state = k_uptime_get();
			uint32_t difference_pars = timer_state - prev;
			printk("\tParsing data time: %u ms\n", difference_pars);
				uint32_t prev_do_uart = timer_state;
		uint16_t txt_buff_size = strlen(text_buffer);

		tx->len = txt_buff_size;
		memcpy(tx->data, text_buffer, tx->len);


//  //  // -------------------------------------------------------------------------------------------------------------------------------

		err = uart_tx(uart, tx->data, tx->len, SYS_FOREVER_MS);
		if (err) {
			k_fifo_put(&fifo_uart_tx_data, tx);
		}
				timer_state = k_uptime_get();
				uint32_t to_uart_difference = timer_state - prev_do_uart;
				printk("\t\t UART data send time: %u ms\n", to_uart_difference);
	}

	return BT_GATT_ITER_CONTINUE;
}


...



static void connected(struct bt_conn *conn, uint8_t conn_err)
{
	char addr[BT_ADDR_LE_STR_LEN];
	int err;
/*	struct bt_nus_client_init_param init = {
		.cb = {
			.received = ble_data_received,
			.sent = ble_data_sent,
		}
	};
*/
	bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));

	if (conn_err) {
		LOG_INF("Failed to connect to %s (%d)", addr,conn_err);

		if (default_conn == conn) {
			bt_conn_unref(default_conn);
			default_conn = NULL;

			err = bt_scan_start(BT_SCAN_TYPE_SCAN_ACTIVE);
			if (err) {
				LOG_ERR("Scanning failed to start (err %d)",
					err);
			}
		}

		return;
	}

	LOG_INF("Connected: %s", addr);

	// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	my_conn = bt_conn_ref(conn);
	// dk_set_led(CONNECTION_STATUS_LED, 1);
	/* STEP 1.1 - Declare a structure to store the connection parameters */
	struct bt_conn_info info;
	err = bt_conn_get_info(conn, &info);
	if (err) {
		LOG_ERR("bt_conn_get_info() returned %d", err);
		return;
	}
	/* STEP 7.2 - Update the PHY mode */
	update_phy(my_conn);
	// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	/*Allocate memory for this connection using the connection context library. For reference,
	this code was taken from hids.c
	*/
	struct bt_nus_client *nus_client =bt_conn_ctx_alloc(&conns_ctx_lib, conn);

	if (!nus_client) {
		LOG_WRN("There is no free memory to "
			"allocate the connection context");
	}
	
	struct bt_nus_client_init_param init = {
		.cb = {
			.received = ble_data_received,
			.sent = ble_data_sent,
		}
	};

	memset(nus_client, 0, bt_conn_ctx_block_size_get(&conns_ctx_lib));

	err = bt_nus_client_init(nus_client, &init);

	bt_conn_ctx_release(&conns_ctx_lib, (void *)nus_client);
	
	if (err) {
		LOG_ERR("NUS Client initialization failed (err %d)", err);
	}else{
		LOG_INF("NUS Client module initialized");
	}

	gatt_discover(conn);

	/*Stop scanning during the discovery*/
	err = bt_scan_stop();
	if ((!err) && (err != -EALREADY)) {
		LOG_ERR("Stop LE scan failed (err %d)", err);
	}

	LOG_INF("BLE address: %s\n", addr);
	LOG_WRN("BLE address: %s\n", addr);
	LOG_ERR("BLE address: %s\n", addr);
	printk("BLE address: %s\n", addr);

}

static void disconnected(struct bt_conn *conn, uint8_t reason)
{
	char addr[BT_ADDR_LE_STR_LEN];
	int err;

	bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));

	LOG_INF("Disconnected: %s (reason %u)", addr,reason);

	err = bt_conn_ctx_free(&conns_ctx_lib, conn);

	if (err) {
		LOG_WRN("The memory was not allocated for the context of this "
			"connection.");
	}

	bt_conn_unref(conn);
	default_conn = NULL;

	// err = bt_scan_start(BT_SCAN_TYPE_SCAN_ACTIVE);
	// if (err) {
	// 	LOG_ERR("Scanning failed to start (err %d)",
	// 		err);
	// }

	// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	bt_conn_unref(my_conn);
	// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

}


...

static struct bt_conn_cb conn_callbacks = {
	.connected = connected,
	.disconnected = disconnected,
//	.security_changed = security_changed
	.security_changed = security_changed,

	.le_param_updated       = on_le_param_updated,
	/* STEP 8.3 - Add the callback for PHY mode updates */
	.le_phy_updated         = on_le_phy_updated,
};

...

Below is log from UART (from Multi NUS device)

COM11_2024_10_22.17.47.05.386.txt
and python program to analyze it (you have to change 'path_for_file' variable and log name to "data")

Fullscreen data_analyzer.py Download

import binascii
from collections import defaultdict

def is_hex(s):
    try:
        int(s, 16)
        return True
    except ValueError:
        return False

# Function to process the lines and perform the subtraction for timestamps
def process_timestamps(lines):
    results = []
    for i in range(len(lines) - 1):
        # Extract the 8 hex digits from each line
        hex1 = lines[i][:8]
        hex2 = lines[i + 1][:8]
        
        # Convert hex to integers
        int1 = int(hex1, 16)
        int2 = int(hex2, 16)
        
        # Perform the subtraction
        diff = int2 - int1
        
        # Convert the difference to decimal and hex
        diff_decimal = diff
        diff_hex = format(diff, 'x').upper()
        
        # Format the result string
        result = f"{hex1} - {hex2}   =   {diff_decimal}   =   {diff_hex}"
        results.append(result)
    
    return results

# Function to process the lines and perform the subtraction for increments
def process_increments(lines):
    results = []
    for i in range(len(lines) - 1):
        # Extract the 8 hex digits from each line
        
        hx_check = lines[i][20:28]
        if is_hex(hx_check):
            hex1 = lines[i][20:28]
        else:
            hex1 = "0"
        
        hx_check = lines[i + 1][20:28]
        if is_hex(hx_check):
            hex2 = lines[i + 1][20:28]
        else:
            hex2 = "1"
        
        # Convert hex to integers
        int1 = int(hex1, 16)
        int2 = int(hex2, 16)
        
        # Perform the subtraction
        diff = int2 - int1
        
        # Convert the difference to decimal and hex
        diff_decimal = diff
        diff_hex = format(diff, 'x').upper()
        
        # Format the result string
        result = f"{hex1} - {hex2}   =   {diff_decimal}   =   {diff_hex}"
        results.append(result)
    
    return results

# Function to calculate summary statistics
def calculate_summary(lines, x):
    summary_results = []
    
    # Difference between the 10th frame and the 5th from the end
    if len(lines) >= 15:
        hex_10th_timestamp = lines[9][:8]
        hex_5th_from_end_timestamp = lines[-5][:8]
        
        hex_10th_increment = lines[9][20:28]
        hex_5th_from_end_increment = lines[-5][20:28]
        
        timestamp_diff_decimal = int(hex_5th_from_end_timestamp, 16) - int(hex_10th_timestamp, 16)
        increment_diff_decimal = int(hex_5th_from_end_increment, 16) - int(hex_10th_increment, 16)
        
        summary_results.append(f"Difference between 10th frame and 5th from end (timestamp): {timestamp_diff_decimal}")
        summary_results.append(f"Difference between 10th frame and 5th from end (increment): {increment_diff_decimal}")
    
    # Check if increments go sequentially and count mismatches
    mismatches_count = 0
    for i in range(len(lines) - 1):
        increment_current = int(lines[i][20:28], 16)
        increment_next = int(lines[i + 1][20:28], 16)
        
        if increment_next != increment_current + 1:
            mismatches_count += 1
    
    summary_results.append(f"Number of mismatches in increments: {mismatches_count}")
    
    # Calculate average difference in timestamps
    total_diff_timestamps = sum(int(lines[i + 1][:8], 16) - int(lines[i][:8], 16) for i in range(len(lines) - 1))
    avg_diff_timestamps = total_diff_timestamps / (len(lines) - 1)
    
    summary_results.append(f"Average difference in timestamps: {avg_diff_timestamps}")
    
    # Count cases where timestamp difference is greater than x and calculate percentage
    count_greater_than_x = sum(1 for i in range(len(lines) - 1) if (int(lines[i + 1][:8], 16) - int(lines[i][:8], 16)) > x)
    percentage_greater_than_x = (count_greater_than_x / (len(lines) - 1)) * 100
    
    summary_results.append(f"Number of cases where timestamp difference is greater than {x}: {count_greater_than_x}")
    summary_results.append(f"Percentage of cases where timestamp difference is greater than {x}: {percentage_greater_than_x:.2f}%")
    
    # Total number of frames received
    total_frames_received = len(lines)
    
    summary_results.append(f"Total number of frames received: {total_frames_received}")
    
    return summary_results

# Main function to handle file reading and processing
def main():
    input_file = 'data.txt'
    path_for_files = 'D://YOUR//PATH//'
    input_file = path_for_files + input_file
    malformed_packet = 0

    try:
        with open(input_file, 'r') as file:
            lines = file.readlines()
    except FileNotFoundError:
        print("Input file not found")
        return

    # Group lines by device ID
    device_logs = defaultdict(list)
    for line in lines:
        if line.strip() == "":
            continue
        
        # if len(line.strip().split(';')[0]) == 34 and len(line.strip().split(';')[1]) == 9 and ';' in line:
        if ';' in line and len(line.strip().split(';')[0]) == 34 and len(line.strip().split(';')[1]) == 9:
            try:
                data, device_id = line.strip().split(';')
                device_logs[device_id].append(data)
            except ValueError:
                print(f"Malformed line: {line.strip()}")
                malformed_packet += 1
        else:
            print(f"Malformed line: {line.strip()}")
            malformed_packet += 1

    # Process each device's logs separately
    # x_value = 1000  # Example value for x
    # x_value = 10 # 10ms
    # x_value = 11 # 
    x_value = 9 
    
    for device_id, device_lines in device_logs.items():
        # Process timestamps and increments
        timestamp_results = process_timestamps(device_lines)
        increment_results = process_increments(device_lines)
        
        # Write timestamp results to file
        with open(f'{path_for_files}results_timestamp_difference{device_id}.txt', 'w') as file:
            file.write(f'\tFor device ID: {device_id}\n')
            for result in timestamp_results:
                file.write(result + '\n')
        
        # Write increment results to file
        with open(f'{path_for_files}results_counter_difference_{device_id}.txt', 'w') as file:
            file.write(f'\tFor device ID: {device_id}\n')
            for result in increment_results:
                file.write(result + '\n')
        
        # Calculate summary statistics
        summary_results = calculate_summary(device_lines, x_value)
        
        # Write summary results to file
        with open(f'{path_for_files}results_summary_{device_id}.txt', 'w') as file:
            file.write(f'\tFor device ID: {device_id}\n')
            for result in summary_results:
                file.write(result + '\n')

    print("Processing complete. Results have been written to respective files for each device.")
    print(f"Number of malformed packets: {malformed_packet}")

if __name__ == "__main__":
    main()

Below therare is example outputs from analyzer program (10ms case and 8ms case)

Output from different logs 

    10ms case:
    
00B00FAE - 00B00FB9   =   11   =   B
00B00FB9 - 00B00FC3   =   10   =   A
00B00FC3 - 00B00FCD   =   10   =   A
00B00FCD - 00B00FD7   =   10   =   A
00B00FD7 - 00B00FEA   =   19   =   13
00B00FEA - 00B00FF5   =   11   =   B
00B00FF5 - 00B00FFF   =   10   =   A
00B00FFF - 00B01009   =   10   =   A
00B01009 - 00B01013   =   10   =   A
00B01013 - 00B01026   =   19   =   13
00B01026 - 00B01031   =   11   =   B
00B01031 - 00B0103B   =   10   =   A
00B0103B - 00B01045   =   10   =   A
00B01045 - 00B0104F   =   10   =   A
00B0104F - 00B01062   =   19   =   13
00B01062 - 00B0106D   =   11   =   B
00B0106D - 00B01077   =   10   =   A
00B01077 - 00B01081   =   10   =   A
00B01081 - 00B0108B   =   10   =   A
00B0108B - 00B0109E   =   19   =   13
00B0109E - 00B010A9   =   11   =   B
00B010A9 - 00B010B3   =   10   =   A
00B010B3 - 00B010BD   =   10   =   A
00B010BD - 00B010C7   =   10   =   A
00B010C7 - 00B010DA   =   19   =   13
00B010DA - 00B010E5   =   11   =   B
00B010E5 - 00B010EF   =   10   =   A
00B010EF - 00B010F9   =   10   =   A
00B010F9 - 00B01103   =   10   =   A
00B01103 - 00B01116   =   19   =   13
00B01116 - 00B01121   =   11   =   B
00B01121 - 00B0112B   =   10   =   A
00B0112B - 00B01135   =   10   =   A
00B01135 - 00B0113F   =   10   =   A
00B0113F - 00B01152   =   19   =   13
00B01152 - 00B0115D   =   11   =   B
00B0115D - 00B01167   =   10   =   A
00B01167 - 00B01171   =   10   =   A
00B01171 - 00B0117B   =   10   =   A
00B0117B - 00B0118E   =   19   =   13
00B0118E - 00B01199   =   11   =   B
00B01199 - 00B011A3   =   10   =   A
00B011A3 - 00B011AD   =   10   =   A
00B011AD - 00B011B7   =   10   =   A
00B011B7 - 00B011CA   =   19   =   13
00B011CA - 00B011D5   =   11   =   B
00B011D5 - 00B011DF   =   10   =   A
00B011DF - 00B011E9   =   10   =   A
00B011E9 - 00B011F3   =   10   =   A
00B011F3 - 00B01206   =   19   =   13
00B01206 - 00B01211   =   11   =   B
00B01211 - 00B0121B   =   10   =   A
00B0121B - 00B01225   =   10   =   A
00B01225 - 00B0122F   =   10   =   A
00B0122F - 00B01242   =   19   =   13
00B01242 - 00B0124D   =   11   =   B
00B0124D - 00B01257   =   10   =   A
00B01257 - 00B01261   =   10   =   A
00B01261 - 00B0126B   =   10   =   A
00B0126B - 00B0127E   =   19   =   13
00B0127E - 00B01289   =   11   =   B
00B01289 - 00B01293   =   10   =   A
00B01293 - 00B0129D   =   10   =   A
00B0129D - 00B012A7   =   10   =   A
00B012A7 - 00B012BA   =   19   =   13
00B012BA - 00B012C5   =   11   =   B
00B012C5 - 00B012CF   =   10   =   A
00B012CF - 00B012D9   =   10   =   A
00B012D9 - 00B012E3   =   10   =   A
00B012E3 - 00B012F6   =   19   =   13
00B012F6 - 00B01301   =   11   =   B
00B01301 - 00B0130B   =   10   =   A
00B0130B - 00B01315   =   10   =   A
00B01315 - 00B0131F   =   10   =   A
00B0131F - 00B01332   =   19   =   13
00B01332 - 00B0133D   =   11   =   B
00B0133D - 00B01347   =   10   =   A
00B01347 - 00B01351   =   10   =   A
00B01351 - 00B0135B   =   10   =   A
00B0135B - 00B0136E   =   19   =   13
00B0136E - 00B01379   =   11   =   B
00B01379 - 00B01383   =   10   =   A
00B01383 - 00B0138D   =   10   =   A
00B0138D - 00B01397   =   10   =   A
00B01397 - 00B013AA   =   19   =   13
00B013AA - 00B013B5   =   11   =   B
00B013B5 - 00B013BF   =   10   =   A
00B013BF - 00B013C9   =   10   =   A
00B013C9 - 00B013D3   =   10   =   A
00B013D3 - 00B013E6   =   19   =   13
00B013E6 - 00B013F1   =   11   =   B
00B013F1 - 00B013FB   =   10   =   A
00B013FB - 00B01405   =   10   =   A
00B01405 - 00B0140F   =   10   =   A
00B0140F - 00B01422   =   19   =   13
00B01422 - 00B0142D   =   11   =   B
00B0142D - 00B01437   =   10   =   A
00B01437 - 00B01441   =   10   =   A
00B01441 - 00B0144B   =   10   =   A
00B0144B - 00B0145E   =   19   =   13
00B0145E - 00B01469   =   11   =   B
00B01469 - 00B01473   =   10   =   A
00B01473 - 00B0147D   =   10   =   A
00B0147D - 00B01487   =   10   =   A
00B01487 - 00B0149A   =   19   =   13
00B0149A - 00B014A5   =   11   =   B
00B014A5 - 00B014AF   =   10   =   A
00B014AF - 00B014B9   =   10   =   A
00B014B9 - 00B014C3   =   10   =   A
00B014C3 - 00B014D6   =   19   =   13






    8ms case:
    
01548F1F - 01548F3B   =   28   =   1C
01548F3B - 01548F43   =   8   =   8
01548F43 - 01548F4B   =   8   =   8
01548F4B - 01548F54   =   9   =   9
01548F54 - 01548F5C   =   8   =   8
01548F5C - 01548F77   =   27   =   1B
01548F77 - 01548F7F   =   8   =   8
01548F7F - 01548F87   =   8   =   8
01548F87 - 01548F90   =   9   =   9
01548F90 - 01548F98   =   8   =   8
01548F98 - 01548FB3   =   27   =   1B
01548FB3 - 01548FBB   =   8   =   8
01548FBB - 01548FC3   =   8   =   8
01548FC3 - 01548FCC   =   9   =   9
01548FCC - 01548FD4   =   8   =   8
01548FD4 - 01548FEF   =   27   =   1B
01548FEF - 01548FF7   =   8   =   8
01548FF7 - 01548FFF   =   8   =   8
01548FFF - 01549008   =   9   =   9
01549008 - 01549010   =   8   =   8
01549010 - 0154902B   =   27   =   1B
0154902B - 01549033   =   8   =   8
01549033 - 0154903B   =   8   =   8
0154903B - 01549044   =   9   =   9
01549044 - 0154904C   =   8   =   8
0154904C - 01549067   =   27   =   1B
01549067 - 0154906F   =   8   =   8
0154906F - 01549077   =   8   =   8
01549077 - 01549080   =   9   =   9
01549080 - 01549088   =   8   =   8
01549088 - 015490A3   =   27   =   1B
015490A3 - 015490AB   =   8   =   8
015490AB - 015490B3   =   8   =   8
015490B3 - 015490BC   =   9   =   9
015490BC - 015490C4   =   8   =   8
015490C4 - 015490DF   =   27   =   1B
015490DF - 015490E7   =   8   =   8
015490E7 - 015490EF   =   8   =   8
015490EF - 015490F8   =   9   =   9
015490F8 - 01549100   =   8   =   8
01549100 - 0154911B   =   27   =   1B
0154911B - 01549123   =   8   =   8
01549123 - 0154912B   =   8   =   8
0154912B - 01549134   =   9   =   9
01549134 - 0154913C   =   8   =   8
0154913C - 01549157   =   27   =   1B
01549157 - 0154915F   =   8   =   8
0154915F - 01549167   =   8   =   8
01549167 - 01549170   =   9   =   9
01549170 - 01549178   =   8   =   8
01549178 - 0154919A   =   34   =   22
0154919A - 015491A2   =   8   =   8
015491A2 - 015491AB   =   9   =   9
015491AB - 015491B3   =   8   =   8
015491B3 - 015491D6   =   35   =   23
015491D6 - 015491DE   =   8   =   8
015491DE - 015491E7   =   9   =   9
015491E7 - 015491EF   =   8   =   8
015491EF - 0154920B   =   28   =   1C
0154920B - 01549213   =   8   =   8
01549213 - 0154921B   =   8   =   8
0154921B - 01549224   =   9   =   9
01549224 - 0154922C   =   8   =   8
0154922C - 01549247   =   27   =   1B
01549247 - 0154924F   =   8   =   8
0154924F - 01549257   =   8   =   8
01549257 - 01549260   =   9   =   9
01549260 - 01549268   =   8   =   8
01549268 - 01549283   =   27   =   1B
01549283 - 0154928B   =   8   =   8
0154928B - 01549293   =   8   =   8
01549293 - 0154929C   =   9   =   9
0154929C - 015492A4   =   8   =   8
015492A4 - 015492BF   =   27   =   1B
015492BF - 015492C7   =   8   =   8
015492C7 - 015492CF   =   8   =   8
015492CF - 015492D8   =   9   =   9
015492D8 - 015492E0   =   8   =   8
015492E0 - 015492FB   =   27   =   1B
015492FB - 01549303   =   8   =   8
01549303 - 0154930B   =   8   =   8
0154930B - 01549314   =   9   =   9
01549314 - 0154931C   =   8   =   8
0154931C - 01549337   =   27   =   1B
01549337 - 0154933F   =   8   =   8
0154933F - 01549347   =   8   =   8
01549347 - 01549350   =   9   =   9
01549350 - 01549358   =   8   =   8
01549358 - 01549373   =   27   =   1B
01549373 - 0154937B   =   8   =   8
0154937B - 01549383   =   8   =   8
01549383 - 0154938C   =   9   =   9
0154938C - 01549394   =   8   =   8
01549394 - 015493AF   =   27   =   1B
015493AF - 015493B7   =   8   =   8
015493B7 - 015493BF   =   8   =   8
015493BF - 015493C8   =   9   =   9
015493C8 - 015493D0   =   8   =   8
015493D0 - 015493EB   =   27   =   1B
015493EB - 015493F3   =   8   =   8
015493F3 - 015493FB   =   8   =   8
015493FB - 01549404   =   9   =   9
01549404 - 0154940C   =   8   =   8
0154940C - 01549427   =   27   =   1B


    

Can you help me resolve this problem?

Best Regards

[.....]

I changed it in prj.conf file.

I also tried it on nRF52840 and it is in build (I tried it with different values but problem still occurs).

[.....]

I was searching for problematic code in Multi NUS, so I copied code fragments from Multi NUS project to ble_peripheral_uart sample (which were modified as I described above). So I add BT_CONN_CTX_DEF(conns, CONFIG_BT_MAX_CONN, sizeof(struct bt_nus_client)); line to ble_peripheral_uart and I replaced uart_init, gatt_discover, connected, disconnected functions in ble_peripheral_uart by their versions from Multi NUS project.

In this point transmission was OK. But when I replaced discovery_complete function, the ble_peripheral_uart project was working like multi NUS, so it was possible to connect to multiple devices, but there was also a problem with transmission.

The discovery_complete function (from Multi NUS file) gives the ability to connect multiple devices, but it also causes a delay of every fifth frame in the transmission.

Is it possible to modify this function to eliminate the transmission problem and retain the ability to connect with multiple devices?

PS: I don't need to connect with 20 devices, I only need to be able to connect with (up to) 3 devices in the same time (with data transmission in both directions).

[Einar Thorsrud]

Hi,

I am not sure I understood this experiment. The unofficial Multi NUS sample is a central, and it needs BT_CONN_CTX_DEF etc to keep track of the multiple connections. And ble_peripheral_uart is a peripheral (and single link before potential modifications). 

Could there be other things that cause problems with the scheduling? Which scan parameters are you using? The controller needs to fit both scanning and connections in, so an alternative could be to reduce the scan window and scan frequency and see if that changes aything. That can be done by populating a bt_le_scan_param struct that you refer to in the bt_scan_init_param struct you pass to scan_init() on the central side (see this post on that). 

[.....]

Hi,

I found a problem.

The problem was with this code in discovery_complete function

	int err = bt_scan_start(BT_SCAN_TYPE_SCAN_ACTIVE);
	if (err) {
		LOG_ERR("Scanning failed to start (err %d)", err);
	} else {
		LOG_INF("Scanning started");
	}

Scanning to connect to additional devices caused a delay in transmission with already connected devices.

I modified discovery_complete function in this way:

static size_t x_device = 2; // maximum number of connected devices
static size_t connected_devices = 0;

static void discovery_complete(struct bt_gatt_dm *dm,
                               void *context)
{
    struct bt_nus_client *nus = context;
    LOG_INF("Service discovery completed");

    bt_gatt_dm_data_print(dm);

    bt_nus_handles_assign(dm, nus);
    bt_nus_subscribe_receive(nus);

    bt_gatt_dm_data_release(dm);

    connected_devices++;

    if (connected_devices < x_device) {
        int err = bt_scan_start(BT_SCAN_TYPE_SCAN_ACTIVE);
        if (err) {
            LOG_ERR("Scanning failed to start (err %d)", err);
        } else {
            LOG_INF("Scanning started");
        }
    } else {
        LOG_INF("Reached the maximum number of connected devices: %d", x_device);
    }

    // Send a message to the new NUS server informing it of its ID in this mini-network
    size_t num_nus_conns = bt_conn_ctx_count(&conns_ctx_lib);
    size_t nus_index = 99;

    for (size_t i = 0; i < num_nus_conns; i++) {
        const struct bt_conn_ctx *ctx = bt_conn_ctx_get_by_id(&conns_ctx_lib, i);

        if (ctx) {
            if (ctx->data == nus) {
                nus_index = i;
                char message[3];
                sprintf(message, "%d", nus_index);
                message[2] = '\r';
                int length = 3;

                int err = bt_nus_client_send(nus, message, length);
                if (err) {
                    LOG_WRN("Failed to send data over BLE connection (err %d)", err);
                } else {
                    LOG_INF("Sent to server %d: %s", nus_index, message);
                }

                bt_conn_ctx_release(&conns_ctx_lib, (void *)ctx->data);
                break;
            } else {
                bt_conn_ctx_release(&conns_ctx_lib, (void *)ctx->data);
            }
        }
    }
}

When the central device is connected to a smaller number of devices than defined in the x_device variable, it works as before (there is a delay in every fifth frame), but when it is connected to the maximum number of devices (defined in the x_device variable), it no longer scans, and therefore there is no delay.

[Einar Thorsrud]

Hi,

Good, that confirms that scanning is the problem. Thanks for letting us know. As long as you don't need more devices, this also seems like a good fix in your case (and scanning withotu reason also waste energy). An alternative would be to look into the scannig paramters (window and interval), scanning for a smaller ammount of time, leaving more time for the connections.