mirrors/flipperzero-firmware
1
Fork 0
mirror of https://github.com/flipperdevices/flipperzero-firmware.git synced 2025-12-12 04:41:26 +04:00
Code Issues 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

115
applications/services/input/input.c
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 INPUT_DEBUG
#define GPIO_Read(input_pin) (furi_hal_gpio_read(input_pin.pin->gpio) ^ (input_pin.pin->inverted)) #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) { void input_press_timer_callback(void* arg) {
InputPinState* input_pin = arg; InputPinState* input_pin = arg;
InputEvent event; InputEvent event;
@@ -15,17 +40,17 @@ void input_press_timer_callback(void* arg) {
input_pin->press_counter++; input_pin->press_counter++;
if(input_pin->press_counter == INPUT_LONG_PRESS_COUNTS) { if(input_pin->press_counter == INPUT_LONG_PRESS_COUNTS) {
event.type = InputTypeLong; 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) { } else if(input_pin->press_counter > INPUT_LONG_PRESS_COUNTS) {
input_pin->press_counter--; input_pin->press_counter--;
event.type = InputTypeRepeat; event.type = InputTypeRepeat;
furi_pubsub_publish(input->event_pubsub, &event); furi_pubsub_publish(input_pin->event_pubsub, &event);
} }
} }
void input_isr(void* _ctx) { void input_isr(void* _ctx) {
UNUSED(_ctx); FuriThreadId thread_id = (FuriThreadId)_ctx;
furi_thread_flags_set(input->thread_id, INPUT_THREAD_FLAG_ISR); furi_thread_flags_set(thread_id, INPUT_THREAD_FLAG_ISR);
} }
const char* input_get_key_name(InputKey key) { 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) { int32_t input_srv(void* p) {
UNUSED(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); furi_hal_gpio_init_simple(&gpio_ext_pa4, GpioModeOutputPushPull);
#endif #endif
#ifdef SRV_CLI #ifdef SRV_CLI
input->cli = furi_record_open(RECORD_CLI); Cli* cli = furi_record_open(RECORD_CLI);
cli_add_command(input->cli, "input", CliCommandFlagParallelSafe, input_cli, input); cli_add_command(cli, "input", CliCommandFlagParallelSafe, input_cli, event_pubsub);
#endif #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++) { for(size_t i = 0; i < input_pins_count; i++) {
furi_hal_gpio_add_int_callback(input_pins[i].gpio, input_isr, NULL); furi_hal_gpio_add_int_callback(input_pins[i].gpio, input_isr, thread_id);
input->pin_states[i].pin = &input_pins[i]; pin_states[i].pin = &input_pins[i];
input->pin_states[i].state = GPIO_Read(input->pin_states[i]); pin_states[i].state = GPIO_Read(pin_states[i]);
input->pin_states[i].debounce = INPUT_DEBOUNCE_TICKS_HALF; pin_states[i].debounce = INPUT_DEBOUNCE_TICKS_HALF;
input->pin_states[i].press_timer = furi_timer_alloc( pin_states[i].press_timer =
input_press_timer_callback, FuriTimerTypePeriodic, &input->pin_states[i]); furi_timer_alloc(input_press_timer_callback, FuriTimerTypePeriodic, &pin_states[i]);
input->pin_states[i].press_counter = 0; pin_states[i].event_pubsub = event_pubsub;
pin_states[i].press_counter = 0;
} }
while(1) { while(1) {
bool is_changing = false; bool is_changing = false;
for(size_t i = 0; i < input_pins_count; i++) { 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(state) {
if(input->pin_states[i].debounce < INPUT_DEBOUNCE_TICKS) if(pin_states[i].debounce < INPUT_DEBOUNCE_TICKS) pin_states[i].debounce += 1;
input->pin_states[i].debounce += 1;
} else { } 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 && if(pin_states[i].debounce > 0 && pin_states[i].debounce < INPUT_DEBOUNCE_TICKS) {
input->pin_states[i].debounce < INPUT_DEBOUNCE_TICKS) {
is_changing = true; is_changing = true;
} else if(input->pin_states[i].state != state) { } else if(pin_states[i].state != state) {
input->pin_states[i].state = state; pin_states[i].state = state;
// Common state info // Common state info
InputEvent event; InputEvent event;
event.sequence_source = INPUT_SEQUENCE_SOURCE_HARDWARE; 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 // Short / Long / Repeat timer routine
if(state) { if(state) {
input->counter++; pin_states[i].counter = counter++;
input->pin_states[i].counter = input->counter; event.sequence_counter = pin_states[i].counter;
event.sequence_counter = input->pin_states[i].counter; furi_timer_start(pin_states[i].press_timer, INPUT_PRESS_TICKS);
furi_timer_start(input->pin_states[i].press_timer, INPUT_PRESS_TICKS);
} else { } else {
event.sequence_counter = input->pin_states[i].counter; event.sequence_counter = pin_states[i].counter;
furi_timer_stop(input->pin_states[i].press_timer); furi_timer_stop(pin_states[i].press_timer);
while(furi_timer_is_running(input->pin_states[i].press_timer)) while(furi_timer_is_running(pin_states[i].press_timer)) furi_delay_tick(1);
furi_delay_tick(1); if(pin_states[i].press_counter < INPUT_LONG_PRESS_COUNTS) {
if(input->pin_states[i].press_counter < INPUT_LONG_PRESS_COUNTS) {
event.type = InputTypeShort; 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 // Send Press/Release event
event.type = input->pin_states[i].state ? InputTypePress : InputTypeRelease; event.type = pin_states[i].state ? InputTypePress : InputTypeRelease;
furi_pubsub_publish(input->event_pubsub, &event); furi_pubsub_publish(event_pubsub, &event);
} }
} }
if(is_changing) { if(is_changing) {
#if INPUT_DEBUG #ifdef INPUT_DEBUG
furi_hal_gpio_write(&gpio_ext_pa4, 1); furi_hal_gpio_write(&gpio_ext_pa4, 1);
#endif #endif
furi_delay_tick(1); furi_delay_tick(1);
} else { } else {
#if INPUT_DEBUG #ifdef INPUT_DEBUG
furi_hal_gpio_write(&gpio_ext_pa4, 0); furi_hal_gpio_write(&gpio_ext_pa4, 0);
#endif #endif
furi_thread_flags_wait(INPUT_THREAD_FLAG_ISR, FuriFlagWaitAny, FuriWaitForever); furi_thread_flags_wait(INPUT_THREAD_FLAG_ISR, FuriFlagWaitAny, FuriWaitForever);

18
applications/services/input/input_cli.c
View File

@@ -1,4 +1,4 @@
#include "input_i.h" #include "input.h"
#include <furi.h> #include <furi.h>
#include <cli/cli.h> #include <cli/cli.h>
@@ -19,11 +19,11 @@ static void input_cli_dump_events_callback(const void* value, void* ctx) {
furi_message_queue_put(input_queue, value, FuriWaitForever); furi_message_queue_put(input_queue, value, FuriWaitForever);
} }
static void input_cli_dump(Cli* cli, FuriString* args, Input* input) { static void input_cli_dump(Cli* cli, FuriString* args, FuriPubSub* event_pubsub) {
UNUSED(args); UNUSED(args);
FuriMessageQueue* input_queue = furi_message_queue_alloc(8, sizeof(InputEvent)); FuriMessageQueue* input_queue = furi_message_queue_alloc(8, sizeof(InputEvent));
FuriPubSubSubscription* input_subscription = FuriPubSubSubscription* input_subscription =
furi_pubsub_subscribe(input->event_pubsub, input_cli_dump_events_callback, input_queue); furi_pubsub_subscribe(event_pubsub, input_cli_dump_events_callback, input_queue);
InputEvent input_event; InputEvent input_event;
printf("Press CTRL+C to stop\r\n"); printf("Press CTRL+C to stop\r\n");
@@ -36,7 +36,7 @@ static void input_cli_dump(Cli* cli, FuriString* args, Input* input) {
} }
} }
furi_pubsub_unsubscribe(input->event_pubsub, input_subscription); furi_pubsub_unsubscribe(event_pubsub, input_subscription);
furi_message_queue_free(input_queue); furi_message_queue_free(input_queue);
} }
@@ -47,7 +47,7 @@ static void input_cli_send_print_usage(void) {
printf("\t\t <type>\t - one of 'press', 'release', 'short', 'long'\r\n"); printf("\t\t <type>\t - one of 'press', 'release', 'short', 'long'\r\n");
} }
static void input_cli_send(Cli* cli, FuriString* args, Input* input) { static void input_cli_send(Cli* cli, FuriString* args, FuriPubSub* event_pubsub) {
UNUSED(cli); UNUSED(cli);
InputEvent event; InputEvent event;
FuriString* key_str; FuriString* key_str;
@@ -90,7 +90,7 @@ static void input_cli_send(Cli* cli, FuriString* args, Input* input) {
} while(false); } while(false);
if(parsed) { //-V547 if(parsed) { //-V547
furi_pubsub_publish(input->event_pubsub, &event); furi_pubsub_publish(event_pubsub, &event);
} else { } else {
input_cli_send_print_usage(); input_cli_send_print_usage();
} }
@@ -100,7 +100,7 @@ static void input_cli_send(Cli* cli, FuriString* args, Input* input) {
void input_cli(Cli* cli, FuriString* args, void* context) { void input_cli(Cli* cli, FuriString* args, void* context) {
furi_assert(cli); furi_assert(cli);
furi_assert(context); furi_assert(context);
Input* input = context; FuriPubSub* event_pubsub = context;
FuriString* cmd; FuriString* cmd;
cmd = furi_string_alloc(); cmd = furi_string_alloc();
@@ -110,11 +110,11 @@ void input_cli(Cli* cli, FuriString* args, void* context) {
break; break;
} }
if(furi_string_cmp_str(cmd, "dump") == 0) { if(furi_string_cmp_str(cmd, "dump") == 0) {
input_cli_dump(cli, args, input); input_cli_dump(cli, args, event_pubsub);
break; break;
} }
if(furi_string_cmp_str(cmd, "send") == 0) { if(furi_string_cmp_str(cmd, "send") == 0) {
input_cli_send(cli, args, input); input_cli_send(cli, args, event_pubsub);
break; break;
} }

48
applications/services/input/input_i.h
View File

@@ -1,48 +0,0 @@
/**
* @file input_i.h
* Input: internal API
*/
#pragma once
#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;
volatile uint8_t press_counter;
volatile uint32_t counter;
} InputPinState;
/** Input state */
typedef struct {
FuriThreadId thread_id;
FuriPubSub* event_pubsub;
InputPinState* pin_states;
Cli* cli;
volatile uint32_t counter;
} Input;
/** Input press timer callback */
void input_press_timer_callback(void* arg);
/** Input interrupt handler */
void input_isr(void* _ctx);
/** Input CLI command handler */
void input_cli(Cli* cli, FuriString* args, void* context);