I have written the code to test the RSSI signal, and the segger shows the result on the debug terminal, However, the debug terminal can only show first 500 data, the first 500 will be erased as the time goes by. I want to save more than 10 thousands data via Tera term. Then I combine the uart with my code. I have add the directories of UART header files. The header files regarding UART are added to my RSSI code. Here are output results.
It shows somethings are wrong with log.h, and I am afraid of changing anything in log.h. There is one thing wrong in main.c, shown as follows, please help me? I have been stuck in this for a month. How is the problem fixed? thank you
#include <stdio.h>
#include "nrf_delay.h"
#include "nrf_gpio.h"
#include "ble.h"
#include "boards.h"
#include "simple_hal.h"
#include "nrf_mesh.h"
#include "log.h"
#include "advertiser.h"
#include "mesh_app_utils.h"
#include "mesh_stack.h"
#include "ble_softdevice_support.h"
#include "mesh_provisionee.h"
#include "nrf_mesh_config_examples.h"
#include "app_timer.h"
#include "example_common.h"
#include "nrf_mesh_configure.h"
#include "ad_type_filter.h"
#include "app_uart.h"
#include <stdint.h>//below is uart header files
#include <string.h>
#include "nordic_common.h"
#include "nrf.h"
#include "ble_hci.h"
#include "ble_advdata.h"
#include "ble_advertising.h"
#include "ble_conn_params.h"
#include "nrf_sdh.h"
#include "nrf_sdh_soc.h"
#include "nrf_sdh_ble.h"
#include "nrf_ble_gatt.h"
#include "nrf_ble_qwr.h"
#include "app_timer.h"
#include "ble_nus.h"
#include "app_util_platform.h"
#include "nrf_uart.h"
#include "nrf_atflags.h"
#define UART_TX_BUF_SIZE 256 /**< UART TX buffer size. */
#define UART_RX_BUF_SIZE 256
#define NRF_LOG_DEBUG(...)
#define NRF_LOG_HEXDUMP_DEBUG(p_data, len)
BLE_NUS_DEF(m_nus, NRF_SDH_BLE_TOTAL_LINK_COUNT);
static uint16_t m_conn_handle = BLE_CONN_HANDLE_INVALID;
#if defined(NRF51) && defined(NRF_MESH_STACK_DEPTH)
#include "stack_depth.h"
#endif
/*****************************************************************************
* Definitions
*****************************************************************************/
#define ADVERTISER_BUFFER_SIZE (64)
/*****************************************************************************
* Forward declaration of static functions
*****************************************************************************/
/*****************************************************************************
* Static variables
*****************************************************************************/
/** Single advertiser instance. May periodically transmit one packet at a time. */
static advertiser_t m_advertiser;
static uint16_t m_ble_nus_max_data_len = BLE_GATT_ATT_MTU_DEFAULT - 3;
static uint8_t m_adv_buffer[ADVERTISER_BUFFER_SIZE];
static bool m_device_provisioned;
//modify
uint8_t adv_addr[BLE_GAP_ADDR_LEN];
static uint8_t scan_rssi;
void uart_event_handle(app_uart_evt_t * p_event)
{
static uint8_t data_array[BLE_NUS_MAX_DATA_LEN];
static uint8_t index = 0;
uint32_t err_code;
switch (p_event->evt_type)
{
case APP_UART_DATA_READY:
UNUSED_VARIABLE(app_uart_get(&data_array[index]));
index++;
if ((data_array[index - 1] == '\n') ||
(data_array[index - 1] == '\r') ||
(index >= m_ble_nus_max_data_len))
{
if (index > 1)
{
NRF_LOG_DEBUG("Ready to send data over BLE NUS");
NRF_LOG_HEXDUMP_DEBUG(data_array, index);
do
{
uint16_t length = (uint16_t)index;
err_code = ble_nus_data_send(&m_nus, data_array, &length, m_conn_handle);
if ((err_code != NRF_ERROR_INVALID_STATE) &&
(err_code != NRF_ERROR_RESOURCES) &&
(err_code != NRF_ERROR_NOT_FOUND))
{
APP_ERROR_CHECK(err_code);
}
} while (err_code == NRF_ERROR_RESOURCES);
}
index = 0;
}
break;
case APP_UART_COMMUNICATION_ERROR:
APP_ERROR_HANDLER(p_event->data.error_communication);
break;
case APP_UART_FIFO_ERROR:
APP_ERROR_HANDLER(p_event->data.error_code);
break;
default:
break;
}
}
static void adv_start(void)
{
/* Let scanner accept Complete Local Name AD Type. */
bearer_adtype_add(BLE_GAP_AD_TYPE_COMPLETE_LOCAL_NAME);
advertiser_enable(&m_advertiser);
// static const uint8_t adv_data[] =
// {
// 0x11, /* AD data length (including type, but not itself) */
// BLE_GAP_AD_TYPE_COMPLETE_LOCAL_NAME, /* AD data type (Complete local name) */
// 'N', /* AD data payload (Name of device) */
// 'o',
// 'r',
// 'd',
// 'i',
// 'c',
// ' ',
// 'S',
// 'e',
// 'm',
// 'i',
// ' ',
// 'M',
// 'e',
// 's',
// 'h'
// };
uint8_t adv_data[]=
{
0x02, /* AD data length (including type, but not itself) */
BLE_GAP_AD_TYPE_COMPLETE_LOCAL_NAME, /* AD data type (Complete local name) */
scan_rssi,
};
adv_data[2]=scan_rssi;
/* Allocate packet */
adv_packet_t * p_packet = advertiser_packet_alloc(&m_advertiser, sizeof(adv_data));
if(p_packet)
{
/* Construct packet contents */
memcpy(p_packet->packet.payload, adv_data, sizeof(adv_data));
/* Repeat forever */
p_packet->config.repeats = ADVERTISER_REPEAT_INFINITE;
advertiser_packet_send(&m_advertiser, p_packet);
//modify
//advertiser_packet_discard(&m_advertiser,p_packet);
//
// char advdata[128];
//
// (void) sprintf(advdata, "adv %d",adv_data[2]);
// __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, advdata);
for(int i=0;i<BLE_GAP_ADDR_LEN;i++)
adv_addr[i]= p_packet->packet.addr[i];
}
}
static void rx_cb(const nrf_mesh_adv_packet_rx_data_t * p_rx_data)
{
LEDS_OFF(BSP_LED_0_MASK); /* @c LED_RGB_RED_MASK on pca10031 */
char msg[128];
char data[128];
// (void) sprintf(msg, "RX [@%u]: RSSI: %3d ADV TYPE: %x ADDR: [%02x:%02x:%02x:%02x:%02x:%02x]",
// p_rx_data->p_metadata->params.scanner.timestamp,
// p_rx_data->p_metadata->params.scanner.rssi,
// p_rx_data->adv_type,
// p_rx_data->p_metadata->params.scanner.adv_addr.addr[0],
// p_rx_data->p_metadata->params.scanner.adv_addr.addr[1],
// p_rx_data->p_metadata->params.scanner.adv_addr.addr[2],
// p_rx_data->p_metadata->params.scanner.adv_addr.addr[3],
// p_rx_data->p_metadata->params.scanner.adv_addr.addr[4],
// p_rx_data->p_metadata->params.scanner.adv_addr.addr[5]);
scan_rssi=(uint8_t)abs( p_rx_data->p_metadata->params.scanner.rssi);
(void) sprintf(data, "adv:[%02x:%02x] scan:[%02x:%02x] ch:%d rssi=%3d",
adv_addr[0],
adv_addr[1],
p_rx_data->p_metadata->params.scanner.adv_addr.addr[0],
p_rx_data->p_metadata->params.scanner.adv_addr.addr[1],
p_rx_data->p_metadata->params.scanner.channel,
p_rx_data->p_metadata->params.scanner.rssi
);
//printf("adv ADDR: [%02x:%02x:%02x:%02x:%02x:%02x] ",adv_addr[0],adv_addr[1],adv_addr[2],adv_addr[3],adv_addr[4],adv_addr[5]);
__LOG_XB(LOG_SRC_APP, LOG_LEVEL_INFO, data, p_rx_data->p_payload, p_rx_data->length);
//__LOG_XB(LOG_SRC_APP, LOG_LEVEL_INFO, msg, p_rx_data->p_payload, p_rx_data->length);
LEDS_ON(BSP_LED_0_MASK); /* @c LED_RGB_RED_MASK on pca10031 */
}
static void adv_init(void)
{
ret_code_t err_code;
advertiser_instance_init(&m_advertiser, NULL, m_adv_buffer, ADVERTISER_BUFFER_SIZE);
//modify tx power
//err_code = sd_ble_gap_tx_power_set(BLE_GAP_TX_POWER_ROLE_ADV, m_advertiser.handle, 4);
//APP_ERROR_CHECK(err_code);
}
static void node_reset(void)
{
__LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "----- Node reset -----\n");
hal_led_blink_ms(LEDS_MASK, LED_BLINK_INTERVAL_MS, LED_BLINK_CNT_RESET);
/* This function may return if there are ongoing flash operations. */
mesh_stack_device_reset();
}
static void config_server_evt_cb(const config_server_evt_t * p_evt)
{
if (p_evt->type == CONFIG_SERVER_EVT_NODE_RESET)
{
node_reset();
}
}
static void device_identification_start_cb(uint8_t attention_duration_s)
{
hal_led_mask_set(LEDS_MASK, false);
hal_led_blink_ms(BSP_LED_2_MASK | BSP_LED_3_MASK,
LED_BLINK_ATTENTION_INTERVAL_MS,
LED_BLINK_ATTENTION_COUNT(attention_duration_s));
}
static void provisioning_aborted_cb(void)
{
hal_led_blink_stop();
}
static void unicast_address_print(void)
{
dsm_local_unicast_address_t node_address;
dsm_local_unicast_addresses_get(&node_address);
__LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Node Address: 0x%04x \n", node_address.address_start);
}
static void provisioning_complete_cb(void)
{
__LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Successfully provisioned\n");
unicast_address_print();
hal_led_blink_stop();
hal_led_mask_set(LEDS_MASK, LED_MASK_STATE_OFF);
hal_led_blink_ms(LEDS_MASK, LED_BLINK_INTERVAL_MS, LED_BLINK_CNT_PROV);
}
static void mesh_init(void)
{
mesh_stack_init_params_t init_params =
{
.core.irq_priority = NRF_MESH_IRQ_PRIORITY_LOWEST,
.core.lfclksrc = DEV_BOARD_LF_CLK_CFG,
.models.config_server_cb = config_server_evt_cb
};
uint32_t status = mesh_stack_init(&init_params, &m_device_provisioned);
switch (status)
{
case NRF_ERROR_INVALID_DATA:
__LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Data in the persistent memory was corrupted. Device starts as unprovisioned.\n");
__LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Reset device before starting of the provisioning process.\n");
break;
case NRF_SUCCESS:
break;
default:
ERROR_CHECK(status);
}
/* Start listening for incoming packets */
nrf_mesh_rx_cb_set(rx_cb);
/* Initialize the advertiser */
adv_init();
}
static void initialize(void)
{
#if defined(NRF51) && defined(NRF_MESH_STACK_DEPTH)
stack_depth_paint_stack();
#endif
ERROR_CHECK(app_timer_init());
hal_leds_init();
__LOG_INIT(LOG_SRC_APP, LOG_LEVEL_INFO, log_callback_rtt);
__LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "----- Bluetooth Mesh Beacon Example -----\n");
ble_stack_init();
mesh_init();
__LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Initialization complete!\n");
}
static void start(void)
{
if (!m_device_provisioned)
{
static const uint8_t static_auth_data[NRF_MESH_KEY_SIZE] = STATIC_AUTH_DATA;
mesh_provisionee_start_params_t prov_start_params =
{
.p_static_data = static_auth_data,
.prov_complete_cb = provisioning_complete_cb,
.prov_device_identification_start_cb = device_identification_start_cb,
.prov_device_identification_stop_cb = NULL,
.prov_abort_cb = provisioning_aborted_cb,
.p_device_uri = EX_URI_BEACON
};
ERROR_CHECK(mesh_provisionee_prov_start(&prov_start_params));
}
else
{
unicast_address_print();
}
/* Start advertising own beacon */
/* Note: If application wants to start beacons at later time, adv_start() API must be called
* from the same IRQ priority context same as that of the Mesh Stack. */
adv_start();
mesh_app_uuid_print(nrf_mesh_configure_device_uuid_get());
ERROR_CHECK(mesh_stack_start());
__LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Bluetooth Mesh Beacon example started!\n");
hal_led_mask_set(LEDS_MASK, LED_MASK_STATE_OFF);
hal_led_blink_ms(LEDS_MASK, LED_BLINK_INTERVAL_MS, LED_BLINK_CNT_START);
}
static void uart_init(void)
{
ret_code_t err_code;
app_uart_comm_params_t const comm_params =
{
.rx_pin_no = RX_PIN_NUMBER,
.tx_pin_no = TX_PIN_NUMBER,
.rts_pin_no = RTS_PIN_NUMBER,
.cts_pin_no = CTS_PIN_NUMBER,
.flow_control = APP_UART_FLOW_CONTROL_DISABLED,
.use_parity = false,
.baud_rate = UART_BAUDRATE_BAUDRATE_Baud115200
};
APP_UART_FIFO_INIT(&comm_params,
UART_RX_BUF_SIZE,
UART_TX_BUF_SIZE,
uart_event_handle,
APP_IRQ_PRIORITY_LOWEST,
err_code);
APP_ERROR_CHECK(err_code);
}
int main(void)
{
uart_init();
printf("hello");
initialize();
start();
for (;;)
{
(void)sd_app_evt_wait();
}
}
