自学教程：C++ APP_UART_FIFO_INIT函数代码示例

/**@brief Function for initializing the UART. */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_Baud38400       };    APP_UART_FIFO_INIT(&comm_params,                          UART_RX_BUF_SIZE,                          UART_TX_BUF_SIZE,                          uart_error_handle,                          APP_IRQ_PRIORITY_LOW,                          err_code);    APP_ERROR_CHECK(err_code);    app_trace_init();}

/**@brief Function for main application entry. Does not return. */int main(){#if defined(TRACE_UART)    // Configure and make UART ready for usage.    app_uart_comm_params_t comm_params =    {        RX_PIN_NUMBER,        TX_PIN_NUMBER,        RTS_PIN_NUMBER,        CTS_PIN_NUMBER,        APP_UART_FLOW_CONTROL_DISABLED,        false,        UART_BAUDRATE_BAUDRATE_Baud38400    };    uint32_t err_code;    APP_UART_FIFO_INIT(&comm_params,                       UART_RX_BUF_SIZE,                       UART_TX_BUF_SIZE,                       uart_error_handle,                       APP_IRQ_PRIORITY_LOW,                       err_code);    APP_ERROR_CHECK(err_code);#endif // defined(TRACE_UART)    softdevice_setup();    // Run bicycle power-only TX main processing loop. Does not return.    bp_only_tx_main_loop_run();    return 0;}

// Initialzes non blocking serial communication with terminal via uart. Returns 0 on success, -1 on an error.int uart_init(){  uint32_t err_code;  const app_uart_comm_params_t comm_params =  {      RX_PIN_NUMBER,      TX_PIN_NUMBER,      UART_PIN_DISCONNECTED,      UART_PIN_DISCONNECTED,      APP_UART_FLOW_CONTROL_DISABLED,      false,      UART_BAUDRATE_BAUDRATE_Baud38400  };  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);  if (err_code != NRF_SUCCESS)  {    return -1;  }  return 0;}

/**@brief Function for application main entry, does not return. */int main(void){#if defined(TRACE_UART)      // Configure and make UART ready for usage.     const app_uart_comm_params_t comm_params =      {        RX_PIN_NUMBER,         TX_PIN_NUMBER,         RTS_PIN_NUMBER,         CTS_PIN_NUMBER,         APP_UART_FLOW_CONTROL_DISABLED,         false,         UART_BAUDRATE_BAUDRATE_Baud38400    };             uint32_t err_code;    APP_UART_FIFO_INIT(&comm_params,                        UART_RX_BUF_SIZE,                        UART_TX_BUF_SIZE,                        uart_error_handle,                        APP_IRQ_PRIORITY_LOW,                       err_code);    APP_ERROR_CHECK(err_code);#endif // defined(TRACE_UART)           printf("+enter main/n");    softdevice_setup();    // Run HRM TX main thread - does not return.    main_hrm_tx_run();       return 0;} 

static void uart_init(void){    const app_uart_comm_params_t comm_params =    {        RX_PIN_NUMBER,        TX_PIN_NUMBER,        0,        0,        APP_UART_FLOW_CONTROL_DISABLED,        false,        UART_BAUDRATE_BAUDRATE_Baud38400    };    uint32_t err_code;    APP_UART_FIFO_INIT(&comm_params,            RX_BUF_SIZE,            TX_BUF_SIZE,            uart_error_handle,            APP_IRQ_PRIORITY_LOW,            err_code);    APP_ERROR_CHECK(err_code);    printf("/r/nbooting/r/n");}

bool bridge_uart_init(){    uint32_t baud_rate_reg;      bridge_set_baud_rate_register(sensor_bridge.config.baud_rate, &baud_rate_reg);          const app_uart_comm_params_t  p_comm_params =     {        UART_RX_PIN,        UART_TX_PIN,        0,        0,           APP_UART_FLOW_CONTROL_DISABLED,        false,        baud_rate_reg    };    uint32_t error;        APP_UART_FIFO_INIT(&p_comm_params,												32,												32,												bridge_uart_event_handler,												APP_IRQ_PRIORITY_LOW,												error);        if(error != NRF_SUCCESS)    {        return false;    }        return true;}

uint32_t sdm_rx_init(void){       #if defined(TRACE_UART)    app_uart_comm_params_t comm_params =      {        RX_PIN_NUMBER,         TX_PIN_NUMBER,         RTS_PIN_NUMBER,         CTS_PIN_NUMBER,         APP_UART_FLOW_CONTROL_DISABLED,         false,         UART_BAUDRATE_BAUDRATE_Baud38400    };             uint32_t err_code;    APP_UART_FIFO_INIT(&comm_params,                        UART_RX_BUF_SIZE,                        UART_TX_BUF_SIZE,                        uart_error_handle,                        APP_IRQ_PRIORITY_LOW,                       err_code);    APP_ERROR_CHECK(err_code);#endif // TRACE_UART#if defined(TRACE_GPIO)    //  Configure pins LED_0 and LED_1 as outputs.     nrf_gpio_range_cfg_output(SDM_GPIO_START, SDM_GPIO_STOP);        //  Reset the pins if they already are in a high state.     nrf_gpio_pin_clear(SDM_GPIO_0);    nrf_gpio_pin_clear(SDM_GPIO_1);    nrf_gpio_pin_clear(SDM_GPIO_2);#endif // TRACE_GPIO    return NRF_SUCCESS;         }

/** @brief Function for main application entry. */int main(void){    // Setup bsp module.    bsp_configuration();	    //uart initialization    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_error_handle,                         APP_IRQ_PRIORITY_LOW,                         err_code);		    APP_ERROR_CHECK(err_code);					while(app_uart_put(86) != NRF_SUCCESS);		intan_setup();				  while(app_uart_put(87) != NRF_SUCCESS);    // initialize the buffer     buffer_init(&db, DATA_BUF_SIZE, sizeof(uint8_t));					while(app_uart_put(88) != NRF_SUCCESS);    for (;;)    {		//	printf("ldsakjf;ljdsaflkjlljlk/n"); 			while(app_uart_put(89) != NRF_SUCCESS);			        if (m_transfer_completed)        {            m_transfer_completed = false;            intan_convert(m_tx_data_spi, m_rx_data_spi,intan_convert_channel);	             //print m_rx_data_spi results            switch_state();					  for (int i; i< RX_MSG_LENGTH; i++){							while(app_uart_put(m_rx_data_spi[i]) != NRF_SUCCESS);						}            nrf_delay_ms(DELAY_MS);						//printf("Hi/n");        }				//printf("Yo/n");    }}

/**@brief Function for application main entry, does not return. * * @details The main function will do all necessary initalization. This includes sdm rx module * and SoftDevice. */int main(void){    uint32_t err_code;#if defined(TRACE_UART)    app_uart_comm_params_t comm_params =    {        RX_PIN_NUMBER,        TX_PIN_NUMBER,        RTS_PIN_NUMBER,        CTS_PIN_NUMBER,        APP_UART_FLOW_CONTROL_DISABLED,        false,        UART_BAUDRATE_BAUDRATE_Baud38400    };    APP_UART_FIFO_INIT(&comm_params,                       UART_RX_BUF_SIZE,                       UART_TX_BUF_SIZE,                       uart_error_handle,                       APP_IRQ_PRIORITY_LOW,                       err_code);    APP_ERROR_CHECK(err_code);#endif // TRACE_UART#if defined(TRACE_GPIO)    // Initialize timer module.    APP_TIMER_INIT(APP_TIMER_PRESCALER, APP_TIMER_MAX_TIMERS, APP_TIMER_OP_QUEUE_SIZE, false);    err_code = bsp_init(BSP_INIT_LED, APP_TIMER_TICKS(100, APP_TIMER_PRESCALER), NULL);    APP_ERROR_CHECK(err_code);#endif // TRACE_GPIO    // In case of logging enabled, we enable sdm_rx module first.    err_code = sdm_rx_init();    APP_ERROR_CHECK(err_code);    // Enable SoftDevice.    err_code = sd_softdevice_enable(NRF_CLOCK_LFCLKSRC_XTAL_50_PPM, softdevice_assert_callback);    APP_ERROR_CHECK(err_code);    // Set application IRQ to lowest priority.    err_code = sd_nvic_SetPriority(SD_EVT_IRQn, NRF_APP_PRIORITY_LOW);    APP_ERROR_CHECK(err_code);    // Enable application IRQ (triggered from protocol).    err_code = sd_nvic_EnableIRQ(SD_EVT_IRQn);    APP_ERROR_CHECK(err_code);    err_code = ant_stack_static_config();    APP_ERROR_CHECK(err_code);    // Setup Channel_0 as a SDM RX.    ant_channel_sdm_rx_setup();    sdm_main_loop();}

/** * @brief Function for application main entry. */int main(void){    timer0_init(); // Timer used to blink the LEDs.    timer1_init(); // Timer to generate events on even number of seconds.    timer2_init(); // Timer to generate events on odd number of seconds.    ppi_init();    // PPI to redirect the event to timer start/stop tasks.    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_error_handle,                    APP_IRQ_PRIORITY_LOW,                    err_code);    APP_ERROR_CHECK(err_code);    // Enabling constant latency as indicated by PAN 11 "HFCLK: Base current with HFCLK     // running is too high" found at Product Anomaly document found at    // https://www.nordicsemi.com/eng/Products/Bluetooth-R-low-energy/nRF51822/#Downloads    //    // @note This example does not go to low power mode therefore constant latency is not needed.    //       However this setting will ensure correct behaviour when routing TIMER events through     //       PPI (shown in this example) and low power mode simultaneously.    NRF_POWER->TASKS_CONSTLAT = 1;        // Start clock.    nrf_drv_timer_enable(&timer0);    nrf_drv_timer_enable(&timer1);    nrf_drv_timer_enable(&timer2);    // Loop and increment the timer count value and capture value into LEDs. @note counter is only incremented between TASK_START and TASK_STOP.    while (true)    {        printf("Current count: %d/n/r", (int)nrf_drv_timer_capture(&timer0,NRF_TIMER_CC_CHANNEL0));        /* increment the counter */        nrf_drv_timer_increment(&timer0);        nrf_delay_ms(100);    }}

/**@snippet [UART Initialization] */static void uart_init(void){    uint32_t                     err_code;    const app_uart_comm_params_t 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);}/**@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;    ble_adv_modes_config_t options;    // 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;    memset(&options, 0, sizeof(options));    options.ble_adv_fast_enabled  = true;    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);    ble_advertising_conn_cfg_tag_set(CONN_CFG_TAG);}

/**@brief  Function for initializing the UART module. */static void uart_init(void){    uint32_t err_code;        APP_UART_FIFO_INIT(&comm_params,                        RX_BUF_SIZE,                        TX_BUF_SIZE,                        uart_evt_callback,                        UART_IRQ_PRIORITY,                        err_code);        APP_ERROR_CHECK(err_code);}

/**@brief Function for application main entry. */int main(void){    uint32_t err_code;    // Initialize.    app_trace_init();    timers_init();    APP_GPIOTE_INIT(1);    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_Baud38400       };    APP_UART_FIFO_INIT(&comm_params,                          UART_RX_BUF_SIZE,                          UART_TX_BUF_SIZE,                          uart_error_handle,                          APP_IRQ_PRIORITY_LOW,                          err_code);    err_code = bsp_init(BSP_INIT_LED | BSP_INIT_BUTTONS,                        APP_TIMER_TICKS(100, APP_TIMER_PRESCALER),                        button_event_handler);    APP_ERROR_CHECK(err_code);    ble_stack_init();    device_manager_init();    gap_params_init();    advertising_init();    services_init();    sensor_simulator_init();    conn_params_init();    // Start execution.    application_timers_start();    advertising_start();    // Enter main loop.    for (;;)    {        power_manage();    }}

/** * @brief Function for application main entry. * @return 0. int return type required by ANSI/ISO standard. */int main(void){    uint32_t err_code = NRF_SUCCESS;        clock_initialization();    APP_TIMER_INIT(APP_TIMER_PRESCALER, APP_TIMER_OP_QUEUE_SIZE, NULL);            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_error_handle,                        APP_IRQ_PRIORITY_LOW,                       err_code);            err_code = bsp_init(BSP_INIT_LED | BSP_INIT_BUTTONS,                        APP_TIMER_TICKS(100, APP_TIMER_PRESCALER),                        bsp_evt_handler);    APP_ERROR_CHECK(err_code);    // Set radio configuration parameters    radio_configure();    // Set payload pointer    NRF_RADIO->PACKETPTR = (uint32_t)&packet;    err_code = bsp_indication_text_set(BSP_INDICATE_USER_STATE_OFF, "Press Any Button/n/r");    APP_ERROR_CHECK(err_code);    while (true)    {        if(packet != 0)        {            send_packet();            printf("The contents of the package was %u/n/r", (unsigned int)packet);            packet = 0;        }        __WFE();    }}

/** @brief Function for main application entry. */int main(void){    // This function contains workaround for PAN_028 rev2.0A anomalies 28, 29,30 and 31.    int32_t volatile temp;    nrf_temp_init();    uint32_t err_code;    APP_GPIOTE_INIT(1);    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_Baud38400     };    APP_UART_FIFO_INIT(&comm_params,                    UART_RX_BUF_SIZE,                    UART_TX_BUF_SIZE,                    uart_error_handle,                    APP_IRQ_PRIORITY_LOW,                    err_code);    APP_ERROR_CHECK(err_code);    while (true)    {        NRF_TEMP->TASKS_START = 1; /** Start the temperature measurement. */        /* Busy wait while temperature measurement is not finished, you can skip waiting if you enable interrupt for DATARDY event and read the result in the interrupt. */        /*lint -e{845} // A zero has been given as right argument to operator '|'" */        while (NRF_TEMP->EVENTS_DATARDY == 0)        {            // Do nothing.        }        NRF_TEMP->EVENTS_DATARDY = 0;        /**@note Workaround for PAN_028 rev2.0A anomaly 29 - TEMP: Stop task clears the TEMP register. */        temp = (nrf_temp_read() / 4);        /**@note Workaround for PAN_028 rev2.0A anomaly 30 - TEMP: Temp module analog front end does not power down when DATARDY event occurs. */        NRF_TEMP->TASKS_STOP = 1; /** Stop the temperature measurement. */        printf("Actual temperature: %d/n/r", (int)temp);        nrf_delay_ms(500);    }}

uint32_t uart_init(void) {  uint32_t err_code;  const app_uart_comm_params_t comm_params = {    .rx_pin_no = RX_PIN_NUMBER,    .tx_pin_no = TX_PIN_NUMBER,    .rts_pin_no = 0,    .cts_pin_no = 0,    .flow_control = APP_UART_FLOW_CONTROL_DISABLED,    .use_parity = false,    .baud_rate = UART_BAUDRATE_BAUDRATE_Baud38400  };  /* With the softdevice interrupts happening we need to use a UART fifo to ensure we don't lose   * bytes. Additionally, the behavior seems unpredictable at 115200 baud, and after reading   * responses from nRF employees the safer plan seems to be to use a lower baud rate */  APP_UART_FIFO_INIT(&comm_params, UART_TX_BUF, UART_RX_BUF, uart_error_handle, APP_IRQ_PRIORITY_LOW, err_code);  return err_code;}int main(void){  uint32_t ret;  uart_init();  puts("welcome to coral.");  for (int i = 0; i < sizeof(tx_buf); i++) {    tx_buf[i] = i;  }  ble_stack_setup();  if ((ret = spi_init()) != NRF_SUCCESS) {    printf("spi_init() failure: %lu/n", ret);  }   while (1) {    nrf_delay_ms(1000);    uint32_t ret = spi_transfer(tx_buf, sizeof(tx_buf), NULL, 0);    if (ret != NRF_SUCCESS) {      printf("SPI Error: %lu/n", ret);      break;    }  }  for(;;)   return 0;}

void boardInit(void){  uint32_t error;  static app_button_cfg_t button_cfg[BOARD_BUTTON_NUM];  /* Configure and enable the timer app */	APP_TIMER_INIT(CFG_TIMER_PRESCALER, CFG_TIMER_MAX_INSTANCE, CFG_TIMER_OPERATION_QUEUE_SIZE, CFG_SCHEDULER_ENABLE);  /* Initialise GPIOTE */  APP_GPIOTE_INIT(CFG_GPIOTE_MAX_USERS);  /* LED Settings */  for(uint8_t i=0; i<BOARD_LED_NUM; i++)  {    nrf_gpio_cfg_output( led_gpio[i] );  }  /* Button Settings */  for(uint8_t i=0; i<BOARD_BUTTON_NUM; i++)  {    /* Pins are configued with pullups since none are present on the PCB */    button_cfg[i] = (app_button_cfg_t)                    {                      .pin_no = button_gpio[i],                      .active_state = BOARD_BUTTON_ACTIVE_STATE ? true : false,                      .pull_cfg = NRF_GPIO_PIN_PULLUP,                      .button_handler = button_event_handler                    };  };  APP_BUTTON_INIT(button_cfg, BOARD_BUTTON_NUM,                  APP_TIMER_TICKS(BOARD_BUTTON_DETECTION_INTERVAL_MS, CFG_TIMER_PRESCALER), false);  /* UART Settings */  app_uart_comm_params_t para_uart =  {    .rx_pin_no    = BOARD_UART_RXD_PIN,    .tx_pin_no    = BOARD_UART_TXD_PIN,    .rts_pin_no   = BOARD_UART_RTS_PIN,    .cts_pin_no   = BOARD_UART_CTS_PIN,    .flow_control = APP_UART_FLOW_CONTROL_ENABLED,    .use_parity   = false,    .baud_rate    = get_baudrate(CFG_UART_BAUDRATE)  };  /* Initialise the UART FIFO */  APP_UART_FIFO_INIT( &para_uart, CFG_UART_BUFSIZE, CFG_UART_BUFSIZE, board_uart_event_handler, APP_IRQ_PRIORITY_LOW, error);  ASSERT_STATUS_RET_VOID( (error_t) error );}

uint32_t UART_Init(uint8_t rx_pin, uint8_t tx_pin, uint32_t baud_rate){	uint32_t err_code = 0;	const app_uart_comm_params_t comm_params = {rx_pin, tx_pin, 0, 0, APP_UART_FLOW_CONTROL_DISABLED, false, baud_rate};		//APP_UART_INIT(&comm_params, uart_error_handle, APP_IRQ_PRIORITY_LOW, err_code);		APP_UART_FIFO_INIT(&comm_params,                         1,		//UART_RX_BUF_SIZE                         256,	//UART_TX_BUF_SIZE                         uart_error_handle,                         APP_IRQ_PRIORITY_LOW,                         err_code);	return err_code;}

void uart_init(){	uint32_t err_code;	app_uart_comm_params_t cfg;	cfg.rx_pin_no = UART_RX_PIN;	cfg.tx_pin_no = UART_TX_PIN;	cfg.rts_pin_no = UART_RTS_PIN;	cfg.cts_pin_no = UART_CTS_PIN;	cfg.flow_control = APP_UART_FLOW_CONTROL_DISABLED;	cfg.use_parity = false;	cfg.baud_rate = UART_BAUDRATE_BAUDRATE_Baud115200;	APP_UART_FIFO_INIT(&cfg, 32, 32, uart_evt_handler, APP_IRQ_PRIORITY_LOW, err_code);}

int main(void){    // Initialization of various modules.    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_Baud38400       };    APP_UART_FIFO_INIT(&comm_params,                          UART_RX_BUF_SIZE,                          UART_TX_BUF_SIZE,                          uart_error_handle,                          APP_IRQ_PRIORITY_LOW,                          err_code);    APP_ERROR_CHECK(err_code);    app_trace_init();    APP_TIMER_INIT(APP_TIMER_PRESCALER, APP_TIMER_MAX_TIMERS, APP_TIMER_OP_QUEUE_SIZE, NULL);    APP_GPIOTE_INIT(1);    err_code = bsp_init(BSP_INIT_LED | BSP_INIT_BUTTONS, APP_TIMER_TICKS(100, APP_TIMER_PRESCALER),NULL);    APP_ERROR_CHECK(err_code);    printf("Heart rate collector example/r/n");    ble_stack_init();    device_manager_init();    db_discovery_init();    hrs_c_init();    bas_c_init();    // Start scanning for peripherals and initiate connection    // with devices that advertise Heart Rate UUID.    scan_start();    for (;; )    {        power_manage();    }}

static void uart_init(void){#ifdef USE_UART_LOGGING  int status = NRF_SUCCESS;  const app_uart_comm_params_t uart_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_ENABLED,    .use_parity = false,    .baud_rate = UART_BAUDRATE_BAUDRATE_Baud38400  };  APP_UART_FIFO_INIT(&uart_params, UART_RX_BUF_SIZE, UART_TX_BUF_SIZE, uart_event_handler, APP_IRQ_PRIORITY_LOW, status);  APP_ERROR_CHECK(status);#endif}static void uart_putstring(const uint8_t * string){#ifdef USE_UART_LOGGING  for(int i = 0; string[i] != 0; ++i)    app_uart_put(string[i]);#endif}/*** Interrupt handler for Softdevice events*/void SD_EVT_IRQHandler(void){  uint32_t evt;  ble_evt_t ble_evt;  uint16_t len;  while(sd_evt_get(&evt) == NRF_SUCCESS)  {    btle_hci_adv_sd_evt_handler(evt);  }  while (sd_ble_evt_get((uint8_t *) &evt, &len) == NRF_SUCCESS)  {    nrf_adv_conn_evt_handler(&ble_evt);  }}

/** @brief Function for main application entry. */int main(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_error_handle,                         APP_IRQ_PRIORITY_LOW,                         err_code);    APP_ERROR_CHECK(err_code);#ifdef SOFTDEVICE_PRESENT    nrf_clock_lf_cfg_t clock_lf_cfg = NRF_CLOCK_LFCLKSRC;    SOFTDEVICE_HANDLER_INIT(&clock_lf_cfg, NULL);#endif // SOFTDEVICE_PRESENT    err_code = nrf_drv_rng_init(NULL);    APP_ERROR_CHECK(err_code);        while (true)    {        uint8_t p_buff[RANDOM_BUFF_SIZE];        uint8_t length = random_vector_generate(p_buff,RANDOM_BUFF_SIZE);        printf("Random Vector:");        for(uint8_t i = 0; i < length; i++)        {            printf(" %3d",(int)p_buff[i]);        }        printf("/n/r");        nrf_delay_ms(100);    }}

/** * @brief Function for application main entry. * @return 0. int return type required by ANSI/ISO standard. */int main(void){    uint32_t err_code = NRF_SUCCESS;    clock_initialization();    APP_TIMER_INIT(APP_TIMER_PRESCALER, APP_TIMER_OP_QUEUE_SIZE, NULL);    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_Baud38400    };    APP_UART_FIFO_INIT(&comm_params,                       UART_RX_BUF_SIZE,                       UART_TX_BUF_SIZE,                       uart_error_handle,                       APP_IRQ_PRIORITY_LOW,                       err_code);    APP_ERROR_CHECK(err_code);    err_code = bsp_init(BSP_INIT_LED, APP_TIMER_TICKS(100, APP_TIMER_PRESCALER), NULL);    APP_ERROR_CHECK(err_code);    // Set radio configuration parameters    radio_configure();    NRF_RADIO->PACKETPTR = (uint32_t)&packet;    err_code = bsp_indication_text_set(BSP_INDICATE_USER_STATE_OFF, "Wait for first packet/n/r");    APP_ERROR_CHECK(err_code);    while (true)    {        uint32_t received = read_packet();        err_code = bsp_indication_text_set(BSP_INDICATE_RCV_OK, "Packet was received/n/r");        APP_ERROR_CHECK(err_code);        printf("The contents of the package is %u/n/r", (unsigned int)received);    }}

void debug_log_init(void){    uint32_t err_code = NRF_SUCCESS;    const app_uart_comm_params_t comm_params =  {        RX_PIN_NUMBER,         TX_PIN_NUMBER,         RTS_PIN_NUMBER,         CTS_PIN_NUMBER,         APP_UART_FLOW_CONTROL_DISABLED,         false,         UART_BAUDRATE_BAUDRATE_Baud115200    };             APP_UART_FIFO_INIT(&comm_params,                        UART_RX_BUF_SIZE,                        UART_TX_BUF_SIZE,                        uart_error_handle,                        APP_IRQ_PRIORITY_LOW,                       err_code);    UNUSED_VARIABLE(err_code);}

void hif_setup(uint8_t rx_pin, uint8_t tx_pin){       uint32_t err_code;    app_uart_comm_params_t comm_params;        comm_params.rx_pin_no  = rx_pin;    comm_params.tx_pin_no  = tx_pin;    comm_params.rts_pin_no = 0;    comm_params.cts_pin_no = 0;    comm_params.flow_control = APP_UART_FLOW_CONTROL_DISABLED;    comm_params.use_parity   = false;    comm_params.baud_rate    = UART_BAUDRATE_BAUDRATE_Baud9600;    APP_UART_FIFO_INIT(&comm_params,                        128,                        128,                        uart_evt_callback,                        APP_IRQ_PRIORITY_LOW,                        err_code);    APP_ERROR_CHECK(err_code);}

void init_uart(void) {    uint32_t err_code;		const app_uart_comm_params_t comm_params =      {          RX_PIN_NUMBER,          TX_PIN_NUMBER,          0xFF,          0xFF,          APP_UART_FLOW_CONTROL_DISABLED,          false,          UART_BAUDRATE_BAUDRATE_Baud230400      };    APP_UART_FIFO_INIT(&comm_params,                         1,                         128,                         uart_error_handle,                         APP_IRQ_PRIORITY_LOW,                         err_code);    APP_ERROR_CHECK(err_code);	}

// Function for initializing the UART module.void uart_init(){    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_Baud38400    };    APP_UART_FIFO_INIT( &comm_params,                       256,                       256,                       uart_event_handle,                       APP_IRQ_PRIORITY_LOW,                       err_code);    APP_ERROR_CHECK(err_code);}

/** * @brief UART initialization. */void uart_config(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_DISABLED,        false,        UART_BAUDRATE_BAUDRATE_Baud38400    };    APP_UART_FIFO_INIT(&comm_params,                       UART_RX_BUF_SIZE,                       UART_TX_BUF_SIZE,                       uart_events_handler,                       APP_IRQ_PRIORITY_LOW,                       err_code);    APP_ERROR_CHECK(err_code);}

uint32_t write_app_uart_init_with_pins(uint8_t rts_pin_number,                                       uint8_t txd_pin_number,                                       uint8_t cts_pin_number,                                       uint8_t rxd_pin_number,                                       bool hwfc) {#ifdef WRITE_TO_APP_UART    static bool already_initialized = false;    if(already_initialized) {        return NRF_ERROR_INVALID_STATE;    }    uint32_t err_code;    const app_uart_comm_params_t comm_params = {        rxd_pin_number,        txd_pin_number,        rts_pin_number,        cts_pin_number,        (hwfc ? APP_UART_FLOW_CONTROL_ENABLED : APP_UART_FLOW_CONTROL_DISABLED),        false,        UART_BAUDRATE_BAUDRATE_Baud38400      };    APP_UART_FIFO_INIT(&comm_params, UART_RX_BUF_SIZE, UART_TX_BUF_SIZE, uart_event_handle, APP_IRQ_PRIORITY_LOW, err_code);    already_initialized = true;    nrf_delay_ms(100);    return err_code;#else				return NRF_SUCCESS;#endif}