Skip to content

Commit

Permalink
[FL-1756, FL-1769, FL-1776, FL-1759] Gui: input events complementary …
Browse files Browse the repository at this point in the history 
…V3, refactoring. SubGhz: read/emulate fixes. Cleanup. (#684)

* Gui: move rotation logic to ViewPort, replace delayed View switch in ViewDispatcher with event filtering and redirection to previous view.
* SubGhz: add function description
* Gui, Input: add event id to input events.
* SubGhz: fix "crashing on ?"
* SubGhz: add icon scanning
* SubGhz: updated interface read scene,  updated interface config scene
* Assets: update subghz assets
* SubGhz:  replaced the picture in the read scene, changed the paths to additional files
* SubGhz: fix deadlock in timer callback
* SubGhz: fix icon read scene
* SubGhz: fix icon read scene
* SubGhz: fix duble text transmitter scene
* SubGhz: correct spelling. Gui: bigger queue for ViewDispatcher.
* SubGhz: fix creation and transmission of dynamic code without the presence of a manufactory key
* SubGhz: fix keelog, setting a name in the absence of a manufactory key
* SubGhz: fix load bad keelog key
* Format sources
* Furi: remove garbage from core. GpioTester: fix memory leak and cleanup
* Accessor: remove obsolete notification code
* MusicPlayer: remove input event injection
* Input: rename id to sequence

Co-authored-by: Aleksandr Kutuzov <alleteam@gmail.com>
  • Loading branch information
@Skorpionm @skotopes
Skorpionm and skotopes authored Sep 1, 2021
1 parent 3ed26e6 commit e173364
Show file tree
Hide file tree
Showing 47 changed files with 752 additions and 465 deletions.
12 changes: 0 additions & 12 deletions applications/accessor/accessor-app.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -35,7 +35,6 @@ AccessorApp::AccessorApp()
: onewire_master{&ibutton_gpio} {
furi_hal_power_insomnia_enter();
notification = static_cast<NotificationApp*>(furi_record_open("notification"));
notify_init();
furi_hal_power_enable_otg();
}

Expand Down Expand Up @@ -104,17 +103,6 @@ AccessorApp::Scene AccessorApp::get_previous_scene() {

/***************************** NOTIFY *******************************/

void AccessorApp::notify_init() {
GPIO_InitTypeDef GPIO_InitStruct = {0};

GPIO_InitStruct.Pin = PB3_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF1_TIM2;
HAL_GPIO_Init(PB3_GPIO_Port, &GPIO_InitStruct);
}

void AccessorApp::notify_green_blink() {
notification_message(notification, &sequence_blink_green_10);
}
Expand Down
2 changes: 0 additions & 2 deletions applications/accessor/accessor-app.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -29,9 +29,7 @@ class AccessorApp {
bool switch_to_previous_scene(uint8_t count = 1);
Scene get_previous_scene();

void notify_init();
void notify_green_blink();

void notify_success();

char* get_text_store();
Expand Down
179 changes: 85 additions & 94 deletions applications/gpio-tester/gpio-tester.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2,143 +2,134 @@
#include <furi-hal.h>

#include <gui/gui.h>
#include <input/input.h>
#include <notification/notification-messages.h>

typedef struct {
const char* name;
GpioPin pin;
const GpioPin* pin;
} GpioItem;

const GpioItem GPIO_PINS[] = {
{"1.2: PA7", {GPIOA, GPIO_PIN_7}},
{"1.3: PA6", {GPIOA, GPIO_PIN_6}},
{"1.4: PA4", {GPIOA, GPIO_PIN_4}},
{"1.5: PB3", {GPIOB, GPIO_PIN_3}},
{"1.6: PB2", {GPIOB, GPIO_PIN_2}},
{"1.7: PC3", {GPIOC, GPIO_PIN_3}},

{"2.7: PC1", {GPIOC, GPIO_PIN_1}},
{"2.8: PC0", {GPIOC, GPIO_PIN_0}},
static const GpioItem GPIO_PINS[] = {
{"1.2: PA7", &gpio_ext_pa7},
{"1.3: PA6", &gpio_ext_pa6},
{"1.4: PA4", &gpio_ext_pa4},
{"1.5: PB3", &gpio_ext_pb3},
{"1.6: PB2", &gpio_ext_pb2},
{"1.7: PC3", &gpio_ext_pc3},
{"2.7: PC1", &gpio_ext_pc1},
{"2.8: PC0", &gpio_ext_pc0},
};

typedef enum {
EventTypeTick,
EventTypeKey,
} EventType;

typedef struct {
union {
InputEvent input;
} value;
EventType type;
} AppEvent;
static const size_t GPIO_PINS_COUNT = sizeof(GPIO_PINS) / sizeof(GPIO_PINS[0]);

typedef struct {
osMessageQueueId_t input_queue;
uint8_t gpio_index;
} State;
ViewPort* view_port;
Gui* gui;
NotificationApp* notification;
} GpioTest;

static void render_callback(Canvas* canvas, void* ctx) {
State* state = (State*)acquire_mutex((ValueMutex*)ctx, 25);
static void gpio_test_render_callback(Canvas* canvas, void* ctx) {
GpioTest* gpio_test = ctx;

canvas_clear(canvas);
canvas_set_color(canvas, ColorBlack);
canvas_set_font(canvas, FontPrimary);
canvas_draw_str(canvas, 2, 10, "GPIO Control");
canvas_set_font(canvas, FontSecondary);
canvas_draw_str(canvas, 2, 25, GPIO_PINS[state->gpio_index].name);

release_mutex((ValueMutex*)ctx, state);
canvas_draw_str(canvas, 2, 25, GPIO_PINS[gpio_test->gpio_index].name);
}

static void input_callback(InputEvent* input_event, void* ctx) {
osMessageQueueId_t event_queue = ctx;
static void gpio_test_input_callback(InputEvent* input_event, void* ctx) {
GpioTest* gpio_test = ctx;

AppEvent event;
event.type = EventTypeKey;
event.value.input = *input_event;
osMessageQueuePut(event_queue, &event, 0, 0);
osMessageQueuePut(gpio_test->input_queue, input_event, 0, 0);
}

int32_t gpio_test_app(void* p) {
osMessageQueueId_t event_queue = osMessageQueueNew(8, sizeof(AppEvent), NULL);
furi_check(event_queue);
static void gpio_test_configure_pins(GpioMode mode) {
for(size_t i = 0; i < GPIO_PINS_COUNT; i++) {
hal_gpio_write(GPIO_PINS[i].pin, false);
hal_gpio_init(GPIO_PINS[i].pin, mode, GpioPullNo, GpioSpeedLow);
}
}

State _state;
_state.gpio_index = 0;
GpioTest* gpio_test_alloc() {
GpioTest* instance = furi_alloc(sizeof(GpioTest));

ValueMutex state_mutex;
if(!init_mutex(&state_mutex, &_state, sizeof(State))) {
printf("[gpio-tester] cannot create mutex\r\n");
return 255;
}
gpio_test_configure_pins(GpioModeOutputPushPull);

ViewPort* view_port = view_port_alloc();
instance->input_queue = osMessageQueueNew(8, sizeof(InputEvent), NULL);
furi_check(instance->input_queue);

view_port_draw_callback_set(view_port, render_callback, &state_mutex);
view_port_input_callback_set(view_port, input_callback, event_queue);
instance->view_port = view_port_alloc();
view_port_draw_callback_set(instance->view_port, gpio_test_render_callback, instance);
view_port_input_callback_set(instance->view_port, gpio_test_input_callback, instance);

// Open GUI and register view_port
Gui* gui = furi_record_open("gui");
gui_add_view_port(gui, view_port, GuiLayerFullscreen);
instance->gui = furi_record_open("gui");
gui_add_view_port(instance->gui, instance->view_port, GuiLayerFullscreen);

NotificationApp* notification = furi_record_open("notification");
instance->notification = furi_record_open("notification");

// configure pin
for(uint8_t i = 0; i < sizeof(GPIO_PINS) / sizeof(GPIO_PINS[0]); i++) {
hal_gpio_init(
(GpioPin*)&GPIO_PINS[i].pin, GpioModeOutputPushPull, GpioPullNo, GpioSpeedLow);
}
return instance;
}

AppEvent event;
while(1) {
osStatus_t event_status = osMessageQueueGet(event_queue, &event, NULL, osWaitForever);
State* state = (State*)acquire_mutex_block(&state_mutex);
void gpio_test_free(GpioTest* instance) {
furi_assert(instance);

if(event_status == osOK) {
if(event.type == EventTypeKey) {
if(event.value.input.type == InputTypeShort &&
event.value.input.key == InputKeyBack) {
printf("[gpio-tester] bye!\r\n");
notification_message(notification, &sequence_reset_green);
furi_record_close("notification");
furi_record_close("notification");

view_port_enabled_set(view_port, false);
gui_remove_view_port(gui, view_port);
view_port_free(view_port);
view_port_enabled_set(instance->view_port, false);
gui_remove_view_port(instance->gui, instance->view_port);
furi_record_close("gui");

return 0;
}
view_port_free(instance->view_port);

if(event.value.input.type == InputTypeShort &&
event.value.input.key == InputKeyRight) {
if(state->gpio_index < (sizeof(GPIO_PINS) / sizeof(GPIO_PINS[0]) - 1)) {
state->gpio_index++;
}
}
osMessageQueueDelete(instance->input_queue);

gpio_test_configure_pins(GpioModeAnalog);

free(instance);
}

if(event.value.input.type == InputTypeShort &&
event.value.input.key == InputKeyLeft) {
if(state->gpio_index > 0) {
state->gpio_index--;
}
int32_t gpio_test_app(void* p) {
GpioTest* gpio_test = gpio_test_alloc();

InputEvent event;
while(osMessageQueueGet(gpio_test->input_queue, &event, NULL, osWaitForever) == osOK) {
if(event.type == InputTypeShort) {
if(event.key == InputKeyBack) {
notification_message(gpio_test->notification, &sequence_reset_green);
break;
}

if(event.key == InputKeyRight) {
if(gpio_test->gpio_index < (GPIO_PINS_COUNT - 1)) {
gpio_test->gpio_index++;
}
}

if(event.value.input.key == InputKeyOk) {
if(event.value.input.type == InputTypePress) {
hal_gpio_write((GpioPin*)&GPIO_PINS[state->gpio_index].pin, true);
notification_message(notification, &sequence_set_green_255);
} else if(event.value.input.type == InputTypeRelease) {
hal_gpio_write((GpioPin*)&GPIO_PINS[state->gpio_index].pin, false);
notification_message(notification, &sequence_reset_green);
}
if(event.key == InputKeyLeft) {
if(gpio_test->gpio_index > 0) {
gpio_test->gpio_index--;
}
}
} else {
if(event.key == InputKeyOk) {
if(event.type == InputTypePress) {
hal_gpio_write(GPIO_PINS[gpio_test->gpio_index].pin, true);
notification_message(gpio_test->notification, &sequence_set_green_255);
} else if(event.type == InputTypeRelease) {
hal_gpio_write(GPIO_PINS[gpio_test->gpio_index].pin, false);
notification_message(gpio_test->notification, &sequence_reset_green);
}
}
}

release_mutex(&state_mutex, state);
view_port_update(view_port);
view_port_update(gpio_test->view_port);
}

gpio_test_free(gpio_test);

return 0;
}
9 changes: 6 additions & 3 deletions applications/gui/canvas.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -309,12 +309,15 @@ void canvas_set_orientation(Canvas* canvas, CanvasOrientation orientation) {
furi_assert(canvas);
if(canvas->orientation != orientation) {
canvas->orientation = orientation;
if(canvas->orientation == CanvasOrientationHorizontal)
if(canvas->orientation == CanvasOrientationHorizontal) {
FURI_SWAP(canvas->width, canvas->height);
u8g2_SetDisplayRotation(&canvas->fb, U8G2_R0);
else if(canvas->orientation == CanvasOrientationVertical)
} else if(canvas->orientation == CanvasOrientationVertical) {
FURI_SWAP(canvas->width, canvas->height);
u8g2_SetDisplayRotation(&canvas->fb, U8G2_R3);
else
} else {
furi_assert(0);
}
}
}

Expand Down
Loading

0 comments on commit e173364

Please sign in to comment.