584c0962d8
* FURI stdglue: stdout hooks, local and global, ISR safe printf. Uniform newlines for terminal/debug output. Power: prevent sleep while core 2 has not started. * Furi record, stdglue: check mutex allocation * remove unused test * Furi stdglue: buferized output, dynamically allocated state. Furi record: dynamically allocated state. Input dump: proper line ending. Hal VCP: dynamically allocated state. * Interrupt manager: explicitly init list. * Makefile: cleanup rules, fix broken dfu upload. F4: add compiler stack protection options. * BLE: call debug uart callback on transmission complete * FreeRTOS: add configUSE_NEWLIB_REENTRANT * API HAL Timebase: fix issue with idle thread stack corruption caused by systick interrupt. BT: cleanup debug info output. FreeRTOS: disable reentry for newlib. * F4: update stack protection CFLAGS to match used compiller * F4: disable compiller stack protection because of incompatibility with current compiller * Makefile: return openocd logs to gdb * BLE: fixed pin, moar power, ble trace info. * Prevent sleep when connection is active * Makefile: return serial port to upload rule, add workaround for mac os * Furi: prevent usage of stack for cmsis functions. * F4: add missing includes, add debugger breakpoints * Applications: per app stack size. * Furi: honor kernel state in stdglue * FreeRTOS: remove unused hooks * Cleanup and format sources Co-authored-by: DrZlo13 <who.just.the.doctor@gmail.com>
103 lines
2.6 KiB
Plaintext
103 lines
2.6 KiB
Plaintext
#include <furi.h>
|
|
|
|
typedef enum {
|
|
EventTypeTick,
|
|
EventTypeKey,
|
|
// add your events type
|
|
} EventType;
|
|
|
|
typedef struct {
|
|
union {
|
|
InputEvent input;
|
|
// add your events payload
|
|
} value;
|
|
EventType type;
|
|
} Event;
|
|
|
|
typedef struct {
|
|
// describe state here
|
|
} State;
|
|
|
|
static void render_callback(Canvas* canvas, void* ctx) {
|
|
State* state = (State*)acquire_mutex((ValueMutex*)ctx, 25);
|
|
|
|
canvas_clear(canvas);
|
|
|
|
// draw your app
|
|
|
|
release_mutex((ValueMutex*)ctx, state);
|
|
}
|
|
|
|
static void input_callback(InputEvent* input_event, void* ctx) {
|
|
osMessageQueueId_t event_queue = (QueueHandle_t)ctx;
|
|
|
|
Event event;
|
|
event.type = EventTypeKey;
|
|
event.value.input = *input_event;
|
|
osMessageQueuePut(event_queue, &event, 0, 0);
|
|
}
|
|
|
|
void template_app(void* p) {
|
|
osMessageQueueId_t event_queue = osMessageQueueNew(1, sizeof(Event), NULL);
|
|
|
|
State _state;
|
|
/* init state here */
|
|
ValueMutex state_mutex;
|
|
if(!init_mutex(&state_mutex, &_state, sizeof(State))) {
|
|
printf("cannot create mutex\r\n");
|
|
furiac_exit(NULL);
|
|
}
|
|
|
|
Widget* widget = widget_alloc();
|
|
|
|
widget_draw_callback_set(widget, render_callback, &state_mutex);
|
|
widget_input_callback_set(widget, input_callback, event_queue);
|
|
|
|
// Open GUI and register widget
|
|
Gui* gui = furi_record_open("gui");
|
|
if(gui == NULL) {
|
|
printf("gui is not available\r\n");
|
|
furiac_exit(NULL);
|
|
}
|
|
gui_add_widget(gui, widget, /* specify UI layer */);
|
|
|
|
Event event;
|
|
while(1) {
|
|
osStatus_t event_status = osMessageQueueGet(
|
|
event_queue, &event, NULL,
|
|
/* specify timeout */
|
|
);
|
|
State* state = (State*)acquire_mutex_block(&state_mutex);
|
|
|
|
if(event_status == osOK) {
|
|
if(event.type == EventTypeKey) {
|
|
// press events
|
|
if(event.value.input.state && event.value.input.input == InputBack) {
|
|
}
|
|
|
|
if(event.value.input.state && event.value.input.input == InputUp) {
|
|
}
|
|
|
|
if(event.value.input.state && event.value.input.input == InputDown) {
|
|
}
|
|
|
|
if(event.value.input.state && event.value.input.input == InputLeft) {
|
|
}
|
|
|
|
if(event.value.input.state && event.value.input.input == InputRight) {
|
|
}
|
|
|
|
if(event.value.input.input == InputOk) {
|
|
}
|
|
}
|
|
} else {
|
|
// event timeout
|
|
}
|
|
|
|
// common code, for example, force update UI
|
|
// widget_update(widget);
|
|
|
|
release_mutex(&state_mutex, state);
|
|
}
|
|
}
|