Mirror/Momentum-Firmware
1
0
Fork 0
mirror of https://github.com/Next-Flip/Momentum-Firmware.git synced 2026-07-24 01:28:11 -07:00
Code Issues Packages Projects Releases Wiki Activity

input_srv: Put input state data on the stack of the service (#3748)

Browse Source 
* input_srv: Put input state data on the stack of the service
* input_srv: Use post-increment on the global counter

Co-authored-by: あく <alleteam@gmail.com>
This commit is contained in:
Silent
2024-07-03 14:09:37 +02:00
committed by GitHub
parent 7e0849b44e
commit 6e0115c2e1
3 changed files with 78 additions and 103 deletions
Download Patch File Download Diff File Expand all files Collapse all files
applications/services/input/input.c
+69 -46
View File
@@ -1,11 +1,36 @@
#include "input_i.h"
#include "input.h"
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <furi.h>
#include <cli/cli.h>
#include <furi_hal_gpio.h>
#define INPUT_DEBOUNCE_TICKS_HALF (INPUT_DEBOUNCE_TICKS / 2)
#define INPUT_PRESS_TICKS 150
#define INPUT_LONG_PRESS_COUNTS 2
#define INPUT_THREAD_FLAG_ISR 0x00000001
/** Input pin state */
typedef struct {
const InputPin* pin;
// State
volatile bool state;
volatile uint8_t debounce;
FuriTimer* press_timer;
FuriPubSub* event_pubsub;
volatile uint8_t press_counter;
volatile uint32_t counter;
} InputPinState;
/** Input CLI command handler */
void input_cli(Cli* cli, FuriString* args, void* context);
// #define INPUT_DEBUG
#define GPIO_Read(input_pin) (furi_hal_gpio_read(input_pin.pin->gpio) ^ (input_pin.pin->inverted))
static Input* input = NULL;
void input_press_timer_callback(void* arg) {
InputPinState* input_pin = arg;
InputEvent event;
@@ -15,17 +40,17 @@ void input_press_timer_callback(void* arg) {
input_pin->press_counter++;
if(input_pin->press_counter == INPUT_LONG_PRESS_COUNTS) {
event.type = InputTypeLong;
furi_pubsub_publish(input->event_pubsub, &event);
furi_pubsub_publish(input_pin->event_pubsub, &event);
} else if(input_pin->press_counter > INPUT_LONG_PRESS_COUNTS) {
input_pin->press_counter--;
event.type = InputTypeRepeat;
furi_pubsub_publish(input->event_pubsub, &event);
furi_pubsub_publish(input_pin->event_pubsub, &event);
}
}
void input_isr(void* _ctx) {
UNUSED(_ctx);
furi_thread_flags_set(input->thread_id, INPUT_THREAD_FLAG_ISR);
FuriThreadId thread_id = (FuriThreadId)_ctx;
furi_thread_flags_set(thread_id, INPUT_THREAD_FLAG_ISR);
}
const char* input_get_key_name(InputKey key) {
@@ -56,85 +81,83 @@ const char* input_get_type_name(InputType type) {
int32_t input_srv(void* p) {
UNUSED(p);
input = malloc(sizeof(Input));
input->thread_id = furi_thread_get_current_id();
input->event_pubsub = furi_pubsub_alloc();
furi_record_create(RECORD_INPUT_EVENTS, input->event_pubsub);
#if INPUT_DEBUG
const FuriThreadId thread_id = furi_thread_get_current_id();
FuriPubSub* event_pubsub = furi_pubsub_alloc();
uint32_t counter = 1;
furi_record_create(RECORD_INPUT_EVENTS, event_pubsub);
#ifdef INPUT_DEBUG
furi_hal_gpio_init_simple(&gpio_ext_pa4, GpioModeOutputPushPull);
#endif
#ifdef SRV_CLI
input->cli = furi_record_open(RECORD_CLI);
cli_add_command(input->cli, "input", CliCommandFlagParallelSafe, input_cli, input);
Cli* cli = furi_record_open(RECORD_CLI);
cli_add_command(cli, "input", CliCommandFlagParallelSafe, input_cli, event_pubsub);
#endif
input->pin_states = malloc(input_pins_count * sizeof(InputPinState));
InputPinState pin_states[input_pins_count];
for(size_t i = 0; i < input_pins_count; i++) {
furi_hal_gpio_add_int_callback(input_pins[i].gpio, input_isr, NULL);
input->pin_states[i].pin = &input_pins[i];
input->pin_states[i].state = GPIO_Read(input->pin_states[i]);
input->pin_states[i].debounce = INPUT_DEBOUNCE_TICKS_HALF;
input->pin_states[i].press_timer = furi_timer_alloc(
input_press_timer_callback, FuriTimerTypePeriodic, &input->pin_states[i]);
input->pin_states[i].press_counter = 0;
furi_hal_gpio_add_int_callback(input_pins[i].gpio, input_isr, thread_id);
pin_states[i].pin = &input_pins[i];
pin_states[i].state = GPIO_Read(pin_states[i]);
pin_states[i].debounce = INPUT_DEBOUNCE_TICKS_HALF;
pin_states[i].press_timer =
furi_timer_alloc(input_press_timer_callback, FuriTimerTypePeriodic, &pin_states[i]);
pin_states[i].event_pubsub = event_pubsub;
pin_states[i].press_counter = 0;
}
while(1) {
bool is_changing = false;
for(size_t i = 0; i < input_pins_count; i++) {
bool state = GPIO_Read(input->pin_states[i]);
bool state = GPIO_Read(pin_states[i]);
if(state) {
if(input->pin_states[i].debounce < INPUT_DEBOUNCE_TICKS)
input->pin_states[i].debounce += 1;
if(pin_states[i].debounce < INPUT_DEBOUNCE_TICKS) pin_states[i].debounce += 1;
} else {
if(input->pin_states[i].debounce > 0) input->pin_states[i].debounce -= 1;
if(pin_states[i].debounce > 0) pin_states[i].debounce -= 1;
}
if(input->pin_states[i].debounce > 0 &&
input->pin_states[i].debounce < INPUT_DEBOUNCE_TICKS) {
if(pin_states[i].debounce > 0 && pin_states[i].debounce < INPUT_DEBOUNCE_TICKS) {
is_changing = true;
} else if(input->pin_states[i].state != state) {
input->pin_states[i].state = state;
} else if(pin_states[i].state != state) {
pin_states[i].state = state;
// Common state info
InputEvent event;
event.sequence_source = INPUT_SEQUENCE_SOURCE_HARDWARE;
event.key = input->pin_states[i].pin->key;
event.key = pin_states[i].pin->key;
// Short / Long / Repeat timer routine
if(state) {
input->counter++;
input->pin_states[i].counter = input->counter;
event.sequence_counter = input->pin_states[i].counter;
furi_timer_start(input->pin_states[i].press_timer, INPUT_PRESS_TICKS);
pin_states[i].counter = counter++;
event.sequence_counter = pin_states[i].counter;
furi_timer_start(pin_states[i].press_timer, INPUT_PRESS_TICKS);
} else {
event.sequence_counter = input->pin_states[i].counter;
furi_timer_stop(input->pin_states[i].press_timer);
while(furi_timer_is_running(input->pin_states[i].press_timer))
furi_delay_tick(1);
if(input->pin_states[i].press_counter < INPUT_LONG_PRESS_COUNTS) {
event.sequence_counter = pin_states[i].counter;
furi_timer_stop(pin_states[i].press_timer);
while(furi_timer_is_running(pin_states[i].press_timer)) furi_delay_tick(1);
if(pin_states[i].press_counter < INPUT_LONG_PRESS_COUNTS) {
event.type = InputTypeShort;
furi_pubsub_publish(input->event_pubsub, &event);
furi_pubsub_publish(event_pubsub, &event);
}
input->pin_states[i].press_counter = 0;
pin_states[i].press_counter = 0;
}
// Send Press/Release event
event.type = input->pin_states[i].state ? InputTypePress : InputTypeRelease;
furi_pubsub_publish(input->event_pubsub, &event);
event.type = pin_states[i].state ? InputTypePress : InputTypeRelease;
furi_pubsub_publish(event_pubsub, &event);
}
}
if(is_changing) {
#if INPUT_DEBUG
#ifdef INPUT_DEBUG
furi_hal_gpio_write(&gpio_ext_pa4, 1);
#endif
furi_delay_tick(1);
} else {
#if INPUT_DEBUG
#ifdef INPUT_DEBUG
furi_hal_gpio_write(&gpio_ext_pa4, 0);
#endif
furi_thread_flags_wait(INPUT_THREAD_FLAG_ISR, FuriFlagWaitAny, FuriWaitForever);