Experimental PCAP on main USART support

esp_flasher/scenes/esp_flasher_scene_quick.c

@@ -107,14 +107,14 @@ bool esp_flasher_scene_quick_on_event(void* context, SceneManagerEvent event) {
             boot = APP_DATA_PATH("assets/marauder/WifidevS2/esp32_marauder.ino.bootloader.bin");
             part = APP_DATA_PATH("assets/marauder/esp32_marauder.ino.partitions.bin");
             app0 = APP_DATA_PATH("assets/marauder/boot_app0.bin");
-            firm = APP_DATA_PATH("assets/marauder/WifidevS2/esp32_marauder_flipper_sd_serial.bin");
+            firm = APP_DATA_PATH("assets/marauder/WifidevS2/esp32_marauder.flipper.bin");
             enter_bootloader = true;
             break;
         case QuickDevproWroomMarauder:
             boot = APP_DATA_PATH("assets/marauder/DevproWroom/esp32_marauder.ino.bootloader.bin");
             part = APP_DATA_PATH("assets/marauder/esp32_marauder.ino.partitions.bin");
             app0 = APP_DATA_PATH("assets/marauder/boot_app0.bin");
-            firm = APP_DATA_PATH("assets/marauder/DevproWroom/esp32_marauder_dev_board_pro.bin");
+            firm = APP_DATA_PATH("assets/marauder/DevproWroom/esp32_marauder.marauder_dev_board_pro.bin");
             break;
         default:
             flash = false;

wifi_marauder_companion/scenes/wifi_marauder_scene_console_output.c

@@ -51,7 +51,7 @@ void wifi_marauder_console_output_handle_rx_data_cb(uint8_t* buf, size_t len, vo
     view_dispatcher_send_custom_event(app->view_dispatcher, WifiMarauderEventRefreshConsoleOutput);
 }
 
-void wifi_marauder_console_output_handle_rx_packets_cb(uint8_t* buf, size_t len, void* context) {
+void wifi_marauder_console_output_handle_rx_pcap_cb(uint8_t* buf, size_t len, void* context) {
     furi_assert(context);
     WifiMarauderApp* app = context;
 
@@ -104,11 +104,9 @@ void wifi_marauder_scene_console_output_on_enter(void* context) {
     wifi_marauder_uart_set_handle_rx_data_cb(
         app->uart,
         wifi_marauder_console_output_handle_rx_data_cb); // setup callback for general log rx thread
-    if(app->ok_to_save_pcaps) {
-        wifi_marauder_uart_set_handle_rx_data_cb(
-            app->lp_uart,
-            wifi_marauder_console_output_handle_rx_packets_cb); // setup callback for packets rx thread
-    }
+    wifi_marauder_uart_set_handle_rx_pcap_cb(
+        app->uart,
+        wifi_marauder_console_output_handle_rx_pcap_cb); // setup callback for general log rx thread
 
     // Get ready to send command
     if((app->is_command && app->selected_tx_string) || app->script) {
@@ -203,9 +201,7 @@ void wifi_marauder_scene_console_output_on_exit(void* context) {
 
     // Unregister rx callback
     wifi_marauder_uart_set_handle_rx_data_cb(app->uart, NULL);
-    if(app->ok_to_save_pcaps) {
-        wifi_marauder_uart_set_handle_rx_data_cb(app->lp_uart, NULL);
-    }
+    wifi_marauder_uart_set_handle_rx_pcap_cb(app->uart, NULL);
 
     wifi_marauder_script_worker_free(app->script_worker);
     app->script_worker = NULL;

wifi_marauder_companion/scenes/wifi_marauder_scene_settings_init.c

@@ -65,9 +65,6 @@ bool wifi_marauder_scene_settings_init_on_event(void* context, SceneManagerEvent
     if(event.type == SceneManagerEventTypeCustom) {
         if(app->which_prompt == PROMPT_PCAPS) {
             wifi_marauder_uart_free(app->uart);
-            if(app->ok_to_save_pcaps) {
-                wifi_marauder_uart_free(app->lp_uart);
-            }
         }
 
         // get which button press: "Yes" or "No"
@@ -91,7 +88,6 @@ bool wifi_marauder_scene_settings_init_on_event(void* context, SceneManagerEvent
         if(app->which_prompt == PROMPT_PCAPS) {
             if(app->ok_to_save_pcaps) {
                 app->uart = wifi_marauder_usart_init(app);
-                app->lp_uart = wifi_marauder_lp_uart_init(app);
             } else {
                 app->uart = wifi_marauder_xtreme_uart_init(app);
             }

wifi_marauder_companion/wifi_marauder_app.c

@@ -159,9 +159,6 @@ void wifi_marauder_app_free(WifiMarauderApp* app) {
     scene_manager_free(app->scene_manager);
 
     wifi_marauder_uart_free(app->uart);
-    if(app->ok_to_save_pcaps) {
-        wifi_marauder_uart_free(app->lp_uart);
-    }
 
     // Close records
     furi_record_close(RECORD_GUI);
@@ -189,7 +186,6 @@ int32_t wifi_marauder_app(void* p) {
 
     if(wifi_marauder_app->ok_to_save_pcaps) {
         wifi_marauder_app->uart = wifi_marauder_usart_init(wifi_marauder_app);
-        wifi_marauder_app->lp_uart = wifi_marauder_lp_uart_init(wifi_marauder_app);
     } else {
         wifi_marauder_app->uart = wifi_marauder_xtreme_uart_init(wifi_marauder_app);
     }

wifi_marauder_companion/wifi_marauder_app_i.h

@@ -82,7 +82,6 @@ struct WifiMarauderApp {
     int open_log_file_num_pages;
 
     WifiMarauderUart* uart;
-    WifiMarauderUart* lp_uart;
     int selected_menu_index;
     int selected_option_index[NUM_MENU_ITEMS];
     const char* selected_tx_string;

wifi_marauder_companion/wifi_marauder_uart.c

@@ -7,7 +7,6 @@
 bool xtreme_uart = false;
 
 #define UART_CH (FuriHalUartIdUSART1)
-#define LP_UART_CH (FuriHalUartIdLPUART1)
 #define BAUDRATE (115200)
 
 struct WifiMarauderUart {
@@ -15,13 +14,19 @@ struct WifiMarauderUart {
     FuriHalUartId channel;
     FuriThread* rx_thread;
     FuriStreamBuffer* rx_stream;
+    FuriStreamBuffer* pcap_stream;
+    uint8_t pcap_test_buf[12];
+    uint8_t pcap_test_idx;
+    bool pcap;
     uint8_t rx_buf[RX_BUF_SIZE + 1];
     void (*handle_rx_data_cb)(uint8_t* buf, size_t len, void* context);
+    void (*handle_rx_pcap_cb)(uint8_t* buf, size_t len, void* context);
 };
 
 typedef enum {
     WorkerEvtStop = (1 << 0),
     WorkerEvtRxDone = (1 << 1),
+    WorkerEvtPcapDone = (1 << 2),
 } WorkerEvtFlags;
 
 void wifi_marauder_uart_set_handle_rx_data_cb(
@@ -31,14 +36,64 @@ void wifi_marauder_uart_set_handle_rx_data_cb(
     uart->handle_rx_data_cb = handle_rx_data_cb;
 }
 
-#define WORKER_ALL_RX_EVENTS (WorkerEvtStop | WorkerEvtRxDone)
+void wifi_marauder_uart_set_handle_rx_pcap_cb(
+    WifiMarauderUart* uart,
+    void (*handle_rx_pcap_cb)(uint8_t* buf, size_t len, void* context)) {
+    furi_assert(uart);
+    uart->handle_rx_pcap_cb = handle_rx_pcap_cb;
+}
+
+#define WORKER_ALL_RX_EVENTS (WorkerEvtStop | WorkerEvtRxDone | WorkerEvtPcapDone)
 
 void wifi_marauder_uart_on_irq_cb(UartIrqEvent ev, uint8_t data, void* context) {
     WifiMarauderUart* uart = (WifiMarauderUart*)context;
 
     if(ev == UartIrqEventRXNE) {
-        furi_stream_buffer_send(uart->rx_stream, &data, 1, 0);
-        furi_thread_flags_set(furi_thread_get_id(uart->rx_thread), WorkerEvtRxDone);
+        if(uart->pcap_test_idx != 0) {
+            // We are trying to match a pcap delimiter
+            const char* pcap_begin = "%PCAP_BEGIN%";
+            const char* pcap_close = "%PCAP_CLOSE%";
+            if(data == pcap_begin[uart->pcap_test_idx] || data == pcap_close[uart->pcap_test_idx]) {
+                // Received char matches next char in a pcap delimiter, append to buffer
+                uart->pcap_test_buf[uart->pcap_test_idx++] = data;
+                if(uart->pcap_test_idx == sizeof(uart->pcap_test_buf)) {
+                    // Buffer reached max length, parse what delimiter this is and discard buffer
+                    if(!memcmp(uart->pcap_test_buf, (void*)pcap_begin, sizeof(uart->pcap_test_buf))) {
+                        uart->pcap = true;
+                    } else if(!memcmp(uart->pcap_test_buf, (void*)pcap_close, sizeof(uart->pcap_test_buf))) {
+                        uart->pcap = false;
+                    }
+                    uart->pcap_test_idx = 0;
+                }
+                // Don't pass to stream
+                return;
+            } else {
+                // Received char doesn't match any expected next char, send old buffer
+                if(uart->pcap) {
+                    furi_stream_buffer_send(uart->pcap_stream, uart->pcap_test_buf, uart->pcap_test_idx, 0);
+                    furi_thread_flags_set(furi_thread_get_id(uart->rx_thread), WorkerEvtPcapDone);
+                } else {
+                    furi_stream_buffer_send(uart->rx_stream, uart->pcap_test_buf, uart->pcap_test_idx, 0);
+                    furi_thread_flags_set(furi_thread_get_id(uart->rx_thread), WorkerEvtRxDone);
+                }
+                // Reset buffer and try parsing this char from scratch
+                uart->pcap_test_idx = 0;
+            }
+        }
+        // If we reach here the buffer is empty
+        if(data == '%') {
+            // Received delimiter start, append to buffer
+            uart->pcap_test_buf[uart->pcap_test_idx++] = data;
+        } else {
+            // Not a delimiter start and we aren't matching a delimiter, this is just data
+            if(uart->pcap) {
+                furi_stream_buffer_send(uart->pcap_stream, &data, 1, 0);
+                furi_thread_flags_set(furi_thread_get_id(uart->rx_thread), WorkerEvtPcapDone);
+            } else {
+                furi_stream_buffer_send(uart->rx_stream, &data, 1, 0);
+                furi_thread_flags_set(furi_thread_get_id(uart->rx_thread), WorkerEvtRxDone);
+            }
+        }
     }
 }
 
@@ -56,9 +111,16 @@ static int32_t uart_worker(void* context) {
                 if(uart->handle_rx_data_cb) uart->handle_rx_data_cb(uart->rx_buf, len, uart->app);
             }
         }
+        if(events & WorkerEvtPcapDone) {
+            size_t len = furi_stream_buffer_receive(uart->pcap_stream, uart->rx_buf, RX_BUF_SIZE, 0);
+            if(len > 0) {
+                if(uart->handle_rx_pcap_cb) uart->handle_rx_pcap_cb(uart->rx_buf, len, uart->app);
+            }
+        }
     }
 
     furi_stream_buffer_free(uart->rx_stream);
+    furi_stream_buffer_free(uart->pcap_stream);
 
     return 0;
 }
@@ -72,10 +134,6 @@ void wifi_marauder_uart_tx(uint8_t* data, size_t len) {
     }
 }
 
-void wifi_marauder_lp_uart_tx(uint8_t* data, size_t len) {
-    furi_hal_uart_tx(LP_UART_CH, data, len);
-}
-
 WifiMarauderUart*
     wifi_marauder_uart_init(WifiMarauderApp* app, FuriHalUartId channel, const char* thread_name) {
     WifiMarauderUart* uart = malloc(sizeof(WifiMarauderUart));
@@ -83,6 +141,7 @@ WifiMarauderUart*
     uart->app = app;
     uart->channel = channel;
     uart->rx_stream = furi_stream_buffer_alloc(RX_BUF_SIZE, 1);
+    uart->pcap_stream = furi_stream_buffer_alloc(RX_BUF_SIZE, 1);
     uart->rx_thread = furi_thread_alloc();
     furi_thread_set_name(uart->rx_thread, thread_name);
     furi_thread_set_stack_size(uart->rx_thread, 1024);
@@ -110,10 +169,6 @@ WifiMarauderUart* wifi_marauder_usart_init(WifiMarauderApp* app) {
     return wifi_marauder_uart_init(app, UART_CH, "WifiMarauderUartRxThread");
 }
 
-WifiMarauderUart* wifi_marauder_lp_uart_init(WifiMarauderApp* app) {
-    return wifi_marauder_uart_init(app, LP_UART_CH, "WifiMarauderLPUartRxThread");
-}
-
 void wifi_marauder_uart_free(WifiMarauderUart* uart) {
     furi_assert(uart);
 

wifi_marauder_companion/wifi_marauder_uart.h

@@ -9,9 +9,10 @@ typedef struct WifiMarauderUart WifiMarauderUart;
 void wifi_marauder_uart_set_handle_rx_data_cb(
     WifiMarauderUart* uart,
     void (*handle_rx_data_cb)(uint8_t* buf, size_t len, void* context));
+void wifi_marauder_uart_set_handle_rx_pcap_cb(
+    WifiMarauderUart* uart,
+    void (*handle_rx_pcap_cb)(uint8_t* buf, size_t len, void* context));
 void wifi_marauder_uart_tx(uint8_t* data, size_t len);
-void wifi_marauder_lp_uart_tx(uint8_t* data, size_t len);
 WifiMarauderUart* wifi_marauder_xtreme_uart_init(WifiMarauderApp* app);
 WifiMarauderUart* wifi_marauder_usart_init(WifiMarauderApp* app);
-WifiMarauderUart* wifi_marauder_lp_uart_init(WifiMarauderApp* app);
 void wifi_marauder_uart_free(WifiMarauderUart* uart);