| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| #include <assert.h> |
| #include "os/mynewt.h" |
| #include "button/button.h" |
| |
| #define _BUTTON_FSM_INIT 0 |
| #define _BUTTON_FSM_PRESSED 1 |
| #define _BUTTON_FSM_WAIT_DBLPRESSED 2 |
| #define _BUTTON_FSM_DBLPRESSED 3 |
| #define _BUTTON_FSM_HOLD_OR_REPEAT 4 |
| |
| #define _BUTTON_RELEASED 0 |
| #define _BUTTON_PRESSED 1 |
| #define _BUTTON_TIMEOUT 2 |
| |
| struct button_event { |
| struct os_event os_event; |
| uint8_t type; |
| uint8_t flags; |
| }; |
| |
| static struct os_eventq *button_internal_evq = NULL; |
| static struct os_eventq *button_callback_default_evq = NULL; |
| |
| #define BUTTON_POST_STATE_EVENT(button, flags) \ |
| button_post_event(button, BUTTON_STATE_CHANGED, flags) |
| |
| #define BUTTON_POST_ACTION_EVENT(button, flags) \ |
| button_post_event(button, BUTTON_ACTION, flags) |
| |
| static struct button_event button_event[MYNEWT_VAL(BUTTON_EVENT_MAX)] = { 0 }; |
| static button_callback_t button_callback = NULL; |
| |
| static struct button_event * |
| button_alloc_event(void) |
| { |
| int i; |
| |
| for (i = 0 ; i < MYNEWT_VAL(BUTTON_EVENT_MAX) ; i++) { |
| if (!OS_EVENT_QUEUED(&button_event[i].os_event)) { |
| return &button_event[i]; |
| } |
| } |
| |
| return NULL; |
| } |
| |
| /** |
| * Process generated event, using the user defined callback. |
| * |
| * @param ev generated event |
| */ |
| static void |
| button_event_handler(struct os_event *ev) |
| { |
| struct button_event *b_ev; |
| button_t *button; |
| |
| b_ev = (struct button_event *)ev; |
| button = (button_t *)ev->ev_arg; |
| button_callback(button->id, b_ev->type, b_ev->flags); |
| } |
| |
| /** |
| * Post an event to the default queue. |
| * |
| * @param button button generating the event |
| * @param type type of event (state or action) |
| * @param flags event description (BUTTON_FLG_*) |
| * |
| * @return -1 unable to post event (not enough buffer) |
| * 0 event posted |
| * 1 event not posted due to filtering |
| */ |
| static int |
| button_post_event(button_t *button, uint8_t type, uint8_t flags) |
| { |
| struct button_event *evt; |
| |
| #if MYNEWT_VAL(BUTTON_USE_FILTERING) |
| if (button->filter.enabled) { |
| uint8_t filter = 0xff; |
| switch(type) { |
| #if MYNEWT_VAL(BUTTON_EMIT_STATE_CHANGED) |
| case BUTTON_STATE_CHANGED: |
| filter = button->filter.state; |
| break; |
| #endif |
| #if MYNEWT_VAL(BUTTON_EMIT_ACTION) |
| case BUTTON_ACTION: |
| filter = button->filter.action; |
| break; |
| #endif |
| } |
| if (~filter & flags) { |
| return 1; |
| } |
| } |
| #endif |
| |
| evt = button_alloc_event(); |
| if (evt) { |
| evt->os_event.ev_cb = button_event_handler; |
| evt->os_event.ev_arg = button; |
| evt->type = type; |
| evt->flags = flags; |
| |
| #if MYNEWT_VAL(BUTTON_USE_PER_BUTTON_CALLBACK_EVENTQ) > 0 |
| os_eventq_put(button->eventq, &evt->os_event); |
| #else |
| os_eventq_put(button_callback_default_evq, &evt->os_event); |
| #endif |
| return 0; |
| } else { |
| button->state |= BUTTON_FLG_MISSED; |
| return -1; |
| } |
| } |
| |
| #if MYNEWT_VAL(BUTTON_USE_EMULATION) |
| /** |
| * Perform button emulation. |
| * |
| * @param button the button to emulate |
| */ |
| static void |
| button_emulating(button_t *button) |
| { |
| bool pressed = true; |
| bool released = true; |
| |
| for (button_t **from = button->emulated ; *from ; from++) { |
| if ((*from)->state & BUTTON_FLG_PRESSED) { |
| released = false; |
| } else { |
| pressed = false; |
| } |
| } |
| |
| if (pressed != !released) |
| return; |
| |
| if (pressed || (released && button->emulating)) { |
| button->emulating = pressed; |
| button_set_low_level_state(button, pressed); |
| } |
| } |
| |
| /** |
| * Process children of a button. Used for emulating button. |
| * |
| * @param button the button to look for children |
| */ |
| static void |
| button_process_children(button_t *button) |
| { |
| if (button->children == NULL) |
| return; |
| |
| for (button_t **child = button->children ; *child ; child++) |
| if ((*child)->emulated) |
| button_emulating(*child); |
| } |
| |
| /** |
| * Check if one of the children is using the action, and so |
| * we shouldn't generate one for ourself. |
| * |
| * @param button the button to look for children |
| */ |
| static bool |
| button_stealed_action(button_t *button) |
| { |
| if (button->children == NULL) |
| return false; |
| |
| for (button_t **child = button->children ; *child ; child++) |
| if ((*child)->emulated && (*child)->emulating) |
| return true; |
| |
| return false; |
| } |
| #endif |
| |
| /** |
| * Use low level action, to generated button state and action. |
| * This one deal with simple state/action, where only pressed/released/click |
| * are considered. |
| * |
| * @param button button to process |
| * @param action low level action associated to the button |
| * (_BUTTON_PRESSED, _BUTTON_RELEASED) |
| */ |
| static void |
| button_exec_simple(button_t *button, int action) |
| { |
| assert(action != _BUTTON_TIMEOUT); |
| |
| switch(action) { |
| case _BUTTON_PRESSED: |
| button->state = BUTTON_FLG_PRESSED; |
| break; |
| case _BUTTON_RELEASED: |
| #if MYNEWT_VAL(BUTTON_EMIT_ACTION) |
| #if MYNEWT_VAL(BUTTON_USE_EMULATION) |
| if (!button_stealed_action(button)) |
| #endif |
| BUTTON_POST_ACTION_EVENT(button, button->state); |
| #endif |
| button->state &= ~BUTTON_FLG_PRESSED; |
| break; |
| } |
| |
| #if MYNEWT_VAL(BUTTON_EMIT_STATE_CHANGED) |
| BUTTON_POST_STATE_EVENT(button, button->state); |
| #endif |
| |
| #if MYNEWT_VAL(BUTTON_USE_EMULATION) |
| button_process_children(button); |
| #endif |
| } |
| |
| #if MYNEWT_VAL(BUTTON_USE_DOUBLE) || \ |
| MYNEWT_VAL(BUTTON_USE_LONG ) || \ |
| MYNEWT_VAL(BUTTON_USE_REPEAT) |
| /** |
| * Use low level action, to generated button state and action. |
| * This one deal with complexe action, such as generating double click, |
| * long click, repeating action, ... |
| * |
| * @param button the button to process |
| * @param action low level action associated to the button |
| * (_BUTTON_PRESSED, _BUTTON_RELEASED, _BUTTON_TIMEOUT) |
| */ |
| static void |
| button_exec_fsm(button_t *button, int action) |
| { |
| struct os_callout *callout; |
| |
| callout = &button->callout; |
| |
| switch (button->fsm_state) { |
| case _BUTTON_FSM_INIT: |
| switch(action) { |
| case _BUTTON_PRESSED: |
| goto do_pressed; |
| case _BUTTON_RELEASED: |
| goto do_nothing; |
| case _BUTTON_TIMEOUT: |
| goto do_assert; |
| } |
| break; |
| |
| case _BUTTON_FSM_PRESSED: |
| switch(action) { |
| case _BUTTON_PRESSED: |
| goto do_nothing; |
| case _BUTTON_RELEASED: |
| #if MYNEWT_VAL(BUTTON_USE_DOUBLE) |
| if (button->mode & BUTTON_FLG_DOUBLED) { |
| goto to_wait_dblpressed; |
| } else { |
| #endif |
| goto do_release; |
| #if MYNEWT_VAL(BUTTON_USE_DOUBLE) |
| } |
| #endif |
| case _BUTTON_TIMEOUT: |
| #if MYNEWT_VAL(BUTTON_USE_LONG) |
| if (button->mode & BUTTON_FLG_LONG) { |
| goto do_longpress; |
| #if MYNEWT_VAL(BUTTON_USE_REPEAT) |
| } else if (button->mode & BUTTON_FLG_REPEATING) { |
| goto do_repeat; |
| #endif |
| } else { |
| goto do_assert; |
| } |
| #elif MYNEWT_VAL(BUTTON_USE_REPEAT) |
| goto do_repeat; |
| #else |
| goto do_assert; |
| #endif |
| } |
| break; |
| |
| #if MYNEWT_VAL(BUTTON_USE_DOUBLE) |
| case _BUTTON_FSM_WAIT_DBLPRESSED: |
| switch(action) { |
| case _BUTTON_TIMEOUT: |
| goto do_release; |
| case _BUTTON_PRESSED: |
| goto do_dblpressed; |
| case _BUTTON_RELEASED: |
| goto do_nothing; |
| } |
| break; |
| |
| case _BUTTON_FSM_DBLPRESSED: |
| switch(action) { |
| case _BUTTON_TIMEOUT : |
| #if MYNEWT_VAL(BUTTON_USE_LONG) |
| if (button->mode & BUTTON_FLG_LONG) { |
| goto do_longpress; |
| #if MYNEWT_VAL(BUTTON_USE_REPEAT) |
| } else if (button->mode & BUTTON_FLG_REPEATING) { |
| goto do_repeat; |
| #endif |
| } else { |
| goto do_assert; |
| } |
| #elif MYNEWT_VAL(BUTTON_USE_REPEAT) |
| goto do_repeat; |
| #else |
| goto do_assert; |
| #endif |
| case _BUTTON_RELEASED: goto do_release; |
| case _BUTTON_PRESSED : goto do_nothing; |
| } |
| break; |
| #endif |
| |
| #if MYNEWT_VAL(BUTTON_USE_LONG ) || \ |
| MYNEWT_VAL(BUTTON_USE_REPEAT) |
| case _BUTTON_FSM_HOLD_OR_REPEAT: |
| switch(action) { |
| case _BUTTON_TIMEOUT: |
| #if MYNEWT_VAL(BUTTON_USE_REPEAT) |
| if (button->mode & BUTTON_FLG_REPEATING) { |
| goto do_repeat; |
| } else { |
| #endif |
| goto do_assert; |
| #if MYNEWT_VAL(BUTTON_USE_REPEAT) |
| } |
| #endif |
| case _BUTTON_RELEASED: |
| goto do_release; |
| case _BUTTON_PRESSED: |
| goto do_nothing; |
| } |
| break; |
| #endif |
| } |
| |
| do_assert: |
| assert(0); |
| |
| do_nothing: |
| return; |
| |
| do_pressed: |
| #if MYNEWT_VAL(BUTTON_USE_LONG) |
| if (button->mode & BUTTON_FLG_LONG) { |
| os_callout_reset(callout, MYNEWT_VAL(BUTTON_LONGHOLD_TICKS)); |
| #if MYNEWT_VAL(BUTTON_USE_REPEAT) |
| } else if (button->mode & BUTTON_FLG_REPEATING) { |
| os_callout_reset(callout, MYNEWT_VAL(BUTTON_REPEAT_FIRST_TICKS)); |
| #endif |
| } |
| #elif MYNEWT_VAL(BUTTON_USE_REPEAT) |
| os_callout_reset(callout, MYNEWT_VAL(BUTTON_REPEAT_FIRST_TICKS)); |
| #endif |
| button->state = BUTTON_FLG_PRESSED; |
| #if MYNEWT_VAL(BUTTON_EMIT_STATE_CHANGED) |
| BUTTON_POST_STATE_EVENT(button, button->state); |
| #endif |
| #if MYNEWT_VAL(BUTTON_USE_EMULATION) |
| button_process_children(button); |
| #endif |
| button->fsm_state = _BUTTON_FSM_PRESSED; |
| return; |
| |
| #if MYNEWT_VAL(BUTTON_USE_DOUBLE) |
| to_wait_dblpressed: |
| os_callout_reset(callout, MYNEWT_VAL(BUTTON_DBLCLICK_TICKS)); |
| button->fsm_state = _BUTTON_FSM_WAIT_DBLPRESSED; |
| return; |
| |
| do_dblpressed: |
| #if MYNEWT_VAL(BUTTON_USE_LONG) |
| if (button->mode & BUTTON_FLG_LONG) { |
| os_callout_reset(callout, MYNEWT_VAL(BUTTON_LONGHOLD_TICKS)); |
| #if MYNEWT_VAL(BUTTON_USE_REPEAT) |
| } else if (button->mode & BUTTON_FLG_REPEATING) { |
| os_callout_reset(callout, MYNEWT_VAL(BUTTON_REPEAT_FIRST_TICKS)); |
| #endif |
| } else { |
| os_callout_stop(callout); |
| } |
| #elif MYNEWT_VAL(BUTTON_USE_REPEAT) |
| os_callout_reset(callout, MYNEWT_VAL(BUTTON_REPEAT_FIRST_TICKS)); |
| #else |
| os_callout_stop(callout); |
| #endif |
| button->state |= BUTTON_FLG_DOUBLED; |
| #if MYNEWT_VAL(BUTTON_EMIT_STATE_CHANGED) |
| BUTTON_POST_STATE_EVENT(button, button->state); |
| #endif |
| button->fsm_state = _BUTTON_FSM_DBLPRESSED; |
| return; |
| #endif |
| |
| #if MYNEWT_VAL(BUTTON_USE_LONG) |
| do_longpress: |
| #if MYNEWT_VAL(BUTTON_USE_REPEAT) |
| if (button->mode & BUTTON_FLG_REPEATING) |
| os_callout_reset(callout, MYNEWT_VAL(BUTTON_REPEAT_FIRST_TICKS)); |
| #endif |
| button->state |= BUTTON_FLG_LONG; |
| #if MYNEWT_VAL(BUTTON_EMIT_STATE_CHANGED) |
| BUTTON_POST_STATE_EVENT(button, button->state); |
| #endif |
| button->fsm_state = _BUTTON_FSM_HOLD_OR_REPEAT; |
| return; |
| #endif |
| |
| #if MYNEWT_VAL(BUTTON_USE_REPEAT) |
| do_repeat: |
| os_callout_reset(callout, MYNEWT_VAL(BUTTON_REPEAT_TICKS)); |
| |
| #if MYNEWT_VAL(BUTTON_EMIT_ACTION) |
| #if MYNEWT_VAL(BUTTON_USE_EMULATION) |
| if (!button_stealed_action(button)) |
| #endif |
| BUTTON_POST_ACTION_EVENT(button, button->state); |
| #endif |
| |
| if (!(button->state & BUTTON_FLG_REPEATING)) { |
| button->state |= BUTTON_FLG_REPEATING; |
| #if MYNEWT_VAL(BUTTON_EMIT_STATE_CHANGED) |
| BUTTON_POST_STATE_EVENT(button, button->state); |
| #endif |
| } |
| return; |
| #endif |
| |
| do_release: |
| os_callout_stop(callout); |
| |
| #if MYNEWT_VAL(BUTTON_EMIT_ACTION) |
| #if MYNEWT_VAL(BUTTON_USE_EMULATION) |
| if (!button_stealed_action(button)) { |
| #endif |
| #if MYNEWT_VAL(BUTTON_USE_REPEAT) |
| if (!(button->state & BUTTON_FLG_REPEATING)) |
| #endif |
| BUTTON_POST_ACTION_EVENT(button, button->state); |
| #if MYNEWT_VAL(BUTTON_USE_EMULATION) |
| } |
| #endif |
| #endif |
| button->state &= ~BUTTON_FLG_PRESSED; |
| #if MYNEWT_VAL(BUTTON_EMIT_STATE_CHANGED) |
| BUTTON_POST_STATE_EVENT(button, button->state); |
| #endif |
| #if MYNEWT_VAL(BUTTON_USE_EMULATION) |
| button_process_children(button); |
| #endif |
| button->fsm_state = _BUTTON_FSM_INIT; |
| return; |
| } |
| |
| |
| /** |
| * Callout function used for processing timeout. |
| * Used for processing complexe action. |
| * |
| * @param ev event from callout |
| */ |
| static void |
| button_fsm_callout(struct os_event *ev) |
| { |
| button_t *button; |
| |
| button = (button_t *)ev->ev_arg; |
| button_exec_fsm(button, _BUTTON_TIMEOUT); |
| } |
| #endif |
| |
| void |
| button_init(button_t *buttons, unsigned int count, button_callback_t cb) |
| { |
| #if MYNEWT_VAL(BUTTON_USE_DOUBLE) || \ |
| MYNEWT_VAL(BUTTON_USE_LONG ) || \ |
| MYNEWT_VAL(BUTTON_USE_REPEAT) || \ |
| MYNEWT_VAL(BUTTON_USE_PER_BUTTON_CALLBACK_EVENTQ) > 0 |
| unsigned int i; |
| #endif |
| |
| if (button_internal_evq == NULL) { |
| button_internal_evq = os_eventq_dflt_get(); |
| } |
| if (button_callback_default_evq == NULL) { |
| button_callback_default_evq = os_eventq_dflt_get(); |
| } |
| |
| button_callback = cb; |
| |
| #if MYNEWT_VAL(BUTTON_USE_DOUBLE) || \ |
| MYNEWT_VAL(BUTTON_USE_LONG ) || \ |
| MYNEWT_VAL(BUTTON_USE_REPEAT) |
| for (i = 0 ; i < count ; i++) { |
| button_t *button = &buttons[i]; |
| os_callout_init(&button->callout, button_internal_evq, |
| button_fsm_callout, button); |
| } |
| #endif |
| |
| #if MYNEWT_VAL(BUTTON_USE_PER_BUTTON_CALLBACK_EVENTQ) > 0 |
| for (i = 0 ; i < count ; i++) { |
| button_t *button = &buttons[i]; |
| if (button->eventq == NULL) { |
| button->eventq = button_callback_default_evq; |
| } |
| } |
| #endif |
| } |
| |
| void |
| button_set_low_level_state(button_t *button, bool pressed) |
| { |
| int action; |
| |
| action = pressed ? _BUTTON_PRESSED : _BUTTON_RELEASED; |
| #if MYNEWT_VAL(BUTTON_USE_DOUBLE) || \ |
| MYNEWT_VAL(BUTTON_USE_LONG ) || \ |
| MYNEWT_VAL(BUTTON_USE_REPEAT) |
| if (button->mode & ~(BUTTON_FLG_PRESSED)) { |
| button_exec_fsm(button, action); |
| } else { |
| button_exec_simple(button, action); |
| } |
| #else |
| button_exec_simple(button, action); |
| #endif |
| } |
| |
| void |
| button_internal_evq_set(struct os_eventq *evq) |
| { |
| button_internal_evq = evq; |
| } |
| |
| void |
| button_callback_default_evq_set(struct os_eventq *evq) |
| { |
| button_callback_default_evq = evq; |
| } |
