/**@brief Function for handling the timeout that delays reporting buttons as pushed. * * @details The detection_delay_timeout_handler(...) is a call-back issued from the app_timer * module. It is called with the p_context parameter. The p_context parameter is * provided to the app_timer module when a timer is started, using the call * @ref app_timer_start. On @ref app_timer_start the p_context will be holding the * currently pressed buttons. * * @param[in] p_context Pointer used for passing information app_start_timer() was called. * In the app_button module the p_context holds information on pressed * buttons. */ static void detection_delay_timeout_handler(void * p_context) { uint8_t i; // Pushed button(s) detected, execute button handler(s). for (i = 0; i < m_button_count; i++) { app_button_cfg_t * p_btn = &mp_buttons[i]; uint32_t btn_mask = 1 << p_btn->pin_no; if (btn_mask & m_pin_transition) { m_pin_transition &= ~btn_mask; bool pin_is_set = nrf_drv_gpiote_in_is_set(p_btn->pin_no); if ((m_pin_state & (1 << p_btn->pin_no)) == (pin_is_set << p_btn->pin_no)) { uint32_t transition = !(pin_is_set ^ (p_btn->active_state == APP_BUTTON_ACTIVE_HIGH)); if (p_btn->button_handler) { p_btn->button_handler(p_btn->pin_no, transition); } } } } }
void reset_bike_state(State* state) { int i = 0; state->last_milli = 0; state->curr_milli = 0; state->last_delta = 0; state->curr_delta = 0; // state->manual_mode = false; if (nrf_drv_gpiote_in_is_set(_pin_mappings[MANUAL_MODE_SWITCH_FLAG])) { state->manual_mode = true; } else { state->manual_mode = false; } state->shift_dir = UP; state->target_gear = 0; state->curr_gear = 0; state->blinking_light_output = LIGHT_STATE_BLINKING_OFF; state->handle_left_turn = false; state->handle_right_turn = false; for(i = 0; i < _NUM_FLAGS; ++i) { state->flags[i] = false; } // state->pin_mappings = _pin_mappings; }
/**@brief Function for the GPIOTE event handler. */ static void gpiote_uart_event_handler(nrf_drv_gpiote_pin_t pin, nrf_gpiote_polarity_t action) { if (nrf_drv_gpiote_in_is_set(pin)) { on_uart_event(ON_CTS_HIGH); } else { on_uart_event(ON_CTS_LOW); } }
uint32_t app_button_is_pushed(uint8_t button_id, bool * p_is_pushed) { ASSERT(button_id <= m_button_count); ASSERT(mp_buttons != NULL); app_button_cfg_t * p_btn = &mp_buttons[button_id]; bool is_set = nrf_drv_gpiote_in_is_set(p_btn->pin_no); *p_is_pushed = !(is_set^(p_btn->active_state == APP_BUTTON_ACTIVE_HIGH)); return NRF_SUCCESS; }
static void gpiote_event_handler(nrf_drv_gpiote_pin_t pin, nrf_gpiote_polarity_t action) { uint32_t err_code; uint32_t pin_mask = 1 << pin; // Start detection timer. If timer is already running, the detection period is restarted. // NOTE: Using the p_context parameter of app_timer_start() to transfer the pin states to the // timeout handler (by casting event_pins_mask into the equally sized void * p_context // parameter). err_code = app_timer_stop(m_detection_delay_timer_id); if (err_code != NRF_SUCCESS) { // The impact in app_button of the app_timer queue running full is losing a button press. // The current implementation ensures that the system will continue working as normal. return; } if (!(m_pin_transition & pin_mask)) { if (nrf_drv_gpiote_in_is_set(pin)) { m_pin_state |= pin_mask; } else { m_pin_state &= ~(pin_mask); } m_pin_transition |= (pin_mask); err_code = app_timer_start(m_detection_delay_timer_id, m_detection_delay, NULL); if (err_code != NRF_SUCCESS) { // The impact in app_button of the app_timer queue running full is losing a button press. // The current implementation ensures that the system will continue working as normal. } } else { m_pin_transition &= ~pin_mask; } }
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; }