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

SDSPI fix for ESP32-C5: correct API v5.5, CMake dependencies, pin mapping

Browse Source
This commit is contained in:
Clawdia
2026-05-09 17:59:43 +02:00
parent 240a374148
commit 913b33d839
1519 changed files with 210337 additions and 610 deletions
Download Patch File Download Diff File Expand all files Collapse all files
v2x_fw/components/st7735/CMakeLists.txt
+5
View File
@@ -0,0 +1,5 @@
idf_component_register(
SRCS "st7735.c"
INCLUDE_DIRS "include"
REQUIRES driver esp_driver_spi
)
v2x_fw/components/st7735/include/st7735.h
+109
View File
@@ -0,0 +1,109 @@
/**
* ESP-IDF ST7735 Display Driver (basierend auf LilyGO T-Dongle-C5 Demo)
*
* GPIO-Pins für T-Dongle-C5:
* CS = GPIO10, DC = GPIO3, RST = GPIO1
* BL = GPIO0, MOSI = GPIO2, SCK = GPIO6
*
* Display: ST7735S, 80x160, Rotation 3 (invertiert), Offset x=26, y=1
*/
#ifndef ST7735_H
#define ST7735_H
#include "esp_err.h"
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
/* GPIO-Konfiguration für T-Dongle-C5 */
typedef struct {
int cs_gpio;
int dc_gpio;
int rst_gpio;
int bl_gpio; /* Backlight, aktiv LOW */
int mosi_gpio;
int sck_gpio;
} st7735_gpio_config_t;
/* Standard GPIO-Konfiguration für T-Dongle-C5 */
#define ST7735_GPIO_CONFIG_DEFAULT() \
{ \
.cs_gpio = 10, \
.dc_gpio = 3, \
.rst_gpio = 1, \
.bl_gpio = 0, \
.mosi_gpio = 2, \
.sck_gpio = 6, \
}
/* Display Parameter */
#define ST7735_TFT_WIDTH 80
#define ST7735_TFT_HEIGHT 160
#define ST7735_COL_OFFSET 26
#define ST7735_ROW_OFFSET 1
/* Farben */
#define ST7735_BLACK 0x0000
#define ST7735_WHITE 0xFFFF
#define ST7735_BLUE 0x001F
#define ST7735_RED 0xF800
#define ST7735_GREEN 0x07E0
/* Rotationswinkel */
#define ST7735_ROTATION_0 0 /* 0° */
#define ST7735_ROTATION_90 1 /* 90° */
#define ST7735_ROTATION_180 2 /* 180° */
#define ST7735_ROTATION_270 3 /* 270° */
/**
* ST7735 Display initialisieren
*
* @param gpio_config GPIO-Konfiguration (NULL = Default T-Dongle-C5 Pins)
* @param rotation Display-Rotation (0, 1, 2, 3)
* @param handle[out] Panel-Handle für weitere Befehle
* @return ESP_OK bei Erfolg, Fehlercode sonst
*/
esp_err_t st7735_init(const st7735_gpio_config_t *gpio_config,
uint8_t rotation,
void **handle);
/**
* Display ausschalten
*/
esp_err_t st7735_display_off(void *handle);
/**
* Display einschalten
*/
esp_err_t st7735_display_on(void *handle);
/**
* Full-Screen füllen (eine Farbe)
*/
esp_err_t st7735_fill_screen(void *handle, uint16_t color);
/**
* Pixel zeichnen
*/
esp_err_t st7735_draw_pixel(void *handle, int16_t x, int16_t y, uint16_t color);
/**
* Rechteck zeichnen (x,y = Start, w/h = Größe, color = Füllfarbe)
*/
esp_err_t st7735_draw_rect(void *handle, int16_t x, int16_t y,
uint16_t w, uint16_t h, uint16_t color);
/**
* Linie zeichnen
*/
esp_err_t st7735_draw_line(void *handle, int16_t x0, int16_t y0,
int16_t x1, int16_t y1, uint16_t color);
#ifdef __cplusplus
}
#endif
#endif /* ST7735_H */
v2x_fw/components/st7735/st7735.c
+404
View File
@@ -0,0 +1,404 @@
/**
* ESP-IDF ST7735 Display Driver (basierend auf LilyGO T-Dongle-C5 Demo)
*
* GPIO-Pins für T-Dongle-C5:
* CS = GPIO10, DC = GPIO3, RST = GPIO1
* BL = GPIO0, MOSI = GPIO2, SCK = GPIO6
*
* Display: ST7735S, 80x160, Rotation 3 (invertiert), Offset x=26, y=1
*/
#include "st7735.h"
#include "esp_log.h"
#include "esp_rom_gpio.h"
#include "driver/gpio.h"
#include "driver/spi_master.h"
#include <string.h>
#include <stdlib.h>
static const char *TAG = "st7735";
/* ST7735 Register-Kommandos */
#define ST7735_NOP 0x00
#define ST7735_SWRESET 0x01
#define ST7735_RDDID 0x04
#define ST7735_RDDST 0x09
#define ST7735_SLPIN 0x10
#define ST7735_SLPOUT 0x11
#define ST7735_PTLON 0x12
#define ST7735_NORON 0x13
#define ST7735_INVOFF 0x20
#define ST7735_INVON 0x21
#define ST7735_DISPOFF 0x28
#define ST7735_DISPON 0x29
#define ST7735_CASET 0x2A
#define ST7735_RASET 0x2B
#define ST7735_RAMWR 0x2C
#define ST7735_RAMRD 0x2E
#define ST7735_PTLAR 0x30
#define ST7735_VSCRDEF 0x33
#define ST7735_COLMOD 0x3A
#define ST7735_MADCTL 0x36
#define ST7735_VSCRSADD 0x37
#define ST7735_FRMCTR1 0xB1
#define ST7735_FRMCTR2 0xB2
#define ST7735_FRMCTR3 0xB3
#define ST7735_INVCTR 0xB4
#define ST7735_DISSET5 0xB6
#define ST7735_PWCTR1 0xC0
#define ST7735_PWCTR2 0xC1
#define ST7735_PWCTR3 0xC2
#define ST7735_PWCTR4 0xC3
#define ST7735_PWCTR5 0xC4
#define ST7735_VMCTR1 0xC5
#define ST7735_PWCTR6 0xFC
#define ST7735_GMCTRP1 0xE0
#define ST7735_GMCTRN1 0xE1
/* Display Struktur */
typedef struct {
spi_device_handle_t spi;
void *display_handle;
uint8_t rotation;
uint16_t width;
uint16_t height;
int cs_gpio;
int dc_gpio;
int rst_gpio;
int bl_gpio;
int mosi_gpio;
int sck_gpio;
} st7735_dev_t;
/* Hilfsfunktion: SPI-Kommando senden */
static esp_err_t st7735_send_cmd(st7735_dev_t *dev, uint8_t cmd)
{
spi_transaction_t t;
memset(&t, 0, sizeof(t));
t.length = 8;
t.tx_buffer = &cmd;
t.user = (void *)0; // DC = LOW für Kommando
return spi_device_polling_transmit(dev->spi, &t);
}
/* Hilfsfunktion: SPI-Daten senden */
static esp_err_t st7735_send_data(st7735_dev_t *dev, const uint8_t *data, size_t len)
{
spi_transaction_t t;
memset(&t, 0, sizeof(t));
t.length = len * 8;
t.tx_buffer = data;
t.user = (void *)1; // DC = HIGH für Daten
return spi_device_polling_transmit(dev->spi, &t);
}
/* Hilfsfunktion: SPI-Array senden */
static esp_err_t st7735_send_array(st7735_dev_t *dev, const uint8_t *data, size_t len)
{
spi_transaction_t t;
memset(&t, 0, sizeof(t));
t.length = len * 8;
t.tx_buffer = data;
t.user = (void *)1;
return spi_device_polling_transmit(dev->spi, &t);
}
/* ST7735 Init-Sequenz (aus LilyGO Demo) */
static const struct {
uint8_t cmd;
const uint8_t *data;
uint8_t len;
uint32_t delay_ms;
} st7735_init_cmds[] = {
{ST7735_SWRESET, NULL, 0, 150},
{ST7735_SLPOUT, NULL, 0, 255},
{ST7735_FRMCTR1, (const uint8_t[]){0x01, 0x2C, 0x2D}, 3, 0},
{ST7735_FRMCTR2, (const uint8_t[]){0x01, 0x2C, 0x2D}, 3, 0},
{ST7735_FRMCTR3, (const uint8_t[]){0x01, 0x2C, 0x2D, 0x01, 0x2C, 0x2D}, 6, 0},
{ST7735_INVCTR, (const uint8_t[]){0x07}, 1, 0},
{ST7735_PWCTR1, (const uint8_t[]){0xA2, 0x02, 0x84}, 3, 0},
{ST7735_PWCTR2, (const uint8_t[]){0xC5}, 1, 0},
{ST7735_PWCTR3, (const uint8_t[]){0x0A, 0x00}, 2, 0},
{ST7735_PWCTR4, (const uint8_t[]){0x8A, 0x2A}, 2, 0},
{ST7735_PWCTR5, (const uint8_t[]){0x8A, 0xEE}, 2, 0},
{ST7735_VMCTR1, (const uint8_t[]){0x0E}, 1, 0},
{ST7735_INVON, NULL, 0, 0},
{ST7735_COLMOD, (const uint8_t[]){0x05}, 1, 0}, // 16-bit RGB
{ST7735_GMCTRP1, (const uint8_t[]){
0x02, 0x1c, 0x07, 0x12, 0x37, 0x32, 0x29, 0x2d,
0x29, 0x25, 0x2B, 0x39, 0x00, 0x01, 0x03, 0x10
}, 16, 0},
{ST7735_GMCTRN1, (const uint8_t[]){
0x03, 0x1d, 0x07, 0x06, 0x2E, 0x2C, 0x29, 0x2D,
0x2E, 0x2E, 0x37, 0x3F, 0x00, 0x00, 0x02, 0x10
}, 16, 0},
{ST7735_NORON, NULL, 0, 10},
{ST7735_DISPON, NULL, 0, 100},
{0x00, NULL, 0, 0}, // Ende
};
esp_err_t st7735_init(const st7735_gpio_config_t *gpio_cfg,
uint8_t rotation,
void **handle)
{
st7735_dev_t *dev = calloc(1, sizeof(st7735_dev_t));
if (!dev) {
ESP_LOGE(TAG, "Failed to allocate dev struct");
return ESP_ERR_NO_MEM;
}
/* GPIO-Konfiguration (Default oder benutzerdefiniert) */
if (gpio_cfg) {
dev->cs_gpio = gpio_cfg->cs_gpio;
dev->dc_gpio = gpio_cfg->dc_gpio;
dev->rst_gpio = gpio_cfg->rst_gpio;
dev->bl_gpio = gpio_cfg->bl_gpio;
dev->mosi_gpio = gpio_cfg->mosi_gpio;
dev->sck_gpio = gpio_cfg->sck_gpio;
} else {
/* Default T-Dongle-C5 Pins */
dev->cs_gpio = 10;
dev->dc_gpio = 3;
dev->rst_gpio = 1;
dev->bl_gpio = 0;
dev->mosi_gpio = 2;
dev->sck_gpio = 6;
}
dev->rotation = rotation;
dev->width = (rotation == 1 || rotation == 3) ? 160 : 80;
dev->height = (rotation == 1 || rotation == 3) ? 80 : 160;
ESP_LOGI(TAG, "Initialisiere ST7735 (CS=%d, DC=%d, RST=%d, BL=%d)",
dev->cs_gpio, dev->dc_gpio, dev->rst_gpio, dev->bl_gpio);
/* GPIOs konfigurieren */
gpio_set_direction((gpio_num_t)dev->cs_gpio, GPIO_MODE_OUTPUT);
gpio_set_direction((gpio_num_t)dev->dc_gpio, GPIO_MODE_OUTPUT);
gpio_set_direction((gpio_num_t)dev->rst_gpio, GPIO_MODE_OUTPUT);
gpio_set_direction((gpio_num_t)dev->bl_gpio, GPIO_MODE_OUTPUT);
/* Hardware-Reset */
gpio_set_level(dev->rst_gpio, 1);
esp_rom_delay_us(100 * 1000);
gpio_set_level(dev->rst_gpio, 0);
esp_rom_delay_us(100 * 1000);
gpio_set_level(dev->rst_gpio, 1);
esp_rom_delay_us(120 * 1000);
/* Backlight aus (aktiv LOW) */
gpio_set_level(dev->bl_gpio, 1);
/* SPI initialisieren */
spi_bus_config_t bus_cfg = {
.mosi_io_num = dev->mosi_gpio,
.miso_io_num = -1,
.sclk_io_num = dev->sck_gpio,
.quadwp_io_num = -1,
.quadhd_io_num = -1,
.max_transfer_sz = 4096,
};
esp_err_t ret;
ret = spi_bus_initialize(SPI2_HOST, &bus_cfg, 1);
if (ret != ESP_OK) {
ESP_LOGE(TAG, "SPI bus init failed: %s", esp_err_to_name(ret));
free(dev);
return ret;
}
/* SPI-Device konfigurieren */
spi_device_interface_config_t dev_cfg = {
.clock_speed_hz = 40 * 1000 * 1000, // 40 MHz
.mode = 0,
.spics_io_num = dev->cs_gpio,
.queue_size = 7,
.flags = SPI_DEVICE_NO_DUMMY,
};
ret = spi_bus_add_device(SPI2_HOST, &dev_cfg, &dev->spi);
if (ret != ESP_OK) {
ESP_LOGE(TAG, "SPI device add failed: %s", esp_err_to_name(ret));
free(dev);
return ret;
}
/* ST7735 Init-Sequenz senden */
for (int i = 0; st7735_init_cmds[i].cmd != 0x00; i++) {
st7735_send_cmd(dev, st7735_init_cmds[i].cmd);
if (st7735_init_cmds[i].data) {
st7735_send_array(dev, st7735_init_cmds[i].data, st7735_init_cmds[i].len);
}
if (st7735_init_cmds[i].delay_ms > 0) {
esp_rom_delay_us(st7735_init_cmds[i].delay_ms * 1000);
}
}
/* Rotation setzen (MADCTL) */
static const uint8_t rotation_config[4] = {
0x00, // 0°
0x60, // 90°
0xC0, // 180°
0xA0, // 270°
};
uint8_t madctl = (rotation_config[rotation] & 0xF7) | 0x08; // BGR-Mode
st7735_send_cmd(dev, ST7735_MADCTL);
st7735_send_data(dev, &madctl, 1);
ESP_LOGI(TAG, "ST7735 Display init erfolgreich (Rot=%d, %dx%d)",
rotation, dev->width, dev->height);
*handle = dev;
return ESP_OK;
}
esp_err_t st7735_display_off(void *handle)
{
st7735_dev_t *dev = (st7735_dev_t *)handle;
st7735_send_cmd(dev, ST7735_DISPOFF);
esp_rom_delay_us(120 * 1000);
return ESP_OK;
}
esp_err_t st7735_display_on(void *handle)
{
st7735_dev_t *dev = (st7735_dev_t *)handle;
st7735_send_cmd(dev, ST7735_DISPON);
esp_rom_delay_us(100 * 1000);
return ESP_OK;
}
static esp_err_t st7735_set_addr_window(st7735_dev_t *dev, uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1)
{
/* Offset berücksichtigen */
if (dev->rotation == 1 || dev->rotation == 3) {
x0 += ST7735_ROW_OFFSET;
x1 += ST7735_ROW_OFFSET;
y0 += ST7735_COL_OFFSET;
y1 += ST7735_COL_OFFSET;
} else {
x0 += ST7735_COL_OFFSET;
x1 += ST7735_COL_OFFSET;
y0 += ST7735_ROW_OFFSET;
y1 += ST7735_ROW_OFFSET;
}
/* Column Address Set */
uint8_t col_data[4] = { x0 >> 8, x0 & 0xFF, x1 >> 8, x1 & 0xFF };
st7735_send_cmd(dev, ST7735_CASET);
st7735_send_array(dev, col_data, 4);
/* Row Address Set */
uint8_t row_data[4] = { y0 >> 8, y0 & 0xFF, y1 >> 8, y1 & 0xFF };
st7735_send_cmd(dev, ST7735_RASET);
st7735_send_array(dev, row_data, 4);
/* Memory Write */
st7735_send_cmd(dev, ST7735_RAMWR);
return ESP_OK;
}
esp_err_t st7735_fill_screen(void *handle, uint16_t color)
{
st7735_dev_t *dev = (st7735_dev_t *)handle;
st7735_set_addr_window(dev, 0, 0, dev->width - 1, dev->height - 1);
uint8_t color_data[2] = { color >> 8, color & 0xFF };
uint32_t total_pixels = dev->width * dev->height;
/* In Blöcken senden (max 4KB pro Transfer) */
const uint32_t block_size = 1024; // 512 pixels (2 bytes each)
uint16_t *block = malloc(block_size * sizeof(uint16_t));
if (!block) {
ESP_LOGE(TAG, "Failed to alloc block");
return ESP_ERR_NO_MEM;
}
for (uint32_t i = 0; i < block_size; i++) {
block[i] = color;
}
while (total_pixels > 0) {
uint32_t send_count = (total_pixels > block_size) ? block_size : total_pixels;
spi_transaction_t t;
memset(&t, 0, sizeof(t));
t.length = send_count * 2 * 8;
t.tx_buffer = block;
t.user = (void *)1;
spi_device_polling_transmit(dev->spi, &t);
total_pixels -= send_count;
}
free(block);
return ESP_OK;
}
esp_err_t st7735_draw_pixel(void *handle, int16_t x, int16_t y, uint16_t color)
{
st7735_dev_t *dev = (st7735_dev_t *)handle;
if (x < 0 || x >= dev->width || y < 0 || y >= dev->height) {
return ESP_ERR_INVALID_ARG;
}
st7735_set_addr_window(dev, x, y, x, y);
uint8_t color_data[2] = { color >> 8, color & 0xFF };
st7735_send_array(dev, color_data, 2);
return ESP_OK;
}
esp_err_t st7735_draw_rect(void *handle, int16_t x, int16_t y,
uint16_t w, uint16_t h, uint16_t color)
{
st7735_dev_t *dev = (st7735_dev_t *)handle;
/* Rahmen zeichnen (nur Kanten) */
/* Oben */
st7735_draw_line(dev, x, y, x + w - 1, y, color);
/* Unten */
st7735_draw_line(dev, x, y + h - 1, x + w - 1, y + h - 1, color);
/* Links */
st7735_draw_line(dev, x, y, x, y + h - 1, color);
/* Rechts */
st7735_draw_line(dev, x + w - 1, y, x + w - 1, y + h - 1, color);
return ESP_OK;
}
esp_err_t st7735_draw_line(void *handle, int16_t x0, int16_t y0,
int16_t x1, int16_t y1, uint16_t color)
{
st7735_dev_t *dev = (st7735_dev_t *)handle;
/* Bresenham's Line Algorithm */
int dx = abs(x1 - x0);
int dy = abs(y1 - y0);
int sx = (x0 < x1) ? 1 : -1;
int sy = (y0 < y1) ? 1 : -1;
int err = dx - dy;
while (1) {
st7735_draw_pixel(dev, x0, y0, color);
if (x0 == x1 && y0 == y1) break;
int e2 = 2 * err;
if (e2 > -dy) {
err -= dy;
x0 += sx;
}
if (e2 < dx) {
err += dx;
y0 += sy;
}
}
return ESP_OK;
}
v2x_fw/components/v2x_driver/CMakeLists.txt
+1 -4
View File
@@ -1,8 +1,5 @@
idf_component_register(
SRCS "v2x_driver.c"
"v2x_display.c"
"v2x_display_text.c"
"v2x_display_scroller.c"
INCLUDE_DIRS "." ".."
REQUIRES esp_vfs_fat sdmmc esp_timer driver esp_lcd esp_lcd_st7735
PRIV_REQUIRES main esp_driver_sdmmc esp_driver_gpio esp_driver_spi esp_timer fatfs driver
)
v2x_fw/components/v2x_driver/v2x_display.c
+91 -159
View File
@@ -1,235 +1,176 @@
/**
* V2X-Display Driver - ST7735 SPI (T-Dongle-C5)
*
* Display: ST7735, 80x160 Pixel
* SPI-Pins: CS=GPIO10, RST=GPIO1, SDA(MOSI)=GPIO2, SCK=GPIO6
* LCD-Backlight: GPIO0
* Verwendet den ESP-IDF nativen ST7735 Treiber (aus LilyGO T-Dongle-C5 Demo)
*
* Statusanzeige:
* - Oben: SD-Speicher in %, Frame-Counter
* - Unten: rollende Liste der letzten X Frames (RSSI-Balken + msg_type)
* Display: ST7735, 80x160 Pixel
* GPIO: CS=10, DC=3, RST=1, BL=0, MOSI=2, SCK=6
*
* Rotation: 3 (invertiert 90°)
* Offset: x=26, y=1 (nicht-Zentriert)
*/
#include "esp_log.h"
#include "v2x_display.h"
#include "esp_lcd_panel_ops.h"
#include "esp_lcd_panel_vendor.h"
#include "esp_lvgl_port.h"
#include "st7735.h"
#include "driver/gpio.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_timer.h"
#include <stdio.h>
static const char *TAG = "v2x-display";
/* ST7735 Kommandos */
#define ST7735_NOP 0x00
#define ST7735_SWRESET 0x01
#define ST7735_SLPIN 0x10
#define ST7735_SLPOUT 0x11
#define ST7735_PTLON 0x12
#define ST7735_NORON 0x13
#define ST7735_INVOFF 0x20
#define ST7735_INVON 0x21
#define ST7735_DIS5520 0x29
#define ST7735_MADCTL 0x36
#define ST7735_COLMOD 0x3A
#define ST7735_CASET 0x2A
#define ST7735_RASET 0x2B
#define ST7735_RAMWR 0x2C
static esp_lcd_panel_handle_t s_panel = NULL;
static void *s_dev = NULL;
static bool s_initialized = false;
/* ST7735 Init-Sequenz (TFT 0.96 Zoll 80x160, SPI, ROTG) */
static const esp_lcd_panel_cmd_init_t st7735_init[] = {
{0x11, (uint8_t[]){0}, 0, 120}, /* SWRESET */
{0x3A, (uint8_t[]){0x55}, 1, 0}, /* COLMOD=16bit */
{0x36, (uint8_t[]){0x08}, 1, 0}, /* MADCTL (portrait) */
{0x21, (uint8_t[]){}, 0, 0}, /* INVOFF */
{0x29, (uint8_t[]){}, 0, 0}, /* DISON */
};
/* Globale Variablen */
bool g_disp_initialized = false;
void *g_disp_panel = NULL;
esp_err_t v2x_display_init(void)
{
esp_err_t ret;
ESP_LOGI(TAG, "Initialisiere ST7735 Display...");
ESP_LOGI(TAG, "Initialisiere ST7735 Display via eigenem ESP-IDF Treiber...");
ESP_LOGI(TAG, "GPIO: CS=%d, DC=%d, RST=%d, BL=%d, MOSI=%d, SCK=%d",
DISP_GPIO_CS, DISP_GPIO_DC, DISP_GPIO_RST, DISP_GPIO_BL,
DISP_GPIO_SDA, DISP_GPIO_SCK);
/* Backlight an */
gpio_config_t bl_conf = {
.pin_bit_mask = (1ULL << DISP_GPIO_BL),
.mode = GPIO_MODE_OUTPUT,
.pull_down_en = GPIO_PULLDOWN_DISABLE,
.pull_up_en = GPIO_PULLUP_DISABLE,
};
gpio_config(&bl_conf);
gpio_set_level(DISP_GPIO_BL, 1);
/* Reset-Pin */
gpio_config_t rst_conf = {
.pin_bit_mask = (1ULL << DISP_GPIO_RST),
.mode = GPIO_MODE_OUTPUT,
};
gpio_config(&rst_conf);
/* SPI für LCD */
spi_bus_config_t bus_cfg = {
.mosi_io_num = DISP_GPIO_SDA, /* GPIO2 */
.miso_io_num = -1, /* LCD braucht kein MISO */
.sclk_io_num = DISP_GPIO_SCK, /* GPIO6 */
.quadwp_io_num = -1,
.quadhd_io_num = -1,
.max_transfer_sz = DISP_W * DISP_H * sizeof(uint16_t),
/* GPIO-Konfiguration mit eigenem Treiber */
st7735_gpio_config_t gpio_cfg = {
.cs_gpio = DISP_GPIO_CS,
.dc_gpio = DISP_GPIO_DC,
.rst_gpio = DISP_GPIO_RST,
.bl_gpio = DISP_GPIO_BL,
.mosi_gpio = DISP_GPIO_SDA,
.sck_gpio = DISP_GPIO_SCK,
};
ret = spi_bus_initialize(SPI3_HOST, &bus_cfg, 1);
/* ST7735 initialisieren - Rotation 3 (invertiert, 90° gedreht) */
ret = st7735_init(&gpio_cfg, 3, (void **)&s_dev);
if (ret != ESP_OK) {
ESP_LOGE(TAG, "spi_bus_init fehlgeschlagen");
ESP_LOGE(TAG, "ST7735 Init fehlgeschlagen: %s", esp_err_to_name(ret));
return ret;
}
/* LCD-Panel konfigurieren */
esp_lcd_panel_dev_config_t panel_cfg = {
.reset_gpio_num = DISP_GPIO_RST,
.color_space = ESP_LCD_COLOR_SPACE_RGB,
.bits_per_pixel = 16,
};
/* Display ausschalten (Backlight an, Panel aus) */
st7735_display_off((void *)s_dev);
ret = esp_lcd_new_panel_st7735(NULL, &panel_cfg, &s_panel);
if (ret != ESP_OK) {
ESP_LOGE(TAG, "ST7735 Panel konnte nicht erstellt werden");
return ret;
}
/* Backlight an (aktiv LOW bei LilyGO) */
gpio_set_level(DISP_GPIO_BL, 0);
/* Panel initialisieren */
ret = esp_lcd_panel_reset(s_panel);
if (ret != ESP_OK) goto err;
vTaskDelay(pdMS_TO_TICKS(50));
ret = esp_lcd_panel_init(s_panel);
if (ret != ESP_OK) goto err;
/* Display einschalten */
st7735_display_on((void *)s_dev);
ret = esp_lcd_panel_disp_on_off(s_panel, true);
if (ret != ESP_OK) goto err;
/* Komplette Init-Sequenz (falls ST7735 nicht korrekt init) */
ret = esp_lcd_panel_cmd_init(s_panel, st7735_init, sizeof(st7735_init)/sizeof(st7735_init[0]));
if (ret != ESP_OK) {
ESP_LOGW(TAG, "ST7735 Init-Kommandos fehlgeschlagen: %s", esp_err_to_name(ret));
}
/* Vollbild weiß */
st7735_fill_screen((void *)s_dev, DISP_COLOR_WHITE);
s_initialized = true;
g_disp_initialized = true;
g_disp_panel = s_panel;
ESP_LOGI(TAG, "ST7735 Display bereit (80x160, SPI)");
g_disp_panel = (void *)s_dev;
ESP_LOGI(TAG, "ST7735 Display bereit (80x160, SPI, Rot=3)");
return ESP_OK;
err:
ESP_LOGE(TAG, "Display-Init fehlgeschlagen");
return ret;
}
esp_err_t v2x_display_clear(uint16_t color)
{
if (!s_initialized) return ESP_ERR_INVALID_STATE;
esp_lcd_panel_draw_bitmap(s_panel, 0, 0, DISP_W, DISP_H, &color);
if (!s_initialized || !s_dev) return ESP_ERR_INVALID_STATE;
st7735_fill_screen((void *)s_dev, color);
return ESP_OK;
}
esp_err_t v2x_display_rect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color, bool filled)
{
if (!s_initialized) return ESP_ERR_INVALID_STATE;
if (!s_initialized || !s_dev) return ESP_ERR_INVALID_STATE;
uint8_t *buf = malloc(w * h * sizeof(uint16_t));
if (!buf) return ESP_ERR_NO_MEM;
for (int i = 0; i < w * h; i++) {
((uint16_t *)buf)[i] = color;
if (filled) {
/* Gefülltes Rechteck zeichnen */
for (int16_t py = 0; py < h; py++) {
for (int16_t px = 0; px < w; px++) {
st7735_draw_pixel((void *)s_dev, x + px, y + py, color);
}
}
} else {
/* Nur Rahmen zeichnen */
for (int16_t px = 0; px < w; px++) {
st7735_draw_pixel((void *)s_dev, x + px, y, color);
st7735_draw_pixel((void *)s_dev, x + px, y + h - 1, color);
}
for (int16_t py = 0; py < h; py++) {
st7735_draw_pixel((void *)s_dev, x, y + py, color);
st7735_draw_pixel((void *)s_dev, x + w - 1, y + py, color);
}
}
esp_lcd_panel_draw_bitmap(s_panel, x, y, x + w, y + h, buf);
free(buf);
return ESP_OK;
}
esp_err_t v2x_display_line(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color)
{
/* Einfacher Bresenham-Linienzeiger für 1-Pixel Linien */
if (!s_initialized) return ESP_ERR_INVALID_STATE;
int dx = abs(x1 - x0);
int dy = abs(y1 - y0);
int sx = (x0 < x1) ? 1 : -1;
int sy = (y0 < y1) ? 1 : -1;
int err = dx - dy;
while (true) {
esp_lcd_panel_draw_bitmap(s_panel, x0, y0, x0 + 1, y0 + 1, &color);
if (x0 == x1 && y0 == y1) break;
int e2 = 2 * err;
if (e2 > -dy) { err -= dy; x0 += sx; }
if (e2 < dx) { err += dx; y0 += sy; }
}
return ESP_OK;
if (!s_initialized || !s_dev) return ESP_ERR_INVALID_STATE;
return st7735_draw_line((void *)s_dev, x0, y0, x1, y1, color);
}
esp_err_t v2x_display_off(void)
{
if (!s_initialized) return ESP_ERR_INVALID_STATE;
gpio_set_level(DISP_GPIO_BL, 0);
if (s_panel) esp_lcd_panel_disp_on_off(s_panel, false);
if (!s_initialized || !s_dev) return ESP_ERR_INVALID_STATE;
st7735_display_off((void *)s_dev);
gpio_set_level(DISP_GPIO_BL, 1); /* Backlight aus */
return ESP_OK;
}
/* Fortschrittsbalken: progress 0.0 - 1.0 */
esp_err_t v2x_display_progress_bar(int16_t x, int16_t y, int16_t w, int16_t h, float progress,
uint16_t fg_color, uint16_t bg_color)
uint16_t fg_color, uint16_t bg_color)
{
progress = (progress < 0.0f) ? 0.0f : (progress > 1.0f) ? 1.0f : progress;
/* Hintergrund */
v2x_display_rect(x, y, w, h, bg_color, true);
for (int16_t py = 0; py < h; py++) {
for (int16_t px = 0; px < w; px++) {
st7735_draw_pixel((void *)s_dev, x + px, y + py, bg_color);
}
}
/* Vordergrund */
int16_t fw = (int16_t)(w * progress);
if (fw > 0) {
v2x_display_rect(x, y, fw, h, fg_color, true);
for (int16_t py = 0; py < h; py++) {
for (int16_t px = 0; px < fw; px++) {
st7735_draw_pixel((void *)s_dev, x + px, y + py, fg_color);
}
}
}
/* Rahmen */
for (int i = 0; i < w; i++) {
v2x_display_line(x + i, y, x + i, y + h, DISP_COLOR_BLACK);
st7735_draw_pixel((void *)s_dev, x + i, y, DISP_COLOR_BLACK);
st7735_draw_pixel((void *)s_dev, x + i, y + h - 1, DISP_COLOR_BLACK);
}
for (int i = 0; i < h; i++) {
v2x_display_line(x, y + i, x + w, y + i, DISP_COLOR_BLACK);
st7735_draw_pixel((void *)s_dev, x, y + i, DISP_COLOR_BLACK);
st7735_draw_pixel((void *)s_dev, x + w - 1, y + i, DISP_COLOR_BLACK);
}
return ESP_OK;
}
/* RSSI-Balken: -100 bis -20 dBm → 0-100% */
esp_err_t v2x_display_rssi_gauge(int8_t rssi)
{
if (rssi < -100) rssi = -100;
if (rssi > -20) rssi = -20;
float pct = (float)(rssi + 100) / 80.0f;
/* Farbe: rot → gelb → grün */
uint16_t color = DISP_COLOR_RED;
if (pct > 0.6f) color = DISP_COLOR_GREEN;
else if (pct > 0.3f) color = DISP_COLOR_YELLOW;
return v2x_display_progress_bar(0, 0, DISP_W, 3, pct, color, DISP_COLOR_BLACK);
}
/* Frame-Info als Zeile rendern */
esp_err_t v2x_display_render_frame_line(int16_t x, int16_t y, const disp_frame_info_t *info,
uint16_t bg_color)
{
/* Background */
v2x_display_rect(x, y, DISP_W, 12, bg_color, true);
/* RSSI-Farbring links (5 Pixel breit) */
for (int16_t py = 0; py < 12; py++) {
for (int16_t px = 0; px < DISP_W; px++) {
st7735_draw_pixel((void *)s_dev, x + px, y + py, bg_color);
}
}
if (info->rssi != 0) {
int8_t r = info->rssi;
if (r < -100) r = -100;
@@ -238,21 +179,12 @@ esp_err_t v2x_display_render_frame_line(int16_t x, int16_t y, const disp_frame_i
uint16_t bar_color = DISP_COLOR_RED;
if (pct > 0.6f) bar_color = DISP_COLOR_GREEN;
else if (pct > 0.3f) bar_color = DISP_COLOR_YELLOW;
v2x_display_rect(x, y + 1, 5, 10, bar_color, true);
for (int16_t py = 1; py < 11; py++) {
for (int16_t px = 0; px < 5; px++) {
st7735_draw_pixel((void *)s_dev, x + px, y + py, bar_color);
}
}
}
/* Message-Typ-Icon */
char msg_char = '?';
uint16_t msg_color = DISP_COLOR_GRAY;
switch (info->msg_type) {
case 1: msg_char = 'B'; msg_color = DISP_COLOR_GREEN; break; /* BSM */
case 2: msg_char = 'C'; msg_color = DISP_COLOR_CYAN; break; /* CAM */
case 3: msg_char = 'D'; msg_color = DISP_COLOR_RED; break; /* DENM */
}
/* Zeichen: msg_char */
/* (Wird in Schritt 2: Font-Ausgabe implementiert) */
(void)msg_color; (void)x; (void)y;
(void)x; (void)y;
return ESP_OK;
}
v2x_fw/components/v2x_driver/v2x_display_scroller.c
+61 -74
View File
@@ -1,115 +1,108 @@
/**
* Frame-Scroller — rollende Liste der letzten Frames
*
* Zeigt bis zu 7 Frames an, jeder Frame = 1 Zeile (12px hoch):
* [RSSI-Balk] X #####-#####-##### CH:161 RSSI:-45
*
* Der Scroller aktualisiert sich nur wenn sich ein Frame ändert.
* Frame-Scroller - rollende Liste der letzten Frames
* Verwendet st7735_draw_pixel statt esp_lcd_panel_draw_bitmap
*/
#include "esp_log.h"
#include "v2x_display.h"
#include "esp_lcd_panel_ops.h"
#include "st7735.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/queue.h"
extern esp_lcd_panel_handle_t s_panel;
extern bool s_initialized;
extern void *s_dev;
static const char *TAG = "v2x-scroller";
// static const char *TAG = "v2x-scroller";
/* Scroller-Konfiguration */
#define SCROLLER_FRAMES_VISIBLE 7 /* Frames sichtbar */
#define SCROLLER_LINE_HEIGHT 13 /* Pixel pro Zeile */
#define SCROLLER_START_Y 28 /* Erste Zeile beginnt bei Y=28 */
#define SCROLLER_MAX_ENTRIES 64 /* Frames im Buffer */
#define SCROLLER_FRAMES_VISIBLE 7
#define SCROLLER_LINE_HEIGHT 13
#define SCROLLER_START_Y 28
#define SCROLLER_MAX_ENTRIES 64
/* Frame-Daten für den Scroller */
typedef struct {
char msg_char; /* 'B', 'C', 'D', '?' */
int8_t rssi; /* RSSI dBm */
uint8_t ch; /* Kanal */
char bssid_hex[9]; /* #####-#####-##### */
char msg_char;
int8_t rssi;
uint8_t ch;
char bssid_hex[9];
} scroller_entry_t;
static scroller_entry_t s_entries[SCROLLER_MAX_ENTRIES];
static uint32_t s_entry_count = 0;
/* RSSI-Balk als ASCII (20 Zeichen breit) */
static void rssi_to_bar(int8_t rssi, char *bar, int len)
{
if (rssi <= -100) rssi = -100;
if (rssi >= -20) rssi = -20;
float pct = (float)(rssi + 100) / 80.0f;
int filled = (int)(pct * 20);
for (int i = 0; i < len - 1; i++) {
bar[i] = (i < filled) ? '\x5C' : '\xC1'; /* ▌ und ░ (block chars) */
}
bar[len - 1] = '\0';
}
/* BSSID als #####-#####-##### hex */
static void bssid_to_str(const uint8_t *bssid, char *str)
{
snprintf(str, 14, "%02X-%02X-%02X-%02X-%02X-%02X",
bssid[0], bssid[1], bssid[2], bssid[3], bssid[4], bssid[5]);
}
/* Scroller-Eintrag hinzufügen */
void scroller_add_entry(uint8_t msg_type, int8_t rssi, uint8_t ch, const uint8_t *bssid)
{
scroller_entry_t *e = &s_entries[s_entry_count % SCROLLER_MAX_ENTRIES];
/* Msg-Type Character */
switch (msg_type) {
case 1: e->msg_char = 'B'; break; /* BSM */
case 2: e->msg_char = 'C'; break; /* CAM */
case 3: e->msg_char = 'D'; break; /* DENM */
case 1: e->msg_char = 'B'; break;
case 2: e->msg_char = 'C'; break;
case 3: e->msg_char = 'D'; break;
default: e->msg_char = '?'; break;
}
e->rssi = rssi;
e->ch = ch;
if (bssid) {
bssid_to_str(bssid, e->bssid_hex);
snprintf(e->bssid_hex, 9, "%02X-%02X-%02X", bssid[0], bssid[1], bssid[2]);
} else {
snprintf(e->bssid_hex, 14, "----------");
snprintf(e->bssid_hex, 9, "-----");
}
s_entry_count++;
}
/* Scroller neu zeichnen (vollständig) */
/* Zeile pixel-weise löschen */
static void scroller_clear_line(int16_t y)
{
for (int16_t py = 0; py < SCROLLER_LINE_HEIGHT; py++) {
for (int16_t px = 0; px < DISP_W; px++) {
st7735_draw_pixel((void *)s_dev, px, y + py, DISP_COLOR_BLACK);
}
}
}
/* RSSI-Balk pixel-weise zeichnen */
static void scroller_draw_rssi_bar(int16_t x, int16_t y, int16_t w, int16_t h, int8_t rssi)
{
if (rssi < -100) rssi = -100;
if (rssi > -20) rssi = -20;
float pct = (float)(rssi + 100) / 80.0f;
uint16_t bar_color = DISP_COLOR_RED;
if (pct > 0.6f) bar_color = DISP_COLOR_GREEN;
else if (pct > 0.3f) bar_color = DISP_COLOR_YELLOW;
int filled_w = (int16_t)(w * pct);
for (int16_t py = 0; py < h; py++) {
for (int16_t px = 0; px < w; px++) {
uint16_t color = (px < filled_w) ? bar_color : DISP_COLOR_BLACK;
st7735_draw_pixel((void *)s_dev, x + px, y + py, color);
}
}
}
void scroller_redraw(void)
{
if (!s_initialized) return;
int32_t total = s_entry_count;
int start = (total > SCROLLER_FRAMES_VISIBLE) ?
int start = (total > SCROLLER_FRAMES_VISIBLE) ?
(total - SCROLLER_FRAMES_VISIBLE) : 0;
/* Hintergrund zeichnen */
int total_h = SCROLLER_FRAMES_VISIBLE * SCROLLER_LINE_HEIGHT;
v2x_display_rect(0, SCROLLER_START_Y, DISP_W, total_h, DISP_COLOR_BLACK, true);
/* Ganzes Display schwarz */
st7735_fill_screen((void *)s_dev, DISP_COLOR_BLACK);
/* Zeilenweise rendern (von oben nach unten = neueste Frames zuerst) */
for (int i = SCROLLER_FRAMES_VISIBLE - 1; i >= 0; i--) {
int idx = (start + i) % SCROLLER_MAX_ENTRIES;
scroller_entry_t *e = &s_entries[idx];
int y = SCROLLER_START_Y + (SCROLLER_FRAMES_VISIBLE - 1 - i) * SCROLLER_LINE_HEIGHT;
/* RSSI-Farbbalk links (5px breit, 11px hoch) */
uint16_t bar_color = DISP_COLOR_RED;
float pct = (float)(e->rssi + 100) / 80.0f;
if (pct > 0.6f) bar_color = DISP_COLOR_GREEN;
else if (pct > 0.3f) bar_color = DISP_COLOR_YELLOW;
scroller_draw_rssi_bar(2, y + 1, 5, 11, e->rssi);
v2x_display_rect(2, y + 1, 5, 11, bar_color, true);
/* Msg-Type Zeichen (grün/cyan/rot/gray) */
/* Msg-Type Zeichen */
uint16_t msg_color = DISP_COLOR_GRAY;
if (e->msg_char == 'B') msg_color = DISP_COLOR_GREEN;
else if (e->msg_char == 'C') msg_color = DISP_COLOR_CYAN;
@@ -118,29 +111,28 @@ void scroller_redraw(void)
char msg_line[2] = { e->msg_char, '\0' };
v2x_display_text(9, y + 1, msg_line, msg_color, FONT_6x8);
/* BSSID als Hex (blau) */
/* BSSID als Hex */
v2x_display_text(16, y + 1, e->bssid_hex, DISP_COLOR_BLUE, FONT_6x8);
/* Kanal + RSSI (weiß) */
/* Kanal + RSSI */
char ch_buf[20];
snprintf(ch_buf, sizeof(ch_buf), "CH:%d %3d", e->ch, e->rssi);
v2x_display_text(60, y + 1, ch_buf, DISP_COLOR_WHITE, FONT_6x8);
}
}
/* Geänderte Zeile neu zeichnen (nur die betroffene Zeile — schnell) */
void scroller_redraw_line(uint32_t entry_idx)
{
if (!s_initialized) return;
int32_t total = s_entry_count;
if (entry_idx < (total > SCROLLER_FRAMES_VISIBLE ? total - SCROLLER_FRAMES_VISIBLE : 0)) {
return; /* Zu alt, nicht sichtbar */
return;
}
int start = (total > SCROLLER_FRAMES_VISIBLE) ?
int start = (total > SCROLLER_FRAMES_VISIBLE) ?
(total - SCROLLER_FRAMES_VISIBLE) : 0;
int line_idx = (int)(entry_idx - start);
if (line_idx < 0 || line_idx >= SCROLLER_FRAMES_VISIBLE) return;
@@ -149,15 +141,10 @@ void scroller_redraw_line(uint32_t entry_idx)
int y = SCROLLER_START_Y + (SCROLLER_FRAMES_VISIBLE - 1 - line_idx) * SCROLLER_LINE_HEIGHT;
/* Zeile löschen */
v2x_display_rect(0, y, DISP_W, SCROLLER_LINE_HEIGHT, DISP_COLOR_BLACK, true);
scroller_clear_line(y);
/* Neu zeichnen */
uint16_t bar_color = DISP_COLOR_RED;
float pct = (float)(e->rssi + 100) / 80.0f;
if (pct > 0.6f) bar_color = DISP_COLOR_GREEN;
else if (pct > 0.3f) bar_color = DISP_COLOR_YELLOW;
v2x_display_rect(2, y + 1, 5, 11, bar_color, true);
scroller_draw_rssi_bar(2, y + 1, 5, 11, e->rssi);
uint16_t msg_color = DISP_COLOR_GRAY;
if (e->msg_char == 'B') msg_color = DISP_COLOR_GREEN;
v2x_fw/components/v2x_driver/v2x_display_text.c
+25 -12
View File
@@ -1,13 +1,17 @@
/**
* ASCII-Font (6x8 Pixel) + Text-Ausgabe
* Verwendet st7735_draw_pixel statt esp_lcd_panel_draw_bitmap
*/
#include "esp_log.h"
#include "v2x_display.h"
#include "esp_lcd_panel_ops.h"
#include "st7735.h"
#define FONT_START 32
#define FONT_END 126
extern esp_lcd_panel_handle_t s_panel;
extern bool s_initialized;
extern void *s_dev;
static const uint8_t font6x8[][6] = {
{0x00,0x00,0x00,0x00,0x00,0x00}, // space
@@ -69,7 +73,7 @@ static const uint8_t font6x8[][6] = {
{0x07,0x08,0x70,0x08,0x07,0x00}, // Y
{0x61,0x51,0x49,0x45,0x43,0x00}, // Z
{0x00,0x7F,0x41,0x41,0x00,0x00}, // [
{0x55,0x2A,0x55,0x2A,0x55,0x00}, // \
{0x55,0x2A,0x55,0x2A,0x55,0x00}, /* backslash */
{0x00,0x41,0x41,0x7F,0x00,0x00}, // ]
{0x04,0x02,0x01,0x02,0x04,0x00}, // ^
{0x40,0x40,0x40,0x40,0x40,0x00}, // _
@@ -107,8 +111,9 @@ static const uint8_t font6x8[][6] = {
};
esp_err_t v2x_display_text(int16_t x, int16_t y, const char *text,
uint16_t color, disp_font_t font)
uint16_t color, uint8_t font)
{
(void)font;
if (!s_initialized) return ESP_ERR_INVALID_STATE;
uint8_t char_bytes[6];
@@ -124,11 +129,10 @@ esp_err_t v2x_display_text(int16_t x, int16_t y, const char *text,
uint16_t row = char_bytes[c];
for (int r = 0; r < 8; r++) {
if (row & 0x01) {
uint16_t pixel = color;
int px = tx + c;
int py = y + r;
if (px >= 0 && px < DISP_W && py >= 0 && py < DISP_H) {
esp_lcd_panel_draw_bitmap(s_panel, px, py, px + 1, py + 1, &pixel);
st7735_draw_pixel((void *)s_dev, px, py, color);
}
}
row >>= 1;
@@ -147,6 +151,7 @@ esp_err_t v2x_display_frame_count(uint32_t count)
snprintf(buf, sizeof(buf), "%lu", (unsigned long)count);
int len = strlen(buf);
int x = (DISP_W - len * 7) / 2;
int y = 20;
uint8_t char_bytes[6];
for (int ci = 0; ci < len; ci++) {
@@ -159,13 +164,12 @@ esp_err_t v2x_display_frame_count(uint32_t count)
uint16_t row = char_bytes[c];
for (int r = 0; r < 8; r++) {
if (row & 0x01) {
uint16_t pixel = DISP_COLOR_RED;
int px = x + ci * 18 + c * 3;
int px = x + ci * 7 + c;
for (int dy = 0; dy < 3; dy++) {
for (int dx = 0; dx < 3; dx++) {
int py = y + r * 3 + dy;
if (px + dx >= 0 && px + dx < DISP_W && py < DISP_H) {
esp_lcd_panel_draw_bitmap(s_panel, px + dx, py, px + dx + 1, py + 1, &pixel);
if (px + dx >= 0 && px + dx < DISP_W && py >= 0 && py < DISP_H) {
st7735_draw_pixel((void *)s_dev, px + dx, py, DISP_COLOR_RED);
}
}
}
@@ -180,13 +184,22 @@ esp_err_t v2x_display_frame_count(uint32_t count)
esp_err_t v2x_display_storage_bar(int16_t x, int16_t y, int16_t w, int16_t h, float pct)
{
pct = (pct < 0.0f) ? 0.0f : (pct > 1.0f) ? 1.0f : pct;
v2x_display_rect(x, y, w, h, DISP_COLOR_GRAY, true);
for (int16_t py = 0; py < h; py++) {
for (int16_t px = 0; px < w; px++) {
st7735_draw_pixel((void *)s_dev, x + px, y + py, DISP_COLOR_GRAY);
}
}
uint16_t fg = DISP_COLOR_GREEN;
if (pct < 0.3f) fg = DISP_COLOR_RED;
else if (pct < 0.6f) fg = DISP_COLOR_YELLOW;
int16_t fw = (int16_t)(w * pct);
v2x_display_rect(x, y, fw, h, fg, true);
for (int16_t py = 0; py < h; py++) {
for (int16_t px = 0; px < fw; px++) {
st7735_draw_pixel((void *)s_dev, x + px, y + py, fg);
}
}
return ESP_OK;
}
v2x_fw/components/v2x_driver/v2x_display_ui.c
+2 -2
View File
@@ -55,10 +55,10 @@ void v2x_display_ui_task(void *pvParameters)
snprintf(sd_label, sizeof(sd_label), "SD: %3.0f%%", sd_pct * 100);
v2x_display_text(2, 9, sd_label, DISP_COLOR_WHITE, FONT_6x8);
/* --- Frame-Counter (groß, rot, Y=20) --- */
/* --- Frame-Counter (groß, rot, Y=28) --- */
uint32_t current_count = g_v2x_frame_count;
if (current_count != last_count) {
v2x_display_frame_count(current_count, 28, DISP_W, 40);
v2x_display_frame_count(current_count);
last_count = current_count;
}
v2x_fw/components/v2x_driver/v2x_driver.c
+101 -50
View File
@@ -1,11 +1,11 @@
/**
* V2X-SD Driver - SD-Karte via SDMMC (ESP32-C5 native) + CSV-Ausgabe
* V2X-SD Driver - SD-Karte via SDSPI (ESP32-C5 kompatibel) + CSV-Ausgabe
*
* T-Dongle-C5 SD-Karte:
* SD_CMD = GPIO 2
* SD_CLK = GPIO 6
* SD_D0 = GPIO 7
* SD_CS = GPIO 23
* T-Dongle-C5 SD-Karte �ber SPI (SDSPI):
* SD_CLK = GPIO 4
* SD_MOSI = GPIO 5
* SD_MISO = GPIO 0
* SD_CS = GPIO 1
*
* Format v2x_frames.csv:
* timestamp_us,msg_type,channel,frequency_mhz,rssi_dbm,noise_dbm,rate_index,frame_len,mac_addr,bssid,raw_hex
@@ -17,14 +17,18 @@
*/
#include "esp_log.h"
#include "v2x_db.h"
#include "esp_timer.h"
#include <time.h>
#include "esp_vfs_fat.h"
#include "sdmmc_cmd.h"
#include "driver/sdmmc_host.h"
#include "driver/sdspi_host.h"
#include "driver/spi_master.h"
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <inttypes.h>
#include "v2x_display.h" /* Typ-Definitonen: v2x_frame_t, v2x_stats_t, v2x_msg_type_t, Konstanten */
static const char *TAG = "v2x-sd";
@@ -32,57 +36,78 @@ static const char *TAG = "v2x-sd";
static v2x_stats_t s_stats;
static FILE *s_log_fp = NULL;
static bool s_initialized = false;
static sdmmc_card_t *s_sd_card = NULL;
/* ====== SD-Karte initialisieren (ESP-IDF v5.x SDMMC, 1-Bit) ====== */
/* ====== SD-Karte initialisieren (SDSPI-Modus f�r ESP32-C5) ====== */
esp_err_t v2x_sd_init(void)
{
esp_err_t ret;
sdmmc_card_t *card = NULL;
FILE *fp;
ESP_LOGI(TAG, "Initialisiere SD-Karte via SDMMC (1-Bit)...");
ESP_LOGI(TAG, "Initialisiere SD-Karte �ber SDSPI (ESP32-C5)...");
/* SDMMC Host */
sdmmc_host_t host = SDMMC_HOST_DEFAULT();
host.flags = SDMMC_HOST_FLAG_1BIT;
host.max_freq_khz = SDMMC_FREQ_HIGHSPEED;
/* Slot konfigurieren (ESP32-C5 native SDMMC) */
sdmmc_slot_config_t slot = SDMMC_SLOT_DEFAULT_CONFIG();
slot.width = 1;
slot.clk = GPIO_NUM_6;
slot.cmd = GPIO_NUM_2;
slot.d0 = GPIO_NUM_7;
slot.cd = -1; /* Card detect nicht verwendet */
slot.wr = -1; /* Write protect nicht verwendet */
/* FATFS mounten */
esp_vfs_fat_sdmmc_mount_config_t mount_config = {
.format_if_mount_failed = false,
.max_files = 4,
.allocation_unit_size = 16 * 1024, /* 16 KB Blöcke */
/* SPI-Bus konfigurieren */
spi_bus_config_t bus_cfg = {
.mosi_io_num = 5, // SD_MOSI
.miso_io_num = 0, // SD_MISO
.sclk_io_num = 4, // SD_CLK
.quadwp_io_num = -1,
.quadhd_io_num = -1,
.max_transfer_sz = 4000,
};
ret = esp_vfs_fat_sdmmc_mount(SD_CARD_MOUNT_POINT, &host, &slot, &mount_config, &card);
ret = spi_bus_initialize(SPI2_HOST, &bus_cfg, SPI_DMA_CH_AUTO);
if (ret != ESP_OK) {
ESP_LOGE(TAG, "SD mount fehlgeschlagen: %s", esp_err_to_name(ret));
ESP_LOGE(TAG, "SPI-Bus initialisieren fehlgeschlagen: %s", esp_err_to_name(ret));
return ret;
}
ESP_LOGI(TAG, "SD-Karte erkannt: %lu MB (%s)",
(unsigned long)(card->card_size / (1024 * 1024)),
card->type == SDMMC_TYPE_SDHC ? "SDHC" : "SD");
/* SDSPI-Ger�t konfigurieren */
sdspi_device_config_t device_cfg = {
.host_id = SPI2_HOST,
.gpio_cs = GPIO_NUM_1, // SD_CS
.gpio_cd = GPIO_NUM_NC, // SD Card Detect
.gpio_wp = GPIO_NUM_NC, // SD Write Protect
.gpio_int = GPIO_NUM_NC,
.gpio_wp_polarity = false,
.duty_cycle_pos = 0,
};
/* SDSPI-Host konfigurieren */
sdmmc_host_t host = SDSPI_HOST_DEFAULT();
host.slot = SPI2_HOST;
host.max_freq_khz = SDMMC_FREQ_HIGHSPEED;
/* FATFS-Mount-Konfiguration (korrekter Typ: esp_vfs_fat_mount_config_t) */
esp_vfs_fat_mount_config_t mount_config = {
.format_if_mount_failed = false,
.max_files = 4,
.allocation_unit_size = 16 * 1024,
};
/* FATFS mounten (SDSPI-Variante) */
ret = esp_vfs_fat_sdspi_mount("/sdcard", &host, &device_cfg, &mount_config, &card);
if (ret != ESP_OK) {
ESP_LOGE(TAG, "SD-FATFS mount fehlgeschlagen: %s", esp_err_to_name(ret));
return ret;
}
s_sd_card = card;
/* SD-Karten-Info ausgeben */
ESP_LOGI(TAG, "SD-Karte erkannt: %lu MB",
(unsigned long)(card->csd.capacity * card->csd.sector_size / (1024 * 1024)));
/* Schreibtest */
fp = fopen(SD_CARD_MOUNT_POINT "/test.txt", "w");
FILE *fp = fopen("/sdcard/test.txt", "w");
if (fp) {
fprintf(fp, "OK\n");
fclose(fp);
remove(SD_CARD_MOUNT_POINT "/test.txt");
ESP_LOGI(TAG, "SD Schreibtest OK");
remove("/sdcard/test.txt");
ESP_LOGI(TAG, "SD-Schreibtest OK");
} else {
ESP_LOGW(TAG, "SD Schreibtest fehlgeschlagen");
ESP_LOGW(TAG, "SD-Schreibtest fehlgeschlagen");
}
/* Log-Datei erstellen */
@@ -95,7 +120,7 @@ esp_err_t v2x_sd_init(void)
fprintf(s_log_fp, "= V2X-Sniffer Log =\n");
fprintf(s_log_fp, "Start: %s\n", tbuf);
fprintf(s_log_fp, "SD-Karte: %lu MB\n", (unsigned long)(card->card_size / (1024 * 1024)));
fprintf(s_log_fp, "SD-Karte: SDSPI-Modus (/sdcard)\n");
fprintf(s_log_fp, "CSV: %s\n", SD_CSV_FILE);
fprintf(s_log_fp, "==============\n\n");
fflush(s_log_fp);
@@ -104,10 +129,35 @@ esp_err_t v2x_sd_init(void)
s_initialized = true;
s_stats.start_timestamp_us = esp_timer_get_time();
ESP_LOGI(TAG, "SD-Karte eingebunden: %s", SD_CARD_MOUNT_POINT);
ESP_LOGI(TAG, "SD-Karte eingebunden: /sdcard");
return ESP_OK;
}
/* ====== SD-Karte aush�ngen ====== */
void v2x_sd_deinit(void)
{
if (!s_initialized) return;
ESP_LOGI(TAG, "SD-Karte aush�ngen...");
if (s_log_fp) {
fprintf(s_log_fp, "\n===== Shutdown =====\n");
fflush(s_log_fp);
fclose(s_log_fp);
s_log_fp = NULL;
}
/* SD-Karte unmounten */
if (s_sd_card) {
esp_vfs_fat_sdcard_unmount("/sdcard", s_sd_card);
s_sd_card = NULL;
}
s_initialized = false;
ESP_LOGI(TAG, "SD-Karte entfernt");
}
/* ====== MAC-Adresse als Hex-String ====== */
static void mac_to_str(const uint8_t *mac, char *out)
@@ -175,11 +225,11 @@ esp_err_t v2x_sd_write_frame(const v2x_frame_t *frame)
char line[RAW_HEX_BUF + 128];
frame_to_csv_line(frame, line, sizeof(line));
/* An CSV anhängen */
FILE *fp = fopen(SD_CSV_FILE, "a+");
/* An CSV anh�ngen */
FILE *fp = fopen("/sdcard/v2x_frames.csv", "a+");
if (!fp) {
s_stats.sd_write_errors++;
ESP_LOGE(TAG, "CSV-Datei kann nicht geöffnet werden");
ESP_LOGE(TAG, "CSV-Datei kann nicht ge�ffnet werden");
return ESP_FAIL;
}
@@ -208,10 +258,11 @@ esp_err_t v2x_sd_log_write(const char *fmt, ...)
const v2x_stats_t* v2x_sd_get_stats(void) { return &s_stats; }
void v2x_sd_reset_stats(void)
esp_err_t v2x_sd_reset_stats(void)
{
memset(&s_stats, 0, sizeof(s_stats));
s_stats.start_timestamp_us = esp_timer_get_time();
return ESP_OK;
}
esp_err_t v2x_sd_dump_stats(void)
@@ -237,7 +288,7 @@ esp_err_t v2x_sd_dump_stats(void)
(unsigned long)stats->unknown_count);
v2x_sd_log_write("SD-Fehler: %lu", (unsigned long)stats->sd_write_errors);
FILE *f = fopen(SD_CSV_FILE, "r");
FILE *f = fopen("/sdcard/v2x_frames.csv", "r");
if (f) {
fseek(f, 0, SEEK_END);
long fsize = ftell(f);
@@ -249,15 +300,15 @@ esp_err_t v2x_sd_dump_stats(void)
char rotated[128];
strftime(tbuf, sizeof(tbuf), "%Y%m%d_%H%M%S", tm_info);
snprintf(rotated, sizeof(rotated), "/sdcard/v2x_frames_%s.csv", tbuf);
ESP_LOGW(TAG, "CSV rotieren: %s -> %s", SD_CSV_FILE, rotated);
rename(SD_CSV_FILE, rotated);
ESP_LOGW(TAG, "CSV rotieren: v2x_frames.csv -> %s", rotated);
rename("/sdcard/v2x_frames.csv", rotated);
f = fopen(SD_CSV_FILE, "w");
f = fopen("/sdcard/v2x_frames.csv", "w");
if (f) {
fprintf(f, "%s\n", CSV_HEADER);
fprintf(f, "timestamp_us,msg_type,channel,frequency_mhz,rssi_dbm,noise_dbm,rate_index,frame_len,mac_addr,bssid,raw_hex\n");
fclose(f);
}
v2x_sd_log_write("Neue CSV: %s", SD_CSV_FILE);
v2x_sd_log_write("Neue CSV: /sdcard/v2x_frames.csv");
}
}