896 lines
26 KiB
C
896 lines
26 KiB
C
/**
|
|
* 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;
|
|
}
|