eddystone message at receiver andriod app nrf connect

Question

Hi All!

I am using nrf52833Dk, NCS Version 2.3.0, and Added a coded phy connectable beacon feature in the "Uart Peripheral" example . It worked fine when I tested it with another nrf52833DK.

I am sending the following Eddystone packet .But on nrf connect andriod app unable to view the Eddystone format. Andriod nrf connect app image also attached.

uint8_t  raw_adv_data[] = { 

       0x02, 0x01, 0x06,
       0x03, 0x03, 0xaa, 0xfe, 0x17, 0x16, 0xaa, 0xfe,           
       0x00, 0x12, 0xDE, 0x33,                                   
       0x00,                                                     
       0xA1,                                                    
       0x2D,0x0D,0x29,0x67,0xA1,0x31,0x6C,                      
       0xF0,                                                     //Tank Level 0
       0xAA,                                                     //Tank Level 1
       0xFF,                                                     //Vbat 
       0x00, 0x00,                                              
       0x00, 0x00                                                //Device ID B Always 0000

       
};

Nrf connect andriod app images

My main.c code is

/*
 * Copyright (c) 2018 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
 */

/** @file
 *  @brief Nordic UART Bridge Service (NUS) sample
 */
#include "uart_async_adapter.h"

#include <zephyr/types.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/uart.h>
#include <zephyr/usb/usb_device.h>

#include <zephyr/device.h>
#include <zephyr/devicetree.h>
#include <soc.h>

#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/uuid.h>
#include <zephyr/bluetooth/gatt.h>
#include <zephyr/bluetooth/hci.h>

#include <bluetooth/services/nus.h>

#include <dk_buttons_and_leds.h>

#include <zephyr/settings/settings.h>

#include <stdio.h>

#include <zephyr/logging/log.h>


#include <zephyr/drivers/gpio.h>


#include <zephyr/drivers/spi.h>
#include<zephyr/devicetree.h>
#include <zephyr/sys/printk.h>


//.............................  code added .................................
#include <zephyr/devicetree.h>
#include <zephyr/drivers/i2c.h>
#include <stdio.h>
#include "Tlv493d.h"
#include "Loading_Events.h"
#include "Timers.h"


#define SLEEP_TIME_MS 1000

#define I2C0_NODE DT_NODELABEL(mysensor)   // line added

#define my_stack_size 512
#define priority 5


//.............................  code added .................................


#define LOG_MODULE_NAME peripheral_uart
LOG_MODULE_REGISTER(LOG_MODULE_NAME,LOG_LEVEL_DBG);

#define STACKSIZE CONFIG_BT_NUS_THREAD_STACK_SIZE
#define PRIORITY 7

#define DEVICE_NAME CONFIG_BT_DEVICE_NAME
#define DEVICE_NAME_LEN	(sizeof(DEVICE_NAME) - 1)

#define RUN_STATUS_LED DK_LED1
#define RUN_LED_BLINK_INTERVAL 1000

#define CON_STATUS_LED DK_LED2

#define KEY_PASSKEY_ACCEPT DK_BTN1_MSK
#define KEY_PASSKEY_REJECT DK_BTN2_MSK

#define UART_BUF_SIZE CONFIG_BT_NUS_UART_BUFFER_SIZE
#define UART_WAIT_FOR_BUF_DELAY K_MSEC(50)
#define UART_WAIT_FOR_RX CONFIG_BT_NUS_UART_RX_WAIT_TIME

//.............................  code added .................................

#define SPI_DEV_NAME "spi_3" 
#define cs  DT_ALIAS(led1)// 11 for nrf52833
#define pdn DT_ALIAS(led2)// 28 for nrf52833

//.............................  code added .................................

static struct k_work start_advertising_worker;
static struct bt_le_ext_adv *adv;


static K_SEM_DEFINE(ble_init_ok, 0, 1);

static struct bt_conn *current_conn;
static struct bt_conn *auth_conn;

static const struct device *uart = DEVICE_DT_GET(DT_CHOSEN(nordic_nus_uart));
static struct k_work_delayable uart_work;


struct uart_data_t {
	void *fifo_reserved;
	uint8_t data[UART_BUF_SIZE];
	uint16_t len;
};

static K_FIFO_DEFINE(fifo_uart_tx_data);
static K_FIFO_DEFINE(fifo_uart_rx_data);

static const struct bt_data ad[] = {
	BT_DATA_BYTES(BT_DATA_FLAGS, (BT_LE_AD_GENERAL | BT_LE_AD_NO_BREDR)),
	BT_DATA(BT_DATA_NAME_COMPLETE, DEVICE_NAME, DEVICE_NAME_LEN),
};



static const struct bt_data sd[] = {
	BT_DATA_BYTES(BT_DATA_UUID128_ALL, BT_UUID_NUS_VAL),
};

#if CONFIG_BT_NUS_UART_ASYNC_ADAPTER
UART_ASYNC_ADAPTER_INST_DEFINE(async_adapter);
#else
static const struct device *const async_adapter;
#endif



///////////////////////////////  code added /////////////////////////////////////////

const struct device * spi_dev;
static struct spi_config spi_cfg = {
	.operation = SPI_WORD_SET(8)
	         | SPI_OP_MODE_MASTER
             | SPI_TRANSFER_MSB
            // | SPI_MODE_CPOL
            // | SPI_MODE_CPHA
             ,
	.frequency = 4000000,
	.slave = 0,
	//.cs=NULL,
};
static const struct gpio_dt_spec cs_low = GPIO_DT_SPEC_GET(cs, gpios);
static const struct gpio_dt_spec pdn_high = GPIO_DT_SPEC_GET(pdn, gpios);
static struct spi_buf rx;
const struct spi_buf_set rx_bufs = {
	.buffers = &rx,
	.count = 1
};

static struct spi_buf tx;
const struct spi_buf_set tx_bufs = {
	.buffers = &tx,
	.count = 1
};

static void spi_init(void)
{
	spi_dev = device_get_binding(SPI_DEV_NAME);

    // code added 
	   if (!spi_dev) {
        printk("SPI device not found\n");
        return;
    }

}


void Nrf21540_Write_Register()
{
		int err,ret;

	static uint8_t tx_buffer[2] = {0xC0, 0x7D};   //  0x7D = 31 ,0x45 = 11 , 0x05  ,// write command to confreg0 (1100 0000 /0xC0) , 0x7D = Tx_En =1 , Mode =0 , Tx gain 11111  

		tx.buf = tx_buffer;
		tx.len = sizeof(tx_buffer);

		static uint8_t rx_buffer[2];
		rx.buf = rx_buffer;
		rx.len = sizeof(rx_buffer);


		ret = gpio_pin_set_dt(&cs_low,0);  // low
			if (ret < 0) {
				return;
			}
	
//err = spi_transceive(spi_dev, &spi_cfg, &tx_bufs, &rx_bufs);   //rx_bufs
	err =  spi_write(spi_dev,&spi_cfg,&tx_bufs);
			if (err < 0) {
				printf("SPI error: %d\n", err);
			} else {
			

	   printf("write successfully : %d\n", err);
		for (int i = 0; i <2; i++){
			printf(" %x",rx_buffer[i]);
			
		}

    printf("\n");
	
	}

    ret = gpio_pin_set_dt(&cs_low,1);   // high
		if (ret < 0) {
			return;
		}
   

}

void Nrf21540_Read_Register()
{
    int err,ret;
    static uint8_t tx_buffer[2] = {0x80, 0x00};   //  0x80 for reading register confreg0 ,0x8 1000 0000 for reading 

    tx.buf = tx_buffer;
	tx.len = sizeof(tx_buffer);

	static uint8_t rx_buffer[2];
	rx.buf = rx_buffer;
	rx.len = sizeof(rx_buffer);

    ret = gpio_pin_set_dt(&cs_low,0);  // low
		if (ret < 0) {
			return;
		}
  
err = spi_transceive(spi_dev, &spi_cfg, &tx_bufs, &rx_bufs);   //rx_bufs
    
 //err =  spi_write(spi_dev,&spi_cfg,&tx_bufs);

//err =  spi_read(spi_dev,&spi_cfg,&rx_bufs);

	if (err < 0) {
		printk("SPI error: %d\n", err);
	} else if (err==0){
	
	    printf("Read successfully : %d\n", err);
		for (int i = 0; i <2; i++){
			printf(" %x",rx_buffer[i]);
		
		}
    printf("\n");
	}

  
    ret = gpio_pin_set_dt(&cs_low,1);   // high
		if (ret < 0) {
			return;
		}
   
  
 
}
///////////////////////////////  code added ///////////////////////////////////
static void uart_cb(const struct device *dev, struct uart_event *evt, void *user_data)
{
	ARG_UNUSED(dev);

	static size_t aborted_len;
	struct uart_data_t *buf;
	static uint8_t *aborted_buf;
	static bool disable_req;

	switch (evt->type) {
	case UART_TX_DONE:
		LOG_DBG("UART_TX_DONE");
		if ((evt->data.tx.len == 0) ||
		    (!evt->data.tx.buf)) {
			return;
		}

		if (aborted_buf) {
			buf = CONTAINER_OF(aborted_buf, struct uart_data_t,
					   data);
			aborted_buf = NULL;
			aborted_len = 0;
		} else {
			buf = CONTAINER_OF(evt->data.tx.buf, struct uart_data_t,
					   data);
		}

		k_free(buf);

		buf = k_fifo_get(&fifo_uart_tx_data, K_NO_WAIT);
		if (!buf) {
			return;
		}

		if (uart_tx(uart, buf->data, buf->len, SYS_FOREVER_MS)) {
			LOG_WRN("Failed to send data over UART");
		}

		break;

	case UART_RX_RDY:
		LOG_DBG("UART_RX_RDY");
		buf = CONTAINER_OF(evt->data.rx.buf, struct uart_data_t, data);
		buf->len += evt->data.rx.len;

		if (disable_req) {
			return;
		}

		if ((evt->data.rx.buf[buf->len - 1] == '\n') ||
		    (evt->data.rx.buf[buf->len - 1] == '\r')) {
			disable_req = true;
			uart_rx_disable(uart);
		}

		break;

	case UART_RX_DISABLED:
		LOG_DBG("UART_RX_DISABLED");
		disable_req = false;

		buf = k_malloc(sizeof(*buf));
		if (buf) {
			buf->len = 0;
		} else {
			LOG_WRN("Not able to allocate UART receive buffer");
			k_work_reschedule(&uart_work, UART_WAIT_FOR_BUF_DELAY);
			return;
		}

		uart_rx_enable(uart, buf->data, sizeof(buf->data),
			       UART_WAIT_FOR_RX);

		break;

	case UART_RX_BUF_REQUEST:
		LOG_DBG("UART_RX_BUF_REQUEST");
		buf = k_malloc(sizeof(*buf));
		if (buf) {
			buf->len = 0;
			uart_rx_buf_rsp(uart, buf->data, sizeof(buf->data));
		} else {
			LOG_WRN("Not able to allocate UART receive buffer");
		}

		break;

	case UART_RX_BUF_RELEASED:
		LOG_DBG("UART_RX_BUF_RELEASED");
		buf = CONTAINER_OF(evt->data.rx_buf.buf, struct uart_data_t,
				   data);

		if (buf->len > 0) {
			k_fifo_put(&fifo_uart_rx_data, buf);
		} else {
			k_free(buf);
		}

		break;

	case UART_TX_ABORTED:
		LOG_DBG("UART_TX_ABORTED");
		if (!aborted_buf) {
			aborted_buf = (uint8_t *)evt->data.tx.buf;
		}

		aborted_len += evt->data.tx.len;
		buf = CONTAINER_OF(aborted_buf, struct uart_data_t,
				   data);

		uart_tx(uart, &buf->data[aborted_len],
			buf->len - aborted_len, SYS_FOREVER_MS);

		break;

	default:
		break;
	}
}

static void uart_work_handler(struct k_work *item)
{
	struct uart_data_t *buf;

	buf = k_malloc(sizeof(*buf));
	if (buf) {
		buf->len = 0;
	} else {
		LOG_WRN("Not able to allocate UART receive buffer");
		k_work_reschedule(&uart_work, UART_WAIT_FOR_BUF_DELAY);
		return;
	}

	uart_rx_enable(uart, buf->data, sizeof(buf->data), UART_WAIT_FOR_RX);
}

static bool uart_test_async_api(const struct device *dev)
{
	const struct uart_driver_api *api =
			(const struct uart_driver_api *)dev->api;

	return (api->callback_set != NULL);
}

static int uart_init(void)
{
	int err;
	int pos;
	struct uart_data_t *rx;
	struct uart_data_t *tx;

	if (!device_is_ready(uart)) {
		return -ENODEV;
	}

	if (IS_ENABLED(CONFIG_USB_DEVICE_STACK)) {
		err = usb_enable(NULL);
		if (err) {
			LOG_ERR("Failed to enable USB");
			return err;
		}
	}

	rx = k_malloc(sizeof(*rx));
	if (rx) {
		rx->len = 0;
	} else {
		return -ENOMEM;
	}

	k_work_init_delayable(&uart_work, uart_work_handler);


	if (IS_ENABLED(CONFIG_BT_NUS_UART_ASYNC_ADAPTER) && !uart_test_async_api(uart)) {
		/* Implement API adapter */
		uart_async_adapter_init(async_adapter, uart);
		uart = async_adapter;
	}

	err = uart_callback_set(uart, uart_cb, NULL);
	if (err) {
		LOG_ERR("Cannot initialize UART callback");
		return err;
	}

	if (IS_ENABLED(CONFIG_UART_LINE_CTRL)) {
		LOG_INF("Wait for DTR");
		while (true) {
			uint32_t dtr = 0;

			uart_line_ctrl_get(uart, UART_LINE_CTRL_DTR, &dtr);
			if (dtr) {
				break;
			}
			/* Give CPU resources to low priority threads. */
			k_sleep(K_MSEC(100));
		}
		LOG_INF("DTR set");
		err = uart_line_ctrl_set(uart, UART_LINE_CTRL_DCD, 1);
		if (err) {
			LOG_WRN("Failed to set DCD, ret code %d", err);
		}
		err = uart_line_ctrl_set(uart, UART_LINE_CTRL_DSR, 1);
		if (err) {
			LOG_WRN("Failed to set DSR, ret code %d", err);
		}
	}

	tx = k_malloc(sizeof(*tx));

	if (tx) {
		pos = snprintf(tx->data, sizeof(tx->data),
			       "Starting Nordic UART service example\r\n");
			

		if ((pos < 0) || (pos >= sizeof(tx->data))) {
			k_free(tx);
			LOG_ERR("snprintf returned %d", pos);
			return -ENOMEM;
		}

		tx->len = pos;
	} else {
		return -ENOMEM;
	}

	err = uart_tx(uart, tx->data, tx->len, SYS_FOREVER_MS);
	if (err) {
		LOG_ERR("Cannot display welcome message (err: %d)", err);
		return err;
	}

	return uart_rx_enable(uart, rx->data, sizeof(rx->data), 50);
}

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

	current_conn = bt_conn_ref(conn);

	dk_set_led_on(CON_STATUS_LED);
}

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

#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,
#ifdef CONFIG_BT_NUS_SECURITY_ENABLED
	.security_changed = security_changed,
#endif
};

#if defined(CONFIG_BT_NUS_SECURITY_ENABLED)
static void auth_passkey_display(struct bt_conn *conn, unsigned int passkey)
{
	char addr[BT_ADDR_LE_STR_LEN];

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

	LOG_INF("Passkey for %s: %06u", addr, passkey);
}

static void auth_passkey_confirm(struct bt_conn *conn, unsigned int passkey)
{
	char addr[BT_ADDR_LE_STR_LEN];

	auth_conn = bt_conn_ref(conn);

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

	LOG_INF("Passkey for %s: %06u", addr, passkey);
	LOG_INF("Press Button 1 to confirm, Button 2 to reject.");
}


static void auth_cancel(struct bt_conn *conn)
{
	char addr[BT_ADDR_LE_STR_LEN];

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

	LOG_INF("Pairing cancelled: %s", addr);
}


static void pairing_complete(struct bt_conn *conn, bool bonded)
{
	char addr[BT_ADDR_LE_STR_LEN];

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

	LOG_INF("Pairing completed: %s, bonded: %d", addr,
		bonded);
}


static void pairing_failed(struct bt_conn *conn, enum bt_security_err reason)
{
	char addr[BT_ADDR_LE_STR_LEN];

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

	LOG_INF("Pairing failed conn: %s, reason %d", addr,
		reason);
}


static struct bt_conn_auth_cb conn_auth_callbacks = {
	.passkey_display = auth_passkey_display,
	.passkey_confirm = auth_passkey_confirm,
	.cancel = auth_cancel,
};

static struct bt_conn_auth_info_cb conn_auth_info_callbacks = {
	.pairing_complete = pairing_complete,
	.pairing_failed = pairing_failed
};
#else
static struct bt_conn_auth_cb conn_auth_callbacks;
#endif

static void bt_receive_cb(struct bt_conn *conn, const uint8_t *const data,
			  uint16_t len)
{
	int err;
	char addr[BT_ADDR_LE_STR_LEN] = {0};

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

	LOG_INF("Received data from: %s", addr);

	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;
		}

		/* 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++;
		}

		err = uart_tx(uart, tx->data, tx->len, SYS_FOREVER_MS);
		if (err) {
			k_fifo_put(&fifo_uart_tx_data, tx);
		}
	}
}

static struct bt_nus_cb nus_cb = {
	.received = bt_receive_cb,
};

void error(void)
{
	dk_set_leds_state(DK_ALL_LEDS_MSK, DK_NO_LEDS_MSK);

	while (true) {
		/* Spin for ever */
		k_sleep(K_MSEC(1000));
	}
}

#ifdef CONFIG_BT_NUS_SECURITY_ENABLED
static void num_comp_reply(bool accept)
{
	if (accept) {
		bt_conn_auth_passkey_confirm(auth_conn);
		LOG_INF("Numeric Match, conn %p", (void *)auth_conn);
	} else {
		bt_conn_auth_cancel(auth_conn);
		LOG_INF("Numeric Reject, conn %p", (void *)auth_conn);
	}

	bt_conn_unref(auth_conn);
	auth_conn = NULL;
}

void button_changed(uint32_t button_state, uint32_t has_changed)
{
	uint32_t buttons = button_state & has_changed;

	if (auth_conn) {
		if (buttons & KEY_PASSKEY_ACCEPT) {
			num_comp_reply(true);
		}

		if (buttons & KEY_PASSKEY_REJECT) {
			num_comp_reply(false);
		}
	}
}
#endif /* CONFIG_BT_NUS_SECURITY_ENABLED */

static void configure_gpio(void)
{
	int err;

#ifdef CONFIG_BT_NUS_SECURITY_ENABLED
	err = dk_buttons_init(button_changed);
	if (err) {
		LOG_ERR("Cannot init buttons (err: %d)", err);
	}
#endif /* CONFIG_BT_NUS_SECURITY_ENABLED */

	err = dk_leds_init();
	if (err) {
		LOG_ERR("Cannot init LEDs (err: %d)", err);
	}
}

static void start_advertising_coded(struct k_work *item)
{
	int err;

	err = bt_le_ext_adv_start(adv, NULL);
	if (err) {
		printk("Failed to start advertising set (%d)\n", err);
		return;
	}

	printk("Advertiser %p set started\n", adv);
}


static int create_advertising_coded(void)
{
	
	int err;
	struct bt_le_adv_param param =
		BT_LE_ADV_PARAM_INIT(BT_LE_ADV_OPT_CONNECTABLE |
				     BT_LE_ADV_OPT_EXT_ADV |
					 BT_LE_ADV_OPT_USE_TX_POWER |
				     BT_LE_ADV_OPT_CODED,
				     BT_GAP_ADV_FAST_INT_MIN_2,
				     BT_GAP_ADV_FAST_INT_MAX_2,
				     NULL);

	err = bt_le_ext_adv_create(&param, NULL, &adv);
	
	if (err) {
		printk("Failed to create advertiser set (%d)\n", err);
		return err;
	}

	printk("Created adv: %p\n", adv);

	err = bt_le_ext_adv_set_data(adv, ad, ARRAY_SIZE(ad), NULL, 0);
	if (err) {
		printk("Failed to set advertising data (%d)\n", err);
		return err;
	}

	return 0;
}
static void bt_ready(void)
{
	int err = 0;

	printk("Bluetooth initialized\n");

	k_work_init(&start_advertising_worker, start_advertising_coded);

	err = create_advertising_coded();
	
	if (err) {
		printk("Advertising failed to create (err %d)\n", err);
		return;
	}

	k_work_submit(&start_advertising_worker);
}

//static const struct gpio_dt_spec pdn_high = GPIO_DT_SPEC_GET(pdn, gpios);



//.............................  code added .................................

static const struct i2c_dt_spec dev_i2c = I2C_DT_SPEC_GET(I2C0_NODE);


//struct k_timer my_timer;     // timer struct defined 

//struct k_work_q tlv493d_work_q;


extern float * Average_Values;
extern float  AverageX,AverageY;

extern void mytimer_cb(struct k_timer *dummy);

extern void tlv493D_work_cb(struct k_work_q * work);


K_WORK_DEFINE(tlv493d_work,tlv493D_work_cb);
K_TIMER_DEFINE(my_timer,mytimer_cb,NULL);

//.............................  code added .................................


void main(void)
{
	int blink_status = 0;
	int err = 0;
	int ret;

	configure_gpio();


  	err = uart_init();
	if (err) {
		error();
	}


//..................................... code added .......................................................


    spi_init();

	if (!device_is_ready(cs_low.port)) {
		return;
	}

	ret = gpio_pin_configure_dt(&cs_low, GPIO_OUTPUT_ACTIVE);
	ret = gpio_pin_configure_dt(&pdn_high ,GPIO_OUTPUT_ACTIVE);
	if (ret < 0) {
		return;
	}

	
 ret = gpio_pin_set_dt(&pdn_high,1);  // 0.28 nrf21540 always high 
		if (ret < 0) {
			return;
		}	

        else
         printk("PDN high at start up ...\n");

  
 //..................................... code added .......................................................
 


 
	if (IS_ENABLED(CONFIG_BT_NUS_SECURITY_ENABLED)) {
		err = bt_conn_auth_cb_register(&conn_auth_callbacks);
		if (err) {
			printk("Failed to register authorization callbacks.\n");
			return;
		}

		err = bt_conn_auth_info_cb_register(&conn_auth_info_callbacks);
		if (err) {
			printk("Failed to register authorization info callbacks.\n");
			return;
		}
	}

	err = bt_enable(NULL);
	if (err) {
		error();
	}

	LOG_INF("Bluetooth initialized");

	k_sem_give(&ble_init_ok);

	


	if (IS_ENABLED(CONFIG_SETTINGS)) {
		settings_load();
	}

   bt_ready();

	err = bt_nus_init(&nus_cb);
	if (err) {
		LOG_ERR("Failed to initialize UART service (err: %d)", err);
		return;
	}


	/*err = bt_le_adv_start(BT_LE_ADV_CONN, ad, ARRAY_SIZE(ad), sd,
			      ARRAY_SIZE(sd));
	if (err) {
		LOG_ERR("Advertising failed to start (err %d)", err);
		printk("Advertising failed to start (err %d)", err);
		return;
	}

	*/
//..................................... code added .......................................................

    Nrf21540_Write_Register();
	
    k_msleep(100);

    Nrf21540_Read_Register();
      
     k_msleep(100);
  
  //.............................  code added .................................



	if(!device_is_ready(dev_i2c.bus)){	

		printf("i2c_dev not ready\n");
		return;


	}

 /* ret = i2c_reg_write_byte_dt(&dev_i2c,0x00,0x01);   // added 7/12/2023
	if(ret != 0){
	printk("Failed to write/read I2C device address %x at Reg. %x \r\n", dev_i2c.addr,0x00);
    }
*/

k_timer_start(&my_timer,K_SECONDS(5),K_SECONDS(1));

  
  /* Average_Values= Read_Sensor_Calc_Average(); 
   AverageX= *(Average_Values); 
   AverageY= *(Average_Values+1); 


  Raw_Avg_Data_To_Angle(AverageX , AverageY);
*/
    
 // k_msleep(SLEEP_TIME_MS);
	//.............................  code added .................................

	  
//..................................... code added .......................................................    
/*	for (;;) {
	//	dk_set_led(led0, (++blink_status) % 2);
		k_sleep(K_MSEC(RUN_LED_BLINK_INTERVAL));

	

	  
	}

	*/
}

void ble_write_thread(void)
{
	/* Don't go any further until BLE is initialized */
	k_sem_take(&ble_init_ok, K_FOREVER);

	for (;;) {
		/* Wait indefinitely for data to be sent over bluetooth */
		struct uart_data_t *buf = k_fifo_get(&fifo_uart_rx_data,
						     K_FOREVER);

        for(int i=0; i<buf->len; i++)
		printk("%c",buf->data[i]);
		
		if (bt_nus_send(NULL, buf->data, buf->len)) {
			LOG_WRN("Failed to send data over BLE connection");
		}

		k_free(buf);

	}
}

K_THREAD_DEFINE(ble_write_thread_id, STACKSIZE, ble_write_thread, NULL, NULL,
		NULL, PRIORITY, 0, 0);

code for sending the packet

   error1=bt_nus_send(NULL,raw_adv_data,sizeof(raw_adv_data));
   if(error1<0) {
		//LOG_WRN("Failed to send data over BLE connection");
    printf("Failed to send data over BLE connection, error is for DK is ... %d", error1);
    //  LOG_WRN("Failed to set DSR, ret code %d", error1);

		}

Can you please help me with what I am doing wrong?

Thanks & Regards,

Muhammad Usman

Sigurd · Accepted Answer

Hi, 
 bt_nus_send() is for sending packets to a connected device. While what you are seeing in nRF connect android pictures are the advertising packets , i.e. two different things.

eddystone message at receiver andriod app nrf connect

Top Replies