devttl/xiaozhi-esp32
1
0
Fork 0
forked from xiaozhi/xiaozhi-esp32
Code Pull Requests Activity
Files
d09537ed5c2c66b6fdb9f2e8a6bd0618fe12f1a3
xiaozhi-esp32/main/boards/esp-sparkbot/esp_sparkbot_board.cc
Xiaoxia d09537ed5c Add V2 parition tables (#1137) 
* v1.9.0: update font icons, add mqtt reconnect

* Add v2 parition tables
2025-08-29 09:04:23 +08:00

304 lines
11 KiB
C++
Raw Blame History

#include "wifi_board.h"
#include "codecs/es8311_audio_codec.h"
#include "display/lcd_display.h"
#include "application.h"
#include "button.h"
#include "config.h"
#include "mcp_server.h"
#include "settings.h"
#include <wifi_station.h>
#include <esp_log.h>
#include <esp_lcd_panel_vendor.h>
#include <driver/i2c_master.h>
#include <driver/spi_common.h>
#include <driver/uart.h>
#include <cstring>
#include "esp32_camera.h"
#define TAG "esp_sparkbot"
LV_FONT_DECLARE(font_puhui_20_4);
LV_FONT_DECLARE(font_awesome_20_4);
class SparkBotEs8311AudioCodec : public Es8311AudioCodec {
private:
public:
SparkBotEs8311AudioCodec(void* i2c_master_handle, i2c_port_t i2c_port, int input_sample_rate, int output_sample_rate,
gpio_num_t mclk, gpio_num_t bclk, gpio_num_t ws, gpio_num_t dout, gpio_num_t din,
gpio_num_t pa_pin, uint8_t es8311_addr, bool use_mclk = true)
: Es8311AudioCodec(i2c_master_handle, i2c_port, input_sample_rate, output_sample_rate,
mclk, bclk, ws, dout, din,pa_pin, es8311_addr, use_mclk = true) {}
void EnableOutput(bool enable) override {
if (enable == output_enabled_) {
return;
}
if (enable) {
Es8311AudioCodec::EnableOutput(enable);
} else {
// Nothing todo because the display io and PA io conflict
}
}
};
class EspSparkBot : public WifiBoard {
private:
i2c_master_bus_handle_t i2c_bus_;
Button boot_button_;
Display* display_;
Esp32Camera* camera_;
light_mode_t light_mode_ = LIGHT_MODE_ALWAYS_ON;
void InitializeI2c() {
// Initialize I2C peripheral
i2c_master_bus_config_t i2c_bus_cfg = {
.i2c_port = I2C_NUM_0,
.sda_io_num = AUDIO_CODEC_I2C_SDA_PIN,
.scl_io_num = AUDIO_CODEC_I2C_SCL_PIN,
.clk_source = I2C_CLK_SRC_DEFAULT,
.glitch_ignore_cnt = 7,
.intr_priority = 0,
.trans_queue_depth = 0,
.flags = {
.enable_internal_pullup = 1,
},
};
ESP_ERROR_CHECK(i2c_new_master_bus(&i2c_bus_cfg, &i2c_bus_));
}
void InitializeSpi() {
spi_bus_config_t buscfg = {};
buscfg.mosi_io_num = DISPLAY_MOSI_GPIO;
buscfg.miso_io_num = GPIO_NUM_NC;
buscfg.sclk_io_num = DISPLAY_CLK_GPIO;
buscfg.quadwp_io_num = GPIO_NUM_NC;
buscfg.quadhd_io_num = GPIO_NUM_NC;
buscfg.max_transfer_sz = DISPLAY_WIDTH * DISPLAY_HEIGHT * sizeof(uint16_t);
ESP_ERROR_CHECK(spi_bus_initialize(SPI3_HOST, &buscfg, SPI_DMA_CH_AUTO));
}
void InitializeButtons() {
boot_button_.OnClick([this]() {
auto& app = Application::GetInstance();
if (app.GetDeviceState() == kDeviceStateStarting && !WifiStation::GetInstance().IsConnected()) {
ResetWifiConfiguration();
}
app.ToggleChatState();
});
}
void InitializeDisplay() {
esp_lcd_panel_io_handle_t panel_io = nullptr;
esp_lcd_panel_handle_t panel = nullptr;
// 液晶屏控制IO初始化
ESP_LOGD(TAG, "Install panel IO");
esp_lcd_panel_io_spi_config_t io_config = {};
io_config.cs_gpio_num = DISPLAY_CS_GPIO;
io_config.dc_gpio_num = DISPLAY_DC_GPIO;
io_config.spi_mode = 0;
io_config.pclk_hz = 40 * 1000 * 1000;
io_config.trans_queue_depth = 10;
io_config.lcd_cmd_bits = 8;
io_config.lcd_param_bits = 8;
ESP_ERROR_CHECK(esp_lcd_new_panel_io_spi(SPI3_HOST, &io_config, &panel_io));
// 初始化液晶屏驱动芯片
ESP_LOGD(TAG, "Install LCD driver");
esp_lcd_panel_dev_config_t panel_config = {};
panel_config.reset_gpio_num = GPIO_NUM_NC;
panel_config.rgb_ele_order = LCD_RGB_ELEMENT_ORDER_RGB;
panel_config.bits_per_pixel = 16;
ESP_ERROR_CHECK(esp_lcd_new_panel_st7789(panel_io, &panel_config, &panel));
esp_lcd_panel_reset(panel);
esp_lcd_panel_init(panel);
esp_lcd_panel_invert_color(panel, true);
esp_lcd_panel_disp_on_off(panel, true);
display_ = new SpiLcdDisplay(panel_io, panel,
DISPLAY_WIDTH, DISPLAY_HEIGHT, DISPLAY_OFFSET_X, DISPLAY_OFFSET_Y, DISPLAY_MIRROR_X, DISPLAY_MIRROR_Y, DISPLAY_SWAP_XY,
{
.text_font = &font_puhui_20_4,
.icon_font = &font_awesome_20_4,
.emoji_font = font_emoji_64_init(),
});
}
void InitializeCamera() {
camera_config_t camera_config = {};
camera_config.pin_pwdn = SPARKBOT_CAMERA_PWDN;
camera_config.pin_reset = SPARKBOT_CAMERA_RESET;
camera_config.pin_xclk = SPARKBOT_CAMERA_XCLK;
camera_config.pin_pclk = SPARKBOT_CAMERA_PCLK;
camera_config.pin_sccb_sda = SPARKBOT_CAMERA_SIOD;
camera_config.pin_sccb_scl = SPARKBOT_CAMERA_SIOC;
camera_config.pin_d0 = SPARKBOT_CAMERA_D0;
camera_config.pin_d1 = SPARKBOT_CAMERA_D1;
camera_config.pin_d2 = SPARKBOT_CAMERA_D2;
camera_config.pin_d3 = SPARKBOT_CAMERA_D3;
camera_config.pin_d4 = SPARKBOT_CAMERA_D4;
camera_config.pin_d5 = SPARKBOT_CAMERA_D5;
camera_config.pin_d6 = SPARKBOT_CAMERA_D6;
camera_config.pin_d7 = SPARKBOT_CAMERA_D7;
camera_config.pin_vsync = SPARKBOT_CAMERA_VSYNC;
camera_config.pin_href = SPARKBOT_CAMERA_HSYNC;
camera_config.pin_pclk = SPARKBOT_CAMERA_PCLK;
camera_config.xclk_freq_hz = SPARKBOT_CAMERA_XCLK_FREQ;
camera_config.ledc_timer = SPARKBOT_LEDC_TIMER;
camera_config.ledc_channel = SPARKBOT_LEDC_CHANNEL;
camera_config.fb_location = CAMERA_FB_IN_PSRAM;
camera_config.sccb_i2c_port = I2C_NUM_0;
camera_config.pixel_format = PIXFORMAT_RGB565;
camera_config.frame_size = FRAMESIZE_240X240;
camera_config.jpeg_quality = 12;
camera_config.fb_count = 1;
camera_config.grab_mode = CAMERA_GRAB_WHEN_EMPTY;
camera_ = new Esp32Camera(camera_config);
Settings settings("sparkbot", false);
// 考虑到部分复刻使用了不可动摄像头的设计，默认启用翻转
bool camera_flipped = static_cast<bool>(settings.GetInt("camera-flipped", 1));
camera_->SetHMirror(camera_flipped);
camera_->SetVFlip(camera_flipped);
}
/*
ESP-SparkBot 的底座
https://gitee.com/esp-friends/esp_sparkbot/tree/master/example/tank/c2_tracked_chassis
*/
void InitializeEchoUart() {
uart_config_t uart_config = {
.baud_rate = ECHO_UART_BAUD_RATE,
.data_bits = UART_DATA_8_BITS,
.parity = UART_PARITY_DISABLE,
.stop_bits = UART_STOP_BITS_1,
.flow_ctrl = UART_HW_FLOWCTRL_DISABLE,
.source_clk = UART_SCLK_DEFAULT,
};
int intr_alloc_flags = 0;
ESP_ERROR_CHECK(uart_driver_install(ECHO_UART_PORT_NUM, BUF_SIZE * 2, 0, 0, NULL, intr_alloc_flags));
ESP_ERROR_CHECK(uart_param_config(ECHO_UART_PORT_NUM, &uart_config));
ESP_ERROR_CHECK(uart_set_pin(ECHO_UART_PORT_NUM, UART_ECHO_TXD, UART_ECHO_RXD, UART_ECHO_RTS, UART_ECHO_CTS));
SendUartMessage("w2");
}
void SendUartMessage(const char * command_str) {
uint8_t len = strlen(command_str);
uart_write_bytes(ECHO_UART_PORT_NUM, command_str, len);
ESP_LOGI(TAG, "Sent command: %s", command_str);
}
void InitializeTools() {
auto& mcp_server = McpServer::GetInstance();
// 定义设备的属性
mcp_server.AddTool("self.chassis.get_light_mode", "获取灯光效果编号", PropertyList(), [this](const PropertyList& properties) -> ReturnValue {
if (light_mode_ < 2) {
return 1;
} else {
return light_mode_ - 2;
}
});
mcp_server.AddTool("self.chassis.go_forward", "前进", PropertyList(), [this](const PropertyList& properties) -> ReturnValue {
SendUartMessage("x0.0 y1.0");
return true;
});
mcp_server.AddTool("self.chassis.go_back", "后退", PropertyList(), [this](const PropertyList& properties) -> ReturnValue {
SendUartMessage("x0.0 y-1.0");
return true;
});
mcp_server.AddTool("self.chassis.turn_left", "向左转", PropertyList(), [this](const PropertyList& properties) -> ReturnValue {
SendUartMessage("x-1.0 y0.0");
return true;
});
mcp_server.AddTool("self.chassis.turn_right", "向右转", PropertyList(), [this](const PropertyList& properties) -> ReturnValue {
SendUartMessage("x1.0 y0.0");
return true;
});
mcp_server.AddTool("self.chassis.dance", "跳舞", PropertyList(), [this](const PropertyList& properties) -> ReturnValue {
SendUartMessage("d1");
light_mode_ = LIGHT_MODE_MAX;
return true;
});
mcp_server.AddTool("self.chassis.switch_light_mode", "打开灯光效果", PropertyList({
Property("light_mode", kPropertyTypeInteger, 1, 6)
}), [this](const PropertyList& properties) -> ReturnValue {
char command_str[5] = {'w', 0, 0};
char mode = static_cast<light_mode_t>(properties["light_mode"].value<int>());
ESP_LOGI(TAG, "Switch Light Mode: %c", (mode + '0'));
if (mode >= 3 && mode <= 8) {
command_str[1] = mode + '0';
SendUartMessage(command_str);
return true;
}
throw std::runtime_error("Invalid light mode");
});
mcp_server.AddTool("self.camera.set_camera_flipped", "翻转摄像头图像方向", PropertyList(), [this](const PropertyList& properties) -> ReturnValue {
Settings settings("sparkbot", true);
// 考虑到部分复刻使用了不可动摄像头的设计，默认启用翻转
bool flipped = !static_cast<bool>(settings.GetInt("camera-flipped", 1));
camera_->SetHMirror(flipped);
camera_->SetVFlip(flipped);
settings.SetInt("camera-flipped", flipped ? 1 : 0);
return true;
});
}
public:
EspSparkBot() : boot_button_(BOOT_BUTTON_GPIO) {
InitializeI2c();
InitializeSpi();
InitializeDisplay();
InitializeButtons();
InitializeCamera();
InitializeEchoUart();
InitializeTools();
GetBacklight()->RestoreBrightness();
}
virtual AudioCodec* GetAudioCodec() override {
static SparkBotEs8311AudioCodec audio_codec(i2c_bus_, I2C_NUM_0, AUDIO_INPUT_SAMPLE_RATE, AUDIO_OUTPUT_SAMPLE_RATE,
AUDIO_I2S_GPIO_MCLK, AUDIO_I2S_GPIO_BCLK, AUDIO_I2S_GPIO_WS, AUDIO_I2S_GPIO_DOUT, AUDIO_I2S_GPIO_DIN,
AUDIO_CODEC_PA_PIN, AUDIO_CODEC_ES8311_ADDR);
return &audio_codec;
}
virtual Display* GetDisplay() override {
return display_;
}
virtual Backlight* GetBacklight() override {
static PwmBacklight backlight(DISPLAY_BACKLIGHT_PIN, DISPLAY_BACKLIGHT_OUTPUT_INVERT);
return &backlight;
}
virtual Camera* GetCamera() override {
return camera_;
}
};
DECLARE_BOARD(EspSparkBot);
View Git Blame Copy Permalink