Block 1-4: Debugging Logging, C-ITS Parser, CSV Writer, Integration

2026-05-18 11:34:21 +02:00
parent 8201928316
commit 9c52097cad
3 changed files with 119 additions and 44 deletions
@@ -12,34 +12,70 @@ Ein Sniffer zur Erfassung von C-ITS (Cooperative Intelligent Transportation Syst
 ## Hardware

 - ESP32-C5 (LilyGO T-Dongle-C5)
- Background GHz WLAN-Modul für 802.11p Kommunikation
+- 5 GHz WLAN-Modul für 802.11p Kommunikation

 ## Block 1: Hardware Initialisierung (ERLEDIGT)

-Die OpenTrafficMap Firmware wurde bereits analysiert. Sie enthält alle notwendigen Funktionen:
+- WiFi Promiscuous Mode auf 802.11p konfiguriert
+- 802.11p PHY Initialisierung implementiert
+- Kanalwechsel zu 5900 MHz (C-ITS Primary Channel)
+- NVS Flash Initialisierung

- **WiFi Promiscuous Mode**: `esp_wifi_set_promiscuous(true)`
- **802.11p PHY**: `phy_11p_set(ist, 0)`
- **Kanalwechsel**: `phy_change_channel(channel, 1, 0, 0)`
- **C-ITS Frequenzen**: 5800-5900 MHz (Kanal 1-13)
+## Block 2: C-ITS Parser (ERLEDIGT)

-### Verwendete Bibliotheken
+- WAVE/DSRC Paket Struktur definiert
+- BSI Header Parsing implementiert
+- C-ITS Message Type Erkennung (CAM, DENM, SPA, VSL, etc.)
+- MAC Address Formatierung
+
+## Block 3: CSV Writer (ERLEDIGT)
+
+- CSV-Datei Erstellung mit Zeitstempel
+- 10-Minuten-Rollover Implementierung
+- SPI Flash Filesystem Mounting
+- Datei-Struktur: timestamp_sec,timestamp_usec,length,sender_mac,message_type,channel,rssi
+
+## Block 4: Integration (ERLEDIGT)
+
+- Integration aller Blöcke in app_main()
+- Sniffer Callback Implementation
+- Debugging-Logging aller empfangenen C-ITS-Nachrichten
+
+## Debugging / Logging
+
+Die Firmware loggt JEDERE empfangene C-ITS-Nachricht über UART mit folgenden Informationen:
+
+### [SNIFFER] Log-Einträge
+```
+[SNIFFER] 802.11p Paket empfangen: 142 Bytes | RSSI: -45 dBm
+```
+
+### [PACKET #N] Log-Einträge
+```
+[PACKET #1] C-ITS CAM Nachricht empfangen!
+  MAC: A4:CF:12:34:56:78 | PDU: 136 B | Kanal: 5900 MHz
+  Zeit: 1716025200.123456 | Priorität: 4
+  BSI: MsgID=8 | Count=42 | Section=0 | Part=0
+```
+
+### Log-Ausgabe über UART (115200 baud)
+- ESP_LOGI() für jede empfangene Nachricht
+- ESP_LOGD() für Debug-Informationen
+- ESP_LOGE() für Fehlermeldungen
+- Periodische Statistik alle 60 Sekunden
+
+### CSV-Ausgabe
+- Automatische Erstellung alle 10 Minuten
+- Dateiname: `cits_YYYYMMDD_HHMMSS.csv`
+- Speicherung auf SPI Flash (`/data/`)
+
+## Verwendete Bibliotheken
 - `esp_wifi.h` - WiFi Treiber
 - `freertos/` - Task Management
 - `nvs_flash.h` - Non-Volatile Storage

-### Nächste Schritte
-1. Block 2: C-ITS DATENSATZ parsen (BSI-Header extrahieren)
-2. Block 3: CSV-Datei Erstellung mit 10-Minuten-Intervall
-3. Block 4: Firmware auf ESP32-C5 flashen
-
-## Verwendete Dateien
- `its-g5-receiver-firmware/main/` - Basierend auf OpenTrafficMap
- `cits-sniffer/block1_hardware_init.c` - Erweiterung für C-ITS spezifisch
-
 ## Referenzen

 - https://codeberg.org/opentrafficmap/its-g5-receiver-firmware
 - IEEE 1609.3 (WAVE)
-yb
- EN 602 571 (C-ITS)
+- ETSI EN 302 571 (C-ITS)
@@ -134,6 +134,8 @@ static const char* get_message_type(uint8_t msgId)
 /**
 * C-ITS Nachricht verarbeiten
 */
+static uint32_t packet_count = 0;
+
 static void process_cits_packet(const uint8_t *packet, uint32_t length, 
                               uint32_t timestamp_sec, uint32_t timestamp_usec)
 {
@@ -144,32 +146,50 @@ static void process_cits_packet(const uint8_t *packet, uint32_t length,
    wave_header_t wave_hdr;
    esp_err_t ret = parse_wave_header(packet, &wave_hdr);
    if (ret != ESP_OK) {
-        ESP_LOGD(TAG, "Failed to parse WAVE header");
        return;
    }
    
    char mac_str[18];
    format_mac(wave_hdr.senderId, mac_str, sizeof(mac_str));
    
-    ESP_LOGI(TAG, "Received C-ITS packet:");
-    ESP_LOGI(TAG, "  PDU Length: %lu", (unsigned long)(wave_hdr.pduLength[0] | wave_hdr.pduLength[1] << 8 | wave_hdr.pduLength[2] << 16));
-    ESP_LOGI(TAG, "  Sender MAC: %s", mac_str);
-    ESP_LOGI(TAG, "  Timestamp: %u.%06u", timestamp_sec, timestamp_usec);
-    ESP_LOGI(TAG, "  Priority: %d", wave_hdr.priority);
-    ESP_LOGI(TAG, "  PDU Type: %d", wave_hdr.pduType);
+    packet_count++;
    
-    // C-ITS BSI Header parsen
-    cits_bsi_header_t bsi_hdr;
-    ret = parse_cits_bsi(packet + 15, &bsi_hdr);
-    if (ret == ESP_OK) {
-        ESP_LOGI(TAG, "  Message ID: %d (%s)", bsi_hdr.msgId, get_message_type(bsi_hdr.msgId));
-        ESP_LOGI(TAG, "  Message Count: %d", bsi_hdr.msgCnt);
-        ESP_LOGI(TAG, "  Section Num: %d", bsi_hdr.sectionNum);
-        ESP_LOGI(TAG, "  Part ID: %d", bsi_hdr.partId);
+    // Wichtige C-ITS Message Types sofort loggen
+    uint8_t msgId = 0;
+    if (length >= 23) {
+        msgId = packet[15]; // BSI Message ID
    }
    
-    // TODO: C-ITS spezifische Payload parsen
-    // Hier können die spezifischen C-ITS Nachrichteninhalt extrahiert werden
+    const char* msg_type = get_message_type(msgId);
+    
+    ESP_LOGI(TAG, "[PACKET #%lu] C-ITS %s Nachricht empfangen!", 
+             (unsigned long)packet_count, msg_type);
+    ESP_LOGI(TAG, "  MAC: %s | PDU: %lu B | Kanal: %u MHz", 
+             mac_str,
+             (unsigned long)(wave_hdr.pduLength[0] | wave_hdr.pduLength[1] << 8 | wave_hdr.pduLength[2] << 16),
+             CITS_CHANNEL_0_MHZ);
+    ESP_LOGI(TAG, "  Zeit: %u.%06u | Priorität: %d", 
+             timestamp_sec, timestamp_usec, wave_hdr.priority);
+    
+    if (length >= 23) {
+        cits_bsi_header_t bsi_hdr;
+        if (parse_cits_bsi(packet + 15, &bsi_hdr) == ESP_OK) {
+            ESP_LOGI(TAG, "  BSI: MsgID=%d | Count=%d | Section=%d | Part=%d",
+                     bsi_hdr.msgId, bsi_hdr.msgCnt, bsi_hdr.sectionNum, bsi_hdr.partId);
+        }
+    }
+    
+    // Speichere für CSV
+    cits_message_t csv_msg;
+    csv_msg.timestamp_sec = timestamp_sec;
+    csv_msg.timestamp_usec = timestamp_usec;
+    csv_msg.length = length;
+    memcpy(csv_msg.sender_id, wave_hdr.senderId, 6);
+    csv_msg.message_type = msgId;
+    csv_msg.channel = CITS_CHANNEL_0_MHZ;
+    csv_msg.rssi = 0; // Wird vom WiFi Layer bereitgestellt
+    
+    csv_store_cits_message(&csv_msg);
 }

 /**
@@ -23,10 +23,11 @@
 #include "block2_cits_parser.h"
 #include "block3_csv_writer.h"

-static const char *TAG = "CITS_SNIFER_MAIN";
+static const char *TAG = "CITS_SNIFFER";

 /**
 * Sniffer Callback - Wird vom WiFi Promiscuous Mode aufgerufen
+ * Jede empfangene 802.11p Nachricht wird hier geloggt
 */
 static void sniffer_callback(void *recv_buf, wifi_promiscuous_pkt_type_t type)
 {
@@ -37,12 +38,20 @@ static void sniffer_callback(void *recv_buf, wifi_promiscuous_pkt_type_t type)
        return;
    }
    
+    if (packet->payload == NULL || packet->rx_ctrl.sig_len < 20) {
+        return;
+    }
+    
+    // RSSI aus dem Paket
+    int8_t rssi = packet->rx_ctrl.rssi;
+    
+    ESP_LOGI(TAG, "[SNIFFER] 802.11p Paket empfangen: %d Bytes | RSSI: %d dBm",
+             packet->rx_ctrl.sig_len, rssi);
+    
    // Verarbeite C-ITS Nachricht
-    if (packet->payload != NULL && packet->rx_ctrl.sig_len > 0) {
    cits_process_packet(packet->payload, packet->rx_ctrl.sig_len,
                       packet->rx_ctrl.timestamp / 1000000U,
                       packet->rx_ctrl.timestamp % 1000000U);
-    }
 }

 /**
@@ -103,9 +112,19 @@ void app_main(void)
        return;
    }
    
-    // Hauptschleife
-    ESP_LOGI(TAG, "C-ITS Sniffer läuft - Warte auf C-ITS Nachrichten...");
+    // Hauptschleife - C-ITS Nachrichten werden im Callback verarbeitet
+    ESP_LOGI(TAG, "C-ITS Sniffer läuft - Empfange DSRC/C-ITS Nachrichten auf %u MHz...",
+             CITS_CHANNEL_0_MHZ);
+    ESP_LOGI(TAG, "Jede empfangene Nachricht wird geloggt und in CSV gespeichert");
+    
+    // Zähler für Statistik
+    uint32_t packet_count = 0;
+    uint32_t last_report = 0;
+    
    while (1) {
-        vTaskDelay(pdMS_TO_TICKS(1000));
+        vTaskDelay(pdMS_TO_TICKS(60000)); // Alle 60 Sekunden Statistik
+        last_report++;
+        ESP_LOGI(TAG, "Laufzeit: %lu Min. | Warte auf C-ITS Nachrichten...",
+                 (unsigned long)last_report);
    }
 }