feat(subghz): file loader

Author: anarchyysm

components/Applications/SubGhz/include/subghz_file_loader.h

@@ -0,0 +1,19 @@
+#ifndef SUBGHZ_FILE_LOADER_H
+#define SUBGHZ_FILE_LOADER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Percorre um diretório procurando arquivos .sub e tenta identificar o protocolo
+ * 
+ * @param dir_path Caminho do diretório (ex: "/assets/tmp")
+ */
+void subghz_loader_process_directory(const char* dir_path);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // SUBGHZ_FILE_LOADER_H

components/Applications/SubGhz/protocols/protocol_rcswitch.c

@@ -37,16 +37,23 @@ static bool check_pulse(int32_t raw_len, uint16_t base_len, uint8_t multiplier)
     return (raw_len >= target - tol) && (raw_len <= target + tol);
 }
 
+static bool check_polarity(int32_t raw_len, bool expect_high) {
+    if (expect_high) return raw_len > 0;
+    else return raw_len < 0;
+}
+
 static bool protocol_rcswitch_decode(const int32_t* raw_data, size_t count, subghz_data_t* out_data) {
     if (count < 20) return false;
 
     // Tenta cada protocolo
     for (int p = 0; p < RC_PROTO_COUNT; p++) {
         const rcswitch_proto_t* proto = &rc_protos[p];
 
-        // Pular protocolo 1 se já tivermos um decoder Princeton dedicado melhor
-        // Mas o RCSwitch 1 é bom para pegar variantes que o nosso Princeton estrito rejeitou.
-        
+        // Determina a polaridade esperada para o primeiro pulso do par (Pulse)
+        // Normal (inverted=false): Pulse=High (>0), Gap=Low (<0)
+        // Inverted (inverted=true): Pulse=Low (<0), Gap=High (>0)
+        bool expect_pulse_high = !proto->inverted;
+
         // RCSwitch geralmente procura Sync Bit primeiro.
         // Sync pode estar no começo ou no fim.
         // Vamos varrer o sinal procurando Sync.
@@ -56,15 +63,13 @@ static bool protocol_rcswitch_decode(const int32_t* raw_data, size_t count, subg
             int32_t p_sync = raw_data[i];
             int32_t g_sync = raw_data[i+1];
 
-            // Se invertido, o pulso é o GAP e o gap é o PULSO (logicamente),
-            // mas o raw_data já vem ajustado pelo RMT invert_in?
-            // O raw_data vem: P, G, P, G... onde P é High (ativo) e G é Low (pausa).
-            // O parametro "inverted" do RCSwitch muda o significado de High/Low.
-            // Se inverted=true, o sinal físico é invertido.
-            // Nosso receiver JÁ inverteu via hardware (invert_in=true).
-            // Então podemos tratar inverted=false como padrão?
-            // Vamos testar sem inversão extra primeiro.
-            
+            // 1. Verifica Polaridade do Sync
+            if (!check_polarity(p_sync, expect_pulse_high) || 
+                !check_polarity(g_sync, !expect_pulse_high)) {
+                continue;
+            }
+
+            // 2. Verifica Duração do Sync
             if (check_pulse(p_sync, proto->pulse_len, proto->sync.high) &&
                 check_pulse(g_sync, proto->pulse_len, proto->sync.low)) {
 
@@ -78,6 +83,13 @@ static bool protocol_rcswitch_decode(const int32_t* raw_data, size_t count, subg
                 while (k < count - 1 && bits < 32) {
                     int32_t p0 = raw_data[k];
                     int32_t g0 = raw_data[k+1];
+
+                    // Verifica Polaridade dos Dados
+                    if (!check_polarity(p0, expect_pulse_high) || 
+                        !check_polarity(g0, !expect_pulse_high)) {
+                        fail = true;
+                        break;
+                    }
 
                     // Test 0
                     if (check_pulse(p0, proto->pulse_len, proto->zero.high) && 
@@ -99,15 +111,9 @@ static bool protocol_rcswitch_decode(const int32_t* raw_data, size_t count, subg
 
                 if (!fail && bits >= 8) {
                     // Sucesso!
-                    // Formatar nome "RCSwitch vX"
-                    static char proto_name[20];
-                    snprintf(proto_name, sizeof(proto_name), "RCSwitch v%d", p+1);
-                    
-                    out_data->protocol_name = strdup(proto_name); // Leak? Deveriamos usar const string
-                    // Como não podemos alocar, vamos usar uma lista estática de nomes ou hack.
-                    // Vamos usar "RCSwitch" genérico e colocar versão no serial ou log
-                    out_data->protocol_name = "RCSwitch"; // Simplificação
-                    // Podemos codificar o protocolo nos bits altos do raw se quiser
+                    static char proto_name[24];
+                    snprintf(proto_name, sizeof(proto_name), "RCSwitch(%d)", p + 1);
+                    out_data->protocol_name = proto_name;
 
                     out_data->bit_count = bits;
                     out_data->raw_value = decoded_val;

components/Applications/SubGhz/protocols/subghz_protocol_registry.c

@@ -15,7 +15,8 @@ extern subghz_protocol_t protocol_rcswitch;
 
 // Lista de protocolos ativos
 static subghz_protocol_t* registry[] = {
-    &protocol_rossi, // Check first (distinctive header)
+    &protocol_rcswitch, // Generic fallback
+    // &protocol_rossi, // Check first (distinctive header)
     &protocol_princeton,
     &protocol_came,
     &protocol_nice_flo,
@@ -24,7 +25,6 @@ static subghz_protocol_t* registry[] = {
     &protocol_holtek,
     &protocol_linear,
     &protocol_liftmaster,
-    &protocol_rcswitch, // Generic fallback
     NULL
 };
 

components/Applications/SubGhz/subghz_file_loader.c

@@ -0,0 +1,133 @@
+#include "subghz_file_loader.h"
+#include "subghz_protocol_registry.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <dirent.h>
+#include <sys/stat.h>
+#include "esp_log.h"
+#include "storage_assets.h"
+
+static const char *TAG = "SUBGHZ_LOADER";
+
+#define MAX_LINE_LEN 2048
+#define INITIAL_BUF_SIZE 2048 // Start with 2048 samples
+
+static void process_file(const char *filepath) {
+    ESP_LOGI(TAG, "Processing file: %s", filepath);
+
+    FILE *f = fopen(filepath, "r");
+    if (!f) {
+        ESP_LOGE(TAG, "Failed to open file: %s", filepath);
+        return;
+    }
+
+    int32_t *raw_data = malloc(INITIAL_BUF_SIZE * sizeof(int32_t));
+    if (!raw_data) {
+        ESP_LOGE(TAG, "OOM: Failed to allocate initial buffer");
+        fclose(f);
+        return;
+    }
+
+    size_t capacity = INITIAL_BUF_SIZE;
+    size_t count = 0;
+    char *line = malloc(MAX_LINE_LEN);
+    if (!line) {
+         ESP_LOGE(TAG, "OOM: Failed to allocate line buffer");
+         free(raw_data);
+         fclose(f);
+         return;
+    }
+
+    while (fgets(line, MAX_LINE_LEN, f)) {
+        if (strncmp(line, "RAW_Data:", 9) == 0) {
+            char *ptr = line + 9;
+            char *endptr;
+            
+            while (*ptr) {
+                // Skip whitespace
+                while (*ptr == ' ' || *ptr == '\t') ptr++;
+                if (*ptr == '\0' || *ptr == '\r' || *ptr == '\n') break;
+
+                long val = strtol(ptr, &endptr, 10);
+                if (ptr == endptr) break; // Conversion failed or no number
+                ptr = endptr;
+
+                // Add to buffer
+                if (count >= capacity) {
+                    size_t new_cap = capacity * 2;
+                    int32_t *new_buf = realloc(raw_data, new_cap * sizeof(int32_t));
+                    if (!new_buf) {
+                        ESP_LOGE(TAG, "OOM: Failed to grow buffer to %d", new_cap);
+                        break;
+                    }
+                    raw_data = new_buf;
+                    capacity = new_cap;
+                }
+                raw_data[count++] = (int32_t)val;
+            }
+        }
+    }
+
+    free(line);
+    fclose(f);
+
+    if (count > 0) {
+        ESP_LOGI(TAG, "Loaded %d samples from %s. Decoding...", count, filepath);
+        subghz_data_t result = {0};
+        
+        // Ensure result is clean
+        memset(&result, 0, sizeof(result));
+
+        if (subghz_process_raw(raw_data, count, &result)) {
+            ESP_LOGI(TAG, ">>> SUCCESS [%s] Protocol: %s | Serial: 0x%lX | Btn: 0x%X | Bits: %d", 
+                     filepath, result.protocol_name, result.serial, result.btn, result.bit_count);
+        } else {
+            ESP_LOGW(TAG, ">>> FAILED [%s] No protocol identified", filepath);
+        }
+    } else {
+        ESP_LOGW(TAG, "No RAW_Data found in file: %s", filepath);
+    }
+
+    free(raw_data);
+}
+
+void subghz_loader_process_directory(const char* dir_path) {
+    if (!storage_assets_is_mounted()) {
+        ESP_LOGE(TAG, "Assets partition not mounted! Call storage_assets_init() first.");
+        return;
+    }
+
+    ESP_LOGI(TAG, "Scanning directory: %s", dir_path);
+
+    DIR *dir = opendir(dir_path);
+    if (!dir) {
+        ESP_LOGE(TAG, "Failed to open directory: %s", dir_path);
+        return;
+    }
+
+    struct dirent *entry;
+    int files_processed = 0;
+
+    while ((entry = readdir(dir)) != NULL) {
+        // Skip hidden files or current/parent
+        if (entry->d_name[0] == '.') continue;
+
+        char fullpath[256];
+        int len = snprintf(fullpath, sizeof(fullpath), "%s/%s", dir_path, entry->d_name);
+        if (len >= sizeof(fullpath)) continue;
+
+        struct stat st;
+        if (stat(fullpath, &st) == 0 && S_ISREG(st.st_mode)) {
+            // Check extension .sub
+            char *ext = strrchr(entry->d_name, '.');
+            if (ext && strcmp(ext, ".sub") == 0) {
+                process_file(fullpath);
+                files_processed++;
+            }
+        }
+    }
+    closedir(dir);
+    
+    ESP_LOGI(TAG, "Done. Processed %d files.", files_processed);
+}