2
0

buttons.c 9.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266
  1. /*
  2. * a crude button press/long-press/shift management based on GPIO
  3. *
  4. * (c) Philippe G. 2019, philippe_44@outlook.com
  5. *
  6. * This program is free software: you can redistribute it and/or modify
  7. * it under the terms of the GNU General Public License as published by
  8. * the Free Software Foundation, either version 3 of the License, or
  9. * (at your option) any later version.
  10. *
  11. * This program is distributed in the hope that it will be useful,
  12. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14. * GNU General Public License for more details.
  15. *
  16. * You should have received a copy of the GNU General Public License
  17. * along with this program. If not, see <http://www.gnu.org/licenses/>.
  18. *
  19. */
  20. #include <stdio.h>
  21. #include <stdlib.h>
  22. #include <unistd.h>
  23. #include <string.h>
  24. #include "freertos/FreeRTOS.h"
  25. #include "freertos/task.h"
  26. #include "freertos/timers.h"
  27. #include "freertos/queue.h"
  28. #include "esp_system.h"
  29. #include "esp_log.h"
  30. #include "esp_task.h"
  31. #include "driver/gpio.h"
  32. #include "buttons.h"
  33. static const char * TAG = "buttons";
  34. static int n_buttons = 0;
  35. #define BUTTON_STACK_SIZE 4096
  36. #define MAX_BUTTONS 16
  37. #define DEBOUNCE 50
  38. static EXT_RAM_ATTR struct button_s {
  39. void *client;
  40. int gpio;
  41. int debounce;
  42. button_handler handler;
  43. struct button_s *self, *shifter;
  44. int shifter_gpio; // this one is just for post-creation
  45. int long_press;
  46. bool long_timer, shifted, shifting;
  47. int type, level;
  48. TimerHandle_t timer;
  49. } buttons[MAX_BUTTONS];
  50. static xQueueHandle button_evt_queue = NULL;
  51. static void buttons_task(void* arg);
  52. /****************************************************************************************
  53. * GPIO low-level handler
  54. */
  55. static void IRAM_ATTR gpio_isr_handler(void* arg)
  56. {
  57. struct button_s *button = (struct button_s*) arg;
  58. BaseType_t woken = pdFALSE;
  59. if (xTimerGetPeriod(button->timer) > button->debounce / portTICK_RATE_MS) xTimerChangePeriodFromISR(button->timer, button->debounce / portTICK_RATE_MS, &woken); // does that restart the timer?
  60. else xTimerResetFromISR(button->timer, &woken);
  61. // ESP_EARLY_LOGI(TAG, "INT gpio %u level %u", button->gpio, button->level);
  62. }
  63. /****************************************************************************************
  64. * Buttons debounce/longpress timer
  65. */
  66. static void buttons_timer( TimerHandle_t xTimer ) {
  67. struct button_s *button = (struct button_s*) pvTimerGetTimerID (xTimer);
  68. button->level = gpio_get_level(button->gpio);
  69. if (button->shifter && button->shifter->type == button->shifter->level) button->shifter->shifting = true;
  70. if (button->long_press && !button->long_timer && button->level == button->type) {
  71. // detect a long press, so hold event generation
  72. ESP_LOGD(TAG, "setting long timer gpio:%u level:%u", button->gpio, button->level);
  73. xTimerChangePeriod(xTimer, button->long_press / portTICK_RATE_MS, 0);
  74. button->long_timer = true;
  75. } else {
  76. // send a button pressed/released event (content is copied in queue)
  77. ESP_LOGD(TAG, "sending event for gpio:%u level:%u", button->gpio, button->level);
  78. // queue will have a copy of button's context
  79. xQueueSend(button_evt_queue, button, 0);
  80. button->long_timer = false;
  81. }
  82. }
  83. /****************************************************************************************
  84. * Tasks that calls the appropriate functions when buttons are pressed
  85. */
  86. static void buttons_task(void* arg) {
  87. ESP_LOGI(TAG, "starting button tasks");
  88. while (1) {
  89. struct button_s button;
  90. button_event_e event;
  91. button_press_e press;
  92. if (!xQueueReceive(button_evt_queue, &button, portMAX_DELAY)) continue;
  93. event = (button.level == button.type) ? BUTTON_PRESSED : BUTTON_RELEASED;
  94. 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);
  95. // find if shifting is activated
  96. if (button.shifter && button.shifter->type == button.shifter->level) press = BUTTON_SHIFTED;
  97. else press = BUTTON_NORMAL;
  98. /*
  99. long_timer will be set either because we truly have a long press
  100. or we have a release before the long press timer elapsed, so two
  101. events shall be sent
  102. */
  103. if (button.long_timer) {
  104. if (event == BUTTON_RELEASED) {
  105. // early release of a long-press button, send press/release
  106. if (!button.shifting) {
  107. (*button.handler)(button.client, BUTTON_PRESSED, press, false);
  108. (*button.handler)(button.client, BUTTON_RELEASED, press, false);
  109. }
  110. // button is a copy, so need to go to real context
  111. button.self->shifting = false;
  112. } else if (!button.shifting) {
  113. // normal long press and not shifting so don't discard
  114. (*button.handler)(button.client, BUTTON_PRESSED, press, true);
  115. }
  116. } else {
  117. // normal press/release of a button or release of a long-press button
  118. if (!button.shifting) (*button.handler)(button.client, event, press, button.long_press);
  119. // button is a copy, so need to go to real context
  120. button.self->shifting = false;
  121. }
  122. }
  123. }
  124. /****************************************************************************************
  125. * dummy button handler
  126. */
  127. void dummy_handler(void *id, button_event_e event, button_press_e press) {
  128. ESP_LOGW(TAG, "should not be here");
  129. }
  130. /****************************************************************************************
  131. * Create buttons
  132. */
  133. void button_create(void *client, int gpio, int type, bool pull, int debounce, button_handler handler, int long_press, int shifter_gpio) {
  134. static DRAM_ATTR StaticTask_t xTaskBuffer __attribute__ ((aligned (4)));
  135. static EXT_RAM_ATTR StackType_t xStack[BUTTON_STACK_SIZE] __attribute__ ((aligned (4)));
  136. if (n_buttons >= MAX_BUTTONS) return;
  137. 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);
  138. if (!n_buttons) {
  139. button_evt_queue = xQueueCreate(10, sizeof(struct button_s));
  140. xTaskCreateStatic( (TaskFunction_t) buttons_task, "buttons_thread", BUTTON_STACK_SIZE, NULL, ESP_TASK_PRIO_MIN + 1, xStack, &xTaskBuffer);
  141. }
  142. // just in case this structure is allocated in a future release
  143. memset(buttons + n_buttons, 0, sizeof(struct button_s));
  144. // set mandatory parameters
  145. buttons[n_buttons].client = client;
  146. buttons[n_buttons].gpio = gpio;
  147. buttons[n_buttons].debounce = debounce ? debounce: DEBOUNCE;
  148. buttons[n_buttons].handler = handler;
  149. buttons[n_buttons].long_press = long_press;
  150. buttons[n_buttons].level = -1;
  151. buttons[n_buttons].shifter_gpio = shifter_gpio;
  152. buttons[n_buttons].type = type;
  153. buttons[n_buttons].timer = xTimerCreate("buttonTimer", buttons[n_buttons].debounce / portTICK_RATE_MS, pdFALSE, (void *) &buttons[n_buttons], buttons_timer);
  154. buttons[n_buttons].self = buttons + n_buttons;
  155. for (int i = 0; i < n_buttons; i++) {
  156. // first try to find our shifter
  157. if (buttons[i].gpio == shifter_gpio) {
  158. buttons[n_buttons].shifter = buttons + i;
  159. // a shifter must have a long-press handler
  160. if (!buttons[i].long_press) buttons[i].long_press = -1;
  161. }
  162. // then try to see if we are a non-assigned shifter
  163. if (buttons[i].shifter_gpio == gpio) {
  164. buttons[i].shifter = buttons + n_buttons;
  165. ESP_LOGI(TAG, "post-assigned shifter gpio %u", buttons[i].gpio);
  166. }
  167. }
  168. gpio_pad_select_gpio(gpio);
  169. gpio_set_direction(gpio, GPIO_MODE_INPUT);
  170. // we need any edge detection
  171. gpio_set_intr_type(gpio, GPIO_INTR_ANYEDGE);
  172. // do we need pullup or pulldown
  173. if (pull) {
  174. if (GPIO_IS_VALID_OUTPUT_GPIO(gpio)) {
  175. if (type == BUTTON_LOW) gpio_set_pull_mode(gpio, GPIO_PULLUP_ONLY);
  176. else gpio_set_pull_mode(gpio, GPIO_PULLDOWN_ONLY);
  177. } else {
  178. ESP_LOGW(TAG, "cannot set pull up/down for gpio %u", gpio);
  179. }
  180. }
  181. gpio_isr_handler_add(gpio, gpio_isr_handler, (void*) &buttons[n_buttons]);
  182. gpio_intr_enable(gpio);
  183. n_buttons++;
  184. }
  185. /****************************************************************************************
  186. * Get stored id
  187. */
  188. void *button_get_client(int gpio) {
  189. for (int i = 0; i < n_buttons; i++) {
  190. if (buttons[i].gpio == gpio) return buttons[i].client;
  191. }
  192. return NULL;
  193. }
  194. /****************************************************************************************
  195. * Update buttons
  196. */
  197. void *button_remap(void *client, int gpio, button_handler handler, int long_press, int shifter_gpio) {
  198. int i;
  199. struct button_s *button = NULL;
  200. void *prev_client;
  201. ESP_LOGI(TAG, "remapping GPIO %u, long press %u shifter %u", gpio, long_press, shifter_gpio);
  202. // find button
  203. for (i = 0; i < n_buttons; i++) {
  204. if (buttons[i].gpio == gpio) {
  205. button = buttons + i;
  206. break;
  207. }
  208. }
  209. // huh
  210. if (!button) return NULL;
  211. prev_client = button->client;
  212. button->client = client;
  213. button->handler = handler;
  214. button->long_press = long_press;
  215. button->shifter_gpio = shifter_gpio;
  216. // find our shifter (if any)
  217. for (i = 0; shifter_gpio != -1 && i < n_buttons; i++) {
  218. if (buttons[i].gpio == shifter_gpio) {
  219. button->shifter = buttons + i;
  220. // a shifter must have a long-press handler
  221. if (!buttons[i].long_press) buttons[i].long_press = -1;
  222. break;
  223. }
  224. }
  225. return prev_client;
  226. }