ret_code_t nrf_drv_csense_sample(void) { ASSERT(m_csense.module_state == NRF_DRV_STATE_POWERED_ON); if(m_csense.adc_channels_input_mask != 0) { if(m_csense.channels_to_read == 0) { #if USE_COMP == 0 && defined(SAADC_PRESENT) nrf_saadc_enable(); #endif if(nrf_drv_csense_is_busy() == true) { return NRF_ERROR_BUSY; } m_csense.busy = true; m_csense.channels_to_read = m_csense.adc_channels_input_mask; calculate_next_channel(); } #if USE_COMP if (!m_csense.timers_powered_on) { nrf_drv_timer_enable(&m_timer0); nrf_drv_timer_enable(&m_timer1); m_csense.timers_powered_on = true; } else { nrf_drv_timer_resume(&m_timer0); nrf_drv_timer_resume(&m_timer1); } nrf_drv_comp_pin_select((nrf_comp_input_t)m_csense.cur_chann_idx); nrf_drv_comp_start(0, 0); #else ret_code_t err_code; #ifdef ADC_PRESENT adc_channel.config.config.ain = (nrf_adc_config_input_t)(1<<m_csense.cur_chann_idx); nrf_gpio_pin_clear(m_csense.output_pin); err_code = nrf_drv_adc_sample_convert(&adc_channel, NULL); #elif defined(SAADC_PRESENT) saadc_channel.pin_p = (nrf_saadc_input_t)(m_csense.cur_chann_idx + 1); nrf_saadc_channel_input_set(0, saadc_channel.pin_p, NRF_SAADC_INPUT_DISABLED); nrf_gpio_pin_clear(m_csense.output_pin); err_code = nrf_drv_saadc_sample(); #endif //ADC_PRESENT if(err_code != NRF_SUCCESS) { return err_code; } #endif //USE_COMP } return NRF_SUCCESS; }
/** * @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); } }
/** * @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. } }
uint32_t app_simple_timer_start(app_simple_timer_mode_t mode, app_simple_timer_timeout_handler_t timeout_handler, uint16_t timeout_ticks, void * p_context) { uint32_t err_code = NRF_SUCCESS; nrf_timer_short_mask_t timer_short; VERIFY_PARAM_NOT_NULL(timeout_handler); if (APP_SIMPLE_TIMER_MODE_REPEATED == mode) { timer_short = NRF_TIMER_SHORT_COMPARE0_CLEAR_MASK; } else if (APP_SIMPLE_TIMER_MODE_SINGLE_SHOT == mode) { timer_short = NRF_TIMER_SHORT_COMPARE0_STOP_MASK; } else { return NRF_ERROR_INVALID_PARAM; } if (SIMPLE_TIMER_STATE_IDLE == m_simple_timer_state) { return NRF_ERROR_INVALID_STATE; } if (SIMPLE_TIMER_STATE_STARTED == m_simple_timer_state) { err_code = app_simple_timer_stop(); APP_ERROR_CHECK(err_code); } if (SIMPLE_TIMER_STATE_STOPPED == m_simple_timer_state) { nrf_drv_timer_clear(&SIMPLE_TIMER); } m_mode = mode; m_timeout_handler = timeout_handler; mp_timeout_handler_context = p_context; nrf_drv_timer_extended_compare( &SIMPLE_TIMER, NRF_TIMER_CC_CHANNEL0, (uint32_t)timeout_ticks, timer_short, true); if (m_simple_timer_state == SIMPLE_TIMER_STATE_STOPPED) { nrf_drv_timer_resume(&SIMPLE_TIMER); } else { nrf_drv_timer_enable(&SIMPLE_TIMER); } m_simple_timer_state = SIMPLE_TIMER_STATE_STARTED; return NRF_SUCCESS; }
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 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 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; }
/* QF callbacks ============================================================*/ void QF_onStartup(void) { nrf_drv_timer_enable(&TIMER1); void advertising_start(); advertising_start(); }