void saadc_sampling_event_init(void) { ret_code_t err_code; err_code = nrf_drv_ppi_init(); APP_ERROR_CHECK(err_code); nrf_drv_timer_config_t timer_config = NRF_DRV_TIMER_DEFAULT_CONFIG; timer_config.frequency = NRF_TIMER_FREQ_31250Hz; err_code = nrf_drv_timer_init(&m_timer, &timer_config, timer_handler); APP_ERROR_CHECK(err_code); /* setup m_timer for compare event */ uint32_t ticks = nrf_drv_timer_ms_to_ticks(&m_timer,SAADC_SAMPLE_RATE); nrf_drv_timer_extended_compare(&m_timer, NRF_TIMER_CC_CHANNEL0, ticks, NRF_TIMER_SHORT_COMPARE0_CLEAR_MASK, false); nrf_drv_timer_enable(&m_timer); uint32_t timer_compare_event_addr = nrf_drv_timer_compare_event_address_get(&m_timer, NRF_TIMER_CC_CHANNEL0); uint32_t saadc_sample_event_addr = nrf_drv_saadc_sample_task_get(); /* setup ppi channel so that timer compare event is triggering sample task in SAADC */ err_code = nrf_drv_ppi_channel_alloc(&m_ppi_channel); APP_ERROR_CHECK(err_code); err_code = nrf_drv_ppi_channel_assign(m_ppi_channel, timer_compare_event_addr, saadc_sample_event_addr); APP_ERROR_CHECK(err_code); }
/** * @brief Function for application main entry. */ int main(void) { ret_code_t err_code; err_code = nrf_drv_ppi_init(); APP_ERROR_CHECK(err_code); err_code = nrf_drv_gpiote_init(); APP_ERROR_CHECK(err_code); nrf_drv_timer_config_t timer_cfg = NRF_DRV_TIMER_DEFAULT_CONFIG; err_code = nrf_drv_timer_init(&timer, &timer_cfg, timer_dummy_handler); APP_ERROR_CHECK(err_code); #ifdef NRF51 //Workaround for PAN-73. *(uint32_t *)0x40008C0C = 1; #endif // Setup PPI channel with event from TIMER compare and task GPIOTE pin toggle. led_blinking_setup(); // Enable timer nrf_drv_timer_enable(&timer); while (true) { // Do Nothing - GPIO can be toggled without software intervention. } }
void BSP_init(void) { uint32_t err_code; err_code = nrf_drv_timer_init(&TIMER1, NULL, Timer1_handler); APP_ERROR_CHECK(err_code); nrf_drv_timer_extended_compare(&TIMER1, NRF_TIMER_CC_CHANNEL0 , nrf_drv_timer_ms_to_ticks(&TIMER1, 1000/BSP_TICKS_PER_SEC) , NRF_TIMER_SHORT_COMPARE0_CLEAR_MASK, true); // Configure button 1 for low accuracy (why not high accuracy?) Q_ALLEGE(nrf_drv_gpiote_init() == NRF_SUCCESS); nrf_drv_gpiote_in_config_t config = GPIOTE_CONFIG_IN_SENSE_TOGGLE(true); config.pull = NRF_GPIO_PIN_PULLUP; Q_ALLEGE(nrf_drv_gpiote_in_init(BTN_PIN, &config, btn1_event_handler) == NRF_SUCCESS); nrf_drv_gpiote_in_event_enable(BTN_PIN, /* int enable = */ true); NRF_GPIO->DIRSET = 1 << GPIO_TP; /* initialize the QS software tracing... */ if (QS_INIT((void *)0) == 0) { Q_ERROR(); } }
/** @brief Function for Timer 1 initialization. * @details Initializes Timer 1 peripheral, creates event and interrupt every 2 seconds, * by configuring CC[0] to timer overflow value, we create events at even number of seconds * for example, events are created at 2,4,6 ... seconds. This event can be used to stop Timer 0 * with Timer1->Event_Compare[0] triggering Timer 0 TASK_STOP through PPI. */ static void timer1_init(void) { // Configure Timer 1 to overflow every 2 seconds. Check TIMER1 configuration for details // The overflow occurs every 0xFFFF/(SysClk/2^PRESCALER). // = 65535/31250 = 2.097 sec ret_code_t err_code = nrf_drv_timer_init(&timer1, NULL, timer_event_handler); APP_ERROR_CHECK(err_code); nrf_drv_timer_extended_compare(&timer1, NRF_TIMER_CC_CHANNEL0, 0xFFFFUL, NRF_TIMER_SHORT_COMPARE0_CLEAR_MASK, false); }
/** @brief Function for Timer 2 initialization. * @details Initializes Timer 2 peripheral, creates event and interrupt every 2 seconds * by configuring CC[0] to half of timer overflow value. Events are created at odd number of seconds. * For example, events are created at 1,3,5,... seconds. This event can be used to start Timer 0 * with Timer2->Event_Compare[0] triggering Timer 0 TASK_START through PPI. */ static void timer2_init(void) { // Generate interrupt/event when half of time before the timer overflows has past, that is at 1,3,5,7... seconds from start. // Check TIMER1 configuration for details // now the overflow occurs every 0xFFFF/(SysClk/2^PRESCALER) // = 65535/31250 = 2.097 sec */ ret_code_t err_code = nrf_drv_timer_init(&timer2, NULL, timer_event_handler); APP_ERROR_CHECK(err_code); nrf_drv_timer_extended_compare(&timer2, NRF_TIMER_CC_CHANNEL0, 0x7FFFUL, NRF_TIMER_SHORT_COMPARE0_CLEAR_MASK, false); }
uint32_t app_simple_timer_init(void) { uint32_t err_code = NRF_SUCCESS; err_code = nrf_drv_timer_init(&SIMPLE_TIMER, NULL, app_simple_timer_event_handler); if(NRF_SUCCESS == err_code) { m_simple_timer_state = SIMPLE_TIMER_STATE_INITIALIZED; } return err_code; }
/** * @brief Function for initializing timers. * * @retval NRF_ERROR_INTERNAL If there were error initializing timers. * @retval NRF_SUCCESS If timers were initialized successfully. */ static ret_code_t timer_init(void) { ret_code_t err_code; //set first timer in timer mode to get period of relaxation oscillator nrf_drv_timer_config_t timer_config = NRF_DRV_TIMER_DEFAULT_CONFIG; timer_config.mode = NRF_TIMER_MODE_TIMER; err_code = nrf_drv_timer_init(&m_timer1, &timer_config, dummy_handler); if (err_code != NRF_SUCCESS) { return NRF_ERROR_INTERNAL; } //set second timer in counter mode and generate event on tenth period timer_config.mode = NRF_TIMER_MODE_COUNTER; err_code = nrf_drv_timer_init(&m_timer0, &timer_config, counter_compare_handler); if (err_code != NRF_SUCCESS) { return NRF_ERROR_INTERNAL; } nrf_drv_timer_extended_compare(&m_timer0, NRF_TIMER_CC_CHANNEL0, MEASUREMENT_PERIOD, (nrf_timer_short_mask_t)(NRF_TIMER_SHORT_COMPARE0_CLEAR_MASK | NRF_TIMER_SHORT_COMPARE0_STOP_MASK), true); return NRF_SUCCESS; }
uint32_t app_simple_timer_init(void) { uint32_t err_code = NRF_SUCCESS; nrf_drv_timer_config_t t_cfg = NRF_DRV_TIMER_DEFAULT_CONFIG; t_cfg.mode = NRF_TIMER_MODE_TIMER; t_cfg.bit_width = NRF_TIMER_BIT_WIDTH_16; t_cfg.frequency = (nrf_timer_frequency_t)SIMPLE_TIMER_CONFIG_FREQUENCY; err_code = nrf_drv_timer_init(&SIMPLE_TIMER, &t_cfg, app_simple_timer_event_handler); if (NRF_SUCCESS == err_code) { m_simple_timer_state = SIMPLE_TIMER_STATE_INITIALIZED; } return err_code; }
/** @brief Function initialization and configuration of timer driver instance. */ static void timer_config(void) { uint32_t time_in_ms = 1000; //Time(in miliseconds) between consecutive compare events. // see uint32_t time2ticks; uint32_t err_code; err_code = nrf_drv_timer_init(&mytimer1, NULL, timer1_handler); APP_ERROR_CHECK(err_code); time2ticks = nrf_drv_timer_ms_to_ticks(&mytimer1, time_in_ms); /* |----| |----| | | | | ____| |______________________..._____| |____... 1s 1s 8s 1s 1s */ nrf_drv_timer_extended_compare(&mytimer1, NRF_TIMER_CC_CHANNEL0, time2ticks, NRF_TIMER_SHORT_COMPARE0_CLEAR_MASK, true); nrf_drv_timer_enable(&mytimer1); }
/** @brief Function for Timer 0 initialization, which will be started and stopped by timer1 and timer2 using PPI. */ static void timer0_init(void) { ret_code_t err_code = nrf_drv_timer_init(&timer0, NULL, timer_event_handler); APP_ERROR_CHECK(err_code); }
/** @brief Function for initializing PPI used in infrared signal decoding * The PPI is needed to convert the timer event into a task. */ uint32_t ir_ppi_init(void) { uint32_t gpiote_event_addr; uint32_t timer_task_addr; nrf_ppi_channel_t ppi_channel; ret_code_t err_code; nrf_drv_gpiote_in_config_t config; config.sense = NRF_GPIOTE_POLARITY_HITOLO; config.pull = NRF_GPIO_PIN_PULLUP; config.hi_accuracy = false; config.is_watcher = false; nrf_drv_timer_config_t timer_config; timer_config.frequency = NRF_TIMER_FREQ_1MHz; timer_config.mode = NRF_TIMER_MODE_TIMER; timer_config.bit_width = NRF_TIMER_BIT_WIDTH_32; timer_config.interrupt_priority = 3; err_code = nrf_drv_timer_init(&ir_timer, &timer_config, timer_dummy_handler); APP_ERROR_CHECK(err_code); // Set up GPIOTE err_code = nrf_drv_gpiote_in_init(IR_RECEIVER_PIN_1, &config, ir_in_pin_handler); APP_ERROR_CHECK(err_code); err_code = nrf_drv_gpiote_in_init(IR_RECEIVER_PIN_2, &config, ir_in_pin_handler); APP_ERROR_CHECK(err_code); err_code = nrf_drv_gpiote_in_init(IR_RECEIVER_PIN_3, &config, ir_in_pin_handler); APP_ERROR_CHECK(err_code); // Set up timer for capturing nrf_drv_timer_capture_get(&ir_timer, NRF_TIMER_CC_CHANNEL0); // Set up PPI channel err_code = nrf_drv_ppi_channel_alloc(&ppi_channel); APP_ERROR_CHECK(err_code); timer_task_addr = nrf_drv_timer_capture_task_address_get(&ir_timer, NRF_TIMER_CC_CHANNEL0); gpiote_event_addr = nrf_drv_gpiote_in_event_addr_get(IR_RECEIVER_PIN_1); //err_code = nrf_drv_ppi_channel_assign(ppi_channel, gpiote_event_addr, timer_task_addr); //APP_ERROR_CHECK(err_code); //err_code = nrf_drv_ppi_channel_enable(ppi_channel); //APP_ERROR_CHECK(err_code); nrf_drv_gpiote_in_event_enable(IR_RECEIVER_PIN_1, true); nrf_drv_gpiote_in_event_enable(IR_RECEIVER_PIN_2, true); nrf_drv_gpiote_in_event_enable(IR_RECEIVER_PIN_3, true); // Enable timer nrf_drv_timer_enable(&ir_timer); return 0; }