350 lines
11 KiB
C
350 lines
11 KiB
C
/**
|
|
* Copyright (c) 2012 - 2019, Nordic Semiconductor ASA
|
|
*
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without modification,
|
|
* are permitted provided that the following conditions are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright notice, this
|
|
* list of conditions and the following disclaimer.
|
|
*
|
|
* 2. Redistributions in binary form, except as embedded into a Nordic
|
|
* Semiconductor ASA integrated circuit in a product or a software update for
|
|
* such product, must reproduce the above copyright notice, this list of
|
|
* conditions and the following disclaimer in the documentation and/or other
|
|
* materials provided with the distribution.
|
|
*
|
|
* 3. Neither the name of Nordic Semiconductor ASA nor the names of its
|
|
* contributors may be used to endorse or promote products derived from this
|
|
* software without specific prior written permission.
|
|
*
|
|
* 4. This software, with or without modification, must only be used with a
|
|
* Nordic Semiconductor ASA integrated circuit.
|
|
*
|
|
* 5. Any software provided in binary form under this license must not be reverse
|
|
* engineered, decompiled, modified and/or disassembled.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
|
|
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
* OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
|
|
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
|
|
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
|
|
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
*/
|
|
#include "sdk_common.h"
|
|
#if NRF_MODULE_ENABLED(BUTTON)
|
|
#include "app_button.h"
|
|
#include "app_timer.h"
|
|
#include "app_error.h"
|
|
#include "nrf_drv_gpiote.h"
|
|
#include "nrf_assert.h"
|
|
|
|
#define NRF_LOG_MODULE_NAME app_button
|
|
#if APP_BUTTON_CONFIG_LOG_ENABLED
|
|
#define NRF_LOG_LEVEL APP_BUTTON_CONFIG_LOG_LEVEL
|
|
#define NRF_LOG_INFO_COLOR APP_BUTTON_CONFIG_INFO_COLOR
|
|
#define NRF_LOG_DEBUG_COLOR APP_BUTTON_CONFIG_DEBUG_COLOR
|
|
#else //APP_BUTTON_CONFIG_LOG_ENABLED
|
|
#define NRF_LOG_LEVEL 0
|
|
#endif //APP_BUTTON_CONFIG_LOG_ENABLED
|
|
#include "nrf_log.h"
|
|
NRF_LOG_MODULE_REGISTER();
|
|
|
|
/*
|
|
* For each pin state machine is used. Since GPIOTE PORT event is common for all pin is might be
|
|
* missed. Module relies on interrupt from GPIOTE only to active periodic app_timer in which pin
|
|
* is sampled. Timer is stopped when there is no active buttons (all buttons are in idle state).
|
|
*
|
|
* Transition to the new state is based on currently sampled button value. State machine has
|
|
* following transitions:
|
|
*
|
|
* -----------------------------------------------------
|
|
* | value | current state | new state |
|
|
* |---------------------------------------------------|
|
|
* | 0 | IDLE | IDLE |
|
|
* | 1 | IDLE | PRESS_ARMED |
|
|
* | 0 | PRESS_ARMED | IDLE |
|
|
* | 1 | PRESS_ARMED | PRESS_DETECTED |
|
|
* | 1 | PRESS_DETECTED | PRESSED (push event) |
|
|
* | 0 | PRESS_DETECTED | PRESS_ARMED |
|
|
* | 0 | PRESSED | RELEASE_DETECTED |
|
|
* | 1 | PRESSED | PRESSED |
|
|
* | 0 | RELEASE_DETECTED | IDLE (release event) |
|
|
* | 1 | RELEASE_DETECTED | PRESSED |
|
|
* -----------------------------------------------------
|
|
*
|
|
*/
|
|
static app_button_cfg_t const * mp_buttons = NULL; /**< Button configuration. */
|
|
static uint8_t m_button_count; /**< Number of configured buttons. */
|
|
static uint32_t m_detection_delay; /**< Delay before a button is reported as pushed. */
|
|
APP_TIMER_DEF(m_detection_delay_timer_id); /**< Polling timer id. */
|
|
|
|
static uint64_t m_pin_active;
|
|
|
|
#define BIT_PER_PIN 4
|
|
#define PINS 32*GPIO_COUNT
|
|
|
|
STATIC_ASSERT(BIT_PER_PIN == 4);
|
|
|
|
static uint8_t m_pin_states[PINS*BIT_PER_PIN/8];
|
|
|
|
typedef enum {
|
|
BTN_IDLE,
|
|
BTN_PRESS_ARMED,
|
|
BTN_PRESS_DETECTED,
|
|
BTN_PRESSED,
|
|
BTN_RELEASE_DETECTED
|
|
} btn_state_t;
|
|
|
|
/* Retrieve given pin state. States are stored in pairs (4 bit per pin) in byte array. */
|
|
static btn_state_t state_get(uint8_t pin)
|
|
{
|
|
uint8_t pair_state = m_pin_states[pin >> 1];
|
|
uint8_t state = (pin & 0x1) ? (pair_state >> BIT_PER_PIN) : (pair_state & 0x0F);
|
|
|
|
return (btn_state_t)state;
|
|
}
|
|
|
|
/* Set pin state. */
|
|
static void state_set(uint8_t pin, btn_state_t state)
|
|
{
|
|
uint8_t mask = (pin & 1) ? 0x0F : 0xF0;
|
|
uint8_t state_mask = (pin & 1) ?
|
|
((uint8_t)state << BIT_PER_PIN) : (uint8_t)state;
|
|
m_pin_states[pin >> 1] &= mask;
|
|
m_pin_states[pin >> 1] |= state_mask;
|
|
}
|
|
|
|
/* Find configuration structure for given pin. */
|
|
static app_button_cfg_t const * button_get(uint8_t pin)
|
|
{
|
|
for (int i = 0; i < m_button_count; i++)
|
|
{
|
|
app_button_cfg_t const * p_btn = &mp_buttons[i];
|
|
if (pin == p_btn->pin_no) {
|
|
return p_btn;
|
|
}
|
|
}
|
|
|
|
/* If button is not found then configuration is wrong. */
|
|
ASSERT(false);
|
|
return NULL;
|
|
}
|
|
|
|
static void usr_event(uint8_t pin, uint8_t type)
|
|
{
|
|
app_button_cfg_t const * p_btn = button_get(pin);
|
|
|
|
if (p_btn && p_btn->button_handler)
|
|
{
|
|
NRF_LOG_DEBUG("Pin %d %s", pin, (type == APP_BUTTON_PUSH) ? "pressed" : "released");
|
|
p_btn->button_handler(pin, type);
|
|
}
|
|
}
|
|
|
|
/* State machine processing. */
|
|
void evt_handle(uint8_t pin, uint8_t value)
|
|
{
|
|
switch(state_get(pin))
|
|
{
|
|
case BTN_IDLE:
|
|
if (value)
|
|
{
|
|
NRF_LOG_DEBUG("Pin %d idle->armed", pin);
|
|
state_set(pin, BTN_PRESS_ARMED);
|
|
CRITICAL_REGION_ENTER();
|
|
m_pin_active |= 1ULL << pin;
|
|
CRITICAL_REGION_EXIT();
|
|
}
|
|
else
|
|
{
|
|
/* stay in IDLE */
|
|
}
|
|
break;
|
|
case BTN_PRESS_ARMED:
|
|
state_set(pin, value ? BTN_PRESS_DETECTED : BTN_IDLE);
|
|
NRF_LOG_DEBUG("Pin %d armed->%s", pin, value ? "detected" : "idle");
|
|
break;
|
|
case BTN_PRESS_DETECTED:
|
|
if (value)
|
|
{
|
|
state_set(pin, BTN_PRESSED);
|
|
usr_event(pin, APP_BUTTON_PUSH);
|
|
}
|
|
else
|
|
{
|
|
state_set(pin, BTN_PRESS_ARMED);
|
|
}
|
|
NRF_LOG_DEBUG("Pin %d detected->%s", pin, value ? "pressed" : "armed");
|
|
break;
|
|
case BTN_PRESSED:
|
|
if (value == 0)
|
|
{
|
|
NRF_LOG_DEBUG("Pin %d pressed->release_detected", pin);
|
|
state_set(pin, BTN_RELEASE_DETECTED);
|
|
}
|
|
else
|
|
{
|
|
/* stay in pressed */
|
|
}
|
|
break;
|
|
case BTN_RELEASE_DETECTED:
|
|
if (value)
|
|
{
|
|
state_set(pin, BTN_PRESSED);
|
|
}
|
|
else
|
|
{
|
|
state_set(pin, BTN_IDLE);
|
|
usr_event(pin, APP_BUTTON_RELEASE);
|
|
CRITICAL_REGION_ENTER();
|
|
m_pin_active &= ~(1ULL << pin);
|
|
CRITICAL_REGION_EXIT();
|
|
}
|
|
NRF_LOG_DEBUG("Pin %d release_detected->%s", pin, value ? "pressed" : "idle");
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void timer_start(void)
|
|
{
|
|
uint32_t err_code = app_timer_start(m_detection_delay_timer_id, m_detection_delay/2, NULL);
|
|
if (err_code != NRF_SUCCESS)
|
|
{
|
|
NRF_LOG_WARNING("Failed to start app_timer (err:%d)", err_code);
|
|
}
|
|
}
|
|
|
|
static void detection_delay_timeout_handler(void * p_context)
|
|
{
|
|
for (int i = 0; i < m_button_count; i++)
|
|
{
|
|
app_button_cfg_t const * p_btn = &mp_buttons[i];
|
|
bool is_set = nrf_drv_gpiote_in_is_set(p_btn->pin_no);
|
|
bool is_active = !((p_btn->active_state == APP_BUTTON_ACTIVE_HIGH) ^ is_set);
|
|
evt_handle(p_btn->pin_no, is_active);
|
|
}
|
|
|
|
if (m_pin_active)
|
|
{
|
|
timer_start();
|
|
}
|
|
else
|
|
{
|
|
NRF_LOG_DEBUG("No active buttons, stopping timer");
|
|
}
|
|
}
|
|
|
|
/* GPIOTE event is used only to start periodic timer when first button is activated. */
|
|
static void gpiote_event_handler(nrf_drv_gpiote_pin_t pin, nrf_gpiote_polarity_t action)
|
|
{
|
|
app_button_cfg_t const * p_btn = button_get(pin);
|
|
bool is_set = nrf_drv_gpiote_in_is_set(p_btn->pin_no);
|
|
bool is_active = !((p_btn->active_state == APP_BUTTON_ACTIVE_HIGH) ^ is_set);
|
|
|
|
/* If event indicates that pin is active and no other pin is active start the timer. All
|
|
* action happens in timeout event.
|
|
*/
|
|
if (is_active && (m_pin_active == 0))
|
|
{
|
|
NRF_LOG_DEBUG("First active button, starting periodic timer");
|
|
timer_start();
|
|
}
|
|
}
|
|
|
|
uint32_t app_button_init(app_button_cfg_t const * p_buttons,
|
|
uint8_t button_count,
|
|
uint32_t detection_delay)
|
|
{
|
|
uint32_t err_code;
|
|
|
|
if (detection_delay < 2*APP_TIMER_MIN_TIMEOUT_TICKS)
|
|
{
|
|
return NRF_ERROR_INVALID_PARAM;
|
|
}
|
|
|
|
if (!nrf_drv_gpiote_is_init())
|
|
{
|
|
err_code = nrf_drv_gpiote_init();
|
|
VERIFY_SUCCESS(err_code);
|
|
}
|
|
|
|
/* Save configuration. */
|
|
mp_buttons = p_buttons;
|
|
m_button_count = button_count;
|
|
m_detection_delay = detection_delay;
|
|
|
|
memset(m_pin_states, 0, sizeof(m_pin_states));
|
|
m_pin_active = 0;
|
|
|
|
while (button_count--)
|
|
{
|
|
app_button_cfg_t const * p_btn = &p_buttons[button_count];
|
|
|
|
#if defined(BUTTON_HIGH_ACCURACY_ENABLED) && (BUTTON_HIGH_ACCURACY_ENABLED == 1)
|
|
nrf_drv_gpiote_in_config_t config = GPIOTE_CONFIG_IN_SENSE_TOGGLE(p_btn->hi_accuracy);
|
|
#else
|
|
nrf_drv_gpiote_in_config_t config = GPIOTE_CONFIG_IN_SENSE_TOGGLE(false);
|
|
#endif
|
|
config.pull = p_btn->pull_cfg;
|
|
|
|
err_code = nrf_drv_gpiote_in_init(p_btn->pin_no, &config, gpiote_event_handler);
|
|
VERIFY_SUCCESS(err_code);
|
|
}
|
|
|
|
/* Create polling timer. */
|
|
return app_timer_create(&m_detection_delay_timer_id,
|
|
APP_TIMER_MODE_SINGLE_SHOT,
|
|
detection_delay_timeout_handler);
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
|
|
uint32_t app_button_disable(void)
|
|
{
|
|
ASSERT(mp_buttons);
|
|
|
|
uint32_t i;
|
|
for (i = 0; i < m_button_count; i++)
|
|
{
|
|
nrf_drv_gpiote_in_event_disable(mp_buttons[i].pin_no);
|
|
}
|
|
CRITICAL_REGION_ENTER();
|
|
m_pin_active = 0;
|
|
CRITICAL_REGION_EXIT();
|
|
|
|
/* Make sure polling timer is not running. */
|
|
return app_timer_stop(m_detection_delay_timer_id);
|
|
}
|
|
|
|
|
|
bool app_button_is_pushed(uint8_t button_id)
|
|
{
|
|
ASSERT(button_id <= m_button_count);
|
|
ASSERT(mp_buttons != NULL);
|
|
|
|
app_button_cfg_t const * p_btn = &mp_buttons[button_id];
|
|
bool is_set = nrf_drv_gpiote_in_is_set(p_btn->pin_no);
|
|
|
|
return !(is_set ^ (p_btn->active_state == APP_BUTTON_ACTIVE_HIGH));
|
|
}
|
|
#endif //NRF_MODULE_ENABLED(BUTTON)
|