void main_cbsc_tx_run(void)
{
// Open the ANT channel and initialize the profile module.
channel_open();
uint32_t err_code = cbsc_tx_initialize();
APP_ERROR_CHECK(err_code);
uint8_t ant_channel;
uint8_t event_message_buffer[ANT_EVENT_MSG_BUFFER_MIN_SIZE];
uint8_t event = NO_EVENT;
// Extract and process all pending events, while maximizing application sleep.
for (;;)
{
err_code = sd_app_event_wait();
APP_ERROR_CHECK(err_code);
// Extract and process all pending ANT stack events.
while (sd_ant_event_get(&ant_channel, &event, event_message_buffer) == NRF_SUCCESS)
{
err_code = cbsc_tx_channel_event_handle(event);
APP_ERROR_CHECK(err_code);
}
}
}
int main( int argc, char **argv )
{
// TODO: Disable DC/DC converter to save power
// enable low power mdoe
// setup GPIO
// setup task to toggle pin.
// Configure GPIOTE_CHANNEL_NUMBER to toggle the GPIO pin state with input.
// @note Only one GPIOTE task can be coupled to an output pin.
// GPIOTE uses too much power. Asked in support forum why.
// nrf_gpiote_task_config( GPIOTE_CHANNEL_NUMBER, outPin /* GPIO_OUTPUT_PIN_NUMBER */, \
// NRF_GPIOTE_POLARITY_TOGGLE, NRF_GPIOTE_INITIAL_VALUE_LOW);
// NRF_GPIO->OUT[0] = 0; // todo
// NRF_GPIO->CONFIG[0] =
// setup RTC to generate event on tick every second
// Use crystal as Low frequency clock source
// while(1)
// ;
timers_init();
erl_ble_init( "WordWatch" );
// hfclk_config();
// lfclk_config(); // Hangs with BLE stack.
// sd_clock_
// gpio_config();
spi_init();
display_init();
// NRF_GPIO->OUTSET = (1UL << PIN_VCOM);
nrf_gpio_cfg_output(PIN_VCOM);
// use app_timer instead
// rtc_config();
// while( 1 )
// {
// updateDisplay();
// nrf_delay_us( 100 );
//}
// NRF_GPIO->OUTSET = (1UL << PIN_VCOM);
// setup PPI to automatically toggle GPIO pin on tick event
// Configure PPI channel 0 to stop Timer 0 counter at TIMER1 COMPARE[0] match, which is every even number of seconds.
// NRF_PPI->CH[0].EEP = (uint32_t)(&NRF_RTC0->EVENTS_COMPARE[0]);
// NRF_PPI->CH[0].TEP = (uint32_t)&NRF_GPIOTE->TASKS_OUT[GPIOTE_CHANNEL_NUMBER];
// Enable PPI channel 0
// NRF_PPI->CHEN = (PPI_CHEN_CH0_Enabled << PPI_CHEN_CH0_Pos);
// sleep
while( 1 )
sd_app_event_wait(); // __WFE();
}
/**@brief Function for Stride and Distance Monitor RX example main loop.
*
* @details The main loop will try to sleep as much as possible. Every time a protocol event
* occours, the application will be woken up, polling the ANT stack event queue. When finished
* processing all events, the application will go back to sleep.
*/
void sdm_main_loop(void)
{
uint8_t event_id;
uint8_t ant_channel;
uint32_t err_code;
// ANT event message buffer.
static uint8_t event_message_buffer[ANT_EVENT_MSG_BUFFER_MIN_SIZE];
// Main loop.
for (;;)
{
// Put CPU in sleep if possible.
err_code = sd_app_event_wait();
APP_ERROR_CHECK(err_code);
// Extract and process all pending ANT events as long as there are any left.
do
{
// Fetch the event.
err_code = sd_ant_event_get(&ant_channel, &event_id, event_message_buffer);
if (err_code == NRF_SUCCESS)
{
// Handle event.
switch (event_id)
{
case EVENT_RX:
err_code = sdm_rx_data_process(
&event_message_buffer[ANT_EVENT_BUFFER_INDEX_PAGE_NUM]);
APP_ERROR_CHECK(err_code);
err_code = sdm_rx_log(
event_message_buffer[ANT_EVENT_BUFFER_INDEX_PAGE_NUM]);
APP_ERROR_CHECK(err_code);
break;
case EVENT_RX_FAIL:
err_code = sdm_rx_log(SDM_PAGE_EVENT_RX_FAIL);
APP_ERROR_CHECK(err_code);
break;
default:
break;
}
}
}
while (err_code == NRF_SUCCESS);
}
}
/**@brief Application main function.
*/
int main(void)
{
uint32_t err_code;
timers_init();
gpiote_init();
buttons_init();
if (is_first_start())
{
// The startup was not because of button presses. This is the first start.
// Go into System-Off mode.
// NOTE: This register cannot be set directly after ble_stack_init() because the SoftDevice
// will be enabled.
GPIO_WAKEUP_BUTTON_CONFIG(HR_INC_BUTTON_PIN_NO);
GPIO_WAKEUP_BUTTON_CONFIG(HR_DEC_BUTTON_PIN_NO);
NRF_POWER->SYSTEMOFF = 1;
}
bond_manager_init();
ble_stack_init();
radio_notification_init();
// Initialize Bluetooth Stack parameters
gap_params_init();
advertising_init();
services_init();
conn_params_init();
sec_params_init();
// Actually start advertising
advertising_start();
// Enter main loop
for (;;)
{
// Switch to a low power state until an event is available for the application
err_code = sd_app_event_wait();
APP_ERROR_CHECK(err_code);
}
}
/**@brief Function for waiting for events.
*
* @details This function will place the chip in low power mode while waiting for events from
* the BLE stack or other peripherals. When interrupted by an event, it will call the @ref
* app_sched_execute function to process the received event. This function will return
* when the final state of the firmware update is reached OR when a tear down is in
* progress.
*/
static void wait_for_events(void)
{
for (;;)
{
// Wait in low power state for any events.
uint32_t err_code = sd_app_event_wait();
APP_ERROR_CHECK(err_code);
// Event received. Process it from the scheduler.
app_sched_execute();
if (m_tear_down_in_progress)
{
// Wait until disconnected event is received. Once the disconnected event is received
// from the stack, the macro IS_CONNECTED will return false.
if (!IS_CONNECTED())
{
err_code = sd_softdevice_disable();
APP_ERROR_CHECK(err_code);
if (m_activate_img_after_tear_down)
{
// Start the currently valid application.
(void)dfu_image_activate();
// Ignoring the error code returned by dfu_image_activate because if the
// function fails, there is nothing that can be done to recover, other than
// returning and letting the system go under reset. Also since the
// tear down of the BLE Transport is already complete and the connection
// with the DFU Controller is down. Hence the DFU Controller cannot be informed
// about this failure. It is assumed that the DFU Controller is already
// aware of a failed update procedure from errors returned by earlier
// operations (eg. Validate operation would have returned a failure if there
// was a failed image transfer).
}
return;
}
}
}
}
/**@brief Application main function.
*/
int main(void)
{
uint32_t err_code;
connected = false;
mlog_init();
timers_init();
gpiote_init();
buttons_init();
step_counter_init();
motor_init();
led1_init();
mlog_str("Starting MAIN...\r\n");
bond_manager_init();
ble_stack_init();
radio_notification_init();
// Initialize Bluetooth Stack parameters
gap_params_init();
advertising_init();
services_init();
conn_params_init();
sec_params_init();
// Actually start advertising
//advertising_start();
app_button_enable();
// Enter main loop
for (;;)
{
// Switch to a low power state until an event is available for the application
err_code = sd_app_event_wait();
APP_ERROR_CHECK(err_code);
}
}
/**@brief Power manager.
*/
static void power_manage(void)
{
uint32_t err_code = sd_app_event_wait();
APP_ERROR_CHECK(err_code);
}
/**@brief Function for application main entry, does not return.
*/
int main(void)
{
uint32_t err_code;
// Setup UART.
#if defined(TRACE_UART)
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_error_handle,
APP_IRQ_PRIORITY_LOW,
err_code);
APP_ERROR_CHECK(err_code);
#endif
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(PROTOCOL_EVENT_IRQn, NRF_APP_PRIORITY_LOW);
APP_ERROR_CHECK(err_code);
// Enable application IRQ (triggered from protocol).
err_code = sd_nvic_EnableIRQ(PROTOCOL_EVENT_IRQn);
APP_ERROR_CHECK(err_code);
// Open HRM RX channel.
hrm_rx_open();
uint8_t event;
uint8_t ant_channel;
uint8_t event_message_buffer[ANT_EVENT_MSG_BUFFER_MIN_SIZE];
printf("Enter hrm rx main processing loop...\n");
// Main loop.
for (;;)
{
err_code = sd_app_event_wait();
APP_ERROR_CHECK(err_code);
// Extract and process all pending ANT events.
do
{
err_code = sd_ant_event_get(&ant_channel, &event, event_message_buffer);
if (err_code == NRF_SUCCESS)
{
if (event == EVENT_RX)
{
// We are only interested of RX events.
hrm_rx_channel_event_handle(event_message_buffer);
}
}
}
while (err_code == NRF_SUCCESS);
}
}
/**@brief Function for application main entry. Does not return.
*/
int main(void)
{
// ANT event message buffer.
static uint8_t event_message_buffer[ANT_EVENT_MSG_BUFFER_MIN_SIZE];
// Configure pins LED0 and LED1 as outputs.
nrf_gpio_range_cfg_output(LED_START, LED_STOP);
// Set LED0 and LED1 high to indicate that the application is running.
NRF_GPIO->OUTSET = (1 << LED0) | (1 << LED1);
// Enable SoftDevice.
uint32_t err_code;
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(PROTOCOL_EVENT_IRQn, NRF_APP_PRIORITY_LOW);
APP_ERROR_CHECK(err_code);
// Enable application IRQ (triggered from protocol).
err_code = sd_nvic_EnableIRQ(PROTOCOL_EVENT_IRQn);
APP_ERROR_CHECK(err_code);
// Setup Channel_0 as a RX Slave.
ant_channel_rx_broadcast_setup();
// Set LED0 and LED1 low to indicate that stack is enabled.
NRF_GPIO->OUTCLR = (1 << LED0) | (1 << LED1);
uint8_t event;
uint8_t ant_channel;
// Main loop.
// Extract events from the stack below when
// availabe and process them in the main loop.
for (;;)
{
// Light up LED1 to indicate that CPU is going to sleep
nrf_gpio_pin_set(LED1);
// Put CPU in sleep if possible
err_code = sd_app_event_wait();
APP_ERROR_CHECK(err_code);
// Turn off LED on GPIO 9 to indicate that CPU is going out of sleep
nrf_gpio_pin_clear(LED1);
// Extract and process all pending ANT events as long as there are any left.
do
{
// Fetch the event.
err_code = sd_ant_event_get(&ant_channel, &event, event_message_buffer);
if (err_code == NRF_SUCCESS)
{
// Handle event.
switch (event)
{
case EVENT_RX:
channel_event_handle(event_message_buffer);
break;
default:
break;
}
}
}
while (err_code == NRF_SUCCESS);
}
}