Jan/Infinity_Vis_Rust
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Software-only show-control readiness baseline

Browse Source
This commit is contained in:
jan
2026-04-17 21:17:23 +02:00
commit a56cecb23d
51 changed files with 16340 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
firmware/esp32_node/CMakeLists.txt Normal file
View File

@@ -0,0 +1,4 @@
cmake_minimum_required(VERSION 3.16)
include($ENV{IDF_PATH}/tools/cmake/project.cmake)
project(infinity_vis_esp32_node)

25
firmware/esp32_node/README.md Normal file
View File

@@ -0,0 +1,25 @@
# ESP32 Node Firmware
This directory contains the ESP-IDF firmware skeleton for one ESP32 node that drives exactly three outputs:
- top
- middle
- bottom
The firmware is intentionally built around a driver abstraction. It does not assume that `UART 6`, `UART 5`, or `UART 4` are real UART peripherals.
## Planned Modules
- Network RX task
- Command decode task
- Render and apply task
- Output task
- Telemetry task
- Watchdog and recovery path
## Current Safety Posture
The skeleton blocks activation while output channels remain marked as `PANEL_DRIVER_KIND_UNVALIDATED`.
That is expected and desirable until the physical backend is confirmed.

8
firmware/esp32_node/main/CMakeLists.txt Normal file
View File

@@ -0,0 +1,8 @@
idf_component_register(
SRCS
"app_main.c"
"panel_driver.c"
INCLUDE_DIRS
"."
)

141
firmware/esp32_node/main/app_main.c Normal file
View File

@@ -0,0 +1,141 @@
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_err.h"
#include "esp_log.h"
#include "esp_system.h"
#include "panel_driver.h"
static const char *TAG = "infinity_node";
typedef struct {
const char *node_id;
panel_output_config_t outputs[INFINITY_NODE_OUTPUT_COUNT];
} node_runtime_config_t;
typedef struct {
uint32_t heartbeat_count;
uint32_t reconnect_count;
} node_metrics_t;
static node_runtime_config_t make_default_runtime_config(void);
static esp_err_t validate_runtime_config(const node_runtime_config_t *config);
static void network_rx_task(void *arg);
static void render_task(void *arg);
static void output_task(void *arg);
static void telemetry_task(void *arg);
void app_main(void) {
static node_metrics_t metrics = {0};
node_runtime_config_t runtime_config = make_default_runtime_config();
esp_err_t validation = validate_runtime_config(&runtime_config);
if (validation != ESP_OK) {
ESP_LOGE(TAG, "startup halted until hardware mapping is validated: %s", esp_err_to_name(validation));
return;
}
xTaskCreate(network_rx_task, "network_rx", 4096, &metrics, 8, NULL);
xTaskCreate(render_task, "render", 4096, &metrics, 7, NULL);
xTaskCreate(output_task, "output", 4096, &metrics, 9, NULL);
xTaskCreate(telemetry_task, "telemetry", 4096, &metrics, 5, NULL);
}
static node_runtime_config_t make_default_runtime_config(void) {
node_runtime_config_t config = {
.node_id = "unassigned-node",
.outputs =
{
{
.panel_slot = PANEL_SLOT_TOP,
.physical_output_name = "UART 6",
.driver_reference = "UART 6",
.driver_kind = PANEL_DRIVER_KIND_UNVALIDATED,
.led_count = INFINITY_LEDS_PER_OUTPUT,
.reverse = false,
.enabled = true,
},
{
.panel_slot = PANEL_SLOT_MIDDLE,
.physical_output_name = "UART 5",
.driver_reference = "UART 5",
.driver_kind = PANEL_DRIVER_KIND_UNVALIDATED,
.led_count = INFINITY_LEDS_PER_OUTPUT,
.reverse = false,
.enabled = true,
},
{
.panel_slot = PANEL_SLOT_BOTTOM,
.physical_output_name = "UART 4",
.driver_reference = "UART 4",
.driver_kind = PANEL_DRIVER_KIND_UNVALIDATED,
.led_count = INFINITY_LEDS_PER_OUTPUT,
.reverse = false,
.enabled = true,
},
},
};
return config;
}
static esp_err_t validate_runtime_config(const node_runtime_config_t *config) {
if (config == NULL) {
return ESP_ERR_INVALID_ARG;
}
for (size_t index = 0; index < INFINITY_NODE_OUTPUT_COUNT; ++index) {
esp_err_t status = panel_driver_validate_output(&config->outputs[index]);
if (status != ESP_OK) {
ESP_LOGE(
TAG,
"output %u (%s) failed validation",
(unsigned int)index,
config->outputs[index].physical_output_name
);
return status;
}
}
return ESP_OK;
}
static void network_rx_task(void *arg) {
node_metrics_t *metrics = (node_metrics_t *)arg;
for (;;) {
metrics->heartbeat_count++;
vTaskDelay(pdMS_TO_TICKS(50));
}
}
static void render_task(void *arg) {
(void)arg;
for (;;) {
vTaskDelay(pdMS_TO_TICKS(16));
}
}
static void output_task(void *arg) {
(void)arg;
for (;;) {
vTaskDelay(pdMS_TO_TICKS(16));
}
}
static void telemetry_task(void *arg) {
node_metrics_t *metrics = (node_metrics_t *)arg;
for (;;) {
ESP_LOGI(
TAG,
"telemetry heartbeat_count=%u reconnect_count=%u free_heap=%u",
metrics->heartbeat_count,
metrics->reconnect_count,
(unsigned int)esp_get_free_heap_size()
);
vTaskDelay(pdMS_TO_TICKS(1000));
}
}

28
firmware/esp32_node/main/panel_driver.c Normal file
View File

@@ -0,0 +1,28 @@
#include "panel_driver.h"
#include "esp_check.h"
#include "esp_log.h"
static const char *TAG = "panel_driver";
esp_err_t panel_driver_validate_output(const panel_output_config_t *config) {
ESP_RETURN_ON_FALSE(config != NULL, ESP_ERR_INVALID_ARG, TAG, "config must not be null");
ESP_RETURN_ON_FALSE(config->led_count == INFINITY_LEDS_PER_OUTPUT, ESP_ERR_INVALID_ARG, TAG, "output must be configured for exactly 106 LEDs");
ESP_RETURN_ON_FALSE(config->enabled, ESP_ERR_INVALID_STATE, TAG, "disabled output cannot enter the active driver set");
ESP_RETURN_ON_FALSE(config->driver_kind != PANEL_DRIVER_KIND_UNVALIDATED, ESP_ERR_INVALID_STATE, TAG, "driver backend is still unvalidated");
ESP_RETURN_ON_FALSE(config->driver_reference != NULL, ESP_ERR_INVALID_ARG, TAG, "driver reference must not be null");
return ESP_OK;
}
esp_err_t panel_driver_self_test_all(panel_driver_t *driver, const panel_output_config_t *outputs, size_t output_count) {
ESP_RETURN_ON_FALSE(driver != NULL, ESP_ERR_INVALID_ARG, TAG, "driver must not be null");
ESP_RETURN_ON_FALSE(driver->vtable != NULL, ESP_ERR_INVALID_STATE, TAG, "driver vtable missing");
ESP_RETURN_ON_FALSE(driver->vtable->self_test != NULL, ESP_ERR_INVALID_STATE, TAG, "driver self test callback missing");
for (size_t index = 0; index < output_count; ++index) {
ESP_RETURN_ON_ERROR(panel_driver_validate_output(&outputs[index]), TAG, "output validation failed before self test");
}
return driver->vtable->self_test(driver);
}

61
firmware/esp32_node/main/panel_driver.h Normal file
View File

@@ -0,0 +1,61 @@
#pragma once
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include "esp_err.h"
#define INFINITY_NODE_OUTPUT_COUNT 3
#define INFINITY_LEDS_PER_OUTPUT 106
typedef enum {
PANEL_SLOT_TOP = 0,
PANEL_SLOT_MIDDLE = 1,
PANEL_SLOT_BOTTOM = 2,
} panel_slot_t;
typedef enum {
PANEL_DRIVER_KIND_UNVALIDATED = 0,
PANEL_DRIVER_KIND_GPIO,
PANEL_DRIVER_KIND_RMT,
PANEL_DRIVER_KIND_I2S,
PANEL_DRIVER_KIND_UART,
PANEL_DRIVER_KIND_SPI,
PANEL_DRIVER_KIND_EXTERNAL,
} panel_driver_kind_t;
typedef struct {
uint8_t r;
uint8_t g;
uint8_t b;
} rgb8_t;
typedef struct {
panel_slot_t panel_slot;
const char *physical_output_name;
const char *driver_reference;
panel_driver_kind_t driver_kind;
uint16_t led_count;
bool reverse;
bool enabled;
} panel_output_config_t;
typedef struct panel_driver panel_driver_t;
typedef struct {
esp_err_t (*init)(panel_driver_t *driver);
esp_err_t (*configure)(panel_driver_t *driver, const panel_output_config_t *config);
esp_err_t (*submit_frame)(panel_driver_t *driver, panel_slot_t panel_slot, const rgb8_t *pixels, size_t pixel_count);
esp_err_t (*apply)(panel_driver_t *driver);
esp_err_t (*self_test)(panel_driver_t *driver);
} panel_driver_vtable_t;
struct panel_driver {
const panel_driver_vtable_t *vtable;
void *context;
};
esp_err_t panel_driver_validate_output(const panel_output_config_t *config);
esp_err_t panel_driver_self_test_all(panel_driver_t *driver, const panel_output_config_t *outputs, size_t output_count);