[LOGGER] LOG_INF dosen't print out in RTT

[seongmincho]

Hello,

I am programming BLE with the nRF52840-DK. [Toolchain Manager: v1.3.0, IDE: Visual Studio Code (VSCode), SDK: ncs v2.6.0 ]

I want to debug using the Logger module. Printing with the 'printk' function works fine, but nothing is output when I use the 'LOG_INF' function.

I wonder what I'm doing wrong.

Additionally, I have another question. If I set the following in prj.conf:

CONFIG_LOG=y 
CONFIG_LOG_BACKEND_RTT=n 
CONFIG_LOG_BACKEND_UART=y 
CONFIG_LOG_PRINTK=n

Will the output from 'LOG_INF' be directed to' COM' instead of 'RTT'?

Is this different from the printk function?"

- Here is my 'main.c' code:

#include <zephyr/bluetooth/conn.h>
#include <zephyr/sys/printk.h>
#include <zephyr/kernel.h>
#include <zephyr/settings/settings.h>
#include <zephyr/logging/log.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <bluetooth/services/nus.h>
#include <zephyr/logging/log.h>
#define STACKSIZE CONFIG_BT_NUS_THREAD_STACK_SIZE
#define PRIORITY 7
int count = 0;
#define LOG_MODULE_NAME cho
LOG_MODULE_REGISTER(LOG_MODULE_NAME);
#define DEVICE_NAME "SEONGMIN"
#define DEVICE_NAME_LEN	(sizeof(DEVICE_NAME) - 1)
static K_SEM_DEFINE(ble_init_ok, 0, 1);
static struct bt_conn *current_conn;
static struct bt_conn *auth_conn;
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),
};
/***************************************************/
/******************                *****************/
/***************************************************/

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 struct bt_conn_auth_cb conn_auth_callbacks = {
	.passkey_display = auth_passkey_display,
	.passkey_confirm = auth_passkey_confirm,
	.cancel = auth_cancel,
};

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_info_cb conn_auth_info_callbacks = {
	.pairing_complete = pairing_complete,
	.pairing_failed = pairing_failed
};

/***************************************************/
/******************                *****************/
/***************************************************/

static void connected(struct bt_conn *conn, uint8_t err)
{
	char addr[BT_ADDR_LE_STR_LEN];
	if (err) {
		LOG_INF("connected: Connection failed (err %u)", err);//printk("connected: Connection failed (err %u)\n", err);
		return;
	}
	bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
	LOG_INF("Connected %s", addr); //printk("Connected %s\n", addr);
	current_conn = bt_conn_ref(conn);
}

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); //printk("Disconnected: %s (reason %u)\n", addr, reason);
	
}

static void le_param_updated(struct bt_conn *conn, uint16_t interval,  uint16_t latency, uint16_t timeout)
{
	LOG_INF("Connection parameters updated.\n"
	       " interval: %d, latency: %d, timeout: %d\n",
	       interval, latency, timeout);

}

static void le_data_length_updated(struct bt_conn *conn, struct bt_conn_le_data_len_info *info){
	LOG_INF("LE data len updated: TX (len: %d time: %d)"
	       " RX (len: %d time: %d)\n", info->tx_max_len,
	       info->tx_max_time, info->rx_max_len, info->rx_max_time);
}

static struct bt_conn_cb conn_callbacks = {
	.connected    = connected,
	.disconnected = disconnected,
	.le_param_updated = le_param_updated,
	.le_data_len_updated = le_data_length_updated,
};

/***************************************************/
/******************                *****************/
/***************************************************/

static void bt_receive_cb(struct bt_conn *conn, const uint8_t *const data, uint16_t len)
{
	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); //printk("Received data from: %s\n", addr);
}
//(*sent)(struct bt_conn *conn);
static void bt_sent_cb(struct bt_conn *conn){
	LOG_INF("bt_sent_cb");//printk("bt_sent_cb\n");
}

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

uint8_t data_to_central[244];
#define MTU_SIZE 64

int main(void){
	int err;
	for(int x=0; x<244; x++){
		data_to_central[x] = x;
	}

	//printk("cho >> 240703_scan_adv_peripheral\n");
	LOG_INF("cho >> 240703_scan_adv_peripheral");
	bt_conn_cb_register(&conn_callbacks);

	err = bt_conn_auth_cb_register(&conn_auth_callbacks);  //success: 0
	//printk("bt_conn_auth_cb_register: %d\n",err);
	LOG_INF("bt_conn_auth_cb_register: %d",err);

	err = bt_conn_auth_info_cb_register(&conn_auth_info_callbacks); //success: 0
	//printk("bt_conn_auth_info_cb_register: %d\n",err);
	LOG_INF("bt_conn_auth_info_cb_register: %d",err);

	err = bt_enable(NULL);
	//printk("bt_enable: %d\n",err);
	LOG_INF("bt_enable: %d",err);
	k_sem_give(&ble_init_ok);
	if (IS_ENABLED(CONFIG_SETTINGS)) {
		settings_load();
	}
	err = bt_nus_init(&nus_cb);
	LOG_INF("bt_nus_init: %d",err);//printk("bt_nus_init: %d\n",err);


	err = bt_le_adv_start(BT_LE_ADV_CONN, ad, ARRAY_SIZE(ad), sd, ARRAY_SIZE(sd));
	LOG_INF("bt_le_adv_start: %d",err);	//printk("bt_le_adv_start: %d\n",err);

	for (;;) {

		k_sleep(K_MSEC(1000));
	}
}

void ble_write_thread(void){
	k_sem_take(&ble_init_ok, K_FOREVER);
	for (;;){
		for(int y =0; y< 244; y++){
			if (bt_nus_send(NULL, data_to_central, MTU_SIZE)) {
				LOG_INF("."); //failed
			}else{
				LOG_INF("-"); //success
			}
			LOG_INF("count: %d", count); //printk("count: %d\n", count);
			count++;
			k_sleep(K_MSEC(1000));
		}
	}
}

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

- Here is my 'prj.conf' code:

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

CONFIG_GPIO=y

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

CONFIG_HEAP_MEM_POOL_SIZE=2048

CONFIG_BT=y
CONFIG_BT_PERIPHERAL=y
CONFIG_BT_DEVICE_NAME="SEONGMIN"
CONFIG_BT_MAX_CONN=1
CONFIG_BT_MAX_PAIRED=1

# 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

# This example requires more stack
CONFIG_MAIN_STACK_SIZE=1152
CONFIG_SYSTEM_WORKQUEUE_STACK_SIZE=2048

# Config logger
CONFIG_LOG=y
CONFIG_USE_SEGGER_RTT=y
CONFIG_LOG_BACKEND_RTT=y
CONFIG_LOG_BACKEND_UART=n
CONFIG_LOG_PRINTK=n
#CONFIG_LOG_PROCESS_THREAD=y
#CONFIG_LOG_DEFAULT_LEVEL=4
# Ensure sufficient buffer size for RTT
# CONFIG_SEGGER_RTT_BUFFER_SIZE_UP=1024
# CONFIG_SEGGER_RTT_BUFFER_SIZE_DOWN=16

CONFIG_ASSERT=y
CONFIG_BT_USER_DATA_LEN_UPDATE=y

[Priyanka]

Hi,

I want to debug using the Logger module. Printing with the 'printk' function works fine, but nothing is output when I use the 'LOG_INF' function.

Please make sure you have enabled all the necessary LOG configs in your prj.conf.

Will the output from 'LOG_INF' be directed to' COM' instead of 'RTT'?

Yes, this is true. If this is the prj.conf that you use, then  the output from LOG_INF will be directed to the UART (COM port) instead of RTT. This is because CONFIG_LOG_BACKEND_UART=y enables the UART backend for the logger, and CONFIG_LOG_BACKEND_RTT=n disables the RTT backend. Please take a look at this documentation.

Is this different from the printk function?"

Yes, because the print_k is a function which is like a basic logger, i.e. it just logs. It does not require any backend. But on the other hand, the LOG_INF  is part of the Logger module and is more advanced with the requirement of a backend like UART or RTT and the logs will be directed to whichever backend you set up. Please refer this ticket.

Regards,

Priyanka

[seongmincho]

are you there..?

[Priyanka]

Hi,

Apologies for the delay as I was away on sick leave.

I would suggest you to take a look at the nRF Connect SDK Fundamentals course in the Devacademy which might be of help.

Also, the contents in the RTT operate in a first in first out basis, so if the buffer if full, and you attempt to write again, the oldest log will be cleared to make space for the latest log. 

Hope this helps.

Regards,

Priyanka

[seongmincho]

oh..I hope you get well soon...

nRF Connect SDK Fundamentals is too basic. I’ll need to get additional information on my own through RTT and by Googling.

thank you!

[Priyanka]

Closing this ticket in case of no further queries. In case of any new doubts unrelated to this ticket topic, feel free to open a new ticket

-Priyanka