Hi,
Referring to the case,
I used the peripheral_uart_coded.rar code, but when tried to flash it on the nRF5340-DK board there is an error been prompted as invalid use of undefined type 'struct bt_conn'. what might be the issue.
I'm using SDK v1.8.0 and Visual studio code.
Regards
Karthik Kumar
Hi Marte,
I'm setting the tx_power using the function,
/******************************************* TX Power*********************************************************************/
static void set_tx_power(uint8_t handle_type, uint16_t handle, int8_t tx_pwr_lvl)
{
struct bt_hci_cp_vs_write_tx_power_level *cp;
struct bt_hci_rp_vs_write_tx_power_level *rp;
struct net_buf *buf, *rsp = NULL;
int err;
buf = bt_hci_cmd_create(BT_HCI_OP_VS_WRITE_TX_POWER_LEVEL,
sizeof(*cp));
if (!buf) {
printk("Unable to allocate command buffer\n");
return;
}
cp = net_buf_add(buf, sizeof(*cp));
cp->handle = sys_cpu_to_le16(handle);
cp->handle_type = handle_type;
cp->tx_power_level = tx_pwr_lvl;
err = bt_hci_cmd_send_sync(BT_HCI_OP_VS_WRITE_TX_POWER_LEVEL,
buf, &rsp);
if (err) {
uint8_t reason = rsp ?
((struct bt_hci_rp_vs_write_tx_power_level *)
rsp->data)->status : 0;
printk("Set Tx power err: %d reason 0x%02x\n", err, reason);
return;
}
rp = (void *)rsp->data;
printk("Actual Tx Power: %d\n", rp->selected_tx_power);
net_buf_unref(rsp);
}
void main(void)
{
int8_t tx_power = 0;
int blink_status = 0;
int err = 0;
configure_gpio();
err = uart_init();
if (err) {
error();
}
bt_conn_cb_register(&conn_callbacks);
if (IS_ENABLED(CONFIG_BT_NUS_SECURITY_ENABLED)) {
bt_conn_auth_cb_register(&conn_auth_callbacks);
}
err = bt_enable(NULL);
if (err) {
error();
}
set_tx_power(BT_HCI_VS_LL_HANDLE_TYPE_ADV,0,tx_power);
LOG_INF("Bluetooth initialized");
k_sem_give(&ble_init_ok);
if (IS_ENABLED(CONFIG_SETTINGS)) {
settings_load();
}
err = bt_nus_init(&nus_cb);
if (err) {
LOG_ERR("Failed to initialize UART service (err: %d)", err);
return;
}
bt_ready();
printk("Starting Nordic UART service example c'est moi\n");
for (;;) {
dk_set_led(RUN_STATUS_LED, (++blink_status) % 2);
k_sleep(K_MSEC(RUN_LED_BLINK_INTERVAL));
/*ran_data();*/
const uint8_t sensor_data ='d';
uint16_t length = 1;
//uint32_t sd_ble_gap_rssi_start ( sd, NULL, NULL)
//uint8_tsdc_hci_cmd_sp_read_rssi(constsdc_hci_cmd_sp_read_rssi_t*p_params, sdc_hci_cmd_sp_read_rssi_return_t*p_return);
if (bt_nus_send(NULL, &sensor_data, length)) {
LOG_WRN("Failed to send data over BLE connection");
printk("Failed to send data over BLE connectionl\n");
}
}
}
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);
//struct uart_user_data *buf ;
const uint8_t sensor_data ='d';
uint16_t length = 1;
if (bt_nus_send(NULL, &sensor_data, length)) {
LOG_WRN("Failed to send data over BLE connection");
printk("Failed to send data over BLE connectionl\n");
}
k_free(buf);
}
}
K_THREAD_DEFINE(ble_write_thread_id, STACKSIZE, ble_write_thread, NULL, NULL,
NULL, PRIORITY, 0, 0);/*
* Copyright (c) 2018 Nordic Semiconductor ASA
*
* SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
*/
/** @file
* @brief Nordic UART Service Client sample
*/
/****************************Coded PHY********************************/
#include <zephyr/types.h>
#include <stddef.h>
/*********************************************************************/
#include <errno.h>
#include <zephyr.h>
#include <sys/byteorder.h>
#include <sys/printk.h>
#include <bluetooth/bluetooth.h>
#include <bluetooth/hci.h>
#include <bluetooth/conn.h>
#include <bluetooth/uuid.h>
#include <bluetooth/gatt.h>
#include <bluetooth/services/nus.h>
#include <bluetooth/services/nus_client.h>
#include <bluetooth/gatt_dm.h>
#include <bluetooth/scan.h>
#include <settings/settings.h>
#include <drivers/uart.h>
#include <logging/log.h>
#define LOG_MODULE_NAME central_uart
LOG_MODULE_REGISTER(LOG_MODULE_NAME);
/* UART payload buffer element size. */
#define UART_BUF_SIZE 20
#define KEY_PASSKEY_ACCEPT DK_BTN1_MSK
#define KEY_PASSKEY_REJECT DK_BTN2_MSK
#define NUS_WRITE_TIMEOUT K_MSEC(150)
#define UART_WAIT_FOR_BUF_DELAY K_MSEC(50)
#define UART_RX_TIMEOUT 50
static const struct device *uart;
static struct k_work_delayable uart_work;
K_SEM_DEFINE(nus_write_sem, 0, 1);
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 struct bt_conn *default_conn;
static struct bt_nus_client nus_client;
static void ble_data_sent(struct bt_nus_client *nus, uint8_t err,
const uint8_t *const data, uint16_t len)
{
ARG_UNUSED(nus);
struct uart_data_t *buf;
/* Retrieve buffer context. */
buf = CONTAINER_OF(data, struct uart_data_t, data);
k_free(buf);
k_sem_give(&nus_write_sem);
if (err) {
LOG_WRN("ATT error code: 0x%02X", err);
}
}
/****************************************Reading RSSI Value*************************************/
static void read_conn_rssi(uint16_t handle, int8_t *rssi)
{
struct net_buf *buf, *rsp = NULL;
struct bt_hci_cp_read_rssi *cp;
struct bt_hci_rp_read_rssi *rp;
int err;
buf = bt_hci_cmd_create(BT_HCI_OP_READ_RSSI, sizeof(*cp));
if (!buf) {
printk("Unable to allocate command buffer\n");
return;
}
cp = net_buf_add(buf, sizeof(*cp));
cp->handle = sys_cpu_to_le16(handle);
err = bt_hci_cmd_send_sync(BT_HCI_OP_READ_RSSI, buf, &rsp);
if (err) {
uint8_t reason = rsp ?
((struct bt_hci_rp_read_rssi *)rsp->data)->status : 0;
printk("Read RSSI err: %d reason 0x%02x\n", err, reason);
return;
}
rp = (void *)rsp->data;
*rssi = rp->rssi;
net_buf_unref(rsp);
}
/*****************************************TX Power**************************************************/
static void set_tx_power(uint8_t handle_type, uint16_t handle, int8_t tx_pwr_lvl)
{
struct bt_hci_cp_vs_write_tx_power_level *cp;
struct bt_hci_rp_vs_write_tx_power_level *rp;
struct net_buf *buf, *rsp = NULL;
int err;
buf = bt_hci_cmd_create(BT_HCI_OP_VS_WRITE_TX_POWER_LEVEL,
sizeof(*cp));
if (!buf) {
printk("Unable to allocate command buffer\n");
return;
}
cp = net_buf_add(buf, sizeof(*cp));
cp->handle = sys_cpu_to_le16(handle);
cp->handle_type = handle_type;
cp->tx_power_level = tx_pwr_lvl;
err = bt_hci_cmd_send_sync(BT_HCI_OP_VS_WRITE_TX_POWER_LEVEL,
buf, &rsp);
if (err) {
uint8_t reason = rsp ?
((struct bt_hci_rp_vs_write_tx_power_level *)
rsp->data)->status : 0;
printk("Set Tx power err: %d reason 0x%02x\n", err, reason);
return;
}
rp = (void *)rsp->data;
printk("Actual Tx Power: %d\n", rp->selected_tx_power);
net_buf_unref(rsp);
}
/****************************************Receving Data Via BLE*************************************/
static uint8_t ble_data_received(struct bt_nus_client *nus,
const uint8_t *data, uint16_t len)
{
ARG_UNUSED(nus);
int err;
int8_t rssi = 0xFF;
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");
printk("Not able to allocate UART send data buffer\n");
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++;
}
/* modifications*/
printk("\n");
//int counter_start(const struct device *dev);
//int counter_get_value(const struct device *dev, uint32_t *ticks)
//typedef uint32_t(* nrf_log_timestamp_func_t)(void);
err = uart_tx(uart, tx->data, tx->len, SYS_FOREVER_MS);
read_conn_rssi(NULL, &rssi);
printk(" RSSI: %d",rssi);
if (err) {
k_fifo_put(&fifo_uart_tx_data, tx);
}
}
return BT_GATT_ITER_CONTINUE;
}
static void uart_cb(const struct device *dev, struct uart_event *evt, void *user_data)
{
ARG_UNUSED(dev);
static uint8_t *current_buf;
static size_t aborted_len;
static bool buf_release;
struct uart_data_t *buf;
static uint8_t *aborted_buf;
switch (evt->type) {
case 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:
buf = CONTAINER_OF(evt->data.rx.buf, struct uart_data_t, data);
buf->len += evt->data.rx.len;
buf_release = false;
if (buf->len == UART_BUF_SIZE) {
k_fifo_put(&fifo_uart_rx_data, buf);
} else if ((evt->data.rx.buf[buf->len - 1] == '\n') ||
(evt->data.rx.buf[buf->len - 1] == '\r')) {
k_fifo_put(&fifo_uart_rx_data, buf);
current_buf = evt->data.rx.buf;
buf_release = true;
uart_rx_disable(uart);
}
break;
case UART_RX_DISABLED:
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_RX_TIMEOUT);
break;
case 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:
buf = CONTAINER_OF(evt->data.rx_buf.buf, struct uart_data_t,
data);
if (buf_release && (current_buf != evt->data.rx_buf.buf)) {
k_free(buf);
buf_release = false;
current_buf = NULL;
}
break;
case 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_RX_TIMEOUT);
}
static int uart_init(void)
{
int err;
struct uart_data_t *rx;
uart = device_get_binding(DT_LABEL(DT_NODELABEL(uart0)));
if (!uart) {
LOG_ERR("UART binding failed");
return -ENXIO;
}
rx = k_malloc(sizeof(*rx));
if (rx) {
rx->len = 0;
} else {
return -ENOMEM;
}
k_work_init_delayable(&uart_work, uart_work_handler);
err = uart_callback_set(uart, uart_cb, NULL);
if (err) {
return err;
}
return uart_rx_enable(uart, rx->data, sizeof(rx->data),
UART_RX_TIMEOUT);
}
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);
}
static void discovery_service_not_found(struct bt_conn *conn,
void *context)
{
LOG_INF("Service not found");
}
static void discovery_error(struct bt_conn *conn,
int err,
void *context)
{
LOG_WRN("Error while discovering GATT database: (%d)", err);
}
struct bt_gatt_dm_cb discovery_cb = {
.completed = discovery_complete,
.service_not_found = discovery_service_not_found,
.error_found = discovery_error,
};
static void gatt_discover(struct bt_conn *conn)
{
int err;
if (conn != default_conn) {
return;
}
err = bt_gatt_dm_start(conn,
BT_UUID_NUS_SERVICE,
&discovery_cb,
&nus_client);
if (err) {
LOG_ERR("could not start the discovery procedure, error "
"code: %d", err);
}
}
static void exchange_func(struct bt_conn *conn, uint8_t err, struct bt_gatt_exchange_params *params)
{
if (!err) {
LOG_INF("MTU exchange done");
} else {
LOG_WRN("MTU exchange failed (err %" PRIu8 ")", err);
}
}
static void connected(struct bt_conn *conn, uint8_t conn_err)
{
char addr[BT_ADDR_LE_STR_LEN];
int err;
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
if (conn_err) {
LOG_INF("Failed to connect to %s (%d)", log_strdup(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", log_strdup(addr));
static struct bt_gatt_exchange_params exchange_params;
exchange_params.func = exchange_func;
err = bt_gatt_exchange_mtu(conn, &exchange_params);
if (err) {
LOG_WRN("MTU exchange failed (err %d)", err);
}
err = bt_conn_set_security(conn, BT_SECURITY_L2);
if (err) {
LOG_WRN("Failed to set security: %d", err);
gatt_discover(conn);
}
err = bt_scan_stop();
if ((!err) && (err != -EALREADY)) {
LOG_ERR("Stop LE scan failed (err %d)", err);
}
}
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)", log_strdup(addr),
reason);
if (default_conn != conn) {
return;
}
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);
}
}
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", log_strdup(addr),
level);
} else {
LOG_WRN("Security failed: %s level %u err %d", log_strdup(addr),
level, err);
}
gatt_discover(conn);
}
static struct bt_conn_cb conn_callbacks = {
.connected = connected,
.disconnected = disconnected,
.security_changed = security_changed
};
/*
static void scan_filter_match(struct bt_scan_device_info *device_info,
struct bt_scan_filter_match *filter_match,
bool connectable)
{
char addr[BT_ADDR_LE_STR_LEN];
bt_addr_le_to_str(device_info->recv_info->addr, addr, sizeof(addr));
LOG_INF("Filters matched. Address: %s connectable: %d",
log_strdup(addr), connectable);
}
*/
/************************* Coded PHY************************************/
static void scan_filter_match(struct bt_scan_device_info *device_info,
struct bt_scan_filter_match *filter_match,
bool connectable)
{
int err;
char addr[BT_ADDR_LE_STR_LEN];
struct bt_conn_le_create_param *conn_params;
bt_addr_le_to_str(device_info->recv_info->addr, addr, sizeof(addr));
printk("Filters matched. Address: %s connectable: %s\n",
addr, connectable ? "yes" : "no");
err = bt_scan_stop();
if (err) {
printk("Stop LE scan failed (err %d)\n", err);
}
conn_params = BT_CONN_LE_CREATE_PARAM(
BT_CONN_LE_OPT_CODED | BT_CONN_LE_OPT_NO_1M,
BT_GAP_SCAN_FAST_INTERVAL,
BT_GAP_SCAN_FAST_INTERVAL);
err = bt_conn_le_create(device_info->recv_info->addr, conn_params,
BT_LE_CONN_PARAM_DEFAULT,
&default_conn);
if (err) {
printk("Create conn failed (err %d)\n", err);
err = bt_scan_start(BT_SCAN_TYPE_SCAN_ACTIVE);
if (err) {
printk("Scanning failed to start (err %d)\n", err);
return;
}
}
printk("Connection pending\n");
}
//BT_SCAN_CB_INIT(scan_cb, scan_filter_match, NULL, NULL, NULL);
/***********************************************************************************/
static void scan_connecting_error(struct bt_scan_device_info *device_info)
{
LOG_WRN("Connecting failed");
}
static void scan_connecting(struct bt_scan_device_info *device_info,
struct bt_conn *conn)
{
default_conn = bt_conn_ref(conn);
}
static int nus_client_init(void)
{
int err;
struct bt_nus_client_init_param init = {
.cb = {
.received = ble_data_received,
.sent = ble_data_sent,
}
};
err = bt_nus_client_init(&nus_client, &init);
if (err) {
LOG_ERR("NUS Client initialization failed (err %d)", err);
return err;
}
LOG_INF("NUS Client module initialized");
return err;
}
BT_SCAN_CB_INIT(scan_cb, scan_filter_match, NULL,
scan_connecting_error, scan_connecting);
static void scan_init(void)
{
int err;
/* Use active scanning and disable duplicate filtering to handle any
* devices that might update their advertising data at runtime. */
struct bt_le_scan_param scan_param = {
.type = BT_LE_SCAN_TYPE_ACTIVE,
.interval = BT_GAP_SCAN_FAST_INTERVAL,
.window = BT_GAP_SCAN_FAST_WINDOW,
.options = BT_LE_SCAN_OPT_CODED | BT_LE_SCAN_OPT_NO_1M
};
struct bt_scan_init_param scan_init = {
.connect_if_match = 0,
.scan_param = &scan_param,
.conn_param = NULL
};
bt_scan_init(&scan_init);
bt_scan_cb_register(&scan_cb);
err = bt_scan_filter_add(BT_SCAN_FILTER_TYPE_UUID, BT_UUID_HRS);
if (err) {
printk("Scanning filters cannot be set (err %d)\n", err);
return;
}
err = bt_scan_filter_enable(BT_SCAN_UUID_FILTER, false);
if (err) {
printk("Filters cannot be turned on (err %d)\n", err);
}
}
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", log_strdup(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", log_strdup(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_WRN("Pairing failed conn: %s, reason %d", log_strdup(addr),
reason);
}
static struct bt_conn_auth_cb conn_auth_callbacks = {
.cancel = auth_cancel,
.pairing_complete = pairing_complete,
.pairing_failed = pairing_failed
};
void main(void)
{
int err;
err = bt_conn_auth_cb_register(&conn_auth_callbacks);
if (err) {
LOG_ERR("Failed to register authorization callbacks.");
return;
}
err = bt_enable(NULL);
if (err) {
LOG_ERR("Bluetooth init failed (err %d)", err);
return;
}
LOG_INF("Bluetooth initialized");
if (IS_ENABLED(CONFIG_SETTINGS)) {
settings_load();
}
bt_conn_cb_register(&conn_callbacks);
int (*module_init[])(void) = {uart_init, scan_init, nus_client_init};
for (size_t i = 0; i < ARRAY_SIZE(module_init); i++) {
err = (*module_init[i])();
if (err) {
return;
}
}
printk("Starting Bluetooth Central UART example\n");
scan_init();
err = bt_scan_start(BT_SCAN_TYPE_SCAN_ACTIVE);
if (err) {
LOG_ERR("Scanning failed to start (err %d)", err);
return;
}
LOG_INF("Scanning successfully started");
for (;;) {
/* Wait indefinitely for data to be sent over Bluetooth */
struct uart_data_t *buf = k_fifo_get(&fifo_uart_rx_data,
K_FOREVER);
err = bt_nus_client_send(&nus_client, buf->data, buf->len);
if (err) {
LOG_WRN("Failed to send data over BLE connection"
"(err %d)", err);
}
err = k_sem_take(&nus_write_sem, NUS_WRITE_TIMEOUT);
if (err) {
LOG_WRN("NUS send timeout");
}
}
}
Hi,
Irrespective of I change values its always 0. But I wNted to set it the the maximum TX_power of nRF5340 which is 3dB.
Regards,
Karthik Kumar
I am using an idential implementation of set_tx_power, and I get the same result. Whenever I request +3 dB I get the Actual tx Power: 0 response.
I spent some time digging and I suspect the request to set +3dB is reduced to a 0 dB request by a call to hal_radio_tx_power_floor() from deep down in the guts of the bluetooth driver / subsystem
Hi,
I can confirm that I am also able to reproduce the issue, but I am still working on finding a solution. It only seems to be an issue on nRF5340 DK, as when trying the same application on a nRF52840 DK the TX power was changed from 0 to 3. Additionally, I tested the HCI Power Control sample in Zephyr, which the set_tx_power() function is originally from, and the TX power is changed successfully on nRF5340 DK using that sample.
Best regards,
Marte
Hi,
I can confirm that I am also able to reproduce the issue, but I am still working on finding a solution. It only seems to be an issue on nRF5340 DK, as when trying the same application on a nRF52840 DK the TX power was changed from 0 to 3. Additionally, I tested the HCI Power Control sample in Zephyr, which the set_tx_power() function is originally from, and the TX power is changed successfully on nRF5340 DK using that sample.
Best regards,
Marte