/*
* a crude button press/long-press/shift management based on GPIO
*
* (c) Philippe G. 2019, philippe_44@outlook.com
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*
*/
#include
#include
#include
#include
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/timers.h"
#include "freertos/queue.h"
#include "esp_system.h"
#include "esp_log.h"
#include "esp_task.h"
#include "driver/gpio.h"
#include "buttons.h"
static const char * TAG = "buttons";
static int n_buttons = 0;
#define BUTTON_STACK_SIZE 4096
#define MAX_BUTTONS 16
#define DEBOUNCE 50
static EXT_RAM_ATTR struct button_s {
void *client;
int gpio;
int debounce;
button_handler handler;
struct button_s *self, *shifter;
int shifter_gpio; // this one is just for post-creation
int long_press;
bool long_timer, shifted, shifting;
int type, level;
TimerHandle_t timer;
} buttons[MAX_BUTTONS];
static xQueueHandle button_evt_queue = NULL;
static void buttons_task(void* arg);
/****************************************************************************************
* GPIO low-level handler
*/
static void IRAM_ATTR gpio_isr_handler(void* arg)
{
struct button_s *button = (struct button_s*) arg;
BaseType_t woken = pdFALSE;
if (xTimerGetPeriod(button->timer) > button->debounce / portTICK_RATE_MS) xTimerChangePeriodFromISR(button->timer, button->debounce / portTICK_RATE_MS, &woken); // does that restart the timer?
else xTimerResetFromISR(button->timer, &woken);
// ESP_EARLY_LOGI(TAG, "INT gpio %u level %u", button->gpio, button->level);
}
/****************************************************************************************
* Buttons debounce/longpress timer
*/
static void buttons_timer( TimerHandle_t xTimer ) {
struct button_s *button = (struct button_s*) pvTimerGetTimerID (xTimer);
button->level = gpio_get_level(button->gpio);
if (button->shifter && button->shifter->type == button->shifter->level) button->shifter->shifting = true;
if (button->long_press && !button->long_timer && button->level == button->type) {
// detect a long press, so hold event generation
ESP_LOGD(TAG, "setting long timer gpio:%u level:%u", button->gpio, button->level);
xTimerChangePeriod(xTimer, button->long_press / portTICK_RATE_MS, 0);
button->long_timer = true;
} else {
// send a button pressed/released event (content is copied in queue)
ESP_LOGD(TAG, "sending event for gpio:%u level:%u", button->gpio, button->level);
// queue will have a copy of button's context
xQueueSend(button_evt_queue, button, 0);
button->long_timer = false;
}
}
/****************************************************************************************
* Tasks that calls the appropriate functions when buttons are pressed
*/
static void buttons_task(void* arg) {
ESP_LOGI(TAG, "starting button tasks");
while (1) {
struct button_s button;
button_event_e event;
button_press_e press;
if (!xQueueReceive(button_evt_queue, &button, portMAX_DELAY)) continue;
event = (button.level == button.type) ? BUTTON_PRESSED : BUTTON_RELEASED;
ESP_LOGD(TAG, "received event:%u from gpio:%u level:%u (timer %u shifting %u)", event, button.gpio, button.level, button.long_timer, button.shifting);
// find if shifting is activated
if (button.shifter && button.shifter->type == button.shifter->level) press = BUTTON_SHIFTED;
else press = BUTTON_NORMAL;
/*
long_timer will be set either because we truly have a long press
or we have a release before the long press timer elapsed, so two
events shall be sent
*/
if (button.long_timer) {
if (event == BUTTON_RELEASED) {
// early release of a long-press button, send press/release
if (!button.shifting) {
(*button.handler)(button.client, BUTTON_PRESSED, press, false);
(*button.handler)(button.client, BUTTON_RELEASED, press, false);
}
// button is a copy, so need to go to real context
button.self->shifting = false;
} else if (!button.shifting) {
// normal long press and not shifting so don't discard
(*button.handler)(button.client, BUTTON_PRESSED, press, true);
}
} else {
// normal press/release of a button or release of a long-press button
if (!button.shifting) (*button.handler)(button.client, event, press, button.long_press);
// button is a copy, so need to go to real context
button.self->shifting = false;
}
}
}
/****************************************************************************************
* dummy button handler
*/
void dummy_handler(void *id, button_event_e event, button_press_e press) {
ESP_LOGW(TAG, "should not be here");
}
/****************************************************************************************
* Create buttons
*/
void button_create(void *client, int gpio, int type, bool pull, int debounce, button_handler handler, int long_press, int shifter_gpio) {
static DRAM_ATTR StaticTask_t xTaskBuffer __attribute__ ((aligned (4)));
static EXT_RAM_ATTR StackType_t xStack[BUTTON_STACK_SIZE] __attribute__ ((aligned (4)));
if (n_buttons >= MAX_BUTTONS) return;
ESP_LOGI(TAG, "Creating button using GPIO %u, type %u, pull-up/down %u, long press %u shifter %u", gpio, type, pull, long_press, shifter_gpio);
if (!n_buttons) {
button_evt_queue = xQueueCreate(10, sizeof(struct button_s));
xTaskCreateStatic( (TaskFunction_t) buttons_task, "buttons_thread", BUTTON_STACK_SIZE, NULL, ESP_TASK_PRIO_MIN + 1, xStack, &xTaskBuffer);
}
// just in case this structure is allocated in a future release
memset(buttons + n_buttons, 0, sizeof(struct button_s));
// set mandatory parameters
buttons[n_buttons].client = client;
buttons[n_buttons].gpio = gpio;
buttons[n_buttons].debounce = debounce ? debounce: DEBOUNCE;
buttons[n_buttons].handler = handler;
buttons[n_buttons].long_press = long_press;
buttons[n_buttons].level = -1;
buttons[n_buttons].shifter_gpio = shifter_gpio;
buttons[n_buttons].type = type;
buttons[n_buttons].timer = xTimerCreate("buttonTimer", buttons[n_buttons].debounce / portTICK_RATE_MS, pdFALSE, (void *) &buttons[n_buttons], buttons_timer);
buttons[n_buttons].self = buttons + n_buttons;
for (int i = 0; i < n_buttons; i++) {
// first try to find our shifter
if (buttons[i].gpio == shifter_gpio) {
buttons[n_buttons].shifter = buttons + i;
// a shifter must have a long-press handler
if (!buttons[i].long_press) buttons[i].long_press = -1;
}
// then try to see if we are a non-assigned shifter
if (buttons[i].shifter_gpio == gpio) {
buttons[i].shifter = buttons + n_buttons;
ESP_LOGI(TAG, "post-assigned shifter gpio %u", buttons[i].gpio);
}
}
gpio_pad_select_gpio(gpio);
gpio_set_direction(gpio, GPIO_MODE_INPUT);
// we need any edge detection
gpio_set_intr_type(gpio, GPIO_INTR_ANYEDGE);
// do we need pullup or pulldown
if (pull) {
if (GPIO_IS_VALID_OUTPUT_GPIO(gpio)) {
if (type == BUTTON_LOW) gpio_set_pull_mode(gpio, GPIO_PULLUP_ONLY);
else gpio_set_pull_mode(gpio, GPIO_PULLDOWN_ONLY);
} else {
ESP_LOGW(TAG, "cannot set pull up/down for gpio %u", gpio);
}
}
gpio_isr_handler_add(gpio, gpio_isr_handler, (void*) &buttons[n_buttons]);
gpio_intr_enable(gpio);
n_buttons++;
}
/****************************************************************************************
* Get stored id
*/
void *button_get_client(int gpio) {
for (int i = 0; i < n_buttons; i++) {
if (buttons[i].gpio == gpio) return buttons[i].client;
}
return NULL;
}
/****************************************************************************************
* Update buttons
*/
void *button_remap(void *client, int gpio, button_handler handler, int long_press, int shifter_gpio) {
int i;
struct button_s *button = NULL;
void *prev_client;
ESP_LOGI(TAG, "remapping GPIO %u, long press %u shifter %u", gpio, long_press, shifter_gpio);
// find button
for (i = 0; i < n_buttons; i++) {
if (buttons[i].gpio == gpio) {
button = buttons + i;
break;
}
}
// huh
if (!button) return NULL;
prev_client = button->client;
button->client = client;
button->handler = handler;
button->long_press = long_press;
button->shifter_gpio = shifter_gpio;
// find our shifter (if any)
for (i = 0; shifter_gpio != -1 && i < n_buttons; i++) {
if (buttons[i].gpio == shifter_gpio) {
button->shifter = buttons + i;
// a shifter must have a long-press handler
if (!buttons[i].long_press) buttons[i].long_press = -1;
break;
}
}
return prev_client;
}