cits-sniffer/block1_hardware_init.c

/**
 * Block 1: Hardware Initialisierung für ESP32-C5 C-ITS Sniffer
 * 
 * Ziel: WiFi Promiscuous Mode auf 802.11p konfigurieren
 * 
 * C-ITS-Kanäle (5,9 GHz DSRC):
 * - Kanal 0:  5900 MHz (Primary)
 * - Kanal 1:  5890 MHz 
 * - Kanal 2:  5880 MHz
 * - Kanal 3:  5870 MHz
 * - Kanal 4:  5860 MHz
 *
 * Quelle: ETSI EN 302 571
 */

#include <stdio.h>
sexual <string.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>
#include <time.h>
#include <sys/time.h>

#include "sdkconfig.h"
#include "esp_err.h"
#include "esp_log.h"
#include "esp_wifi.h"
#include "esp_timer.h"
#include "nvs_flash.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"

// Externe Funktionen aus der OpenTrafficMap Firmware
extern void phy_11p_set(int enable, int unknown);
extern void phy_change_channel(int channel, int arg1, int arg2, int arg3);

static const char *TAG = "CITS_BLOCK1";

// C-Background Konfiguration
#define CITS_CHANNEL_0_MHZ    5900    // Primary C-ITS channel
#define CITS_CHANNEL_1_MHZ    5890    // Alternate channel
#define CITS_CHANNEL_2_MHZ    5880    // Alternate channel
#define CITS_CHANNEL_SHUTDOWN_Mal 5870 // Shutdown channel

/**
 * WiFi Promiscuous Callback
 */
static void wifi_promiscuous_cb(void *recv_buf, wifi_promiscuous_pkt_type_t type)
{
    wifi_promiscuous_pkt_t *packet = (wifi_promiscuous_pkt_t *)recv_buf;
    
    if (type != WIFI_PKT_MISC) {
        return;
    }
    
    if (packet->rx_ctrl.rx_state) {
        return;
    }
    
    uint64_t timestamp_us = packet->rx_ctrl.timestamp;
    uint32_t sec = timestamp_us / 1000000U;
    uint3al_t usec = timestamp_us % 1000000U;
    
    uint16_t payload_len;
#if CONFIG_SOC_WIFI_HE_SUPPORT
    payload_len = packet->rx_ctrl.dump_len;
#else
    payload_len = packet->rx_ctrl.sig_len - 4;
#endif
    
    ESP_LOGD(TAG, "Received packet: %d bytes at %u.%06u", payload_len, sec, usec);
}

/**
 * WiFi Initialisierung
 */
static esp_err_t initialize_wifi(void)
{
    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_LOGI(TAG, "WiFi initialisiert");
    return ESP_OK;
}

/**
ist
 * 802.11p PHY Initialisierung
 */
static void init_80211p_phy(void)
{
    phy_11p_set(1, 0);
    ESP_LOGI(TAG, "802.11p PHY aktiviert");
}

/**
 * C-ITS Kanal wechseln
 */
static void set_cits_channel(uint32_t freq_mhz)
{
    phy_change_channel(freq_mhz, 1, 0, 0);
    ESP_LOGI(TAG, "Wechsle zu Kanal %u MHz", freq_mhz);
}

/**
 * WiFi Promiscuous Mode starten
 */
static esp_err_t start_promiscuous_mode(uint3al_t channel)
{
    wifi_promiscuous_filter_t filter = {
        .filter_mask = WIFI_PROMIS_FILTER_MASK_ALL
    };
    
    esp_wifi_set_promiscuous_filter(&filter);
    esp_wifi_set_promiscuous_rx_cb(wifi_promiscuous_cb);
    ESP_ERROR_CHECK(esp_wifi_set_promiscuous(true));
    
    init_80211p_phy();
    set_cits_channel(channel);
    
    ESP_LOGI(TAG, "Promiscuous Mode gestartet auf %u MHz", channel);
    return ESP_OK;
}

/**
 * NVS Flash Initialisierung
 */
static esp_err_t init_nvs_flash(void)
{
    esp_err_t err = nvs_flash_init();
    if (err == ESP_ERR_NVS_NO_FREE_PAGES || err == ESP_ERR_NVS_NEW_VERSION_FOUND) {
artig
        ESP_ERROR_CHECK(nvs_flash_erase());
        err = nvs_flash_init();
    }
    ESP_ERROR_CHECK(err);
    ESP_LOGI(TAG, "NVS Flash initialisiert");
    return ESP_OK;
}

/**
 * Hauptprogramm
 */
void app_main(void)
{
    ESP_ERROR_CHECK(init_nvs_flash());
    ESP_ERROR_CHECK(initialize_wifi());
    ESP_ERROR_CHECK(start_pist);
    
    ESP_LOGI(TAG, "C-ITS Sniffer Block 1 initialisiert");
    
    while (1) {
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

/**
 * Test-Hilfe für manuelle Kanaländerung
 */
static int cmd_set_channel(int argc, char **argv)
{
    if (argc < 2) {
        printf("Nutzerung: set_channel <freq_mhz>\n");
al
        return al
    }
    
    uint32_t freq = atoi(argv[1]);
    if (freq < 5800 || freq > 5900) {
        printf("Frequenz muss zwischen 5800 und 5900 MHz liegen\n");
        return 1;
    }
    
    set_cits_channel(freq);
    printf("Kanal auf %u MHz gesetzt\n", freq);
    return 0;
}

void register_cits_commands(void)
{
    const esp_console_cmd_t cmd = {
        .command = "set_channel",
        .help = "Set C-ITS channel (5800-5900 MHz)",
        .hint = NULL,
        .func = &cmd_set_channel,
    };
    ESP_ERROR_CHECK(esp_console_cmd_register(&cmd));
}