static void ser_phy_init_gpiote(void) { if (!nrf_drv_gpiote_is_init()) { (void)nrf_drv_gpiote_init(); } NVIC_SetPriority(GPIOTE_IRQn, APP_IRQ_PRIORITY_HIGH); nrf_drv_gpiote_in_config_t config = GPIOTE_CONFIG_IN_SENSE_TOGGLE(true); /* Enable pullup to ensure high state while connectivity device is reset */ config.pull = NRF_GPIO_PIN_PULLUP; (void)nrf_drv_gpiote_in_init(SER_PHY_SPI_MASTER_PIN_SLAVE_REQUEST, &config, ser_phy_spi_master_request); nrf_drv_gpiote_in_event_enable(SER_PHY_SPI_MASTER_PIN_SLAVE_REQUEST,true); m_slave_request_flag = !(nrf_gpio_pin_read(SER_PHY_SPI_MASTER_PIN_SLAVE_REQUEST)); #ifdef _SPI_5W_ m_slave_ready_flag = true; #else (void)nrf_drv_gpiote_in_init(SER_PHY_SPI_MASTER_PIN_SLAVE_READY, &config, ser_phy_spi_master_ready); nrf_drv_gpiote_in_event_enable(SER_PHY_SPI_MASTER_PIN_SLAVE_READY,true); m_slave_ready_flag = !(nrf_gpio_pin_read(SER_PHY_SPI_MASTER_PIN_SLAVE_READY)); #endif NVIC_ClearPendingIRQ(SW_IRQn); }
static void qenc_init_gpiote(nrf_qdec_ledpol_t led_pol) { nrf_drv_gpiote_in_config_t config = GPIOTE_CONFIG_IN_SENSE_HITOLO(true); nrf_drv_gpiote_out_config_t out_config = GPIOTE_CONFIG_OUT_SIMPLE(false); config.pull = NRF_GPIO_PIN_PULLUP; if (!nrf_drv_gpiote_is_init()) { (void)nrf_drv_gpiote_init(); } // change state on inactive edge of led pulse if (led_pol == NRF_QDEC_LEPOL_ACTIVE_LOW) { config.sense = NRF_GPIOTE_POLARITY_HITOLO; } (void)nrf_drv_gpiote_in_init(QENC_CONFIG_PIO_LED,&config,gpiote_event_handler); nrf_drv_gpiote_in_event_enable(QENC_CONFIG_PIO_LED, true); //Configure output pins. (void)nrf_drv_gpiote_out_init(QENC_CONFIG_PIO_A, &out_config); (void)nrf_drv_gpiote_out_init(QENC_CONFIG_PIO_B, &out_config); }
/** * Public methods */ void initLEDDriver(void) { ret_code_t err_code; // gpioteモジュールを初期化する if(!nrf_drv_gpiote_is_init()) { err_code = nrf_drv_gpiote_init(); APP_ERROR_CHECK(err_code); } nrf_drv_gpiote_out_config_t out_config; out_config.init_state = NRF_GPIOTE_INITIAL_VALUE_LOW; out_config.task_pin = false; err_code = nrf_drv_gpiote_out_init(PIN_NUMBER_LED, &out_config); APP_ERROR_CHECK(err_code); // 変数の初期化 m_pattern_index = 0; m_blink_count = 1; m_blank_period = 1000; // タイマーの初期化 err_code = app_timer_create(&(m_led_timer_id), APP_TIMER_MODE_REPEATED, led_timer_handler); APP_ERROR_CHECK(err_code); err_code = app_timer_start(m_led_timer_id, APP_TIMER_TICKS(100, APP_TIMER_PRESCALER), NULL); APP_ERROR_CHECK(err_code); }
uint32_t app_gpiote_init(uint8_t max_users, void * p_buffer) { uint32_t ret_code = NRF_SUCCESS; if (p_buffer == NULL) { return NRF_ERROR_INVALID_PARAM; } // Check that buffer is correctly aligned. if (!is_word_aligned(p_buffer)) { return NRF_ERROR_INVALID_PARAM; } // Initialize file globals. mp_users = (gpiote_user_t *)p_buffer; m_user_array_size = max_users; m_user_count = 0; m_pins = 0; memset(mp_users, 0, m_user_array_size * sizeof(gpiote_user_t)); if (nrf_drv_gpiote_is_init()==false) { ret_code = nrf_drv_gpiote_init(); } return ret_code; }
static void spi_slave_gpiote_init(void) { if (!nrf_drv_gpiote_is_init()) { (void)nrf_drv_gpiote_init(); } nrf_drv_gpiote_out_config_t config = GPIOTE_CONFIG_OUT_TASK_TOGGLE(true); (void)nrf_drv_gpiote_out_init(m_spi_slave_raw_config.gpiote_rdy_ch, &config); return; }
uint32_t gpio_init(gpio_cfg_t *gpio_cfgs, uint8_t gpio_count) { // assert(gpio_count < NUM_GPIO_PINS); uint32_t err_code; // TODO: WE MIGHT OR MIGHT NOT NEED THIS!! probably do tho if (!nrf_drv_gpiote_is_init()) { err_code = nrf_drv_gpiote_init(); if (err_code != NRF_SUCCESS) { return err_code; } _pin_direction_reset(); } // Save configuration. _gpio_cfgs = gpio_cfgs; _gpio_count = gpio_count; while (gpio_count--) { gpio_cfg_t* curr_input = &_gpio_cfgs[gpio_count]; // assert(curr_input->pin_no < NUM_GPIO_PINS && _pin_direction[curr_input->pin_no] == PIN_UNDEFINED); // assert(curr_input->pin_direction != PIN_UNDEFINED); if (curr_input->pin_direction == PIN_OUT) { nrf_gpio_cfg_output(curr_input->pin_no); } else { // (PIN_GPIOTE_IN || PIN_PORT_IN) nrf_drv_gpiote_in_config_t p_config = {curr_input->polarity, curr_input->pull_cfg, false, (curr_input->pin_direction == PIN_GPIOTE_IN) ? true : false}; err_code = nrf_drv_gpiote_in_init(curr_input->pin_no, &p_config, curr_input->gpio_handler); if (curr_input->pin_direction == PIN_PORT_IN) { nrf_gpio_cfg_sense_input(curr_input->pin_no, curr_input->pull_cfg, curr_input->polarity); } } if (err_code != NRF_SUCCESS) { return err_code; } _pin_direction[curr_input->pin_no] = curr_input->pin_direction; } return NRF_SUCCESS; }
/** * \brief Board specific initialization * * This function will enable SoftDevice is present. */ static void board_init(void) { #ifdef SOFTDEVICE_PRESENT /* Initialize the SoftDevice handler module */ SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_XTAL_20_PPM, NULL); #endif #ifdef PLATFORM_HAS_BUTTON if (!nrf_drv_gpiote_is_init()) { nrf_drv_gpiote_init(); } #endif }
void nrf_gpiote_init(void){ uint32_t err_code; if(!nrf_drv_gpiote_is_init()) { err_code = nrf_drv_gpiote_init(); } APP_ERROR_CHECK(err_code); nrf_drv_gpiote_in_config_t rfid_config = GPIOTE_CONFIG_IN_SENSE_TOGGLE(false); rfid_config.pull = NRF_GPIO_PIN_PULLDOWN; nrf_drv_gpiote_in_init(RFID_INTERRUPT_PIN, &rfid_config, pin_event_handler); nrf_drv_gpiote_in_event_enable(RFID_INTERRUPT_PIN, true); }
uint32_t app_button_init(app_button_cfg_t * p_buttons, uint8_t button_count, uint32_t detection_delay) { uint32_t err_code; if (detection_delay < APP_TIMER_MIN_TIMEOUT_TICKS) { return NRF_ERROR_INVALID_PARAM; } if (!nrf_drv_gpiote_is_init()) { err_code = nrf_drv_gpiote_init(); if (err_code != NRF_SUCCESS) { return err_code; } } // Save configuration. mp_buttons = p_buttons; m_button_count = button_count; m_detection_delay = detection_delay; m_pin_state = 0; m_pin_transition = 0; while (button_count--) { app_button_cfg_t * p_btn = &p_buttons[button_count]; nrf_drv_gpiote_in_config_t config = GPIOTE_CONFIG_IN_SENSE_TOGGLE(false); config.pull = p_btn->pull_cfg; err_code = nrf_drv_gpiote_in_init(p_btn->pin_no, &config, gpiote_event_handler); if (err_code != NRF_SUCCESS) { return err_code; } } // Create polling timer. return app_timer_create(&m_detection_delay_timer_id, APP_TIMER_MODE_SINGLE_SHOT, detection_delay_timeout_handler); }
int main(void) { uint32_t err_code; nrf_drv_gpiote_in_config_t temp_t = {NRF_GPIOTE_POLARITY_HITOLO, NRF_GPIO_PIN_NOPULL, false, false}; // Initialization led_init(LED_0); //led_on(LED_0); led_init(LED_1); led_init(LED_2); //led_on(LED_1); // Setup clock SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_RC_250_PPM_8000MS_CALIBRATION, false); //nrf_gpio_cfg_input(22, NRF_GPIO_PIN_NOPULL); //nrf_gpio_cfg_input(21, NRF_GPIO_PIN_NOPULL); if (!nrf_drv_gpiote_is_init()) { err_code = nrf_drv_gpiote_init(); if (err_code != NRF_SUCCESS) { return err_code; } } nrf_drv_gpiote_in_init(21, &temp_t, &pin_handler); nrf_gpio_cfg_sense_input(21, NRF_GPIO_PIN_NOPULL, NRF_GPIO_PIN_SENSE_LOW); nrf_drv_gpiote_in_init(22, &temp_t, &pin_handler); nrf_gpio_cfg_sense_input(22, NRF_GPIO_PIN_NOPULL, NRF_GPIO_PIN_SENSE_LOW); // nrf_drv_gpiote_in_init(0, &temp_t, &pin_handler); NRF_GPIOTE->INTENSET = 0x8000000F; NVIC_EnableIRQ(GPIOTE_IRQn); // Setup and start timer //timers_init(); //timers_start(); while (1) { power_manage(); } }
void setup_example(void) { uint32_t event; nrf_ppi_channel_t ppi_channel; uint32_t err_code; nrf_gpio_cfg_output(BSP_LED_0); err_code = nrf_drv_rtc_init(&rtc, NULL, rtc_evt_handler); APP_ERROR_CHECK(err_code); nrf_drv_rtc_tick_enable(&rtc, false); event = nrf_drv_rtc_event_address_get(&rtc, NRF_RTC_EVENT_TICK); if (!nrf_drv_gpiote_is_init()) { err_code = nrf_drv_gpiote_init(); APP_ERROR_CHECK(err_code); } nrf_drv_gpiote_out_config_t pin_out_config = GPIOTE_CONFIG_OUT_TASK_TOGGLE(false); err_code = nrf_drv_gpiote_out_init(BSP_LED_0,&pin_out_config); APP_ERROR_CHECK(err_code); nrf_drv_gpiote_out_task_enable(BSP_LED_0); uint32_t gpiote_task_addr = nrf_drv_gpiote_out_task_addr_get(BSP_LED_0); err_code = nrf_drv_ppi_init(); APP_ERROR_CHECK(err_code); err_code = nrf_drv_ppi_channel_alloc(&ppi_channel); APP_ERROR_CHECK(err_code); err_code = nrf_drv_ppi_channel_assign(ppi_channel,event,gpiote_task_addr); APP_ERROR_CHECK(err_code); err_code = nrf_drv_ppi_channel_enable(ppi_channel); APP_ERROR_CHECK(err_code); nrf_drv_rtc_enable(&rtc); }
uint32_t app_uart_init(const app_uart_comm_params_t * p_comm_params, app_uart_buffers_t * p_buffers, app_uart_event_handler_t event_handler, app_irq_priority_t irq_priority, uint16_t * p_app_uart_uid) { uint32_t err_code; m_current_state = UART_OFF; m_event_handler = event_handler; m_rx_byte = BYTE_INVALID; // Configure RX and TX pins. nrf_gpio_pin_set(p_comm_params->tx_pin_no); nrf_gpio_cfg_output(p_comm_params->tx_pin_no); nrf_gpio_cfg_input(p_comm_params->rx_pin_no, NRF_GPIO_PIN_PULLUP); NRF_UART0->PSELTXD = p_comm_params->tx_pin_no; NRF_UART0->PSELRXD = p_comm_params->rx_pin_no; // Configure baud rate and parity. NRF_UART0->BAUDRATE = (p_comm_params->baud_rate << UART_BAUDRATE_BAUDRATE_Pos); if (p_comm_params->use_parity) { NRF_UART0->CONFIG = (UART_CONFIG_PARITY_Included << UART_CONFIG_PARITY_Pos); } else { NRF_UART0->CONFIG = (UART_CONFIG_PARITY_Excluded << UART_CONFIG_PARITY_Pos); } if (p_comm_params->flow_control == APP_UART_FLOW_CONTROL_LOW_POWER) { if (!nrf_drv_gpiote_is_init()) { err_code = nrf_drv_gpiote_init(); if (err_code != NRF_SUCCESS) { return err_code; } } // Configure hardware flow control. nrf_drv_gpiote_out_config_t rts_config = GPIOTE_CONFIG_OUT_SIMPLE(true); err_code = nrf_drv_gpiote_out_init(p_comm_params->rts_pin_no, &rts_config); if (err_code != NRF_SUCCESS) { return err_code; } NRF_UART0->PSELCTS = UART_PIN_DISCONNECTED; NRF_UART0->PSELRTS = p_comm_params->rts_pin_no; NRF_UART0->CONFIG |= (UART_CONFIG_HWFC_Enabled << UART_CONFIG_HWFC_Pos); // Setup the gpiote to handle pin events on cts-pin. // For the UART we want to detect both low->high and high->low transitions in order to // know when to activate/de-activate the TX/RX in the UART. // Configure pin. nrf_drv_gpiote_in_config_t cts_config = GPIOTE_CONFIG_IN_SENSE_TOGGLE(false); err_code = nrf_drv_gpiote_in_init(p_comm_params->cts_pin_no, &cts_config, gpiote_uart_event_handler); if (err_code != NRF_SUCCESS) { return err_code; } nrf_drv_gpiote_in_event_enable(p_comm_params->cts_pin_no, true); // UART CTS pin is active when low. if (nrf_drv_gpiote_in_is_set(p_comm_params->cts_pin_no)) { on_uart_event(ON_CTS_HIGH); } else { on_uart_event(ON_CTS_LOW); } } else if (p_comm_params->flow_control == APP_UART_FLOW_CONTROL_ENABLED) { uart_standard_flow_control_init(p_comm_params); m_current_state = UART_READY; } else { uart_no_flow_control_init(); m_current_state = UART_READY; } if (*p_app_uart_uid == UART_INSTANCE_ID_INVALID) { *p_app_uart_uid = m_instance_counter++; } // Enable UART interrupt NRF_UART0->INTENCLR = 0xffffffffUL; NRF_UART0->INTENSET = (UART_INTENSET_RXDRDY_Set << UART_INTENSET_RXDRDY_Pos) | (UART_INTENSET_TXDRDY_Set << UART_INTENSET_TXDRDY_Pos) | (UART_INTENSET_ERROR_Set << UART_INTENSET_ERROR_Pos); NVIC_ClearPendingIRQ(UART_IRQ); NVIC_SetPriority(UART_IRQ, irq_priority); NVIC_EnableIRQ(UART_IRQ); return NRF_SUCCESS; }