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); }
void gpio_irq_enable(gpio_irq_t *obj) { m_gpio_irq_enabled |= ((gpio_mask_t)1 << obj->ch); if (m_gpio_cfg[obj->ch].irq_rise || m_gpio_cfg[obj->ch].irq_fall) { nrf_drv_gpiote_in_event_enable(obj->ch, true); } }
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 enabling event on pin (if not yet enabled) or disabling the event if no other * user requires it. * * @param pin Pin to enable * @param enable If true function will attempt to enable the pin else it will attempt to disable it. */ static void pin_event_enable(uint32_t pin, bool enable) { uint32_t i; uint32_t pin_mask = 1UL << pin; bool enabled = false; //search if any user already enabled given pin for (i = 0; i < m_user_count; i++) { if (mp_users[i].enabled && (mp_users[i].pins_mask & pin_mask)) { enabled = true; break; } } if (!enabled) { if (enable) { m_last_pins_state = nrf_gpio_pins_read(); nrf_drv_gpiote_in_event_enable(pin, true); } else { nrf_drv_gpiote_in_event_disable(pin); } } }
static void gpio_apply_config(uint8_t pin) { if (m_gpio_initialized & (1UL << pin)) { if ((m_gpio_cfg[pin].direction == PIN_OUTPUT) && (!m_gpio_cfg[pin].used_as_irq)) { nrf_drv_gpiote_out_uninit(pin); } else { nrf_drv_gpiote_in_uninit(pin); } } if (m_gpio_cfg[pin].used_as_gpio || m_gpio_cfg[pin].used_as_irq) { if ((m_gpio_cfg[pin].direction == PIN_INPUT) || (m_gpio_cfg[pin].used_as_irq)) { //Configure as input. nrf_drv_gpiote_in_config_t cfg; cfg.hi_accuracy = false; cfg.is_watcher = false; cfg.sense = NRF_GPIOTE_POLARITY_TOGGLE; if (m_gpio_cfg[pin].used_as_irq) { cfg.pull = NRF_GPIO_PIN_PULLUP; nrf_drv_gpiote_in_init(pin, &cfg, gpiote_irq_handler); if ((m_gpio_irq_enabled & (1 << pin)) && (m_gpio_cfg[pin].irq_rise || m_gpio_cfg[pin].irq_fall)) { nrf_drv_gpiote_in_event_enable(pin, true); } } else { switch(m_gpio_cfg[pin].pull) { case PullUp: cfg.pull = NRF_GPIO_PIN_PULLUP; break; case PullDown: cfg.pull = NRF_GPIO_PIN_PULLDOWN; break; default: cfg.pull = NRF_GPIO_PIN_NOPULL; break; } nrf_drv_gpiote_in_init(pin, &cfg, NULL); } } else { // Configure as output. nrf_drv_gpiote_out_config_t cfg = GPIOTE_CONFIG_OUT_SIMPLE(m_gpio_cfg[pin].init_high); nrf_drv_gpiote_out_init(pin, &cfg); } m_gpio_initialized |= (1UL << pin); } else { m_gpio_initialized &= ~(1UL << pin); } }
void gpio_input_enable_all(void) { int8_t i; for (i=0; i<_gpio_count; ++i) { uint8_t pin_no = _gpio_cfgs[i].pin_no; if (_pin_direction[pin_no] == PIN_GPIOTE_IN || _pin_direction[pin_no] == PIN_PORT_IN) { nrf_drv_gpiote_in_event_enable(pin_no, true); } } }
uint32_t app_button_enable(void) { ASSERT(mp_buttons); uint32_t i; for (i = 0; i < m_button_count; i++) { nrf_drv_gpiote_in_event_enable(mp_buttons[i].pin_no, true); } return NRF_SUCCESS; }
IOEventFlags jshPinWatch(Pin pin, bool shouldWatch) { if (!jshIsPinValid(pin)) return EV_NONE; uint32_t p = (uint32_t)pinInfo[pin].pin; if (shouldWatch) { nrf_drv_gpiote_in_config_t cls_1_config = GPIOTE_CONFIG_IN_SENSE_TOGGLE(true); nrf_drv_gpiote_in_init(p, &cls_1_config, jsvPinWatchHandler); nrf_drv_gpiote_in_event_enable(p, true); return jshGetEventFlagsForWatchedPin(p); } else { nrf_drv_gpiote_in_event_disable(p); return EV_NONE; } } // start watching pin - return the EXTI associated with it
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); }
static void gpio_init(void) { ret_code_t err_code; err_code = nrf_drv_gpiote_init(); APP_ERROR_CHECK(err_code); nrf_drv_gpiote_out_config_t out_config = GPIOTE_CONFIG_OUT_SIMPLE(false); err_code = nrf_drv_gpiote_out_init(PIN_OUT, &out_config); APP_ERROR_CHECK(err_code); nrf_drv_gpiote_in_config_t in_config = GPIOTE_CONFIG_IN_SENSE_TOGGLE(true); in_config.pull = NRF_GPIO_PIN_PULLUP; err_code = nrf_drv_gpiote_in_init(PIN_IN, &in_config, in_pin_handler); APP_ERROR_CHECK(err_code); nrf_drv_gpiote_in_event_enable(PIN_IN, true); }
/** * @brief GPIO初期化 */ static void gpio_init(void) { ret_code_t err_code; nrf_drv_gpiote_out_config_t out_config = GPIOTE_CONFIG_OUT_SIMPLE(true); /* 初期値 : 1 */ nrf_drv_gpiote_in_config_t in_config = GPIOTE_CONFIG_IN_SENSE_HITOLO(true); /* 立ち下がり,EVENT使用 */ err_code = nrf_drv_gpiote_init(); APP_ERROR_CHECK(err_code); /* output */ err_code = nrf_drv_gpiote_out_init(LED_PIN_NO_ADVERTISING, &out_config); APP_ERROR_CHECK(err_code); err_code = nrf_drv_gpiote_out_init(LED_PIN_NO_CONNECTED, &out_config); APP_ERROR_CHECK(err_code); err_code = nrf_drv_gpiote_out_init(LED_PIN_NO_ASSERT, &out_config); APP_ERROR_CHECK(err_code); /* input */ in_config.pull = NRF_GPIO_PIN_NOPULL; err_code = nrf_drv_gpiote_in_init(RCS730_IRQ, &in_config, gpiote_irq_handler); APP_ERROR_CHECK(err_code); nrf_drv_gpiote_in_event_enable(RCS730_IRQ, true); }
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; }
/** @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; }