ESP32-P4 加无线协处理器：把大屏看板跑起来

# ---- host/CMakeLists.txt ----
# SPDX-License-Identifier: MIT
cmake_minimum_required(VERSION 3.16)
include($ENV{IDF_PATH}/tools/cmake/project.cmake)
project(v09_p4_dashboard VERSION 1.0.0)
# ---- cp/CMakeLists.txt ----
# SPDX-License-Identifier: MIT
cmake_minimum_required(VERSION 3.16)
include($ENV{IDF_PATH}/tools/cmake/project.cmake)
project(v09_c6_coprocessor VERSION 1.0.0)

# ---- tools/status_server.py ----
#!/usr/bin/env python3
# SPDX-License-Identifier: MIT
"""Own-lab synthetic HTTP source. No sensor, no ESP communication proof."""
import argparse
import http.server
import time

class StatusHandler(http.server.BaseHTTPRequestHandler):
    mode = "valid"
    def do_GET(self):
        if self.path != "/status":
            self.send_error(404); return
        if self.mode == "redirect":
            self.send_response(302); self.send_header("Location", "/status"); self.end_headers(); return
        if self.mode == "status503":
            self.send_error(503); return
        if self.mode == "malformed": body = b"level=101\n"
        elif self.mode == "oversize": body = b"x" * 97
        else: body = f"level={int(time.monotonic()) % 101}\n".encode("ascii")
        self.send_response(200); self.send_header("Content-Type", "text/plain; charset=us-ascii")
        self.send_header("Content-Length", str(len(body))); self.send_header("Cache-Control", "no-store")
        self.end_headers()
        try:
            if self.mode == "slow":
                for byte in body:
                    self.wfile.write(bytes([byte])); self.wfile.flush(); time.sleep(0.5)
            else: self.wfile.write(body)
        except (BrokenPipeError, ConnectionResetError): pass
    def log_message(self, fmt, *args): pass

def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--bind", default="127.0.0.1", help="Use your own LAN IPv4 for an ESP test")
    parser.add_argument("--port", type=int, default=8099)
    parser.add_argument("--mode", choices=["valid","malformed","oversize","status503","redirect","slow"], default="valid")
    args = parser.parse_args()
    if not 0 <= args.port <= 65535: parser.error("port must be 0..65535")
    StatusHandler.mode = args.mode
    server = http.server.ThreadingHTTPServer((args.bind,args.port),StatusHandler)
    server.daemon_threads = True
    print(f"LAB_SYNTHETIC http://{args.bind}:{server.server_port}/status mode={args.mode}",flush=True)
    try: server.serve_forever()
    except KeyboardInterrupt: pass
    finally: server.server_close()

if __name__ == "__main__": main()

// ---- host/main/dashboard_policy.h ----
// SPDX-License-Identifier: MIT
#ifndef V09_DASHBOARD_POLICY_H
#define V09_DASHBOARD_POLICY_H
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <string.h>

#define V09_BODY_CAP 96U
#define V09_STALE_MS UINT64_C(10000)

/* Exact lab wire format: level=0..100 followed by one LF. No physical sensor. */
static inline bool v09_parse_level(const char *p, size_t n, uint8_t *out)
{
    if (!p || !out || n < 8 || n > 10 || memcmp(p, "level=", 6) || p[n - 1] != '\n') return false;
    unsigned value = 0;
    for (size_t i = 6; i + 1 < n; ++i) {
        if (p[i] < '0' || p[i] > '9') return false;
        value = value * 10 + (unsigned)(p[i] - '0');
    }
    if (value > 100) return false;
    *out = (uint8_t)value;
    return true;
}

typedef struct {
    bool has_value;
    uint8_t value;
    uint64_t received_ms;
    uint32_t accepted;
    uint32_t rejected;
} v09_sample_t;

static inline void v09_accept(v09_sample_t *s, uint8_t value, uint64_t now)
{
    s->has_value = true; s->value = value; s->received_ms = now;
    if (s->accepted != UINT32_MAX) ++s->accepted;
}
static inline void v09_reject(v09_sample_t *s)
{
    if (s->rejected != UINT32_MAX) ++s->rejected;
}
static inline bool v09_fresh(const v09_sample_t *s, uint64_t now)
{
    return s->has_value && now >= s->received_ms && now - s->received_ms <= V09_STALE_MS;
}
static inline bool v09_config_ready(bool enabled, const char *ssid, const char *password, const char *url)
{
    if (!enabled || !ssid || !password || !url) return false;
    return strlen(ssid) >= 1 && strlen(ssid) <= 31 && strlen(password) >= 8 && strlen(password) <= 63 &&
           strlen(url) < 192 && strncmp(url, "http://", 7) == 0 &&
           !strstr(ssid, "REPLACE_") && !strstr(password, "REPLACE_") && !strstr(url, "REPLACE_");
}
static inline uint64_t v09_deadline(uint64_t now, uint64_t delay)
{
    return UINT64_MAX - now < delay ? UINT64_MAX : now + delay;
}
typedef struct { uint64_t due_ms; unsigned delay_s; } v09_retry_t;
static inline void v09_retry_reset(v09_retry_t *r) { r->due_ms = 0; r->delay_s = 2; }
static inline void v09_retry_fail(v09_retry_t *r, uint64_t now)
{
    if (r->delay_s < 2 || r->delay_s > 30) r->delay_s = 2;
    r->due_ms = v09_deadline(now, (uint64_t)r->delay_s * 1000);
    r->delay_s = r->delay_s >= 16 ? 30 : r->delay_s * 2;
}
static inline bool v09_retry_due(const v09_retry_t *r, uint64_t now) { return now >= r->due_ms; }
#endif

// ---- host/main/main.c ----
// SPDX-License-Identifier: MIT
#include <inttypes.h>
#include <stdio.h>
#include <string.h>
#include "sdkconfig.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/queue.h"
#include "esp_event.h"
#include "esp_http_client.h"
#include "esp_hosted.h"
#include "esp_log.h"
#include "esp_netif.h"
#include "esp_system.h"
#include "esp_timer.h"
#include "esp_wifi.h"
#include "nvs_flash.h"
#include "bsp/esp-bsp.h"
#include "lvgl.h"
#include "dashboard_policy.h"

#ifndef CONFIG_APP_ENABLE_NETWORK
#define CONFIG_APP_ENABLE_NETWORK 0
#endif

static const char *TAG = "v09";
typedef struct { bool online, transport_failed; char ip[16]; uint32_t cp_boot_notices; } link_t;
typedef struct { char phase[72]; v09_sample_t sample; } view_t;
static portMUX_TYPE s_lock = portMUX_INITIALIZER_UNLOCKED;
static link_t s_link;
static view_t s_view = { .phase = "Display starting; network not started" };
static QueueHandle_t s_restart;
static lv_obj_t *s_phase, *s_link_label, *s_value, *s_stats;

static uint64_t now_ms(void) { return (uint64_t)esp_timer_get_time() / 1000; }
static link_t link_snapshot(void)
{
    portENTER_CRITICAL(&s_lock); link_t out = s_link; portEXIT_CRITICAL(&s_lock); return out;
}
static void publish(const char *phase, const v09_sample_t *sample)
{
    portENTER_CRITICAL(&s_lock);
    if (phase) snprintf(s_view.phase, sizeof(s_view.phase), "%s", phase);
    if (sample) s_view.sample = *sample;
    portEXIT_CRITICAL(&s_lock);
}

/* Callback copies state only. Network APIs belong to network_task. */
static void event(void *arg, esp_event_base_t base, int32_t id, void *data)
{
    (void)arg;
    portENTER_CRITICAL(&s_lock);
    if (base == IP_EVENT && id == IP_EVENT_STA_GOT_IP && data) {
        ip_event_got_ip_t *got = data;
        s_link.online = !s_link.transport_failed && got->ip_info.ip.addr != 0;
        if (s_link.online) snprintf(s_link.ip, sizeof(s_link.ip), IPSTR, IP2STR(&got->ip_info.ip));
        else s_link.ip[0] = 0;
    } else if ((base == WIFI_EVENT && id == WIFI_EVENT_STA_DISCONNECTED) ||
               (base == IP_EVENT && id == IP_EVENT_STA_LOST_IP)) {
        s_link.online = false; s_link.ip[0] = 0;
    } else if (base == ESP_HOSTED_EVENT &&
               (id == ESP_HOSTED_EVENT_TRANSPORT_FAILURE || id == ESP_HOSTED_EVENT_TRANSPORT_DOWN)) {
        s_link.transport_failed = true; s_link.online = false; s_link.ip[0] = 0;
    } else if (base == ESP_HOSTED_EVENT && id == ESP_HOSTED_EVENT_CP_INIT) {
        if (s_link.cp_boot_notices != UINT32_MAX) ++s_link.cp_boot_notices;
    }
    portEXIT_CRITICAL(&s_lock);
}

typedef struct { char body[V09_BODY_CAP]; size_t used; bool overflow; } body_t;
static esp_err_t http_event(esp_http_client_event_t *e)
{
    body_t *b = e->user_data;
    if (e->event_id == HTTP_EVENT_ON_DATA && e->data_len > 0) {
        if ((size_t)e->data_len > sizeof(b->body) - b->used) { b->overflow = true; return ESP_FAIL; }
        memcpy(b->body + b->used, e->data, (size_t)e->data_len); b->used += (size_t)e->data_len;
    }
    return ESP_OK;
}
static bool fetch_level(uint8_t *value)
{
    body_t body = {0};
    const esp_http_client_config_t cfg = {
        .url = CONFIG_APP_STATUS_URL, .timeout_ms = 3000, .buffer_size = 512,
        .event_handler = http_event, .user_data = &body, .disable_auto_redirect = true,
    };
    esp_http_client_handle_t h = esp_http_client_init(&cfg);
    if (!h) return false;
    const esp_err_t result = esp_http_client_perform(h);
    const int status = esp_http_client_get_status_code(h);
    const bool ok = result == ESP_OK && status == 200 && !body.overflow &&
                    v09_parse_level(body.body, body.used, value);
    esp_http_client_cleanup(h);
    return ok;
}

/* This task owns every application Wi-Fi/Hosted/HTTP API. No API in callbacks/UI. */
static void network_task(void *arg)
{
    (void)arg;
    v09_sample_t sample = {0};
    if (!v09_config_ready(CONFIG_APP_ENABLE_NETWORK, CONFIG_APP_WIFI_SSID,
                          CONFIG_APP_WIFI_PASSWORD, CONFIG_APP_STATUS_URL)) {
        publish("CONFIG_MISSING: fill private sdkconfig.local; network stays off", NULL);
        vTaskDelete(NULL); return;
    }
    esp_err_t result = nvs_flash_init();
    if (result != ESP_OK) { publish("NVS init failed; stopped without erase", NULL); goto stopped; }
    ESP_ERROR_CHECK(esp_netif_init());
    ESP_ERROR_CHECK(esp_event_loop_create_default());
    ESP_ERROR_CHECK(esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID, event, NULL));
    ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, event, NULL));
    ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, IP_EVENT_STA_LOST_IP, event, NULL));
    ESP_ERROR_CHECK(esp_event_handler_register(ESP_HOSTED_EVENT, ESP_EVENT_ANY_ID, event, NULL));
    if (!esp_netif_create_default_wifi_sta()) { publish("STA netif allocation failed", NULL); goto stopped; }
    publish("SDIO: starting C6; fixed startup strategy resets CP", NULL);
    if (esp_hosted_init() != 0 || esp_hosted_connect_to_slave() != 0) {
        publish("CP bring-up failed; check pair/power/bus, then restart both", NULL); goto stopped;
    }
    esp_hosted_coprocessor_fwver_t version = {0}; uint32_t chip = 0; char target[16] = {0};
    if (esp_hosted_get_coprocessor_fwversion(&version) != ESP_OK ||
        esp_hosted_get_cp_info(&chip, target, sizeof(target)) != ESP_OK ||
        version.major1 != 3 || version.minor1 != 0 || version.patch1 != 9 || strcmp(target, "esp32c6")) {
        publish("CP identity/version mismatch or RPC failed; Wi-Fi not started", NULL); goto stopped;
    }
    ESP_LOGI(TAG, "CP %s, chip=%" PRIu32 ", Hosted=%" PRIu32 ".%" PRIu32 ".%" PRIu32,
             target, chip, version.major1, version.minor1, version.patch1);
    wifi_init_config_t init = WIFI_INIT_CONFIG_DEFAULT();
    result = esp_wifi_init(&init);
    if (result != ESP_OK) { publish("Wi-Fi init RPC failed; restart both", NULL); goto stopped; }
    wifi_config_t wifi = {0};
    snprintf((char *)wifi.sta.ssid, sizeof(wifi.sta.ssid), "%s", CONFIG_APP_WIFI_SSID);
    snprintf((char *)wifi.sta.password, sizeof(wifi.sta.password), "%s", CONFIG_APP_WIFI_PASSWORD);
    wifi.sta.threshold.authmode = WIFI_AUTH_WPA2_PSK;
    if (esp_wifi_set_storage(WIFI_STORAGE_RAM) != ESP_OK || esp_wifi_set_mode(WIFI_MODE_STA) != ESP_OK ||
        esp_wifi_set_config(WIFI_IF_STA, &wifi) != ESP_OK || esp_wifi_start() != ESP_OK) {
        publish("Wi-Fi setup RPC failed; stopped, no automatic erase", NULL); goto stopped;
    }
    v09_retry_t retry; v09_retry_reset(&retry);
    bool connecting = false, previously_online = false;
    uint64_t connect_until = 0, poll_at = 0;
    for (;;) {
        /* Take event snapshot before time. The callback's latest link state wins. */
        link_t link = link_snapshot(); uint64_t now = now_ms();
        if (link.transport_failed) { publish("CP transport failed; restart P4 + reset C6 to recover", &sample); goto stopped; }
        if (link.online) {
            if (!previously_online) { v09_retry_reset(&retry); connecting = false; poll_at = now; }
            previously_online = true;
            if (now >= poll_at) {
                uint8_t value = 0; const bool fetched = fetch_level(&value);
                link = link_snapshot(); now = now_ms();
                if (fetched && link.online && !link.transport_failed) {
                    v09_accept(&sample, value, now); publish("ONLINE: valid lab level received", &sample);
                } else { v09_reject(&sample); publish("HTTP/link error: old value retained with age", &sample); }
                poll_at = v09_deadline(now, 3000);
            }
        } else {
            if (previously_online) { previously_online = false; connecting = false; v09_retry_fail(&retry, now); }
            if (connecting && now >= connect_until) {
                connecting = false; v09_retry_fail(&retry, now); publish("No IP after app window; backing off", &sample);
            }
            if (!connecting && v09_retry_due(&retry, now)) {
                /* Stop a previous attempt before starting the next; callbacks never call connect. */
                (void)esp_wifi_disconnect();
                if (esp_wifi_connect() == ESP_OK) {
                    connecting = true; connect_until = v09_deadline(now_ms(), 15000);
                    publish("CONNECTING: waiting for non-zero DHCP address", &sample);
                } else { v09_retry_fail(&retry, now_ms()); publish("Connect RPC failed; backing off", &sample); }
            }
        }
        vTaskDelay(pdMS_TO_TICKS(100));
    }
stopped:
    ESP_LOGW(TAG, "network task stopped; display/restart control remain available");
    vTaskDelete(NULL);
}

/* Restart runs independently of a potentially blocked network operation.
 * This intentionally restarts the P4 as well. Hosted startup then resets C6.
 * No application GPIO write races the driver's ownership of GPIO54. */
static void restart_task(void *arg)
{
    (void)arg; uint8_t command;
    if (xQueueReceive(s_restart, &command, portMAX_DELAY) == pdTRUE) {
        publish("Restart requested: P4 reboots, then Hosted resets C6", NULL);
        vTaskDelay(pdMS_TO_TICKS(300)); esp_restart();
    }
    vTaskDelete(NULL);
}
static void request_restart(lv_event_t *e)
{
    (void)e; const uint8_t command = 1; (void)xQueueSend(s_restart, &command, 0);
}
static void refresh_ui(lv_timer_t *timer)
{
    (void)timer;
    portENTER_CRITICAL(&s_lock); view_t view = s_view; link_t link = s_link; portEXIT_CRITICAL(&s_lock);
    const uint64_t now = now_ms();
    lv_label_set_text(s_phase, view.phase);
    lv_label_set_text_fmt(s_link_label, "C6 radio / P4 TCP-IP | %s | IP %s | CP boot notices %" PRIu32,
                          link.online ? "IP ready" : "OFFLINE", link.ip[0] ? link.ip : "--", link.cp_boot_notices);
    if (!view.sample.has_value) lv_label_set_text(s_value, "LAB level: -- / 100 | NO SAMPLE");
    else lv_label_set_text_fmt(s_value, "LAB level: %u / 100 | %s | age %" PRIu64 " ms",
                              (unsigned)view.sample.value, v09_fresh(&view.sample, now) ? "FRESH" : "STALE",
                              now >= view.sample.received_ms ? now - view.sample.received_ms : 0);
    lv_label_set_text_fmt(s_stats, "accepted %" PRIu32 " | errors %" PRIu32 " | uptime %" PRIu64 " s\n"
                         "HTTP data is synthetic. No sensor / FPS / throughput measurement.",
                         view.sample.accepted, view.sample.rejected, now / 1000);
}
static lv_obj_t *label_at(lv_obj_t *root, int y)
{
    lv_obj_t *label = lv_label_create(root); lv_obj_set_width(label, 960); lv_obj_set_pos(label, 24, y);
    lv_label_set_long_mode(label, LV_LABEL_LONG_WRAP); return label;
}
void app_main(void)
{
    s_restart = xQueueCreate(1, sizeof(uint8_t));
    if (!s_restart || xTaskCreate(restart_task, "v09_restart", 3072, NULL, 6, NULL) != pdPASS) {
        ESP_LOGE(TAG, "restart control allocation failed; network not started"); return;
    }
    bsp_display_cfg_t cfg = {
        .lvgl_port_cfg = ESP_LVGL_PORT_INIT_CONFIG(), .buffer_size = 1024 * 32,
        .double_buffer = false, .hw_cfg = { .hdmi_resolution = BSP_HDMI_RES_NONE,
            .dsi_bus = { .phy_clk_src = 0, .lane_bit_rate_mbps = BSP_LCD_MIPI_DSI_LANE_BITRATE_MBPS } },
        .flags = { .buff_dma = true, .buff_spiram = false, .sw_rotate = false },
    };
    lv_display_t *display = bsp_display_start_with_config(&cfg);
    if (!display) { ESP_LOGE(TAG, "display/touch init failed; network not started"); return; }
    if (!bsp_display_lock(2000)) { ESP_LOGE(TAG, "LVGL lock failed; network not started"); return; }
    lv_obj_t *root = lv_screen_active();
    lv_obj_set_style_bg_color(root, lv_color_hex(0x101c2d), 0);
    lv_obj_set_style_text_color(root, lv_color_hex(0xe8f2ff), 0);
    lv_obj_t *title = label_at(root, 28); lv_label_set_text(title, "V09 | P4 display + C6 wireless");
    s_phase = label_at(root, 104); s_link_label = label_at(root, 160);
    s_value = label_at(root, 235); s_stats = label_at(root, 310);
    lv_obj_t *button = lv_button_create(root); lv_obj_set_pos(button, 24, 438); lv_obj_set_size(button, 650, 82);
    lv_obj_t *caption = lv_label_create(button); lv_label_set_text(caption, "Restart P4 + reset C6 (both will reconnect)"); lv_obj_center(caption);
    lv_obj_add_event_cb(button, request_restart, LV_EVENT_CLICKED, NULL);
    lv_timer_create(refresh_ui, 250, NULL); refresh_ui(NULL); bsp_display_unlock();
    if (bsp_display_brightness_set(30) != ESP_OK) { ESP_LOGE(TAG, "backlight failed; network not started"); return; }
    if (xTaskCreate(network_task, "v09_network", 8192, NULL, 5, NULL) != pdPASS)
        publish("Network task allocation failed; display still available", NULL);
}

// ---- cp/main/main.c ----
// SPDX-License-Identifier: MIT
#include "sdkconfig.h"
#include "esp_event.h"
#include "esp_log.h"
#include "nvs_flash.h"
#include "eh_cp.h"

void app_main(void)
{
#if !CONFIG_APP_ENABLE_COPROCESSOR
    ESP_LOGW("v09_cp", "CP_DISABLED: enable sdkconfig.lab only after checking this board/pair");
    return;
#else
    const esp_err_t nvs = nvs_flash_init();
    if (nvs != ESP_OK) {
        ESP_LOGE("v09_cp", "NVS init failed (%s); stopped without erasing", esp_err_to_name(nvs));
        return;
    }
    const esp_err_t events = esp_event_loop_create_default();
    if (events != ESP_OK && events != ESP_ERR_INVALID_STATE) {
        ESP_LOGE("v09_cp", "event loop failed: %s", esp_err_to_name(events));
        return;
    }
    const esp_err_t started = eh_cp_init();
    ESP_LOGI("v09_cp", "Hosted3.0.9 CP init=%s; Wi-Fi commands/data come from the P4 host",
             esp_err_to_name(started));
#endif
}