void nrf_drv_pwm_uninit(nrf_drv_pwm_t const * const p_instance) { pwm_control_block_t * p_cb = &m_cb[p_instance->drv_inst_idx]; ASSERT(p_cb->state != NRF_DRV_STATE_UNINITIALIZED); nrf_drv_common_irq_disable(nrf_drv_get_IRQn(p_instance->p_registers)); nrf_pwm_disable(p_instance->p_registers); p_cb->state = NRF_DRV_STATE_UNINITIALIZED; }
ret_code_t nrf_drv_timer_init(nrf_drv_timer_t const * const p_instance, nrf_drv_timer_config_t const * p_config, nrf_timer_event_handler_t timer_event_handler) { timer_control_block_t * p_cb = &m_cb[p_instance->instance_id]; #ifdef SOFTDEVICE_PRESENT ASSERT(p_instance->p_reg != NRF_TIMER0); ASSERT(p_config); #endif if (p_cb->state != NRF_DRV_STATE_UNINITIALIZED) { return NRF_ERROR_INVALID_STATE; } if (timer_event_handler == NULL) { return NRF_ERROR_INVALID_PARAM; } /* Warning 685: Relational operator '<=' always evaluates to 'true'" * Warning in NRF_TIMER_IS_BIT_WIDTH_VALID macro. Macro validate timers resolution. * Not necessary in nRF52 based systems. Obligatory in nRF51 based systems. */ /*lint -save -e685 */ ASSERT(NRF_TIMER_IS_BIT_WIDTH_VALID(p_instance->p_reg, p_config->bit_width)); //lint -restore p_cb->handler = timer_event_handler; p_cb->context = p_config->p_context; uint8_t i; for (i = 0; i < p_instance->cc_channel_count; ++i) { nrf_timer_event_clear(p_instance->p_reg, nrf_timer_compare_event_get(i)); } nrf_drv_common_irq_enable(nrf_drv_get_IRQn(p_instance->p_reg), p_config->interrupt_priority); nrf_timer_mode_set(p_instance->p_reg, p_config->mode); nrf_timer_bit_width_set(p_instance->p_reg, p_config->bit_width); nrf_timer_frequency_set(p_instance->p_reg, p_config->frequency); p_cb->state = NRF_DRV_STATE_INITIALIZED; return NRF_SUCCESS; }
void nrf_drv_timer_uninit(nrf_drv_timer_t const * const p_instance) { nrf_drv_common_irq_disable(nrf_drv_get_IRQn(p_instance->p_reg)); #define DISABLE_ALL UINT32_MAX nrf_timer_shorts_disable(p_instance->p_reg, DISABLE_ALL); nrf_timer_int_disable(p_instance->p_reg, DISABLE_ALL); #undef DISABLE_ALL nrf_drv_timer_disable(p_instance); m_cb[p_instance->instance_id].state = NRF_DRV_STATE_UNINITIALIZED; }
ret_code_t nrf_drv_timer_init(nrf_drv_timer_t const * const p_instance, nrf_drv_timer_config_t const * p_config, nrf_timer_event_handler_t timer_event_handler) { timer_control_block_t * p_cb = &m_cb[p_instance->instance_id]; #ifdef SOFTDEVICE_PRESENT ASSERT(p_instance->p_reg != NRF_TIMER0); #endif ASSERT(NRF_TIMER_IS_BIT_WIDTH_VALID(p_instance->p_reg, p_config->bit_width)); if (p_cb->state != NRF_DRV_STATE_UNINITIALIZED) { return NRF_ERROR_INVALID_STATE; } if (timer_event_handler == NULL) { return NRF_ERROR_INVALID_PARAM; } if (p_config == NULL) { p_config = &m_default_config[p_instance->instance_id]; } p_cb->handler = timer_event_handler; p_cb->context = p_config->p_context; uint8_t i; for (i = 0; i < p_instance->cc_channel_count; ++i) { nrf_timer_event_clear(p_instance->p_reg, nrf_timer_compare_event_get(i)); } nrf_drv_common_irq_enable(nrf_drv_get_IRQn(p_instance->p_reg), p_config->interrupt_priority); nrf_timer_mode_set(p_instance->p_reg, p_config->mode); nrf_timer_bit_width_set(p_instance->p_reg, p_config->bit_width); nrf_timer_frequency_set(p_instance->p_reg, p_config->frequency); p_cb->state = NRF_DRV_STATE_INITIALIZED; return NRF_SUCCESS; }
void nrf_drv_timer_uninit(nrf_drv_timer_t const * const p_instance) { nrf_drv_common_irq_disable(nrf_drv_get_IRQn(p_instance->p_reg)); #define DISABLE_ALL UINT32_MAX nrf_timer_shorts_disable(p_instance->p_reg, DISABLE_ALL); nrf_timer_int_disable(p_instance->p_reg, DISABLE_ALL); #undef DISABLE_ALL if (m_cb[p_instance->instance_id].state == NRF_DRV_STATE_POWERED_ON) { nrf_drv_timer_disable(p_instance); } m_cb[p_instance->instance_id].state = NRF_DRV_STATE_UNINITIALIZED; NRF_LOG_INFO("Uninitialized instance: %d.\r\n", p_instance->instance_id); }
ret_code_t nrf_drv_pwm_init(nrf_drv_pwm_t const * const p_instance, nrf_drv_pwm_config_t const * p_config, nrf_drv_pwm_handler_t handler) { ASSERT(p_config) pwm_control_block_t * p_cb = &m_cb[p_instance->drv_inst_idx]; if (p_cb->state != NRF_DRV_STATE_UNINITIALIZED) { return NRF_ERROR_INVALID_STATE; } p_cb->handler = handler; configure_pins(p_instance, p_config); nrf_pwm_enable(p_instance->p_registers); nrf_pwm_configure(p_instance->p_registers, p_config->base_clock, p_config->count_mode, p_config->top_value); nrf_pwm_decoder_set(p_instance->p_registers, p_config->load_mode, p_config->step_mode); nrf_pwm_shorts_set(p_instance->p_registers, 0); nrf_pwm_int_set(p_instance->p_registers, 0); nrf_pwm_event_clear(p_instance->p_registers, NRF_PWM_EVENT_LOOPSDONE); nrf_pwm_event_clear(p_instance->p_registers, NRF_PWM_EVENT_SEQEND0); nrf_pwm_event_clear(p_instance->p_registers, NRF_PWM_EVENT_SEQEND1); nrf_pwm_event_clear(p_instance->p_registers, NRF_PWM_EVENT_STOPPED); if (p_cb->handler) { nrf_drv_common_irq_enable(nrf_drv_get_IRQn(p_instance->p_registers), p_config->irq_priority); } p_cb->state = NRF_DRV_STATE_INITIALIZED; return NRF_SUCCESS; }
void common_rtc_init(void) { if (m_common_rtc_enabled) { return; } errata_20(); NVIC_SetVector(RTC1_IRQn, (uint32_t)RTC1_IRQHandler); // RTC is driven by the low frequency (32.768 kHz) clock, a proper request // must be made to have it running. // Currently this clock is started in 'SystemInit' (see "system_nrf51.c" // or "system_nrf52.c", respectively). nrf_rtc_prescaler_set(COMMON_RTC_INSTANCE, 0); nrf_rtc_event_clear(COMMON_RTC_INSTANCE, US_TICKER_EVENT); #if defined(TARGET_MCU_NRF51822) nrf_rtc_event_clear(COMMON_RTC_INSTANCE, OS_TICK_EVENT); #endif #if DEVICE_LOWPOWERTIMER nrf_rtc_event_clear(COMMON_RTC_INSTANCE, LP_TICKER_EVENT); #endif nrf_rtc_event_clear(COMMON_RTC_INSTANCE, NRF_RTC_EVENT_OVERFLOW); // Interrupts on all related events are enabled permanently. Particular // events will be enabled or disabled as needed (such approach is more // energy efficient). nrf_rtc_int_enable(COMMON_RTC_INSTANCE, #if DEVICE_LOWPOWERTIMER LP_TICKER_INT_MASK | #endif US_TICKER_INT_MASK | NRF_RTC_INT_OVERFLOW_MASK); // This event is enabled permanently, since overflow indications are needed // continuously. nrf_rtc_event_enable(COMMON_RTC_INSTANCE, NRF_RTC_INT_OVERFLOW_MASK); // All other relevant events are initially disabled. nrf_rtc_event_disable(COMMON_RTC_INSTANCE, #if defined(TARGET_MCU_NRF51822) OS_TICK_INT_MASK | #endif #if DEVICE_LOWPOWERTIMER LP_TICKER_INT_MASK | #endif US_TICKER_INT_MASK); nrf_drv_common_irq_enable(nrf_drv_get_IRQn(COMMON_RTC_INSTANCE), #ifdef NRF51 APP_IRQ_PRIORITY_LOW #elif defined(NRF52) || defined(NRF52840_XXAA) APP_IRQ_PRIORITY_LOWEST #endif ); nrf_rtc_task_trigger(COMMON_RTC_INSTANCE, NRF_RTC_TASK_START); m_common_rtc_enabled = true; }
static rt_err_t _uart_cfg(struct rt_serial_device *serial, struct serial_configure *cfg) { nrf_drv_uart_config_t config = NRF_DRV_UART_DEFAULT_CONFIG; UART_CFG_T *instance = &uart0; RT_ASSERT(serial != RT_NULL); RT_ASSERT(cfg != RT_NULL); if (serial->parent.user_data != RT_NULL) { instance = (UART_CFG_T*)serial->parent.user_data; } nrf_uart_disable(instance->uart.reg.p_uart); switch (cfg->baud_rate) { case 115200: config.baudrate = NRF_UART_BAUDRATE_115200; break; case 9600: config.baudrate = NRF_UART_BAUDRATE_9600; break; default: config.baudrate = NRF_UART_BAUDRATE_115200; break; } if (cfg->parity == PARITY_NONE) { config.parity = NRF_UART_PARITY_EXCLUDED; } else { config.parity = NRF_UART_PARITY_INCLUDED; } config.hwfc = NRF_UART_HWFC_DISABLED; config.interrupt_priority = APP_IRQ_PRIORITY_LOWEST; config.pselcts = 0; config.pselrts = 0; config.pselrxd = instance->rx_pin; config.pseltxd = instance->tx_pin; nrf_gpio_pin_set(config.pseltxd); nrf_gpio_cfg_output(config.pseltxd); nrf_gpio_pin_clear(config.pseltxd); nrf_gpio_cfg_input(config.pselrxd, NRF_GPIO_PIN_NOPULL); nrf_uart_baudrate_set(instance->uart.reg.p_uart, config.baudrate); nrf_uart_configure(instance->uart.reg.p_uart, config.parity, config.hwfc); nrf_uart_txrx_pins_set(instance->uart.reg.p_uart, config.pseltxd, config.pselrxd); if (config.hwfc == NRF_UART_HWFC_ENABLED) { nrf_uart_hwfc_pins_set(instance->uart.reg.p_uart, config.pselrts, config.pselcts); } nrf_uart_event_clear(instance->uart.reg.p_uart, NRF_UART_EVENT_TXDRDY); nrf_uart_event_clear(instance->uart.reg.p_uart, NRF_UART_EVENT_RXDRDY); nrf_uart_event_clear(instance->uart.reg.p_uart, NRF_UART_EVENT_RXTO); nrf_uart_event_clear(instance->uart.reg.p_uart, NRF_UART_EVENT_ERROR); nrf_uart_int_enable(instance->uart.reg.p_uart, NRF_UART_INT_MASK_RXDRDY | NRF_UART_INT_MASK_RXTO | NRF_UART_INT_MASK_ERROR); nrf_drv_common_irq_enable(nrf_drv_get_IRQn((void *)instance->uart.reg.p_uart), config.interrupt_priority); nrf_uart_enable(instance->uart.reg.p_uart); // nrf_uart_task_trigger(instance->uart.reg.p_uart, NRF_UART_TASK_STARTRX); working_cfg = instance; return RT_EOK; }
static rt_err_t _uart_ctrl(struct rt_serial_device *serial, int cmd, void *arg) { UART_CFG_T *instance = working_cfg; RT_ASSERT(serial != RT_NULL); if (serial->parent.user_data != RT_NULL) { instance = (UART_CFG_T*)serial->parent.user_data; } switch (cmd) { /* disable interrupt */ case RT_DEVICE_CTRL_CLR_INT: nrf_uart_task_trigger(instance->uart.reg.p_uart, NRF_UART_TASK_STOPRX); nrf_uart_int_disable(instance->uart.reg.p_uart, NRF_UART_INT_MASK_RXDRDY | NRF_UART_INT_MASK_RXTO | NRF_UART_INT_MASK_ERROR); nrf_drv_common_irq_disable(nrf_drv_get_IRQn((void *)instance->uart.reg.p_uart)); break; /* enable interrupt */ case RT_DEVICE_CTRL_SET_INT: nrf_uart_event_clear(instance->uart.reg.p_uart, NRF_UART_EVENT_RXDRDY); nrf_uart_event_clear(instance->uart.reg.p_uart, NRF_UART_EVENT_RXTO); nrf_uart_event_clear(instance->uart.reg.p_uart, NRF_UART_EVENT_ERROR); /* Enable RX interrupt. */ nrf_uart_int_enable(instance->uart.reg.p_uart, NRF_UART_INT_MASK_RXDRDY | NRF_UART_INT_MASK_RXTO | NRF_UART_INT_MASK_ERROR); nrf_drv_common_irq_enable(nrf_drv_get_IRQn((void *)instance->uart.reg.p_uart), APP_IRQ_PRIORITY_LOWEST); nrf_uart_task_trigger(instance->uart.reg.p_uart, NRF_UART_TASK_STARTRX); break; case RT_DEVICE_CTRL_CUSTOM: if ((rt_uint32_t)(arg) == UART_CONFIG_BAUD_RATE_9600) { instance->serial->config.baud_rate = 9600; nrf_uart_baudrate_set(instance->uart.reg.p_uart, NRF_UART_BAUDRATE_9600); } else if ((rt_uint32_t)(arg) == UART_CONFIG_BAUD_RATE_115200) { instance->serial->config.baud_rate = 115200; nrf_uart_baudrate_set(instance->uart.reg.p_uart, NRF_UART_BAUDRATE_115200); } // _uart_cfg(instance->serial, &(instance->serial->config)); // nrf_uart_task_trigger(instance->uart.reg.p_uart, NRF_UART_TASK_STARTRX); break; case RT_DEVICE_CTRL_PIN: if (working_cfg != instance) { _uart_cfg(instance->serial, &(instance->serial->config)); } break; case RT_DEVICE_POWERSAVE: nrf_uart_disable(instance->uart.reg.p_uart); nrf_uart_txrx_pins_disconnect(instance->uart.reg.p_uart); nrf_gpio_pin_clear(instance->rx_pin); nrf_gpio_cfg_output(instance->rx_pin); nrf_gpio_pin_clear(instance->tx_pin); nrf_gpio_cfg_output(instance->tx_pin); break; case RT_DEVICE_WAKEUP: _uart_cfg(instance->serial, &(instance->serial->config)); break; default: return RT_ERROR; } return RT_EOK; }
ret_code_t nrf_drv_timer_init(nrf_drv_timer_t const * const p_instance, nrf_drv_timer_config_t const * p_config, nrf_timer_event_handler_t timer_event_handler) { timer_control_block_t * p_cb = &m_cb[p_instance->instance_id]; ASSERT(((p_instance->p_reg == NRF_TIMER0) && TIMER0_ENABLED) || (p_instance->p_reg != NRF_TIMER0)); ASSERT(((p_instance->p_reg == NRF_TIMER1) && TIMER1_ENABLED) || (p_instance->p_reg != NRF_TIMER1)); ASSERT(((p_instance->p_reg == NRF_TIMER2) && TIMER2_ENABLED) || (p_instance->p_reg != NRF_TIMER2)); #if TIMER_COUNT == 5 ASSERT(((p_instance->p_reg == NRF_TIMER3) && TIMER3_ENABLED) || (p_instance->p_reg != NRF_TIMER3)); ASSERT(((p_instance->p_reg == NRF_TIMER4) && TIMER4_ENABLED) || (p_instance->p_reg != NRF_TIMER4)); #endif //TIMER_COUNT #ifdef SOFTDEVICE_PRESENT ASSERT(p_instance->p_reg != NRF_TIMER0); ASSERT(p_config); #endif ret_code_t err_code; if (p_cb->state != NRF_DRV_STATE_UNINITIALIZED) { err_code = NRF_ERROR_INVALID_STATE; NRF_LOG_WARNING("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)ERR_TO_STR(err_code)); return err_code; } if (timer_event_handler == NULL) { err_code = NRF_ERROR_INVALID_PARAM; NRF_LOG_WARNING("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)ERR_TO_STR(err_code)); return err_code; } /* Warning 685: Relational operator '<=' always evaluates to 'true'" * Warning in NRF_TIMER_IS_BIT_WIDTH_VALID macro. Macro validate timers resolution. * Not necessary in nRF52 based systems. Obligatory in nRF51 based systems. */ /*lint -save -e685 */ ASSERT(NRF_TIMER_IS_BIT_WIDTH_VALID(p_instance->p_reg, p_config->bit_width)); //lint -restore p_cb->handler = timer_event_handler; p_cb->context = p_config->p_context; uint8_t i; for (i = 0; i < p_instance->cc_channel_count; ++i) { nrf_timer_event_clear(p_instance->p_reg, nrf_timer_compare_event_get(i)); } nrf_drv_common_irq_enable(nrf_drv_get_IRQn(p_instance->p_reg), p_config->interrupt_priority); nrf_timer_mode_set(p_instance->p_reg, p_config->mode); nrf_timer_bit_width_set(p_instance->p_reg, p_config->bit_width); nrf_timer_frequency_set(p_instance->p_reg, p_config->frequency); p_cb->state = NRF_DRV_STATE_INITIALIZED; err_code = NRF_SUCCESS; NRF_LOG_INFO("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)ERR_TO_STR(err_code)); return err_code; }