peripheral_uart sleep mode ncs2.3.0

[Muhammad Usman]

Hi All!

Hope you are doing well! 

I am using peripheral_uart example NCS v2.3.0,nrf52833DK, trying to enable the sleep mode. When I tested with the LED On/Off when button pressed example. It gave me 0.4562mA when wakeup and 0.017mA / 17uA when in sleep mode.

After that, I tested it with peripheral_uart example with some modifications

I added some features in the peripheral_uart example

• coded phy
• i2c for sensor communication
• timers 
• SPI for nrf21540

When I tested with these extra features, I got 1.6mA in wakeup and sleep mode 0.954mA current. Should I have to disable the above features to go into sleep mode? Any guidelines please 

My project main.c 

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

/** @file
 *  @brief Nordic UART Bridge Service (NUS) sample//i added // added from luis pc
 */
#include "uart_async_adapter.h"
//#include "nrf52.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_vs.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>
#include <zephyr/drivers/bluetooth/hci_driver.h>

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


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


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

#define SLEEP_TIME_MS 1000
#define I2C0_NODE DT_NODELABEL(mysensor)   // line added
#define my_stack_size 512
#define priority 5

uint8_t mac_address[6];

char Tx_Pwr_Nrf21540;



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 .................................




#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



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


 //BT_DATA(BT_DATA_NAME_COMPLETE, DEVICE_NAME, DEVICE_NAME_LEN),
 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),
  BT_DATA_BYTES(BT_DATA_UUID16_ALL, 0xaa, 0xfe),

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

  BT_DATA_BYTES(BT_DATA_SVC_DATA16,
      0xaa, 0xfe, /* Eddystone UUID */
      0x00, /* Eddystone-UID frame type */
      0x00, /* Calibrated Tx power at 0m */
      0x00, 0x01, 0x22, 0x33, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, /* 10-byte Namespace */
      0x0a, 0x0b, 0x0c, 0x0d, 0xee, 0x0f) /* 6-byte Instance */


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


	  
	 
};



static const struct bt_data sd[] = {
	//BT_DATA_BYTES(BT_DATA_UUID128_ALL, BT_UUID_NUS_VAL),
//BT_DATA(BT_DATA_NAME_COMPLETE, DEVICE_NAME, DEVICE_NAME_LEN)

};

#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 NRF21540.................................

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 = 17 , 0x05 = 1  ,// write command to confreg0 (1100 0000 /0xC0) , 0x7D = Tx_En =1 , Mode =0 , Tx gain 11111  

        Tx_Pwr_Nrf21540= tx_buffer[1]>>3;          //(1A) for tx gain set at the nrf21540,0x7D = 0111 1101 >>3 = 0xF
		
		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 NRF21540.................................

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

#ifdef CONFIG_UART_ASYNC_API
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);
}
#endif
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);
	}
  //  bt_ready();
	
}

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


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

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);
	//err = bt_le_ext_adv_set_data(adv, ad, ARRAY_SIZE(ad),sd, ARRAY_SIZE(sd));
	if (err) {
		printk("Failed to set advertising data (%d)\n", err);
		return err;
	}

	return 0;
}

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


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




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

	
	//................................  code added MAC Address Read ......................................

	unsigned int device_addr_0 = NRF_FICR->DEVICEADDR[0];
	unsigned int device_addr_1 = NRF_FICR->DEVICEADDR[1];
	uint8_t* part_0 = (&device_addr_0);
	uint8_t* part_1 = (&device_addr_1);

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

	configure_gpio();

#ifdef CONFIG_UART_ASYNC_API
  	err = uart_init();
	if (err) {
		error();
	}

#endif
//..................................... 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();
	}


	//................................  code added MAC Address Read ......................................

		mac_address[0] = part_1[1];
		mac_address[1] = part_1[0];
		mac_address[2] = part_0[3];
		mac_address[3] = part_0[2];
		mac_address[4] = part_0[1];
		mac_address[5] = part_0[0];

		for(int l=0; l<6; l++){
		printf("    %x :",mac_address[l]);

		}

	//................................  code added MAC Address Read ......................................


	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 .......................................................


   // read_device_serial_number();

    

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


//................................  code added TIMER for LEC & LED ......................................

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


 	//.............................. code added TIMER for LEC & LED ......................................
 
  /* 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);

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


        for(int i=0; i<buf->len; i++)
		printk("%c",buf->data[i]);
		
  //.............................  code added .................................

		//LOG_INF("Data ready to send .....\n");
		if (bt_nus_send(NULL, buf->data, buf->len)) {
			LOG_WRN("Failed to send data over BLE connection");
		}
       // LOG_INF("Data Sent **********\n");
		k_free(buf);

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


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

 

Prj.conf

#
# Copyright (c) 2018 Nordic Semiconductor
#
# SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
#
#CONFIG_GPIO=y
CONFIG_SPI=y
CONFIG_SPI_NRFX=y

#CONFIG_PM_DEVICE=y


# Enable the UART driver
#CONFIG_UART_ASYNC_API=y                    #y
#CONFIG_NRFX_UARTE0=y                        #y
#CONFIG_SERIAL=y                

CONFIG_GPIO=y

# Make sure printk is printing to the UART console
#CONFIG_CONSOLE=y                             #y 
#CONFIG_UART_CONSOLE=y                        #y              

CONFIG_I2C=y
CONFIG_NEWLIB_LIBC=y
CONFIG_NEWLIB_LIBC_FLOAT_PRINTF=y
CONFIG_CBPRINTF_FP_SUPPORT=y

CONFIG_HEAP_MEM_POOL_SIZE=2048

CONFIG_BT=y
CONFIG_BT_PERIPHERAL=y
CONFIG_BT_DEVICE_NAME="Nordic_UART_Service"
CONFIG_BT_DEVICE_APPEARANCE=833
CONFIG_BT_MAX_CONN=1
CONFIG_BT_MAX_PAIRED=1
CONFIG_BT_HCI_VS_EXT=y

# Enable the NUS service
CONFIG_BT_NUS=y

# Enable bonding
CONFIG_BT_SETTINGS=y
CONFIG_FLASH=y
CONFIG_FLASH_PAGE_LAYOUT=y
CONFIG_FLASH_MAP=y
CONFIG_NVS=y
CONFIG_SETTINGS=y

# Enable DK LED and Buttons library
CONFIG_DK_LIBRARY=y

# This example requires more workqueue stack
CONFIG_SYSTEM_WORKQUEUE_STACK_SIZE=2048

# Config logger
CONFIG_LOG=n                                       #y
#CONFIG_USE_SEGGER_RTT=y
#CONFIG_LOG_BACKEND_RTT=y                          #y
#CONFIG_LOG_BACKEND_UART=y

CONFIG_ASSERT=y

# i added these 3 lines from child image of coded phy uart pheripheral
CONFIG_BT_EXT_ADV=y
CONFIG_BT_CTLR_ADV_EXT=y
CONFIG_BT_CTLR_PHY_CODED=y

#CONFIG_BT_USER_PHY_UPDATE=y

#CONFIG_BT_LL_SW_SPLIT=y
#CONFIG_BT_CTLR=y
#CONFIG_BT_HCI=y
#CONFIG_BT=y

#CONFIG_BT_CTLR_ADVANCED_FEATURES=y

#CONFIG_BT_CTLR_CONN_RSSI=y





#CONFIG_BT_CTLR_TX_PWR_DYNAMIC_CONTROL=y
CONFIG_BT_CTLR_TX_PWR_0=y
#CONFIG_MY_CUSTOM_TX_PWR_LEVEL=8
#CONFIG_BT_USER_DATA_LEN_UPDATE=y
#CONFIG_BT_AUTO_DATA_LEN_UPDATE=y
#CONFIG_BT_L2CAP_TX_MTU=247
#CONFIG_BT_BUF_ACL_TX_SIZE=251
#CONFIG_BT_BUF_ACL_RX_SIZE=251
#CONFIG_BT_CTLR_DATA_LENGTH_MAX=251

#CONFIG_BT_CTLR_TX_PWR_MINUS_20=y
#CONFIG_BT_CTLR_TX_PWR_MINUS_4=y

#CONFIG_BT_CTLR_TX_PWR_ANTENNA=20

#CONFIG_MPSL=y
#CONFIG_MPSL_FEM=y
#CONFIG_MPSL_FEM_NRF21540_GPIO_SPI=y
#CONFIG_MPSL_FEM_NRF21540_RX_GAIN_DB=0
#CONFIG_MPSL_FEM_NRF21540_TX_GAIN_DB=20

def_conf

# SPDX-License-Identifier: Apache-2.0

CONFIG_SOC_SERIES_NRF52X=y
CONFIG_SOC_NRF52833_QIAA=y
CONFIG_BOARD_NRF52833DK_NRF52833=y

# Enable MPU
CONFIG_ARM_MPU=y

# Enable hardware stack protection
CONFIG_HW_STACK_PROTECTION=y

# Enable RTT
CONFIG_USE_SEGGER_RTT=n

# enable GPIO
CONFIG_GPIO=y

# enable uart driver
CONFIG_SERIAL=n

# enable console
CONFIG_CONSOLE=n
CONFIG_UART_CONSOLE=n

# additional board options
CONFIG_GPIO_AS_PINRESET=y

CONFIG_PINCTRL=y

Thanks & Regards,

[Bendik Heiskel]

Hi,

When measuring the current consumption is the nRF21540EK attached to the nRF52833DK? If so have you made sure that all the input pins for the nRF21540 is pulled low before entering sleep?

The sleep current of the nRF21540 can be a lot higher than what is specified in the PS if any of the input pins are pulled high:
https://infocenter.nordicsemi.com/topic/errata_nRF21540_Rev2/ERR/nRF21540/Rev2/latest/anomaly_540_13.html?cp=8_0_1_0_1_3

 

Best regards,

Bendik

[Muhammad Usman]

Hi Bendik Heiskel 

Thank you so much for the response!

Bendik Heiskel said:

When measuring the current consumption is the nRF21540EK attached to the nRF52833DK?

No, I am testing with nrf52833Dk only, nrf21540 is integrated with nrf52833 in a custom board. But SPI communication is enabled in the nrf52833DK.

One thing more i want to update is that, I am not using FEM libraries. I am directly configuring the nrf21540 registers (confreg0 and confreg1 )via SPI 

I used the following API for SPI

 pm_device_action_run(spi_dev, PM_DEVICE_ACTION_SUSPEND);

   &

 pm_device_action_run(spi_dev, PM_DEVICE_ACTION_RESUME);

After using that, the current goes down to 80uA almost from 460uA (in a connected state with the central). Will above

API will work the same way as you suggested.?

But still 80uA, now i2c pins are left, what do you suggest regarding that?

Thanks & Regards,