Create project for flipper zero integration

flip_monitor/can_monitor.c

@@ -0,0 +1,327 @@
+/**
+ * CAN Monitor for Flipper Zero
+ *
+ * Receives CAN sniffer statistics from RPI5 via UART.
+ * Displays: IP address, total frames, pending frames, processed frames.
+ *
+ * UART Configuration:
+ *   - TX: GPIO 13 (pin 13)
+ *   - RX: GPIO 14 (pin 14)
+ *   - Baud: 115200
+ *   - 8N1
+ *
+ * Protocol: Text-based
+ *   Format: STATS:ip=<ip>,total=<n>,pending=<n>,processed=<n>\n
+ *   Example: STATS:ip=192.168.1.100,total=12345,pending=100,processed=12245\n
+ */
+
+#include <furi.h>
+#include <furi_hal.h>
+#include <gui/gui.h>
+#include <gui/view_port.h>
+#include <notification/notification.h>
+#include <notification/notification_messages.h>
+
+#include <expansion/expansion.h>
+#include <furi_hal_serial.h>
+
+#include <stdlib.h>
+#include <string.h>
+
+#define TAG "CANMonitor"
+
+// UART configuration
+#define UART_CH FuriHalSerialIdUsart
+#define UART_BAUD 115200
+
+// Buffer sizes
+#define RX_BUFFER_SIZE 256
+#define IP_BUFFER_SIZE 32
+
+// Statistics structure
+typedef struct {
+    char ip_address[IP_BUFFER_SIZE];
+    uint32_t total_frames;
+    uint32_t pending_frames;
+    uint32_t processed_frames;
+    bool connected;
+    uint32_t last_update_tick;
+} CanStats;
+
+// Application context
+typedef struct {
+    Gui* gui;
+    ViewPort* view_port;
+    FuriMessageQueue* event_queue;
+    FuriMutex* mutex;
+
+    FuriHalSerialHandle* serial_handle;
+    FuriStreamBuffer* rx_stream;
+    FuriThread* rx_thread;
+
+    CanStats stats;
+    bool running;
+} CanMonitorApp;
+
+// Event types
+typedef enum {
+    EventTypeKey,
+    EventTypeStats,
+} EventType;
+
+typedef struct {
+    EventType type;
+    InputEvent input;
+} CanMonitorEvent;
+
+// Parse statistics from received line
+static bool parse_stats_line(const char* line, CanStats* stats) {
+    // Format: STATS:ip=192.168.1.100,total=12345,pending=100,processed=12245
+    if(strncmp(line, "STATS:", 6) != 0) {
+        return false;
+    }
+
+    const char* data = line + 6;
+
+    // Parse ip=
+    const char* ip_start = strstr(data, "ip=");
+    if(ip_start) {
+        ip_start += 3;
+        const char* ip_end = strchr(ip_start, ',');
+        if(ip_end) {
+            size_t len = ip_end - ip_start;
+            if(len < IP_BUFFER_SIZE) {
+                strncpy(stats->ip_address, ip_start, len);
+                stats->ip_address[len] = '\0';
+            }
+        }
+    }
+
+    // Parse total=
+    const char* total_start = strstr(data, "total=");
+    if(total_start) {
+        stats->total_frames = strtoul(total_start + 6, NULL, 10);
+    }
+
+    // Parse pending=
+    const char* pending_start = strstr(data, "pending=");
+    if(pending_start) {
+        stats->pending_frames = strtoul(pending_start + 8, NULL, 10);
+    }
+
+    // Parse processed=
+    const char* processed_start = strstr(data, "processed=");
+    if(processed_start) {
+        stats->processed_frames = strtoul(processed_start + 10, NULL, 10);
+    }
+
+    stats->connected = true;
+    stats->last_update_tick = furi_get_tick();
+
+    return true;
+}
+
+// UART receive callback
+static void uart_rx_callback(
+    FuriHalSerialHandle* handle,
+    FuriHalSerialRxEvent event,
+    void* context) {
+    CanMonitorApp* app = context;
+    UNUSED(handle);
+
+    if(event == FuriHalSerialRxEventData) {
+        uint8_t data = furi_hal_serial_async_rx(handle);
+        furi_stream_buffer_send(app->rx_stream, &data, 1, 0);
+    }
+}
+
+// UART receive thread
+static int32_t uart_rx_thread(void* context) {
+    CanMonitorApp* app = context;
+    char rx_buffer[RX_BUFFER_SIZE];
+    size_t rx_index = 0;
+
+    while(app->running) {
+        uint8_t data;
+        size_t len = furi_stream_buffer_receive(app->rx_stream, &data, 1, 100);
+
+        if(len > 0) {
+            if(data == '\n' || data == '\r') {
+                if(rx_index > 0) {
+                    rx_buffer[rx_index] = '\0';
+
+                    // Parse the received line
+                    furi_mutex_acquire(app->mutex, FuriWaitForever);
+                    if(parse_stats_line(rx_buffer, &app->stats)) {
+                        // Notify view to redraw
+                        view_port_update(app->view_port);
+                    }
+                    furi_mutex_release(app->mutex);
+
+                    rx_index = 0;
+                }
+            } else if(rx_index < RX_BUFFER_SIZE - 1) {
+                rx_buffer[rx_index++] = data;
+            }
+        }
+
+        // Check connection timeout (5 seconds)
+        furi_mutex_acquire(app->mutex, FuriWaitForever);
+        if(app->stats.connected &&
+           (furi_get_tick() - app->stats.last_update_tick) > 5000) {
+            app->stats.connected = false;
+            view_port_update(app->view_port);
+        }
+        furi_mutex_release(app->mutex);
+    }
+
+    return 0;
+}
+
+// Draw callback
+static void draw_callback(Canvas* canvas, void* context) {
+    CanMonitorApp* app = context;
+
+    furi_mutex_acquire(app->mutex, FuriWaitForever);
+
+    canvas_clear(canvas);
+    canvas_set_font(canvas, FontPrimary);
+
+    // Title
+    canvas_draw_str_aligned(canvas, 64, 2, AlignCenter, AlignTop, "CAN Monitor");
+
+    canvas_set_font(canvas, FontSecondary);
+
+    // Connection status
+    if(app->stats.connected) {
+        canvas_draw_str(canvas, 0, 14, "Status: Connected");
+    } else {
+        canvas_draw_str(canvas, 0, 14, "Status: Waiting...");
+    }
+
+    // IP Address
+    char buf[64];
+    if(strlen(app->stats.ip_address) > 0) {
+        snprintf(buf, sizeof(buf), "IP: %s", app->stats.ip_address);
+    } else {
+        snprintf(buf, sizeof(buf), "IP: ---");
+    }
+    canvas_draw_str(canvas, 0, 26, buf);
+
+    // Total frames
+    snprintf(buf, sizeof(buf), "Total: %lu", (unsigned long)app->stats.total_frames);
+    canvas_draw_str(canvas, 0, 38, buf);
+
+    // Pending frames
+    snprintf(buf, sizeof(buf), "Pending: %lu", (unsigned long)app->stats.pending_frames);
+    canvas_draw_str(canvas, 0, 50, buf);
+
+    // Processed frames
+    snprintf(buf, sizeof(buf), "Processed: %lu", (unsigned long)app->stats.processed_frames);
+    canvas_draw_str(canvas, 0, 62, buf);
+
+    furi_mutex_release(app->mutex);
+}
+
+// Input callback
+static void input_callback(InputEvent* input_event, void* context) {
+    CanMonitorApp* app = context;
+    CanMonitorEvent event = {.type = EventTypeKey, .input = *input_event};
+    furi_message_queue_put(app->event_queue, &event, FuriWaitForever);
+}
+
+// Initialize application
+static CanMonitorApp* can_monitor_app_alloc(void) {
+    CanMonitorApp* app = malloc(sizeof(CanMonitorApp));
+    memset(app, 0, sizeof(CanMonitorApp));
+
+    app->running = true;
+    app->mutex = furi_mutex_alloc(FuriMutexTypeNormal);
+    app->event_queue = furi_message_queue_alloc(8, sizeof(CanMonitorEvent));
+
+    // Initialize stats
+    memset(&app->stats, 0, sizeof(CanStats));
+    strcpy(app->stats.ip_address, "");
+
+    // Disable expansion protocol to use UART
+    Expansion* expansion = furi_record_open(RECORD_EXPANSION);
+    expansion_disable(expansion);
+    furi_record_close(RECORD_EXPANSION);
+
+    // Initialize UART
+    app->rx_stream = furi_stream_buffer_alloc(RX_BUFFER_SIZE, 1);
+    app->serial_handle = furi_hal_serial_control_acquire(UART_CH);
+    furi_hal_serial_init(app->serial_handle, UART_BAUD);
+    furi_hal_serial_async_rx_start(app->serial_handle, uart_rx_callback, app, false);
+
+    // Start RX thread
+    app->rx_thread = furi_thread_alloc_ex("CANMonitorRx", 1024, uart_rx_thread, app);
+    furi_thread_start(app->rx_thread);
+
+    // Initialize 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);
+
+    return app;
+}
+
+// Free application
+static void can_monitor_app_free(CanMonitorApp* app) {
+    // Stop RX thread
+    app->running = false;
+    furi_thread_join(app->rx_thread);
+    furi_thread_free(app->rx_thread);
+
+    // Deinitialize UART
+    furi_hal_serial_async_rx_stop(app->serial_handle);
+    furi_hal_serial_deinit(app->serial_handle);
+    furi_hal_serial_control_release(app->serial_handle);
+    furi_stream_buffer_free(app->rx_stream);
+
+    // Re-enable expansion protocol
+    Expansion* expansion = furi_record_open(RECORD_EXPANSION);
+    expansion_enable(expansion);
+    furi_record_close(RECORD_EXPANSION);
+
+    // Free GUI
+    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_message_queue_free(app->event_queue);
+    furi_mutex_free(app->mutex);
+
+    free(app);
+}
+
+// Main application entry point
+int32_t can_monitor_app(void* p) {
+    UNUSED(p);
+
+    CanMonitorApp* app = can_monitor_app_alloc();
+
+    CanMonitorEvent event;
+    bool running = true;
+
+    // Main event loop
+    while(running) {
+        if(furi_message_queue_get(app->event_queue, &event, 100) == FuriStatusOk) {
+            if(event.type == EventTypeKey) {
+                if(event.input.type == InputTypeShort ||
+                   event.input.type == InputTypeLong) {
+                    if(event.input.key == InputKeyBack) {
+                        running = false;
+                    }
+                }
+            }
+        }
+    }
+
+    can_monitor_app_free(app);
+
+    return 0;
+}