dreamstack/devices/waveshare-p4-panel/main/main.c

236 lines
7.8 KiB
C
Raw Normal View History

/**
* DreamStack Thin Client Waveshare ESP32-P4 10.1" Panel
*
* Firmware that turns the panel into a dumb pixel display
* with touch input. All rendering happens on the source device.
*
* Flow: WiFi WebSocket receive delta frames blit to display
* Touch encode event send over WebSocket
*
* Dependencies (via ESP Component Registry):
* - waveshare/esp_lcd_jd9365_10_1 (10.1" MIPI DSI display driver)
* - espressif/esp_websocket_client (WebSocket client)
*/
#include <stdio.h>
#include <string.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_log.h"
#include "esp_wifi.h"
#include "esp_event.h"
#include "nvs_flash.h"
#include "esp_lcd_panel_ops.h"
#include "esp_websocket_client.h"
#include "ds_codec.h"
#include "ds_protocol.h"
static const char *TAG = "ds-panel";
// ─── Configuration (set via menuconfig or hardcode for POC) ───
#define PANEL_WIDTH 800
#define PANEL_HEIGHT 1280
#define PIXEL_BYTES 2 // RGB565
#define FB_SIZE (PANEL_WIDTH * PANEL_HEIGHT * PIXEL_BYTES) // ~2MB
#define WIFI_SSID CONFIG_WIFI_SSID
#define WIFI_PASS CONFIG_WIFI_PASS
#define RELAY_URL CONFIG_RELAY_URL // e.g. "ws://192.168.1.100:9100/stream/home"
// ─── Framebuffers (in PSRAM) ───
static uint8_t *framebuffer; // Current display state
static uint8_t *scratch_buf; // Temp buffer for delta decode
// ─── Display handle ───
static esp_lcd_panel_handle_t panel_handle = NULL;
// ─── Touch state ───
static uint16_t input_seq = 0;
// ─── WebSocket event handler ───
static void ws_event_handler(void *arg, esp_event_base_t base,
int32_t event_id, void *event_data) {
esp_websocket_event_data_t *data = (esp_websocket_event_data_t *)event_data;
switch (event_id) {
case WEBSOCKET_EVENT_CONNECTED:
ESP_LOGI(TAG, "WebSocket connected to relay");
break;
case WEBSOCKET_EVENT_DATA:
if (data->data_len < DS_HEADER_SIZE) break;
ds_header_t hdr;
if (ds_parse_header((const uint8_t *)data->data_ptr, &hdr) != 0) break;
const uint8_t *payload = (const uint8_t *)data->data_ptr + DS_HEADER_SIZE;
size_t payload_len = data->data_len - DS_HEADER_SIZE;
switch (hdr.frame_type) {
case DS_FRAME_PIXELS:
// Full keyframe — copy directly to framebuffer
if (payload_len == FB_SIZE) {
memcpy(framebuffer, payload, FB_SIZE);
esp_lcd_panel_draw_bitmap(panel_handle,
0, 0, PANEL_WIDTH, PANEL_HEIGHT, framebuffer);
ESP_LOGI(TAG, "Keyframe received (%zu bytes)", payload_len);
}
break;
case DS_FRAME_DELTA:
// Delta frame — RLE decode + XOR apply
if (ds_apply_delta_rle(framebuffer, FB_SIZE,
payload, payload_len, scratch_buf) == 0) {
esp_lcd_panel_draw_bitmap(panel_handle,
0, 0, PANEL_WIDTH, PANEL_HEIGHT, framebuffer);
} else {
ESP_LOGW(TAG, "Delta decode failed (len=%zu)", payload_len);
}
break;
case DS_FRAME_PING:
// Respond with pong (same message back)
break;
case DS_FRAME_END:
ESP_LOGI(TAG, "Stream ended");
break;
}
break;
case WEBSOCKET_EVENT_DISCONNECTED:
ESP_LOGW(TAG, "WebSocket disconnected, reconnecting...");
break;
case WEBSOCKET_EVENT_ERROR:
ESP_LOGE(TAG, "WebSocket error");
break;
}
}
// ─── Send touch event over WebSocket ───
static void send_touch_event(esp_websocket_client_handle_t ws,
uint8_t id, uint16_t x, uint16_t y, uint8_t phase) {
uint8_t buf[DS_HEADER_SIZE + sizeof(ds_touch_event_t)];
ds_touch_event_t touch = { .id = id, .x = x, .y = y, .phase = phase };
size_t len = ds_encode_touch(buf, input_seq++,
(uint32_t)(esp_timer_get_time() / 1000),
&touch);
esp_websocket_client_send_bin(ws, (const char *)buf, len, portMAX_DELAY);
}
// ─── Touch polling task ───
//
// TODO: Replace with actual GT9271 I2C touch driver.
// The Waveshare BSP should provide touch reading functions.
// This is a placeholder showing the integration pattern.
//
static void touch_task(void *arg) {
esp_websocket_client_handle_t ws = (esp_websocket_client_handle_t)arg;
while (1) {
// TODO: Read from GT9271 touch controller via I2C
// Example (pseudocode):
//
// gt9271_touch_data_t td;
// if (gt9271_read(&td) == ESP_OK && td.num_points > 0) {
// for (int i = 0; i < td.num_points; i++) {
// send_touch_event(ws, td.points[i].id,
// td.points[i].x, td.points[i].y,
// td.points[i].phase);
// }
// }
vTaskDelay(pdMS_TO_TICKS(10)); // 100Hz touch polling
}
}
// ─── Display initialization ───
//
// TODO: Initialize MIPI DSI display using Waveshare component.
// Add `waveshare/esp_lcd_jd9365_10_1` to idf_component.yml
//
static esp_err_t display_init(void) {
// TODO: Configure MIPI DSI bus and JD9365 panel driver
// Example (pseudocode):
//
// esp_lcd_dsi_bus_config_t bus_cfg = { ... };
// esp_lcd_new_dsi_bus(&bus_cfg, &dsi_bus);
//
// esp_lcd_panel_dev_config_t panel_cfg = {
// .reset_gpio_num = ...,
// .rgb_ele_order = LCD_RGB_ELEMENT_ORDER_RGB,
// .bits_per_pixel = 16, // RGB565
// };
// esp_lcd_new_panel_jd9365_10_1(dsi_bus, &panel_cfg, &panel_handle);
// esp_lcd_panel_init(panel_handle);
ESP_LOGI(TAG, "Display initialized (%dx%d RGB565)", PANEL_WIDTH, PANEL_HEIGHT);
return ESP_OK;
}
// ─── WiFi initialization ───
static void wifi_init(void) {
esp_netif_init();
esp_event_loop_create_default();
esp_netif_create_default_wifi_sta();
wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
esp_wifi_init(&cfg);
wifi_config_t wifi_cfg = {
.sta = {
.ssid = WIFI_SSID,
.password = WIFI_PASS,
},
};
esp_wifi_set_mode(WIFI_MODE_STA);
esp_wifi_set_config(WIFI_IF_STA, &wifi_cfg);
esp_wifi_start();
esp_wifi_connect();
ESP_LOGI(TAG, "WiFi connecting to %s...", WIFI_SSID);
}
// ─── Main ───
void app_main(void) {
ESP_LOGI(TAG, "DreamStack Thin Client v0.1");
ESP_LOGI(TAG, "Panel: %dx%d @ %d bpp = %d bytes",
PANEL_WIDTH, PANEL_HEIGHT, PIXEL_BYTES * 8, FB_SIZE);
// Initialize NVS (required for WiFi)
nvs_flash_init();
// Allocate framebuffers in PSRAM
framebuffer = heap_caps_calloc(1, FB_SIZE, MALLOC_CAP_SPIRAM);
scratch_buf = heap_caps_calloc(1, FB_SIZE, MALLOC_CAP_SPIRAM);
if (!framebuffer || !scratch_buf) {
ESP_LOGE(TAG, "Failed to allocate framebuffers in PSRAM (%d bytes each)", FB_SIZE);
return;
}
ESP_LOGI(TAG, "Framebuffers allocated in PSRAM (%d MB each)", FB_SIZE / (1024 * 1024));
// Initialize display
display_init();
// Initialize WiFi
wifi_init();
vTaskDelay(pdMS_TO_TICKS(3000)); // Wait for WiFi connection
// Connect WebSocket to relay
esp_websocket_client_config_t ws_cfg = {
.uri = RELAY_URL,
.buffer_size = 64 * 1024, // 64KB receive buffer
};
esp_websocket_client_handle_t ws = esp_websocket_client_init(&ws_cfg);
esp_websocket_register_events(ws, WEBSOCKET_EVENT_ANY, ws_event_handler, NULL);
esp_websocket_client_start(ws);
ESP_LOGI(TAG, "WebSocket connecting to %s...", RELAY_URL);
// Start touch polling task
xTaskCreate(touch_task, "touch", 4096, ws, 5, NULL);
ESP_LOGI(TAG, "Thin client running. Waiting for frames...");
}