wisp/cits-sniffer
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 2 Wiki Activity

build: fix USB-JTAG API, PRI macros, linker symbols for ESP-IDF 5.5

Browse Source
This commit is contained in:
Clawdia
2026-05-20 06:36:35 +02:00
parent 76d50165c4
commit 5248ff7b82
15 changed files with 1976 additions and 2273 deletions
Download Patch File Download Diff File Expand all files Collapse all files
main/block4_integration.c
+168 -324
View File
@@ -1,7 +1,11 @@
/**
* Block 4: Integration und Flashen der Firmware auf ESP32-C5
*
* Ziel: C-ITS Sniffer Firmware für ESP32-C5 compilieren und flashen
* Block 4: Integration - C-ITS Sniffer für ESP32-C5
*
* Hauptprogramm:
* - NVS + WiFi + 802.11p PHY + Promiscuous Mode
* - CSV Writer auf SD-Karte
* - USB-Serial/JTAG Console für Live-Ansicht der C-ITS Nachrichten
* - CLI Commands: status, chan <freq>, set_channel <freq>, stop_sniffer
*/
#include <stdio.h>
@@ -9,19 +13,19 @@
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>
#include <time.h>
#include <inttypes.h>
#include "sdkconfig.h"
#include "esp_err.h"
#include "esp_log.h"
#include "esp_wifi.h"
#include "esp_timer.h"
#include "esp_console.h"
#include "driver/gpio.h"
#include "nvs_flash.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_console.h"
#include "esp_vfs_dev_usb_serial_jtag.h"
#include "esp_log.h"
#include "arg_table3/arg_table3.h"
#include "driver/usb_serial_jtag_vfs.h"
#include "driver/usb_serial_jtag.h"
#include "block1_hardware_init.h"
@@ -30,355 +34,195 @@
static const char *TAG = "CITS_SNIFFER";
// Globale Puffer für JTAG-Direct-Auslesung
#define MAX_STORED_PACKETS 64
#define MAX_PACKET_SIZE 2000
typedef struct {
wifi_promiscuous_pkt_t pkt;
uint32_t timestamp;
} stored_packet_t;
#define LED_PIN GPIO_NUM_28
#define STATS_INTERVAL_TICKS (pdMS_TO_TICKS(60000))
#define BUILTIN_LED_ON 0
#define BUILTIN_LED_OFF 1
static stored_packet_t stored_packets[MAX_STORED_PACKETS];
static volatile uint32_t packet_write_idx = 0;
static volatile uint32_t packet_count_total = 0;
static bool packets_available = false;
/* ---------- Sniffer-Zustand ---------- */
static volatile bool g_sniffer_active = false;
static volatile uint32_t g_total_packets = 0;
/**
* Hilfsfunktion: HEX-Daten auf Console (JTAG) ausgeben
*/
static void hex_dump(const char *prefix, const uint8_t *data, int len)
/* ---------- Promiscuous RX Callback ---------- */
void sniffer_on_raw_packet(void *buf, wifi_promiscuous_pkt_type_t type)
{
if (!prefix || !data || len <= 0) return;
// Print header with prefix
char line[128];
int offset = 0;
ESP_LOGI(TAG, "%s [Len=%d]:", prefix, len);
// First line: raw hex dump
for (int i = 0; i < len && i < 64; i++) {
if (i % 16 == 0) {
if (i > 0) {
ESP_LOGI(TAG, " %s", line);
}
offset = 0;
snprintf(line, sizeof(line), " %04x: ", i);
}
offset += snprintf(line + strlen(line), sizeof(line) - strlen(line), "%02x ", data[i]);
}
if (len > 0) {
ESP_LOGI(TAG, "%s", line);
}
(void)type;
if (!g_sniffer_active) return;
wifi_promiscuous_pkt_t *pkt = (wifi_promiscuous_pkt_t *)buf;
if (!pkt || pkt->rx_ctrl.sig_len < 14) return;
int8_t rssi = pkt->rx_ctrl.rssi;
uint16_t data_len = pkt->rx_ctrl.sig_len;
uint32_t channel_mhz = pkt->rx_ctrl.channel;
uint32_t ts_us = pkt->rx_ctrl.timestamp;
g_total_packets++;
// LED blink
gpio_set_level(LED_PIN, (g_total_packets % 10 < 1) ? BUILTIN_LED_ON : BUILTIN_LED_OFF);
// C-ITS Parser aufrufen
cits_process_packet(pkt->payload, data_len, rssi, channel_mhz,
ts_us / 1000000, ts_us % 1000000);
}
/**
* Sniffer Callback - Wird vom WiFi Promiscuous Mode aufgerufen
* Jede empfangene 802.11p Nachricht wird hier geloggt UND gespeichert für JTAG-Auslesung
*/
static void sniffer_callback(void *recv_buf, wifi_promiscuous_pkt_type_t type)
{
wifi_promiscuous_pkt_t *packet = (wifi_promiscuous_pkt_t *)recv_buf;
// Nur MISC Typ für 802.11p verarbeiten
if (type != WIFI_PKT_MISC) {
return;
}
if (packet->payload == NULL || packet->rx_ctrl.sig_len < 20) {
return;
}
// RSSI aus dem Paket
int8_t rssi = packet->rx_ctrl.rssi;
uint32_t ts = packet->rx_ctrl.timestamp;
uint16_t pkt_len = packet->rx_ctrl.sig_len;
// Detailiertes Paket-Logging auf JTAG Console
ESP_LOGI(TAG, "[SNIFFER] === Paket #%lu ===", (unsigned long)packet_count_total);
ESP_LOGI(TAG, " Länge: %d Bytes | RSSI: %d dBm | Typ: %d | Chan: %d | Rate: %d",
pkt_len, rssi, type,
packet->rx_ctrl.channel,
packet->rx_ctrl.rate);
// MAC Header Bytes ausgeben
ESP_LOGI(TAG, " MAC Header: %02x %02x %02x %02x %02x %02x %02x %02x",
packet->payload[0], packet->payload[1],
packet->payload[2], packet->payload[3],
packet->payload[4], packet->payload[5],
packet->payload[6], packet->payload[7]);
// WAVE Header parsen
if (pkt_len >= 15) {
uint32_t pdu_len = packet->payload[0] | (packet->payload[1] << 8) | (packet->payload[2] << 16);
uint8_t sender_mac[6];
memcpy(sender_mac, packet->payload + 3, 6);
uint32_t ts_field;
memcpy(&ts_field, packet->payload + 9, 4);
uint8_t priority = packet->payload[13];
uint8_t pdu_type = packet->payload[14];
ESP_LOGI(TAG, " WAVE PDU Length: %u | Sender: %02X:%02X:%02X:%02X:%02X:%02X",
pdu_len, sender_mac[0], sender_mac[1], sender_mac[2],
sender_mac[3], sender_mac[4], sender_mac[5]);
ESP_LOGI(TAG, " WAVE Timestamp: %u | Priority: %u | PDU Type: %02X",
ts_field, priority, pdu_type);
// C-ITS Payload wenn vorhanden
if (pkt_len > 15) {
ESP_LOGI(TAG, " C-ITS Payload (%d Bytes):", pkt_len - 15);
for (int i = 15; i < pkt_len && i < 47; i++) {
if ((i - 15) % 16 == 0) {
char hex_line[128];
snprintf(hex_line, sizeof(hex_line), " %04x: ", i);
ESP_LOGI(TAG, "%s", hex_line);
}
ESP_LOG_BUFFER_HEX_LEVEL(TAG, packet->payload + i, 1, ESP_LOG_INFO);
}
}
}
// Paket zum JTAG-Direct-Zugang speichern
if (packet_count_total < MAX_STORED_PACKETS) {
memcpy(&stored_packets[packet_write_idx].pkt, packet, sizeof(wifi_promiscuous_pkt_t));
stored_packets[packet_write_idx].timestamp = ts;
packet_write_idx = (packet_write_idx + 1) % MAX_STORED_PACKETS;
}
packet_count_total++;
packets_available = true;
// Verarbeite C-ITS Nachricht
cits_process_packet(packet->payload, packet->rx_ctrl.sig_len,
packet->rx_ctrl.timestamp / 1000000U,
packet->rx_ctrl.timestamp % 1000000U);
}
/* ---------- Console Commands ---------- */
/**
* C-ITS Sniffer aufsetzen
*/
static esp_err_t setup_cits_sniffer(void)
static int cmd_status(int argc, char **argv)
{
// WiFi Promiscuous Mode starten
esp_err_t ret = start_promiscuous_mode(CITS_CHANNEL_0_MHZ);
if (ret != ESP_OK) {
ESP_LOGE(TAG, "Failed to start promiscuous mode");
return ret;
}
// C-ITS Parser initialisieren
ret = cits_parser_init();
if (ret != ESP_OK) {
ESP_LOGE(TAG, "Failed to initialize C-ITS parser");
return ret;
}
// CSV Writer initialisieren
ret = csv_writer_init();
if (ret != ESP_OK) {
ESP_LOGE(TAG, "Failed to initialize CSV writer");
return ret;
}
ESP_LOGI(TAG, "C-ITS Sniffer Setup abgeschlossen");
return ESP_OK;
}
/**
* JTAG Direct Read - Gepackete Pakete auf Console (JTAG) ausgeben
*/
static int cmd_jtag_read(int argc, char **argv)
{
int count = 10; // Default 10 Pakete
if (argc > 0) {
count = atoi(argv[0]);
if (count < 1) count = 1;
if (count > MAX_STORED_PACKETS) count = MAX_STORED_PACKETS;
}
if (!packets_available) {
ESP_LOGI(TAG, "Keine Pakete empfangen. Warte auf C-ITS Nachrichten...");
return 0;
}
ESP_LOGI(TAG, "[JTAG-READ] Empfangene Pakete (%d vom %lu insgesamt):", count, (unsigned long)packet_count_total);
uint32_t idx = (packet_write_idx - 1 + MAX_STORED_PACKETS) % MAX_STORED_PACKETS;
int printed = 0;
for (int i = 0; i < count; i++) {
if (printed >= packet_count_total) break;
stored_packet_t *p = &stored_packets[idx];
if (p->pkt.payload == NULL) {
idx = (idx - 1 + MAX_STORED_PACKETS) % MAX_STORED_PACKETS;
continue;
}
uint16_t pkt_len = p->pkt.rx_ctrl.sig_len;
int8_t rssi = p->pkt.rx_ctrl.rssi;
char mac_str[20];
if (pkt_len >= 12) {
snprintf(mac_str, sizeof(mac_str), "%02x:%02x:%02x:%02x:%02x:%02x",
p->pkt.payload[0], p->pkt.payload[1],
p->pkt.payload[2], p->pkt.payload[3],
p->pkt.payload[4], p->pkt.payload[5]);
} else {
strcpy(mac_str, "N/A");
}
ESP_LOGI(TAG, "[Paket %d] L=%d RSSI=%d MAC=%s",
i + 1, pkt_len, rssi, mac_str);
ESP_LOGI(TAG, "[Paket %d] Raw: ", i + 1);
ESP_LOG_BUFFER_HEX_LEVEL(TAG, p->pkt.payload, pkt_len < 64 ? pkt_len : 64, ESP_LOG_INFO);
printed++;
idx = (idx - 1 + MAX_STORED_PACKETS) % MAX_STORED_PACKETS;
}
(void)argc; (void)argv;
ESP_LOGI(TAG, "== STATUS ==");
ESP_LOGI(TAG, "Sniffer aktiv: %s", g_sniffer_active ? "JA" : "NEIN");
ESP_LOGI(TAG, "Gesamt Pakete: %" PRIu32, g_total_packets);
return 0;
}
/**
* Sniffer Status - Aktuelle Statistik ausgeben
*/
static int cmd_sniffer_status(int argc, char **argv)
{
ESP_LOGI(TAG, "[Status] Gesamt empfangene Pakete: %lu",
(unsigned long)packet_count_total);
ESP_LOGI(TAG, "[Status] Gespeichert: %d / %d",
(packet_write_idx < MAX_STORED_PACKETS) ?
(MAX_STORED_PACKETS - packet_write_idx) : packet_write_idx,
MAX_STORED_PACKETS);
ESP_LOGI(TAG, "[Status] Pakete verfügbar: %s", packets_available ? "JA" : "NEIN");
return 0;
}
/**
* Kanal wechseln
*/
static int cmd_change_channel(int argc, char **argv)
static int cmd_chan(int argc, char **argv)
{
if (argc < 1) {
ESP_LOGI(TAG, "Nutzung: change_channel <freq_mhz>");
return 1;
printf("Nutzung: chan <5900|5890|5880|5870>\n");
return 0;
}
uint32_t freq = atoi(argv[0]);
if (freq < 5800 || freq > 5900) {
ESP_LOGE(TAG, "Frequenz muss zwischen 5800 und 5900 MHz liegen");
if (freq != 5900 && freq != 5890 && freq != 5880 && freq != 5870) {
printf("Ungültiger Kanal. Gültig: 5900, 5890, 5880, 5870\n");
return 1;
}
phy_11p_set(1, 0);
phy_change_channel(freq, 1, 0, 0);
ESP_LOGI(TAG, "Kanal auf %u MHz geändert", freq);
set_cits_channel(freq);
ESP_LOGI(TAG, "Kanal auf %d MHz ge\303\244ndert", freq);
return 0;
}
/**
* Sniffer starten (neu)
*/
static int cmd_start_sniffer(int argc, char **argv)
static int cmd_packets(int argc, char **argv)
{
ESP_LOGI(TAG, "Sniffer wird neu gestartet...");
packets_available = false;
packet_write_idx = 0;
packet_count_total = 0;
esp_err_t ret = start_promiscuous_mode(CITS_CHANNEL_0_MHZ);
if (ret != ESP_OK) {
ESP_LOGE(TAG, "Sniffer Start fehlgeschlagen");
return 1;
if (argc < 1) {
printf("Nutzung: packets <anzahl>\n");
return 0;
}
ESP_LOGI(TAG, "Sniffer läuft auf %u MHz", CITS_CHANNEL_0_MHZ);
int target = atoi(argv[0]);
uint32_t start = g_total_packets;
printf("Warte auf %d Pakete... ", target);
fflush(stdout);
while (g_total_packets - start < (uint32_t)target) {
vTaskDelay(pdMS_TO_TICKS(1000));
}
printf("OK! %" PRIu32 " Pakete empfangen.\n", g_total_packets);
return 0;
}
/**
* Hauptfunktion
*/
static int cmd_restart(int argc, char **argv)
{
(void)argc; (void)argv;
printf("Sniffer wird neu gestartet...\n");
stop_promiscuous_mode();
g_sniffer_active = false;
vTaskDelay(pdMS_TO_TICKS(500));
g_total_packets = 0;
esp_err_t ret = start_promiscuous_mode(CITS_CHANNEL_0_MHZ);
if (ret == ESP_OK) {
g_sniffer_active = true;
ESP_LOGI(TAG, "Sniffer l\303\274uft auf %d MHz", CITS_CHANNEL_0_MHZ);
}
return (ret == ESP_OK) ? 0 : 1;
}
/* ---------- Hauptfunktion ---------- */
void app_main(void)
{
// USB-Serial/JTAG Console initialisieren
usb_serial_jtag_driver_install(0, 0, 0);
esp_vfs_dev_usb_serial_jtag_set_console();
ESP_LOGI(TAG, "=== C-ITS Sniffer für ESP32-C5 startet ===");
ESP_LOGI(TAG, "Console: USB-Serial/JTAG (115200 bps)");
// NVS initialisieren
esp_err_t ret = init_nvs_flash();
if (ret != ESP_OK) {
ESP_LOGE(TAG, "Failed to initialize NVS");
return;
ESP_LOGI(TAG, "====== C-ITS SNIFFER ESP32-C5 ======");
ESP_LOGI(TAG, " Release v2.0.0 — C-ITS Live + SD-Card");
ESP_LOGI(TAG, " Build: %s %s", __DATE__, __TIME__);
ESP_LOGI(TAG, "======================================");
// LED
gpio_reset_pin(LED_PIN);
gpio_set_direction(LED_PIN, GPIO_MODE_OUTPUT);
gpio_set_level(LED_PIN, BUILTIN_LED_OFF);
// NVS
esp_err_t ret = nvs_flash_init();
if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
nvs_flash_erase();
ret = nvs_flash_init();
}
// WiFi initialisieren
ret = initialize_wifi();
ESP_ERROR_CHECK(ret);
// WiFi
wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
ESP_ERROR_CHECK(esp_wifi_init(&cfg));
ESP_ERROR_CHECK(esp_wifi_set_storage(WIFI_STORAGE_RAM));
ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_NULL));
ESP_ERROR_CHECK(esp_wifi_start());
ESP_LOGI(TAG, "WiFi initialisiert (NULL-Mode / Promiscuous)");
// CSV Writer (SD-Karte)
ret = csv_writer_init();
if (ret != ESP_OK) {
ESP_LOGE(TAG, "Failed to initialize WiFi");
return;
ESP_LOGE(TAG, "CSV Writer init failed: %s", esp_err_to_name(ret));
}
// C-ITS Sniffer aufsetzen
ret = setup_cits_sniffer();
if (ret != ESP_OK) {
ESP_LOGE(TAG, "Failed to setup C-ITS Sniffer");
return;
}
// Console Commands registrieren
const esp_console_cmd_t cmd_jtag_read_cmd = {
.command = "jtag_read",
.help = "Read captured packets via JTAG (optional count)",
.hint = NULL,
.func = &cmd_jtag_read,
// C-ITS Parser
cits_parser_init();
// USB-Serial/JTAG Console
#ifdef CONFIG_ESP_CONSOLE_USB_SERIAL_JTAG
usb_serial_jtag_driver_config_t jtag_cfg = USB_SERIAL_JTAG_DRIVER_CONFIG_DEFAULT();
usb_serial_jtag_driver_install(&jtag_cfg);
usb_serial_jtag_vfs_register();
usb_serial_jtag_vfs_use_nonblocking();
usb_serial_jtag_vfs_use_driver();
ESP_LOGI(TAG, "Console: USB-Serial/JTAG @ 115200 bps");
#else
ESP_LOGI(TAG, "Console: UART default");
#endif
// Promiscuous Mode starten
start_promiscuous_mode(CITS_CHANNEL_0_MHZ);
g_sniffer_active = true;
// CLI Commands
esp_console_register_help_command();
const esp_console_cmd_t cmd_status_def = {
.command = "status", .help = "Show sniffer status", .func = cmd_status,
};
esp_console_cmd_register(&cmd_jtag_read_cmd);
const esp_console_cmd_t cmd_status_cmd = {
.command = "sniffer_status",
.help = "Show sniffer statistics",
.hint = NULL,
.func = &cmd_sniffer_status,
esp_console_cmd_register(&cmd_status_def);
const esp_console_cmd_t cmd_chan_def = {
.command = "chan", .help = "Change C-ITS channel (5900|5890|5880|5870)", .func = cmd_chan,
};
esp_console_cmd_register(&cmd_status_cmd);
const esp_console_cmd_t cmd_chan_cmd = {
.command = "chan",
.help = "Change C-ITS channel (5800-5900 MHz)",
.hint = NULL,
.func = &cmd_change_channel,
esp_console_cmd_register(&cmd_chan_def);
const esp_console_cmd_t cmd_pkts_def = {
.command = "packets", .help = "Wait for N packets", .func = cmd_packets,
};
esp_console_cmd_register(&cmd_chan_cmd);
const esp_console_cmd_t cmd_start_cmd = {
.command = "start_sniffer",
.help = "Restart sniffer",
.hint = NULL,
.func = &cmd_start_sniffer,
esp_console_cmd_register(&cmd_pkts_def);
const esp_console_cmd_t cmd_restart_def = {
.command = "restart", .help = "Restart sniffer", .func = cmd_restart,
};
esp_console_cmd_register(&cmd_start_cmd);
esp_console_cmd_register(&cmd_restart_def);
// register_cits_commands() aus block1
register_cits_commands();
// 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, "Verwende USB-Serial/JTAG für Console/Ausgabe");
ESP_LOGI(TAG, "Commands: jtag_read [count], sniffer_status, chan <freq>, start_sniffer");
// Zähler für Statistik
uint32_t packet_count = 0;
uint32_t last_report = 0;
// Hauptschleife
ESP_LOGI(TAG, ">>> C-ITS SNIFFER LAUFT <<<");
ESP_LOGI(TAG, "Kanal: %d MHz | SD-Karte: /storage/ | Console: USB-JTAG", CITS_CHANNEL_0_MHZ);
ESP_LOGI(TAG, "Commands: status, chan <freq>, set_channel <freq>, packets <n>, restart");
ESP_LOGI(TAG, "Live-Ansicht: Alle Pakete erscheinen als [PKT#...] auf Console");
uint32_t tick = 0;
while (1) {
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);
tick++;
gpio_set_level(LED_PIN, (tick % 2) ? BUILTIN_LED_ON : BUILTIN_LED_OFF);
if (tick % 60 == 0) {
ESP_LOGI(TAG, "[STAT] Uptime=%" PRIu32 " min | Total pkts=%" PRIu32,
tick / 60, g_total_packets);
}
vTaskDelay(1);
}
}
}