Advertising issue of BLE and RTC combine code

[Ankush]

Hi

I have to combine both BLE UART profile and RTC examples of nrf52 of 11.0.0 SDK for my application.When I run them individually, they are working fine.After combining both examples I am getting problem in RTC initialization.When I put the nrf52 in debugg mode in Keil, i am getting issue in rtc initialization part.

After combining both examples advertising is not happening.Is it the issue of clock frequency?Am i missing something? please give suggestions.

This is the combined code:

		#include <stdint.h>
		#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 "softdevice_handler.h"
		#include "app_timer.h"
		#include "app_button.h"
		#include "ble_nus.h"
		#include "app_uart.h"
		#include "app_util_platform.h"
		#include "bsp.h"
		#include "bsp_btn_ble.h"
		
		
	#include "nrf.h"
	#include "nrf_gpio.h"
	#include "nrf_drv_config.h"
	#include "nrf_drv_rtc.h"
	#include "nrf_drv_clock.h"
	#include "boards.h"
	#include "app_error.h"
	#include <stdint.h>
	#include <stdbool.h>

	#include <string.h>
	#include <stdint.h>
	#include <stdio.h>
	#include "app_uart.h"
	#include "app_error.h"
	#include "nrf_delay.h"
	#include "nrf.h"
	#include "bsp.h"
	//====================================RTC===================================================================
	#define COMPARE_COUNTERTIME  (1UL)                                        /**< Get Compare event COMPARE_TIME seconds after the counter starts from 0. */

	#ifdef BSP_LED_2
			#define TICK_EVENT_OUTPUT     BSP_LED_2                                 /**< Pin number for indicating tick event. */
	#endif
	#ifndef TICK_EVENT_OUTPUT
			#error "Please indicate output pin"
	#endif
	#ifdef BSP_LED_3
			#define COMPARE_EVENT_OUTPUT   BSP_LED_3                                /**< Pin number for indicating compare event. */
	#endif
	#ifndef COMPARE_EVENT_OUTPUT
			#error "Please indicate output pin"
	#endif
	const nrf_drv_rtc_t rtc = NRF_DRV_RTC_INSTANCE(0); /**< Declaring an instance of nrf_drv_rtc for RTC0. */
	uint32_t count=0;
	bool ov_flag=false;

	typedef struct{
		uint8_t second;
		uint8_t minute;
		uint8_t hour;
		uint8_t date;
		uint8_t month;
		int year;
		}time;
	time t,m={0},p={0};

	void start_date(void)
	{
			time m={0};
			time p={0};
			t.second	=10;
			t.minute	=27;
			t.hour		=18;
			t.date		=7;
			t.month		=7;
			t.year		=2016;
			printf("START DATE\r\nDATE =  %d-%d-%d TIME = %d:%d:%d\r\n",t.date,t.month,t.year,t.hour,t.minute,t.second);
	}
	static char not_leap(void)      //check for leap year
	{
		
	}
	void update_date_time(void)
	{		
			
	}

	void get_time_date(void)
	{		
			
		update_date_time();
	}


	static void rtc_handler(nrf_drv_rtc_int_type_t int_type)
	{
			if (int_type == NRF_DRV_RTC_INT_COMPARE0)
			{
				 // nrf_gpio_pin_toggle(COMPARE_EVENT_OUTPUT);
					//get_time_date();
			}
			else if (int_type == NRF_DRV_RTC_INT_TICK)
			{
					nrf_gpio_pin_toggle(TICK_EVENT_OUTPUT);
					//get_time_date();
			}
			else if (int_type == NRF_DRV_RTC_INT_OVERFLOW)
			{
					ov_flag=true;
					get_time_date();
					memcpy(&t,&p,sizeof(p));				// memcpy (dest_struct, source_struct, sizeof (dest_struct));
					printf("DATE_TIME after overflow\r\nDATE =  %d-%d-%d TIME = %d:%d:%d\r\n",t.date,t.month,t.year,t.hour,t.minute,t.second);
			}
	}

	/** @brief Function configuring gpio for pin toggling.
	 */
	static void leds_config(void)
	{
			LEDS_CONFIGURE(((1<<COMPARE_EVENT_OUTPUT) | (1<<TICK_EVENT_OUTPUT)));
			LEDS_OFF((1<<COMPARE_EVENT_OUTPUT) | (1<<TICK_EVENT_OUTPUT));
	}

	/** @brief Function starting the internal LFCLK XTAL oscillator.
	 */
	static void lfclk_config(void)
	{
			ret_code_t err_code = nrf_drv_clock_init();
			APP_ERROR_CHECK(err_code);

			nrf_drv_clock_lfclk_request(NULL);
	}

	/** @brief Function initialization and configuration of RTC driver instance.
	 */
	static void rtc_config(void)
	{
			uint32_t err_code;

			//Initialize RTC instance
			err_code = nrf_drv_rtc_init(&rtc, NULL, rtc_handler);
			APP_ERROR_CHECK(err_code);

			//Enable tick event & interrupt
		 // nrf_drv_rtc_tick_enable(&rtc,true);

			//Set compare channel to trigger interrupt after COMPARE_COUNTERTIME seconds
			//err_code = nrf_drv_rtc_cc_set(&rtc,0,COMPARE_COUNTERTIME*RTC0_CONFIG_FREQUENCY,true);
			//APP_ERROR_CHECK(err_code);
		
			nrf_drv_rtc_overflow_enable(&rtc,true);

			//Power on RTC instance
			nrf_drv_rtc_enable(&rtc);
	}
	//==========================================================================================================
		#define IS_SRVC_CHANGED_CHARACT_PRESENT 0                                           /**< Include the service_changed characteristic. If not enabled, the server's database cannot be changed for the lifetime of the device. */
		#define CENTRAL_LINK_COUNT              0                                           /**< Number of central links used by the application. When changing this number remember to adjust the RAM settings*/
		#define PERIPHERAL_LINK_COUNT           1                                           /**< Number of peripheral links used by the application. When changing this number remember to adjust the RAM settings*/
		#define DEVICE_NAME                     "UART_RTC"                               /**< Name of device. Will be included in the advertising data. */
		#define NUS_SERVICE_UUID_TYPE           BLE_UUID_TYPE_VENDOR_BEGIN                  /**< UUID type for the Nordic UART Service (vendor specific). */
		#define APP_ADV_INTERVAL                64                                          /**< The advertising interval (in units of 0.625 ms. This value corresponds to 40 ms). */
		#define APP_ADV_TIMEOUT_IN_SECONDS      180                                         /**< The advertising timeout (in units of seconds). */
		#define APP_TIMER_PRESCALER             0                                           /**< Value of the RTC1 PRESCALER register. */
		#define APP_TIMER_OP_QUEUE_SIZE         4                                           /**< Size of timer operation queues. */
		#define MIN_CONN_INTERVAL               MSEC_TO_UNITS(20, UNIT_1_25_MS)             /**< Minimum acceptable connection interval (20 ms), Connection interval uses 1.25 ms units. */
		#define MAX_CONN_INTERVAL               MSEC_TO_UNITS(75, UNIT_1_25_MS)             /**< Maximum acceptable connection interval (75 ms), Connection interval uses 1.25 ms units. */
		#define SLAVE_LATENCY                   0                                           /**< Slave latency. */
		#define CONN_SUP_TIMEOUT                MSEC_TO_UNITS(4000, UNIT_10_MS)             /**< Connection supervisory timeout (4 seconds), Supervision Timeout uses 10 ms units. */
		#define FIRST_CONN_PARAMS_UPDATE_DELAY  APP_TIMER_TICKS(5000, APP_TIMER_PRESCALER)  /**< Time from initiating event (connect or start of notification) to first time sd_ble_gap_conn_param_update is called (5 seconds). */
		#define NEXT_CONN_PARAMS_UPDATE_DELAY   APP_TIMER_TICKS(30000, APP_TIMER_PRESCALER) /**< Time between each call to sd_ble_gap_conn_param_update after the first call (30 seconds). */
		#define MAX_CONN_PARAMS_UPDATE_COUNT    3                                           /**< Number of attempts before giving up the connection parameter negotiation. */
		#define DEAD_BEEF                       0xDEADBEEF                                  /**< Value used as error code on stack dump, can be used to identify stack location on stack unwind. */
		#define UART_TX_BUF_SIZE                256                                         /**< UART TX buffer size. */
		#define UART_RX_BUF_SIZE                256                                         /**< UART RX buffer size. */

		static ble_nus_t                        m_nus;                                      /**< Structure to identify the Nordic UART Service. */
		static uint16_t                         m_conn_handle = BLE_CONN_HANDLE_INVALID;    /**< Handle of the current connection. */

		static ble_uuid_t                       m_adv_uuids[] = {{BLE_UUID_NUS_SERVICE, NUS_SERVICE_UUID_TYPE}};  /**< Universally unique service identifier. */


		/**@brief Function for assert macro callback.
		 *
		 * @details This function will be called in case of an assert in the SoftDevice.
		 *
		 * @warning This handler is an example only and does not fit a final product. You need to analyse 
		 *          how your product is supposed to react in case of Assert.
		 * @warning On assert from the SoftDevice, the system can only recover on reset.
		 *
		 * @param[in] line_num    Line number of the failing ASSERT call.
		 * @param[in] p_file_name File name of the failing ASSERT call.
		 */
		void assert_nrf_callback(uint16_t line_num, const uint8_t * p_file_name)
		{
				app_error_handler(DEAD_BEEF, line_num, p_file_name);
		}


		/**@brief Function for the GAP initialization.
		 *
		 * @details This function will set up all the necessary GAP (Generic Access Profile) parameters of 
		 *          the device. It also sets the permissions and appearance.
		 */
		static void gap_params_init(void)
		{
				uint32_t                err_code;
				ble_gap_conn_params_t   gap_conn_params;
				ble_gap_conn_sec_mode_t sec_mode;

				BLE_GAP_CONN_SEC_MODE_SET_OPEN(&sec_mode);
				
				err_code = sd_ble_gap_device_name_set(&sec_mode,
																							(const uint8_t *) DEVICE_NAME,
																							strlen(DEVICE_NAME));
				APP_ERROR_CHECK(err_code);

				memset(&gap_conn_params, 0, sizeof(gap_conn_params));

				gap_conn_params.min_conn_interval = MIN_CONN_INTERVAL;
				gap_conn_params.max_conn_interval = MAX_CONN_INTERVAL;
				gap_conn_params.slave_latency     = SLAVE_LATENCY;
				gap_conn_params.conn_sup_timeout  = CONN_SUP_TIMEOUT;

				err_code = sd_ble_gap_ppcp_set(&gap_conn_params);
				APP_ERROR_CHECK(err_code);
		}


		/**@brief Function for handling the data from the Nordic UART Service.
		 *
		 * @details This function will process the data received from the Nordic UART BLE Service and send
		 *          it to the UART module.
		 *
		 * @param[in] p_nus    Nordic UART Service structure.
		 * @param[in] p_data   Data to be send to UART module.
		 * @param[in] length   Length of the data.
		 */
		/**@snippet [Handling the data received over BLE] */
		static void nus_data_handler(ble_nus_t * p_nus, uint8_t * p_data, uint16_t length)
		{
				for (uint32_t i = 0; i < length; i++)
				{
						while(app_uart_put(p_data[i]) != NRF_SUCCESS);
				}
				while(app_uart_put('\n') != NRF_SUCCESS);
				
		}
		/**@snippet [Handling the data received over BLE] */


		/**@brief Function for initializing services that will be used by the application.
		 */
		static void services_init(void)
		{
				uint32_t       err_code;
				ble_nus_init_t nus_init;
				
				memset(&nus_init, 0, sizeof(nus_init));

				nus_init.data_handler = nus_data_handler;
				
				err_code = ble_nus_init(&m_nus, &nus_init);
				APP_ERROR_CHECK(err_code);
		}


		/**@brief Function for handling an event from the Connection Parameters Module.
		 *
		 * @details This function will be called for all events in the Connection Parameters Module
		 *          which are passed to the application.
		 *
		 * @note All this function does is to disconnect. This could have been done by simply setting
		 *       the disconnect_on_fail config parameter, but instead we use the event handler
		 *       mechanism to demonstrate its use.
		 *
		 * @param[in] p_evt  Event received from the Connection Parameters Module.
		 */
		static void on_conn_params_evt(ble_conn_params_evt_t * p_evt)
		{
				uint32_t err_code;
				
				if(p_evt->evt_type == BLE_CONN_PARAMS_EVT_FAILED)
				{
						err_code = sd_ble_gap_disconnect(m_conn_handle, BLE_HCI_CONN_INTERVAL_UNACCEPTABLE);
						APP_ERROR_CHECK(err_code);
				}
		}


		/**@brief Function for handling errors from the Connection Parameters module.
		 *
		 * @param[in] nrf_error  Error code containing information about what went wrong.
		 */
		static void conn_params_error_handler(uint32_t nrf_error)
		{
				APP_ERROR_HANDLER(nrf_error);
		}


		/**@brief Function for initializing the Connection Parameters module.
		 */
		static void conn_params_init(void)
		{
				uint32_t               err_code;
				ble_conn_params_init_t cp_init;
				
				memset(&cp_init, 0, sizeof(cp_init));

				cp_init.p_conn_params                  = NULL;
				cp_init.first_conn_params_update_delay = FIRST_CONN_PARAMS_UPDATE_DELAY;
				cp_init.next_conn_params_update_delay  = NEXT_CONN_PARAMS_UPDATE_DELAY;
				cp_init.max_conn_params_update_count   = MAX_CONN_PARAMS_UPDATE_COUNT;
				cp_init.start_on_notify_cccd_handle    = BLE_GATT_HANDLE_INVALID;
				cp_init.disconnect_on_fail             = false;
				cp_init.evt_handler                    = on_conn_params_evt;
				cp_init.error_handler                  = conn_params_error_handler;
				
				err_code = ble_conn_params_init(&cp_init);
				APP_ERROR_CHECK(err_code);
		}


		/**@brief Function for putting the chip into sleep mode.
		 *
		 * @note This function will not return.
		 */
		static void sleep_mode_enter(void)
		{
				uint32_t err_code = bsp_indication_set(BSP_INDICATE_IDLE);
				APP_ERROR_CHECK(err_code);

				// Prepare wakeup buttons.
				err_code = bsp_btn_ble_sleep_mode_prepare();
				APP_ERROR_CHECK(err_code);

				// Go to system-off mode (this function will not return; wakeup will cause a reset).
				err_code = sd_power_system_off();
				APP_ERROR_CHECK(err_code);
		}


		/**@brief Function for handling advertising events.
		 *
		 * @details This function will be called for advertising events which are passed to the application.
		 *
		 * @param[in] ble_adv_evt  Advertising event.
		 */
		static void on_adv_evt(ble_adv_evt_t ble_adv_evt)
		{
				uint32_t err_code;

				switch (ble_adv_evt)
				{
						case BLE_ADV_EVT_FAST:
								err_code = bsp_indication_set(BSP_INDICATE_ADVERTISING);
								APP_ERROR_CHECK(err_code);
								break;
						case BLE_ADV_EVT_IDLE:
								sleep_mode_enter();
								break;
						default:
								break;
				}
		}


		/**@brief Function for the application's SoftDevice event handler.
		 *
		 * @param[in] p_ble_evt SoftDevice event.
		 */
		static void on_ble_evt(ble_evt_t * p_ble_evt)
		{
				uint32_t                         err_code;
				
				switch (p_ble_evt->header.evt_id)
				{
						case BLE_GAP_EVT_CONNECTED:
								err_code = bsp_indication_set(BSP_INDICATE_CONNECTED);
								APP_ERROR_CHECK(err_code);
								m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
								break;
								
						case BLE_GAP_EVT_DISCONNECTED:
								err_code = bsp_indication_set(BSP_INDICATE_IDLE);
								APP_ERROR_CHECK(err_code);
								m_conn_handle = BLE_CONN_HANDLE_INVALID;
								break;

						case BLE_GAP_EVT_SEC_PARAMS_REQUEST:
								// Pairing not supported
								err_code = sd_ble_gap_sec_params_reply(m_conn_handle, BLE_GAP_SEC_STATUS_PAIRING_NOT_SUPP, NULL, NULL);
								APP_ERROR_CHECK(err_code);
								break;

						case BLE_GATTS_EVT_SYS_ATTR_MISSING:
								// No system attributes have been stored.
								err_code = sd_ble_gatts_sys_attr_set(m_conn_handle, NULL, 0, 0);
								APP_ERROR_CHECK(err_code);
								break;

						default:
								// No implementation needed.
								break;
				}
		}


		/**@brief Function for dispatching a SoftDevice event to all modules with a SoftDevice 
		 *        event handler.
		 *
		 * @details This function is called from the SoftDevice event interrupt handler after a 
		 *          SoftDevice event has been received.
		 *
		 * @param[in] p_ble_evt  SoftDevice event.
		 */
		static void ble_evt_dispatch(ble_evt_t * p_ble_evt)
		{
				ble_conn_params_on_ble_evt(p_ble_evt);
				ble_nus_on_ble_evt(&m_nus, p_ble_evt);
				on_ble_evt(p_ble_evt);
				ble_advertising_on_ble_evt(p_ble_evt);
				bsp_btn_ble_on_ble_evt(p_ble_evt);
				
		}


		/**@brief Function for the SoftDevice initialization.
		 *
		 * @details This function initializes the SoftDevice and the BLE event interrupt.
		 */
		static void ble_stack_init(void)
		{
				uint32_t err_code;
				
				nrf_clock_lf_cfg_t clock_lf_cfg = NRF_CLOCK_LFCLKSRC;
				
				// Initialize SoftDevice.
				SOFTDEVICE_HANDLER_INIT(&clock_lf_cfg, NULL);
				
				ble_enable_params_t ble_enable_params;
				err_code = softdevice_enable_get_default_config(CENTRAL_LINK_COUNT,
																												PERIPHERAL_LINK_COUNT,
																												&ble_enable_params);
				APP_ERROR_CHECK(err_code);
						
				//Check the ram settings against the used number of links
				CHECK_RAM_START_ADDR(CENTRAL_LINK_COUNT,PERIPHERAL_LINK_COUNT);
				// Enable BLE stack.
				err_code = softdevice_enable(&ble_enable_params);
				APP_ERROR_CHECK(err_code);
				
				// Subscribe for BLE events.
				err_code = softdevice_ble_evt_handler_set(ble_evt_dispatch);
				APP_ERROR_CHECK(err_code);
		}


		/**@brief Function for handling events from the BSP module.
		 *
		 * @param[in]   event   Event generated by button press.
		 */
		void bsp_event_handler(bsp_event_t event)
		{
				uint32_t err_code;
				switch (event)
				{
						case BSP_EVENT_SLEEP:
								sleep_mode_enter();
								break;

						case BSP_EVENT_DISCONNECT:
								err_code = sd_ble_gap_disconnect(m_conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
								if (err_code != NRF_ERROR_INVALID_STATE)
								{
										APP_ERROR_CHECK(err_code);
								}
								break;

						case BSP_EVENT_WHITELIST_OFF:
								err_code = ble_advertising_restart_without_whitelist();
								if (err_code != NRF_ERROR_INVALID_STATE)
								{
										APP_ERROR_CHECK(err_code);
								}
								break;

						default:
								break;
				}
		}


		/**@brief   Function for handling app_uart events.
		 *
		 * @details This function will receive a single character from the app_uart module and append it to 
		 *          a string. The string will be be sent over BLE when the last character received was a 
		 *          'new line' i.e '\n' (hex 0x0D) or if the string has reached a length of 
		 *          @ref NUS_MAX_DATA_LENGTH.
		 */
		/**@snippet [Handling the data received over UART] */
		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] == '\r') || (index >= (BLE_NUS_MAX_DATA_LEN)))
								{
										err_code = ble_nus_string_send(&m_nus, data_array, index);
										if (err_code != NRF_ERROR_INVALID_STATE)
										{
												APP_ERROR_CHECK(err_code);
										}
										
										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;
				}
		}
		/**@snippet [Handling the data received over UART] */


		/**@brief  Function for initializing the UART module.
		 */
		/**@snippet [UART Initialization] */
		static void uart_init(void)
		{
				uint32_t                     err_code;
				const app_uart_comm_params_t comm_params =
				{
						RX_PIN_NUMBER,
						TX_PIN_NUMBER,
						RTS_PIN_NUMBER,
						CTS_PIN_NUMBER,
						APP_UART_FLOW_CONTROL_ENABLED,
						false,
						UART_BAUDRATE_BAUDRATE_Baud115200
				};

				APP_UART_FIFO_INIT( &comm_params,
													 UART_RX_BUF_SIZE,
													 UART_TX_BUF_SIZE,
													 uart_event_handle,
													 APP_IRQ_PRIORITY_LOW,
													 err_code);
				APP_ERROR_CHECK(err_code);
		}
		/**@snippet [UART Initialization] */


		/**@brief Function for initializing the Advertising functionality.
		 */
		static void advertising_init(void)
		{
				uint32_t      err_code;
				ble_advdata_t advdata;
				ble_advdata_t scanrsp;

				// Build advertising data struct to pass into @ref ble_advertising_init.
				memset(&advdata, 0, sizeof(advdata));
			
				advdata.name_type          = BLE_ADVDATA_FULL_NAME;
				advdata.include_appearance = false;
				advdata.flags              = BLE_GAP_ADV_FLAGS_LE_ONLY_LIMITED_DISC_MODE;

				memset(&scanrsp, 0, sizeof(scanrsp));
				scanrsp.uuids_complete.uuid_cnt = sizeof(m_adv_uuids) / sizeof(m_adv_uuids[0]);
				scanrsp.uuids_complete.p_uuids  = m_adv_uuids;

				ble_adv_modes_config_t options = {0};
				options.ble_adv_fast_enabled  = BLE_ADV_FAST_ENABLED;
				options.ble_adv_fast_interval = APP_ADV_INTERVAL;
				options.ble_adv_fast_timeout  = APP_ADV_TIMEOUT_IN_SECONDS;

				err_code = ble_advertising_init(&advdata, &scanrsp, &options, on_adv_evt, NULL);
				APP_ERROR_CHECK(err_code);
		}


		/**@brief Function for initializing buttons and leds.
		 *
		 * @param[out] p_erase_bonds  Will be true if the clear bonding button was pressed to wake the application up.
		 */
		static void buttons_leds_init(bool * p_erase_bonds)
		{
				bsp_event_t startup_event;

				uint32_t err_code = bsp_init(BSP_INIT_LED | BSP_INIT_BUTTONS,
																		 APP_TIMER_TICKS(100, APP_TIMER_PRESCALER), 
																		 bsp_event_handler);
				APP_ERROR_CHECK(err_code);

				err_code = bsp_btn_ble_init(NULL, &startup_event);
				APP_ERROR_CHECK(err_code);

				*p_erase_bonds = (startup_event == BSP_EVENT_CLEAR_BONDING_DATA);
		}


		/**@brief Function for placing the application in low power state while waiting for events.
		 */
		static void power_manage(void)
		{
				uint32_t err_code = sd_app_evt_wait();
				APP_ERROR_CHECK(err_code);
		}


		/**@brief Application main function.
		 */
		int main(void)
		{
				uint32_t err_code;
				bool erase_bonds;

				// Initialize.
				APP_TIMER_INIT(APP_TIMER_PRESCALER, APP_TIMER_OP_QUEUE_SIZE, false);
				uart_init();
				
				buttons_leds_init(&erase_bonds);
				//leds_config();
				ble_stack_init();
				gap_params_init();
				services_init();
				advertising_init();
				conn_params_init();
		

				printf("\r\nUART Start!\r\n");
				err_code = ble_advertising_start(BLE_ADV_MODE_FAST);
				APP_ERROR_CHECK(err_code);
				
				lfclk_config();
				rtc_config();
				start_date();
				// Enter main loop.
				for (;;)
				{
						power_manage();
				}
		}


		/** 
		 * @}
		 */

[Sanket]

I have same question. I don't know what has gone wrong! I have imported RTC code to ble_app_uart code. I am using SDK 14.2.0.

My sdk_config.h seems like:

// <e> RTC_ENABLED - nrf_drv_rtc - RTC peripheral driver
//==========================================================
#ifndef RTC_ENABLED
#define RTC_ENABLED 1
#endif
// <o> RTC_DEFAULT_CONFIG_FREQUENCY - Frequency <16-32768>


#ifndef RTC_DEFAULT_CONFIG_FREQUENCY
#define RTC_DEFAULT_CONFIG_FREQUENCY 32768
#endif

// <q> RTC_DEFAULT_CONFIG_RELIABLE - Ensures safe compare event triggering

#ifndef RTC_DEFAULT_CONFIG_RELIABLE
#define RTC_DEFAULT_CONFIG_RELIABLE 0
#endif

// <o> RTC_DEFAULT_CONFIG_IRQ_PRIORITY - Interrupt priority

// <i> Priorities 0,2 (nRF51) and 0,1,4,5 (nRF52) are reserved for SoftDevice
// <0=> 0 (highest) 
// <1=> 1 
// <2=> 2 
// <3=> 3 
// <4=> 4 
// <5=> 5 
// <6=> 6 
// <7=> 7

#ifndef RTC_DEFAULT_CONFIG_IRQ_PRIORITY
#define RTC_DEFAULT_CONFIG_IRQ_PRIORITY 7
#endif

// <q> RTC0_ENABLED - Enable RTC0 instance

#ifndef RTC0_ENABLED
#define RTC0_ENABLED 0
#endif

// <q> RTC1_ENABLED - Enable RTC1 instance

#ifndef RTC1_ENABLED
#define RTC1_ENABLED 0
#endif

// <q> RTC2_ENABLED - Enable RTC2 instance

#ifndef RTC2_ENABLED
#define RTC2_ENABLED 1
#endif

My code is very similar to the one posted in the discussion:

/**
* Copyright (c) 2014 - 2017, Nordic Semiconductor ASA
* 
* All rights reserved.
* 
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
* 
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
* 
* 2. Redistributions in binary form, except as embedded into a Nordic
* Semiconductor ASA integrated circuit in a product or a software update for
* such product, must reproduce the above copyright notice, this list of
* conditions and the following disclaimer in the documentation and/or other
* materials provided with the distribution.
* 
* 3. Neither the name of Nordic Semiconductor ASA nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
* 
* 4. This software, with or without modification, must only be used with a
* Nordic Semiconductor ASA integrated circuit.
* 
* 5. Any software provided in binary form under this license must not be reverse
* engineered, decompiled, modified and/or disassembled.
* 
* THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* 
*/
/** @file
*
* @defgroup ble_sdk_uart_over_ble_main main.c
* @{
* @ingroup ble_sdk_app_nus_eval
* @brief UART over BLE application main file.
*
* This file contains the source code for a sample application that uses the Nordic UART service.
* This application uses the @ref srvlib_conn_params module.
*/



#include <stdint.h>
#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 "app_timer.h"
#include "ble_nus.h"
#include "app_uart.h"
#include "app_util_platform.h"
#include "bsp_btn_ble.h"
#include "nrf_gpio.h"
#include "nrf_drv_rtc.h"
#include "nrf_drv_clock.h"
#include "boards.h"
#include "app_error.h"
#include <stdbool.h>
#include "nrf_delay.h"

#if defined (UART_PRESENT)
#include "nrf_uart.h"
#endif
#if defined (UARTE_PRESENT)
#include "nrf_uarte.h"
#endif

#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"

#define APP_BLE_CONN_CFG_TAG 1 /**< A tag identifying the SoftDevice BLE configuration. */

#define APP_FEATURE_NOT_SUPPORTED BLE_GATT_STATUS_ATTERR_APP_BEGIN + 2 /**< Reply when unsupported features are requested. */

#define DEVICE_NAME "Nordic_UART" /**< Name of device. Will be included in the advertising data. */
#define NUS_SERVICE_UUID_TYPE BLE_UUID_TYPE_VENDOR_BEGIN /**< UUID type for the Nordic UART Service (vendor specific). */

#define APP_BLE_OBSERVER_PRIO 3 /**< Application's BLE observer priority. You shouldn't need to modify this value. */

#define APP_ADV_INTERVAL 64 /**< The advertising interval (in units of 0.625 ms. This value corresponds to 40 ms). */
#define APP_ADV_TIMEOUT_IN_SECONDS 180 /**< The advertising timeout (in units of seconds). */

#define MIN_CONN_INTERVAL MSEC_TO_UNITS(20, UNIT_1_25_MS) /**< Minimum acceptable connection interval (20 ms), Connection interval uses 1.25 ms units. */
#define MAX_CONN_INTERVAL MSEC_TO_UNITS(75, UNIT_1_25_MS) /**< Maximum acceptable connection interval (75 ms), Connection interval uses 1.25 ms units. */
#define SLAVE_LATENCY 0 /**< Slave latency. */
#define CONN_SUP_TIMEOUT MSEC_TO_UNITS(4000, UNIT_10_MS) /**< Connection supervisory timeout (4 seconds), Supervision Timeout uses 10 ms units. */
#define FIRST_CONN_PARAMS_UPDATE_DELAY APP_TIMER_TICKS(5000) /**< Time from initiating event (connect or start of notification) to first time sd_ble_gap_conn_param_update is called (5 seconds). */
#define NEXT_CONN_PARAMS_UPDATE_DELAY APP_TIMER_TICKS(30000) /**< Time between each call to sd_ble_gap_conn_param_update after the first call (30 seconds). */
#define MAX_CONN_PARAMS_UPDATE_COUNT 3 /**< Number of attempts before giving up the connection parameter negotiation. */

#define DEAD_BEEF 0xDEADBEEF /**< Value used as error code on stack dump, can be used to identify stack location on stack unwind. */

#define UART_TX_BUF_SIZE 256 /**< UART TX buffer size. */
#define UART_RX_BUF_SIZE 256 /**< UART RX buffer size. */


BLE_NUS_DEF(m_nus); /**< BLE NUS service instance. */
NRF_BLE_GATT_DEF(m_gatt); /**< GATT module instance. */
BLE_ADVERTISING_DEF(m_advertising); /**< Advertising module instance. */

static uint16_t m_conn_handle = BLE_CONN_HANDLE_INVALID; /**< Handle of the current connection. */
static uint16_t m_ble_nus_max_data_len = BLE_GATT_ATT_MTU_DEFAULT - 3; /**< Maximum length of data (in bytes) that can be transmitted to the peer by the Nordic UART service module. */
static ble_uuid_t m_adv_uuids[] = /**< Universally unique service identifier. */
{
{BLE_UUID_NUS_SERVICE, NUS_SERVICE_UUID_TYPE}
};

#define COMPARE_COUNTERTIME (3UL) /**< Get Compare event COMPARE_TIME seconds after the counter starts from 0. */

const nrf_drv_rtc_t rtc = NRF_DRV_RTC_INSTANCE(2); /**< Declaring an instance of nrf_drv_rtc for RTC0. */

#ifdef BSP_LED_2
#define TICK_EVENT_OUTPUT BSP_LED_2 /**< Pin number for indicating tick event. */
#endif
#ifndef TICK_EVENT_OUTPUT
#error "Please indicate output pin"
#endif
#ifdef BSP_LED_3
#define COMPARE_EVENT_OUTPUT BSP_LED_3 /**< Pin number for indicating compare event. */
#endif
#ifndef COMPARE_EVENT_OUTPUT
#error "Please indicate output pin"
#endif

/** @brief: Function for handling the RTC0 interrupts.
* Triggered on TICK and COMPARE0 match.
*/
static void rtc_handler(nrf_drv_rtc_int_type_t int_type)
{
if (int_type == NRF_DRV_RTC_INT_COMPARE2)
{
nrf_gpio_pin_toggle(COMPARE_EVENT_OUTPUT);
}
else if (int_type == NRF_DRV_RTC_INT_TICK)
{
nrf_gpio_pin_toggle(TICK_EVENT_OUTPUT);
}
}


/** @brief Function configuring gpio for pin toggling.
*/
static void leds_config(void)
{
bsp_board_leds_init();
}


/** @brief Function starting the internal LFCLK XTAL oscillator.
*/
static void lfclk_config(void)
{
ret_code_t err_code = nrf_drv_clock_init();
APP_ERROR_CHECK(err_code);

nrf_drv_clock_lfclk_request(NULL);
}


/** @brief Function initialization and configuration of RTC driver instance.
*/
static void rtc_config(void)
{
uint32_t err_code;

//Initialize RTC instance
nrf_drv_rtc_config_t config = NRF_DRV_RTC_DEFAULT_CONFIG;
config.prescaler = 4095;
err_code = nrf_drv_rtc_init(&rtc, &config, rtc_handler);
APP_ERROR_CHECK(err_code);

//Enable tick event & interrupt
nrf_drv_rtc_tick_enable(&rtc,true);

//Set compare channel to trigger interrupt after COMPARE_COUNTERTIME seconds
err_code = nrf_drv_rtc_cc_set(&rtc,2,COMPARE_COUNTERTIME * 8,true);
APP_ERROR_CHECK(err_code);

//Power on RTC instance
nrf_drv_rtc_enable(&rtc);
}
/**@brief Function for assert macro callback.
*
* @details This function will be called in case of an assert in the SoftDevice.
*
* @warning This handler is an example only and does not fit a final product. You need to analyse
* how your product is supposed to react in case of Assert.
* @warning On assert from the SoftDevice, the system can only recover on reset.
*
* @param[in] line_num Line number of the failing ASSERT call.
* @param[in] p_file_name File name of the failing ASSERT call.
*/
void assert_nrf_callback(uint16_t line_num, const uint8_t * p_file_name)
{
app_error_handler(DEAD_BEEF, line_num, p_file_name);
}


/**@brief Function for the GAP initialization.
*
* @details This function will set up all the necessary GAP (Generic Access Profile) parameters of
* the device. It also sets the permissions and appearance.
*/
static void gap_params_init(void)
{
uint32_t err_code;
ble_gap_conn_params_t gap_conn_params;
ble_gap_conn_sec_mode_t sec_mode;

BLE_GAP_CONN_SEC_MODE_SET_OPEN(&sec_mode);

err_code = sd_ble_gap_device_name_set(&sec_mode,
(const uint8_t *) DEVICE_NAME,
strlen(DEVICE_NAME));
APP_ERROR_CHECK(err_code);

memset(&gap_conn_params, 0, sizeof(gap_conn_params));

gap_conn_params.min_conn_interval = MIN_CONN_INTERVAL;
gap_conn_params.max_conn_interval = MAX_CONN_INTERVAL;
gap_conn_params.slave_latency = SLAVE_LATENCY;
gap_conn_params.conn_sup_timeout = CONN_SUP_TIMEOUT;

err_code = sd_ble_gap_ppcp_set(&gap_conn_params);
APP_ERROR_CHECK(err_code);

}


/**@brief Function for handling the data from the Nordic UART Service.
*
* @details This function will process the data received from the Nordic UART BLE Service and send
* it to the UART module.
*
* @param[in] p_nus Nordic UART Service structure.
* @param[in] p_data Data to be send to UART module.
* @param[in] length Length of the data.
*/
/**@snippet [Handling the data received over BLE] */
static void nus_data_handler(ble_nus_evt_t * p_evt)
{

if (p_evt->type == BLE_NUS_EVT_RX_DATA)
{
uint32_t err_code;

NRF_LOG_DEBUG("Received data from BLE NUS. Writing data on UART.");
NRF_LOG_HEXDUMP_DEBUG(p_evt->params.rx_data.p_data, p_evt->params.rx_data.length);

for (uint32_t i = 0; i < p_evt->params.rx_data.length; i++)
{
do
{
err_code = app_uart_put(p_evt->params.rx_data.p_data[i]);
if ((err_code != NRF_SUCCESS) && (err_code != NRF_ERROR_BUSY))
{
NRF_LOG_ERROR("Failed receiving NUS message. Error 0x%x. ", err_code);
APP_ERROR_CHECK(err_code);
}
} while (err_code == NRF_ERROR_BUSY);
}
if (p_evt->params.rx_data.p_data[p_evt->params.rx_data.length-1] == '\r')
{
while (app_uart_put('\n') == NRF_ERROR_BUSY);
}
}

}
/**@snippet [Handling the data received over BLE] */


/**@brief Function for initializing services that will be used by the application.
*/
static void services_init(void)
{
uint32_t err_code;
ble_nus_init_t nus_init;

memset(&nus_init, 0, sizeof(nus_init));

nus_init.data_handler = nus_data_handler;

err_code = ble_nus_init(&m_nus, &nus_init);
APP_ERROR_CHECK(err_code);
}


/**@brief Function for handling an event from the Connection Parameters Module.
*
* @details This function will be called for all events in the Connection Parameters Module
* which are passed to the application.
*
* @note All this function does is to disconnect. This could have been done by simply setting
* the disconnect_on_fail config parameter, but instead we use the event handler
* mechanism to demonstrate its use.
*
* @param[in] p_evt Event received from the Connection Parameters Module.
*/
static void on_conn_params_evt(ble_conn_params_evt_t * p_evt)
{
uint32_t err_code;

if (p_evt->evt_type == BLE_CONN_PARAMS_EVT_FAILED)
{
err_code = sd_ble_gap_disconnect(m_conn_handle, BLE_HCI_CONN_INTERVAL_UNACCEPTABLE);
APP_ERROR_CHECK(err_code);
}
}


/**@brief Function for handling errors from the Connection Parameters module.
*
* @param[in] nrf_error Error code containing information about what went wrong.
*/
static void conn_params_error_handler(uint32_t nrf_error)
{
APP_ERROR_HANDLER(nrf_error);
}


/**@brief Function for initializing the Connection Parameters module.
*/
static void conn_params_init(void)
{
uint32_t err_code;
ble_conn_params_init_t cp_init;

memset(&cp_init, 0, sizeof(cp_init));

cp_init.p_conn_params = NULL;
cp_init.first_conn_params_update_delay = FIRST_CONN_PARAMS_UPDATE_DELAY;
cp_init.next_conn_params_update_delay = NEXT_CONN_PARAMS_UPDATE_DELAY;
cp_init.max_conn_params_update_count = MAX_CONN_PARAMS_UPDATE_COUNT;
cp_init.start_on_notify_cccd_handle = BLE_GATT_HANDLE_INVALID;
cp_init.disconnect_on_fail = false;
cp_init.evt_handler = on_conn_params_evt;
cp_init.error_handler = conn_params_error_handler;

err_code = ble_conn_params_init(&cp_init);
APP_ERROR_CHECK(err_code);
}


/**@brief Function for putting the chip into sleep mode.
*
* @note This function will not return.
*/
static void sleep_mode_enter(void)
{
uint32_t err_code = bsp_indication_set(BSP_INDICATE_IDLE);
APP_ERROR_CHECK(err_code);

// Prepare wakeup buttons.
err_code = bsp_btn_ble_sleep_mode_prepare();
APP_ERROR_CHECK(err_code);

// Go to system-off mode (this function will not return; wakeup will cause a reset).
err_code = sd_power_system_off();
APP_ERROR_CHECK(err_code);
}


/**@brief Function for handling advertising events.
*
* @details This function will be called for advertising events which are passed to the application.
*
* @param[in] ble_adv_evt Advertising event.
*/
static void on_adv_evt(ble_adv_evt_t ble_adv_evt)
{
uint32_t err_code;

switch (ble_adv_evt)
{
case BLE_ADV_EVT_FAST:
err_code = bsp_indication_set(BSP_INDICATE_ADVERTISING);
APP_ERROR_CHECK(err_code);
break;
case BLE_ADV_EVT_IDLE:
sleep_mode_enter();
break;
default:
break;
}
}


/**@brief Function for handling BLE events.
*
* @param[in] p_ble_evt Bluetooth stack event.
* @param[in] p_context Unused.
*/
static void ble_evt_handler(ble_evt_t const * p_ble_evt, void * p_context)
{
uint32_t err_code;

switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_CONNECTED:
NRF_LOG_INFO("Connected");
err_code = bsp_indication_set(BSP_INDICATE_CONNECTED);
APP_ERROR_CHECK(err_code);
m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
break;

case BLE_GAP_EVT_DISCONNECTED:
NRF_LOG_INFO("Disconnected");
// LED indication will be changed when advertising starts.
m_conn_handle = BLE_CONN_HANDLE_INVALID;
break;

#ifndef S140
case BLE_GAP_EVT_PHY_UPDATE_REQUEST:
{
NRF_LOG_DEBUG("PHY update request.");
ble_gap_phys_t const phys =
{
.rx_phys = BLE_GAP_PHY_AUTO,
.tx_phys = BLE_GAP_PHY_AUTO,
};
err_code = sd_ble_gap_phy_update(p_ble_evt->evt.gap_evt.conn_handle, &phys);
APP_ERROR_CHECK(err_code);
} break;
#endif

case BLE_GAP_EVT_SEC_PARAMS_REQUEST:
// Pairing not supported
err_code = sd_ble_gap_sec_params_reply(m_conn_handle, BLE_GAP_SEC_STATUS_PAIRING_NOT_SUPP, NULL, NULL);
APP_ERROR_CHECK(err_code);
break;
#if !defined (S112)
case BLE_GAP_EVT_DATA_LENGTH_UPDATE_REQUEST:
{
ble_gap_data_length_params_t dl_params;

// Clearing the struct will effectivly set members to @ref BLE_GAP_DATA_LENGTH_AUTO
memset(&dl_params, 0, sizeof(ble_gap_data_length_params_t));
err_code = sd_ble_gap_data_length_update(p_ble_evt->evt.gap_evt.conn_handle, &dl_params, NULL);
APP_ERROR_CHECK(err_code);
} break;
#endif //!defined (S112)
case BLE_GATTS_EVT_SYS_ATTR_MISSING:
// No system attributes have been stored.
err_code = sd_ble_gatts_sys_attr_set(m_conn_handle, NULL, 0, 0);
APP_ERROR_CHECK(err_code);
break;

case BLE_GATTC_EVT_TIMEOUT:
// Disconnect on GATT Client timeout event.
err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gattc_evt.conn_handle,
BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
APP_ERROR_CHECK(err_code);
break;

case BLE_GATTS_EVT_TIMEOUT:
// Disconnect on GATT Server timeout event.
err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gatts_evt.conn_handle,
BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
APP_ERROR_CHECK(err_code);
break;

case BLE_EVT_USER_MEM_REQUEST:
err_code = sd_ble_user_mem_reply(p_ble_evt->evt.gattc_evt.conn_handle, NULL);
APP_ERROR_CHECK(err_code);
break;

case BLE_GATTS_EVT_RW_AUTHORIZE_REQUEST:
{
ble_gatts_evt_rw_authorize_request_t req;
ble_gatts_rw_authorize_reply_params_t auth_reply;

req = p_ble_evt->evt.gatts_evt.params.authorize_request;

if (req.type != BLE_GATTS_AUTHORIZE_TYPE_INVALID)
{
if ((req.request.write.op == BLE_GATTS_OP_PREP_WRITE_REQ) ||
(req.request.write.op == BLE_GATTS_OP_EXEC_WRITE_REQ_NOW) ||
(req.request.write.op == BLE_GATTS_OP_EXEC_WRITE_REQ_CANCEL))
{
if (req.type == BLE_GATTS_AUTHORIZE_TYPE_WRITE)
{
auth_reply.type = BLE_GATTS_AUTHORIZE_TYPE_WRITE;
}
else
{
auth_reply.type = BLE_GATTS_AUTHORIZE_TYPE_READ;
}
auth_reply.params.write.gatt_status = APP_FEATURE_NOT_SUPPORTED;
err_code = sd_ble_gatts_rw_authorize_reply(p_ble_evt->evt.gatts_evt.conn_handle,
&auth_reply);
APP_ERROR_CHECK(err_code);
}
}
} break; // BLE_GATTS_EVT_RW_AUTHORIZE_REQUEST

default:
// No implementation needed.
break;
}
}


/**@brief Function for the SoftDevice initialization.
*
* @details This function initializes the SoftDevice and the BLE event interrupt.
*/
static void ble_stack_init(void)
{
ret_code_t err_code;

err_code = nrf_sdh_enable_request();
APP_ERROR_CHECK(err_code);

// Configure the BLE stack using the default settings.
// Fetch the start address of the application RAM.
uint32_t ram_start = 0;
err_code = nrf_sdh_ble_default_cfg_set(APP_BLE_CONN_CFG_TAG, &ram_start);
APP_ERROR_CHECK(err_code);

// Enable BLE stack.
err_code = nrf_sdh_ble_enable(&ram_start);
APP_ERROR_CHECK(err_code);

// Register a handler for BLE events.
NRF_SDH_BLE_OBSERVER(m_ble_observer, APP_BLE_OBSERVER_PRIO, ble_evt_handler, NULL);
}


/**@brief Function for handling events from the GATT library. */
void gatt_evt_handler(nrf_ble_gatt_t * p_gatt, nrf_ble_gatt_evt_t const * p_evt)
{
if ((m_conn_handle == p_evt->conn_handle) && (p_evt->evt_id == NRF_BLE_GATT_EVT_ATT_MTU_UPDATED))
{
m_ble_nus_max_data_len = p_evt->params.att_mtu_effective - OPCODE_LENGTH - HANDLE_LENGTH;
NRF_LOG_INFO("Data len is set to 0x%X(%d)", m_ble_nus_max_data_len, m_ble_nus_max_data_len);
}
NRF_LOG_DEBUG("ATT MTU exchange completed. central 0x%x peripheral 0x%x",
p_gatt->att_mtu_desired_central,
p_gatt->att_mtu_desired_periph);
}


/**@brief Function for initializing the GATT library. */
void gatt_init(void)
{
ret_code_t err_code;

err_code = nrf_ble_gatt_init(&m_gatt, gatt_evt_handler);
APP_ERROR_CHECK(err_code);

err_code = nrf_ble_gatt_att_mtu_periph_set(&m_gatt, 64);
APP_ERROR_CHECK(err_code);
}


/**@brief Function for handling events from the BSP module.
*
* @param[in] event Event generated by button press.
*/
void bsp_event_handler(bsp_event_t event)
{
uint32_t err_code;
switch (event)
{
case BSP_EVENT_SLEEP:
sleep_mode_enter();
break;

case BSP_EVENT_DISCONNECT:
err_code = sd_ble_gap_disconnect(m_conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
if (err_code != NRF_ERROR_INVALID_STATE)
{
APP_ERROR_CHECK(err_code);
}
break;

case BSP_EVENT_WHITELIST_OFF:
if (m_conn_handle == BLE_CONN_HANDLE_INVALID)
{
err_code = ble_advertising_restart_without_whitelist(&m_advertising);
if (err_code != NRF_ERROR_INVALID_STATE)
{
APP_ERROR_CHECK(err_code);
}
}
break;

default:
break;
}
}


/**@brief Function for handling app_uart events.
*
* @details This function will receive a single character from the app_uart module and append it to
* a string. The string will be be sent over BLE when the last character received was a
* 'new line' '\n' (hex 0x0A) or if the string has reached the maximum data length.
*/
/**@snippet [Handling the data received over UART] */
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') || (index >= (m_ble_nus_max_data_len)))
{
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_string_send(&m_nus, data_array, &length);
if ( (err_code != NRF_ERROR_INVALID_STATE) && (err_code != NRF_ERROR_BUSY) )
{
APP_ERROR_CHECK(err_code);
}
} while (err_code == NRF_ERROR_BUSY);

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;
}
}
/**@snippet [Handling the data received over UART] */


/**@brief Function for initializing the UART module.
*/
/**@snippet [UART Initialization] */
static void uart_init(void)
{
uint32_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 = NRF_UART_BAUDRATE_115200
};

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);
}
/**@snippet [UART Initialization] */


/**@brief Function for initializing the Advertising functionality.
*/
static void advertising_init(void)
{
uint32_t err_code;
ble_advertising_init_t init;

memset(&init, 0, sizeof(init));

init.advdata.name_type = BLE_ADVDATA_FULL_NAME;
init.advdata.include_appearance = false;
init.advdata.flags = BLE_GAP_ADV_FLAGS_LE_ONLY_LIMITED_DISC_MODE;

init.srdata.uuids_complete.uuid_cnt = sizeof(m_adv_uuids) / sizeof(m_adv_uuids[0]);
init.srdata.uuids_complete.p_uuids = m_adv_uuids;

init.config.ble_adv_fast_enabled = true;
init.config.ble_adv_fast_interval = APP_ADV_INTERVAL;
init.config.ble_adv_fast_timeout = APP_ADV_TIMEOUT_IN_SECONDS;

init.evt_handler = on_adv_evt;

err_code = ble_advertising_init(&m_advertising, &init);
APP_ERROR_CHECK(err_code);

ble_advertising_conn_cfg_tag_set(&m_advertising, APP_BLE_CONN_CFG_TAG);
}


/**@brief Function for initializing buttons and leds.
*
* @param[out] p_erase_bonds Will be true if the clear bonding button was pressed to wake the application up.
*/
static void buttons_leds_init(bool * p_erase_bonds)
{
bsp_event_t startup_event;

uint32_t err_code = bsp_init(BSP_INIT_LED | BSP_INIT_BUTTONS, bsp_event_handler);
APP_ERROR_CHECK(err_code);

err_code = bsp_btn_ble_init(NULL, &startup_event);
APP_ERROR_CHECK(err_code);

*p_erase_bonds = (startup_event == BSP_EVENT_CLEAR_BONDING_DATA);
}


/**@brief Function for initializing the nrf log module.
*/
static void log_init(void)
{
ret_code_t err_code = NRF_LOG_INIT(NULL);
APP_ERROR_CHECK(err_code);

NRF_LOG_DEFAULT_BACKENDS_INIT();
}


/**@brief Function for placing the application in low power state while waiting for events.
*/
static void power_manage(void)
{
uint32_t err_code = sd_app_evt_wait();
APP_ERROR_CHECK(err_code);
}


/**@brief Application main function.
*/
int main(void)
{
uint32_t err_code;
bool erase_bonds;

// Initialize.
err_code = app_timer_init();
APP_ERROR_CHECK(err_code);

uart_init();
log_init();

buttons_leds_init(&erase_bonds);
ble_stack_init();
gap_params_init();
gatt_init();
services_init();
advertising_init();
conn_params_init();

printf("\r\nUART Start!\r\n");
NRF_LOG_INFO("UART Start!");
err_code = ble_advertising_start(&m_advertising, BLE_ADV_MODE_FAST);
APP_ERROR_CHECK(err_code);


leds_config();

lfclk_config();

rtc_config();
// Enter main loop.
for (;;)
{
__SEV();
__WFE();
__WFE();
// UNUSED_RETURN_VALUE(NRF_LOG_PROCESS());
// power_manage();
}
}


/**
* @}
*/

If RTC part commented, BLE advertising works well.

// leds_config();

// lfclk_config();

// rtc_config();

Similarly, if BLE part commented, RTC part works well, i.e. LED 3 is blinking and LED 4 starts after compare event: 3 seconds.

Together it fails!

Please provide your suggestions!

Thank you!

[tesc]

Hi Sanket,

I see that you have started a new thread as well, for this slightly different (but similar) issue that you see. Please keep further discussion in that thread: combining RTC to ble_app_uart fails.

Thanks,
Terje