/**@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 main application entry.
*/
int main(void)
{
LEDS_CONFIGURE(LEDS_MASK);
LEDS_OFF(LEDS_MASK);
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);
#ifndef ENABLE_LOOPBACK_TEST
printf("\n\rStart: \n\r");
while (true)
{
uint8_t cr;
while(app_uart_get(&cr) != NRF_SUCCESS);
while(app_uart_put(cr) != NRF_SUCCESS);
if (cr == 'q' || cr == 'Q')
{
printf(" \n\rExit!\n\r");
while (true)
{
// Do nothing.
}
}
}
#else
// This part of the example is just for testing the loopback .
while (true)
{
uart_loopback_test();
}
#endif
}
/**@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( ¶_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
}
