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(¶m, 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