qsethuk/carpibord
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
carpibord/flip_monitor/can_monitor.c

896 lines
26 KiB
C
Raw Permalink Blame History

/**
* CAN Monitor for Flipper Zero - Dynamic UI Version
*
* Multi-page application with dynamic content from RPI5.
*
* Protocol:
* RPi -> Flipper:
* PAGE:<idx>/<total>|<type>|<title>|<lines>|<actions>|<selected>
* ACK:<device>,ip=<ip>
* RESULT:<status>|<message>
*
* Flipper -> RPi:
* INIT:flipper
* STOP:flipper
* CMD:NAV:next / CMD:NAV:prev
* CMD:SELECT:<index>
* CMD:CONFIRM / CMD:CANCEL
* CMD:REFRESH
*
* Wiring:
* RPI5 TX (GPIO14, Pin 8) -> Flipper RX (Pin 14)
* RPI5 RX (GPIO15, Pin 10) <- Flipper TX (Pin 13)
* RPI5 GND (Pin 6) -> Flipper GND (Pin 8/11/18)
*/
#include <furi.h>
#include <furi_hal.h>
#include <gui/gui.h>
#include <gui/view_port.h>
#include <gui/elements.h>
#include <expansion/expansion.h>
#include <stdlib.h>
#include <string.h>
#define TAG "CANMonitor"
#define UART_BAUD 115200
#define RX_BUFFER_SIZE 512
#define MAX_LINES 5
#define MAX_ACTIONS 4
#define MAX_LINE_LENGTH 32
#define MAX_TITLE_LENGTH 24
// Connection state
typedef enum {
StateDisconnected,
StateConnecting,
StateConnected,
} ConnectionState;
// Page types
typedef enum {
PageTypeInfo,
PageTypeMenu,
PageTypeConfirm,
} PageType;
// Page content received from RPi
typedef struct {
uint8_t page_index;
uint8_t total_pages;
PageType page_type;
char title[MAX_TITLE_LENGTH];
char lines[MAX_LINES][MAX_LINE_LENGTH];
uint8_t line_count;
char actions[MAX_ACTIONS][MAX_LINE_LENGTH];
uint8_t action_count;
uint8_t selected_index;
bool data_valid;
uint32_t last_update_tick;
} PageContent;
// Result message
typedef struct {
bool has_result;
bool success;
char message[MAX_LINE_LENGTH];
uint32_t show_until_tick;
} ResultMessage;
// App context
typedef struct {
Gui* gui;
ViewPort* view_port;
FuriMutex* mutex;
FuriHalSerialHandle* serial;
FuriStreamBuffer* rx_stream;
FuriThread* worker_thread;
PageContent page;
ResultMessage result;
ConnectionState conn_state;
char ip_address[32];
uint32_t connecting_start_tick; // Time when INIT was sent or ACK received
volatile bool running;
volatile bool send_init;
} CanMonitorApp;
// Forward declarations
static void draw_callback(Canvas* canvas, void* ctx);
static void input_callback(InputEvent* event, void* ctx);
// Send data via UART
static void uart_send(CanMonitorApp* app, const char* data) {
if(app->serial) {
furi_hal_serial_tx(app->serial, (uint8_t*)data, strlen(data));
FURI_LOG_I(TAG, "TX: %s", data);
}
}
// Clear page content
static void clear_page_content(PageContent* page) {
page->page_index = 0;
page->total_pages = 0;
page->page_type = PageTypeInfo;
page->title[0] = '\0';
page->line_count = 0;
page->action_count = 0;
page->selected_index = 0;
page->data_valid = false;
for(int i = 0; i < MAX_LINES; i++) {
page->lines[i][0] = '\0';
}
for(int i = 0; i < MAX_ACTIONS; i++) {
page->actions[i][0] = '\0';
}
}
// Parse semicolon-separated items into array
static uint8_t parse_items(const char* str, char items[][MAX_LINE_LENGTH], uint8_t max_items) {
uint8_t count = 0;
if(!str || str[0] == '\0') {
return 0;
}
const char* start = str;
const char* end;
while(count < max_items && start && *start) {
end = strchr(start, ';');
size_t len;
if(end) {
len = end - start;
} else {
len = strlen(start);
}
if(len >= MAX_LINE_LENGTH) {
len = MAX_LINE_LENGTH - 1;
}
if(len > 0) {
memcpy(items[count], start, len);
items[count][len] = '\0';
count++;
}
if(end) {
start = end + 1;
} else {
break;
}
}
return count;
}
// Parse PAGE message
// Format: PAGE:<idx>/<total>|<type>|<title>|<lines>|<actions>|<selected>
// Returns true if page changed (different page_index or page_type)
static bool parse_page(const char* line, PageContent* page, bool* page_changed) {
if(strncmp(line, "PAGE:", 5) != 0) {
return false;
}
const char* p = line + 5;
char* end;
// Save old values to detect page change
uint8_t old_page_index = page->page_index;
PageType old_page_type = page->page_type;
bool was_valid = page->data_valid;
// Parse page index and total
page->page_index = (uint8_t)strtoul(p, &end, 10);
if(*end != '/') return false;
p = end + 1;
page->total_pages = (uint8_t)strtoul(p, &end, 10);
if(*end != '|') return false;
p = end + 1;
// Parse page type
const char* type_end = strchr(p, '|');
if(!type_end) return false;
PageType new_page_type;
if(strncmp(p, "info", type_end - p) == 0) {
new_page_type = PageTypeInfo;
} else if(strncmp(p, "menu", type_end - p) == 0) {
new_page_type = PageTypeMenu;
} else if(strncmp(p, "confirm", type_end - p) == 0) {
new_page_type = PageTypeConfirm;
} else {
new_page_type = PageTypeInfo;
}
page->page_type = new_page_type;
p = type_end + 1;
// Detect if page changed (index OR type changed)
bool is_page_change = !was_valid ||
(page->page_index != old_page_index) ||
(new_page_type != old_page_type);
if(page_changed) {
*page_changed = is_page_change;
}
// Parse title
const char* title_end = strchr(p, '|');
if(!title_end) return false;
size_t title_len = title_end - p;
if(title_len >= MAX_TITLE_LENGTH) {
title_len = MAX_TITLE_LENGTH - 1;
}
memcpy(page->title, p, title_len);
page->title[title_len] = '\0';
p = title_end + 1;
// Parse lines
const char* lines_end = strchr(p, '|');
if(!lines_end) return false;
char lines_buf[256];
size_t lines_len = lines_end - p;
if(lines_len >= sizeof(lines_buf)) {
lines_len = sizeof(lines_buf) - 1;
}
memcpy(lines_buf, p, lines_len);
lines_buf[lines_len] = '\0';
page->line_count = parse_items(lines_buf, page->lines, MAX_LINES);
p = lines_end + 1;
// Parse actions
const char* actions_end = strchr(p, '|');
if(!actions_end) return false;
char actions_buf[128];
size_t actions_len = actions_end - p;
if(actions_len >= sizeof(actions_buf)) {
actions_len = sizeof(actions_buf) - 1;
}
memcpy(actions_buf, p, actions_len);
actions_buf[actions_len] = '\0';
page->action_count = parse_items(actions_buf, page->actions, MAX_ACTIONS);
p = actions_end + 1;
// Parse selected index from server
uint8_t server_selected = (uint8_t)strtoul(p, NULL, 10);
// IMPORTANT: Only update selected_index on page change
// For menu/confirm pages, preserve local selection during updates
if(is_page_change) {
page->selected_index = server_selected;
} else if(page->page_type == PageTypeInfo) {
// Info pages don't have selection, always use server value
page->selected_index = server_selected;
}
// For menu/confirm on same page: keep old_selected (local user choice)
page->data_valid = true;
page->last_update_tick = furi_get_tick();
return true;
}
// Parse ACK message
static bool parse_ack(const char* line, char* ip_out, size_t ip_size) {
if(strncmp(line, "ACK:", 4) != 0) {
return false;
}
const char* ip = strstr(line, "ip=");
if(ip) {
ip += 3;
size_t len = 0;
while(ip[len] && ip[len] != ',' && ip[len] != '\n' && ip[len] != '\r') {
len++;
}
if(len > 0 && len < ip_size) {
memcpy(ip_out, ip, len);
ip_out[len] = '\0';
}
}
return true;
}
// Parse RESULT message
static bool parse_result(const char* line, ResultMessage* result) {
if(strncmp(line, "RESULT:", 7) != 0) {
return false;
}
const char* p = line + 7;
// Parse status
if(strncmp(p, "OK|", 3) == 0) {
result->success = true;
p += 3;
} else if(strncmp(p, "ERROR|", 6) == 0) {
result->success = false;
p += 6;
} else {
return false;
}
// Parse message
size_t len = strlen(p);
if(len >= MAX_LINE_LENGTH) {
len = MAX_LINE_LENGTH - 1;
}
memcpy(result->message, p, len);
result->message[len] = '\0';
result->has_result = true;
result->show_until_tick = furi_get_tick() + 3000; // Show for 3 seconds
return true;
}
// Process received line
static void process_line(CanMonitorApp* app, const char* line) {
FURI_LOG_I(TAG, "RX: %s", line);
furi_mutex_acquire(app->mutex, FuriWaitForever);
if(app->conn_state == StateConnecting) {
// Waiting for ACK
if(parse_ack(line, app->ip_address, sizeof(app->ip_address))) {
FURI_LOG_I(TAG, "ACK received, IP: %s", app->ip_address);
app->conn_state = StateConnected;
// Reset tick for data waiting timeout
app->connecting_start_tick = furi_get_tick();
}
} else if(app->conn_state == StateConnected) {
// Parse PAGE or RESULT
if(line[0] == 'P') {
bool page_changed = false;
parse_page(line, &app->page, &page_changed);
if(page_changed) {
FURI_LOG_I(TAG, "Page changed to %d", app->page.page_index);
}
} else if(line[0] == 'R') {
parse_result(line, &app->result);
}
}
furi_mutex_release(app->mutex);
view_port_update(app->view_port);
}
// UART RX callback
static void uart_callback(FuriHalSerialHandle* handle, FuriHalSerialRxEvent event, void* ctx) {
CanMonitorApp* app = ctx;
if(event == FuriHalSerialRxEventData) {
uint8_t byte = furi_hal_serial_async_rx(handle);
furi_stream_buffer_send(app->rx_stream, &byte, 1, 0);
}
}
// Worker thread
static int32_t worker_thread(void* ctx) {
CanMonitorApp* app = ctx;
char buffer[RX_BUFFER_SIZE];
size_t idx = 0;
uint32_t last_rx_tick = 0;
FURI_LOG_I(TAG, "Worker started");
while(app->running) {
// Check if we need to send INIT
if(app->send_init) {
app->send_init = false;
uart_send(app, "INIT:flipper\n");
furi_mutex_acquire(app->mutex, FuriWaitForever);
app->conn_state = StateConnecting;
app->connecting_start_tick = furi_get_tick();
clear_page_content(&app->page);
furi_mutex_release(app->mutex);
view_port_update(app->view_port);
}
// Receive data
uint8_t byte;
size_t len = furi_stream_buffer_receive(app->rx_stream, &byte, 1, 50);
if(len > 0) {
last_rx_tick = furi_get_tick();
if(byte == '\n' || byte == '\r') {
if(idx > 0) {
buffer[idx] = '\0';
process_line(app, buffer);
idx = 0;
}
} else if(idx < RX_BUFFER_SIZE - 1) {
buffer[idx++] = byte;
}
} else {
// Timeout: parse partial data after 500ms
if(idx > 0 && (furi_get_tick() - last_rx_tick) > 500) {
buffer[idx] = '\0';
process_line(app, buffer);
idx = 0;
}
}
// Check data timeout (5 sec) - only when connected
furi_mutex_acquire(app->mutex, FuriWaitForever);
if(app->conn_state == StateConnected && app->page.data_valid) {
if((furi_get_tick() - app->page.last_update_tick) > 5000) {
// Data timeout - RPi likely restarted, go back to disconnected state
// This allows user to reconnect by pressing OK
FURI_LOG_W(TAG, "Data timeout, disconnecting");
app->conn_state = StateDisconnected;
app->page.data_valid = false;
clear_page_content(&app->page);
view_port_update(app->view_port);
}
}
// Check connecting timeout (3 sec) - ACK not received
if(app->conn_state == StateConnecting) {
if((furi_get_tick() - app->connecting_start_tick) > 3000) {
// Connection timeout - RPi not responding, go back to disconnected
FURI_LOG_W(TAG, "Connection timeout, no ACK received");
app->conn_state = StateDisconnected;
view_port_update(app->view_port);
}
}
// Check initial data timeout (5 sec) - ACK received but no PAGE data yet
if(app->conn_state == StateConnected && !app->page.data_valid) {
if((furi_get_tick() - app->connecting_start_tick) > 5000) {
// No data received after ACK - RPi not sending data
FURI_LOG_W(TAG, "Data wait timeout, no PAGE received after ACK");
app->conn_state = StateDisconnected;
view_port_update(app->view_port);
}
}
// Clear result message after timeout
if(app->result.has_result && furi_get_tick() > app->result.show_until_tick) {
app->result.has_result = false;
view_port_update(app->view_port);
}
furi_mutex_release(app->mutex);
}
FURI_LOG_I(TAG, "Worker stopped");
return 0;
}
// Draw header with page indicator
static void draw_header(Canvas* canvas, CanMonitorApp* app) {
// Page indicator
char page_str[16];
snprintf(
page_str,
sizeof(page_str),
"[%d/%d]",
app->page.page_index + 1,
app->page.total_pages);
canvas_draw_str(canvas, 0, 8, page_str);
// Title (centered)
uint16_t title_width = canvas_string_width(canvas, app->page.title);
uint16_t title_x = (128 - title_width) / 2;
canvas_draw_str(canvas, title_x, 8, app->page.title);
// Connection indicator (right side)
if(app->page.data_valid) {
canvas_draw_disc(canvas, 122, 4, 3);
} else {
canvas_draw_circle(canvas, 122, 4, 3);
}
// Separator line
canvas_draw_line(canvas, 0, 11, 128, 11);
}
// Draw footer with navigation hints
static void draw_footer(Canvas* canvas, PageType page_type, uint8_t total_pages, uint8_t current_page) {
canvas_draw_line(canvas, 0, 54, 128, 54);
canvas_set_font(canvas, FontSecondary);
// Left arrow (if not first page)
if(current_page > 0) {
canvas_draw_str(canvas, 2, 63, "<");
}
// Center action hint
const char* hint = "";
switch(page_type) {
case PageTypeInfo:
hint = "Up/Dn=Scroll";
break;
case PageTypeMenu:
hint = "Up/Dn OK=Select";
break;
case PageTypeConfirm:
hint = "Up/Dn OK Back=No";
break;
}
uint16_t hint_width = canvas_string_width(canvas, hint);
canvas_draw_str(canvas, (128 - hint_width) / 2, 63, hint);
// Right arrow (if not last page)
if(current_page < total_pages - 1) {
canvas_draw_str(canvas, 122, 63, ">");
}
}
// Draw info page
static void draw_info_page(Canvas* canvas, CanMonitorApp* app) {
canvas_set_font(canvas, FontSecondary);
uint8_t y = 22;
for(uint8_t i = 0; i < app->page.line_count && i < MAX_LINES; i++) {
canvas_draw_str(canvas, 2, y, app->page.lines[i]);
y += 10;
}
}
// Draw menu page
static void draw_menu_page(Canvas* canvas, CanMonitorApp* app) {
canvas_set_font(canvas, FontSecondary);
uint8_t y = 22;
for(uint8_t i = 0; i < app->page.action_count && i < MAX_ACTIONS; i++) {
// Selection indicator
if(i == app->page.selected_index) {
canvas_draw_box(canvas, 0, y - 8, 128, 10);
canvas_set_color(canvas, ColorWhite);
}
canvas_draw_str(canvas, 4, y, app->page.actions[i]);
if(i == app->page.selected_index) {
canvas_set_color(canvas, ColorBlack);
}
y += 10;
}
}
// Draw confirm page
static void draw_confirm_page(Canvas* canvas, CanMonitorApp* app) {
canvas_set_font(canvas, FontSecondary);
// Message (centered)
if(app->page.line_count > 0) {
uint16_t msg_width = canvas_string_width(canvas, app->page.lines[0]);
canvas_draw_str(canvas, (128 - msg_width) / 2, 30, app->page.lines[0]);
}
// Yes/No options
uint8_t btn_y = 44;
uint8_t yes_x = 32;
uint8_t no_x = 80;
// Draw Yes
if(app->page.selected_index == 0) {
canvas_draw_box(canvas, yes_x - 2, btn_y - 8, 24, 12);
canvas_set_color(canvas, ColorWhite);
}
canvas_draw_str(canvas, yes_x, btn_y, "Yes");
if(app->page.selected_index == 0) {
canvas_set_color(canvas, ColorBlack);
}
// Draw No
if(app->page.selected_index == 1) {
canvas_draw_box(canvas, no_x - 2, btn_y - 8, 20, 12);
canvas_set_color(canvas, ColorWhite);
}
canvas_draw_str(canvas, no_x, btn_y, "No");
if(app->page.selected_index == 1) {
canvas_set_color(canvas, ColorBlack);
}
}
// Draw result overlay
static void draw_result_overlay(Canvas* canvas, ResultMessage* result) {
// Semi-transparent background
canvas_set_color(canvas, ColorWhite);
canvas_draw_box(canvas, 10, 20, 108, 28);
canvas_set_color(canvas, ColorBlack);
canvas_draw_frame(canvas, 10, 20, 108, 28);
canvas_set_font(canvas, FontPrimary);
const char* status = result->success ? "OK" : "Error";
canvas_draw_str(canvas, 14, 32, status);
canvas_set_font(canvas, FontSecondary);
canvas_draw_str(canvas, 14, 44, result->message);
}
// Draw welcome/connecting screen
static void draw_welcome(Canvas* canvas, CanMonitorApp* app) {
canvas_clear(canvas);
canvas_set_font(canvas, FontPrimary);
canvas_draw_str_aligned(canvas, 64, 8, AlignCenter, AlignCenter, "CAN Monitor");
canvas_set_font(canvas, FontSecondary);
canvas_draw_str_aligned(canvas, 64, 22, AlignCenter, AlignCenter, "RPI5 Dynamic UI");
furi_mutex_acquire(app->mutex, FuriWaitForever);
ConnectionState state = app->conn_state;
char ip_buf[32];
strncpy(ip_buf, app->ip_address, sizeof(ip_buf));
furi_mutex_release(app->mutex);
switch(state) {
case StateDisconnected:
canvas_draw_str_aligned(canvas, 64, 38, AlignCenter, AlignCenter, "Press OK to connect");
canvas_draw_str_aligned(canvas, 64, 50, AlignCenter, AlignCenter, "[OK]");
break;
case StateConnecting:
canvas_draw_str_aligned(canvas, 64, 38, AlignCenter, AlignCenter, "Connecting...");
canvas_draw_str_aligned(canvas, 64, 50, AlignCenter, AlignCenter, "Waiting for RPI5");
break;
case StateConnected:
canvas_draw_str_aligned(canvas, 64, 34, AlignCenter, AlignCenter, "Connected!");
if(strlen(ip_buf) > 0) {
char buf[48];
snprintf(buf, sizeof(buf), "RPI5: %s", ip_buf);
canvas_draw_str_aligned(canvas, 64, 46, AlignCenter, AlignCenter, buf);
}
canvas_draw_str_aligned(canvas, 64, 58, AlignCenter, AlignCenter, "Waiting for data...");
break;
}
}
// Draw callback
static void draw_callback(Canvas* canvas, void* ctx) {
CanMonitorApp* app = ctx;
furi_mutex_acquire(app->mutex, FuriWaitForever);
// Check if we should show welcome screen
if(app->conn_state != StateConnected || !app->page.data_valid) {
furi_mutex_release(app->mutex);
draw_welcome(canvas, app);
return;
}
canvas_clear(canvas);
canvas_set_font(canvas, FontPrimary);
// Draw header
draw_header(canvas, app);
// Draw content based on page type
switch(app->page.page_type) {
case PageTypeInfo:
draw_info_page(canvas, app);
break;
case PageTypeMenu:
draw_menu_page(canvas, app);
break;
case PageTypeConfirm:
draw_confirm_page(canvas, app);
break;
}
// Draw footer
draw_footer(canvas, app->page.page_type, app->page.total_pages, app->page.page_index);
// Draw result overlay if present
if(app->result.has_result) {
draw_result_overlay(canvas, &app->result);
}
furi_mutex_release(app->mutex);
}
// Input callback
static void input_callback(InputEvent* event, void* ctx) {
CanMonitorApp* app = ctx;
if(event->type != InputTypeShort && event->type != InputTypeRepeat) {
return;
}
furi_mutex_acquire(app->mutex, FuriWaitForever);
// Handle welcome screen input
if(app->conn_state == StateDisconnected) {
if(event->key == InputKeyOk) {
app->send_init = true;
} else if(event->key == InputKeyBack) {
app->running = false;
}
furi_mutex_release(app->mutex);
return;
}
// Handle connected state input
if(app->conn_state == StateConnected && app->page.data_valid) {
switch(event->key) {
case InputKeyUp:
if(app->page.page_type == PageTypeInfo) {
// Scroll up on info pages
uart_send(app, "CMD:SCROLL:up\n");
} else if(app->page.page_type == PageTypeMenu && app->page.selected_index > 0) {
app->page.selected_index--;
view_port_update(app->view_port);
} else if(app->page.page_type == PageTypeConfirm) {
app->page.selected_index = 0; // Yes
view_port_update(app->view_port);
}
break;
case InputKeyDown:
if(app->page.page_type == PageTypeInfo) {
// Scroll down on info pages
uart_send(app, "CMD:SCROLL:down\n");
} else if(app->page.page_type == PageTypeMenu &&
app->page.selected_index < app->page.action_count - 1) {
app->page.selected_index++;
view_port_update(app->view_port);
} else if(app->page.page_type == PageTypeConfirm) {
app->page.selected_index = 1; // No
view_port_update(app->view_port);
}
break;
case InputKeyLeft:
// Navigate to previous page
uart_send(app, "CMD:NAV:prev\n");
break;
case InputKeyRight:
// Navigate to next page
uart_send(app, "CMD:NAV:next\n");
break;
case InputKeyOk:
if(app->page.page_type == PageTypeMenu) {
// Send selection
char cmd[32];
snprintf(cmd, sizeof(cmd), "CMD:SELECT:%d\n", app->page.selected_index);
uart_send(app, cmd);
} else if(app->page.page_type == PageTypeConfirm) {
if(app->page.selected_index == 0) {
uart_send(app, "CMD:CONFIRM\n");
} else {
uart_send(app, "CMD:CANCEL\n");
}
}
break;
case InputKeyBack:
if(app->page.page_type == PageTypeConfirm) {
// Cancel confirmation
uart_send(app, "CMD:CANCEL\n");
} else if(app->page.page_index == 0) {
// On first page, disconnect
uart_send(app, "STOP:flipper\n");
app->conn_state = StateDisconnected;
clear_page_content(&app->page);
view_port_update(app->view_port);
} else {
// Go to previous page
uart_send(app, "CMD:NAV:prev\n");
}
break;
default:
break;
}
} else if(event->key == InputKeyBack) {
// Disconnect and exit
if(app->conn_state != StateDisconnected) {
uart_send(app, "STOP:flipper\n");
}
app->running = false;
}
furi_mutex_release(app->mutex);
}
// Main entry point
int32_t can_monitor_app(void* p) {
UNUSED(p);
FURI_LOG_I(TAG, "Starting CAN Monitor (Dynamic UI)");
// Allocate app
CanMonitorApp* app = malloc(sizeof(CanMonitorApp));
memset(app, 0, sizeof(CanMonitorApp));
app->running = true;
app->conn_state = StateDisconnected;
app->send_init = false;
clear_page_content(&app->page);
// Mutex
app->mutex = furi_mutex_alloc(FuriMutexTypeNormal);
// Disable expansion protocol
Expansion* expansion = furi_record_open(RECORD_EXPANSION);
expansion_disable(expansion);
furi_record_close(RECORD_EXPANSION);
FURI_LOG_I(TAG, "Expansion disabled");
// Init UART
app->rx_stream = furi_stream_buffer_alloc(RX_BUFFER_SIZE, 1);
app->serial = furi_hal_serial_control_acquire(FuriHalSerialIdUsart);
if(app->serial) {
furi_hal_serial_init(app->serial, UART_BAUD);
furi_hal_serial_async_rx_start(app->serial, uart_callback, app, false);
FURI_LOG_I(TAG, "UART initialized at %d baud", UART_BAUD);
} else {
FURI_LOG_E(TAG, "Failed to acquire UART");
}
// Start worker
app->worker_thread = furi_thread_alloc_ex("CanMonitorWorker", 2048, worker_thread, app);
furi_thread_start(app->worker_thread);
// Init GUI
app->gui = furi_record_open(RECORD_GUI);
app->view_port = view_port_alloc();
view_port_draw_callback_set(app->view_port, draw_callback, app);
view_port_input_callback_set(app->view_port, input_callback, app);
gui_add_view_port(app->gui, app->view_port, GuiLayerFullscreen);
FURI_LOG_I(TAG, "GUI initialized");
// Main loop
while(app->running) {
furi_delay_ms(100);
}
FURI_LOG_I(TAG, "Shutting down");
// Send disconnect signal
if(app->conn_state != StateDisconnected) {
uart_send(app, "STOP:flipper\n");
}
// Cleanup
furi_thread_join(app->worker_thread);
furi_thread_free(app->worker_thread);
if(app->serial) {
furi_hal_serial_async_rx_stop(app->serial);
furi_hal_serial_deinit(app->serial);
furi_hal_serial_control_release(app->serial);
}
furi_stream_buffer_free(app->rx_stream);
// Re-enable expansion
expansion = furi_record_open(RECORD_EXPANSION);
expansion_enable(expansion);
furi_record_close(RECORD_EXPANSION);
view_port_enabled_set(app->view_port, false);
gui_remove_view_port(app->gui, app->view_port);
view_port_free(app->view_port);
furi_record_close(RECORD_GUI);
furi_mutex_free(app->mutex);
free(app);
FURI_LOG_I(TAG, "Bye!");
return 0;
}
Reference in New Issue View Git Blame Copy Permalink