- {units.map((group, index) => {
- const unit = base * group.radius;
- // 点位沿用 3D 模型的归一化布局,只把最外圈的发动机圆心固定在圆环内壁的 72% 处,
- // 这样不管一个舱里是 1 台还是 33 台,最外圈与圆环之间都恒定留出一圈空隙。
- const placements = engineLayout(group.engines, 1);
+
+ {cells.map(({ group, x, y }, index) => {
+ const unit = base * 2 * group.radius * BAY_GAP;
+ // engineLayout 的归一化坐标与喷管半径都以「舱半径 = 1」为单位,
+ // 圆环内壁正好就是一个舱半径,所以点位按内壁半径等比换算即可,
+ // 发动机再多也只会挤到圆环内壁上,不会画到舱外。
const inner = unit / 2 - 2;
- let outerPos = 0;
- let nearestPair = Infinity;
- placements.forEach((placement, position) => {
- outerPos = Math.max(outerPos, Math.hypot(placement.x, placement.z));
- placements.slice(position + 1).forEach((other) => {
- nearestPair = Math.min(nearestPair, Math.hypot(placement.x - other.x, placement.z - other.z));
- });
- });
- const scale = (inner * OUTER_RING_FILL) / Math.max(outerPos, 0.5);
- // 单台发动机的直径只跟所在舱室的直径同比(与 diameter_ratio 同一口径),
- // 不随机数增减;只有相邻点位挤不下时才缩小,避免圆圈叠在一起。
- const dot = Math.max(3, Math.min(unit * ENGINE_DOT_RATIO, nearestPair * scale * 0.88));
+ const placements = engineLayout(group.engines, 1);
return (
@@ -508,7 +511,7 @@ function EngineBank({
{
'--dx': placement.x,
'--dy': placement.z,
- '--dot': `${dot}px`,
+ '--dot': `${Math.max(3, placement.bellRadius * 2 * inner * DOT_GAP)}px`,
} as CSSProperties
}
/>
@@ -586,8 +589,19 @@ function RocketMission({ rockets }: { rockets: RocketConfig[] }) {
: '继续';
const clockText = state.phase === 'ready' && !state.isRunning ? 'T-00:00:00' : formatTime(state.time);
+ /*
+ * 左右两块面板:离地升空后自动收起,把画面让给箭体。
+ * 手动开合记成 override,没动过把手就完全交给「是否已升空」决定,
+ * 于是自动收起之后手动展开不会被再次收起,按重置回到发射台又会展开。
+ * 两块面板共用一个开关:窄屏下左侧面板整块隐藏,分开记状态可能出现
+ * 「收起之后没有把手能打开」。
+ */
+ const [panelsOverride, setPanelsOverride] = useState
(null);
+ const panelsOpen = panelsOverride ?? state.altitude <= 0;
+ const togglePanels = () => setPanelsOverride(!panelsOpen);
+
return (
-
+
+ {/* 收起后贴在屏幕边缘的把手:点一下展开,再点一下收起 */}
+
+
+
{/* Bottom: engine bank + mission clock + progress + attitude + controls */}
**坑:TCA9554 的 bit6(`SYS_EN`)绝不能拉低。** 它和板 1 的 XL9555 同址(0x20)但只有 8 位、
+> 寄存器编号也不同,照板 1 的初始化写法写进去就是整板断电——现象是"烧完没反应,像变砖"。
+> `SYS_EN` 是**电源锁**(PWR 键只是临时接通):上电第一件事就是把它拉高,见下面「电池与开机」。
+> 复位和背光分别走 bit5 / bit1。
+> V1 版板上没有 TCA9554,探测不到 0x20 时退回直连:RST=GPIO21、背光=GPIO8。
+
### 输入方式:只有按键,没有触摸
设计稿里的底部按钮不能点——**这块屏不带触摸层**。两条证据:
@@ -55,6 +77,213 @@
> `read_reg()` 里那句 `endTransmission(false)` + `requestFrom()` 就是修这个的。
> 空闲 `input=0xFFFD`:低字节 P0_0 是 ALS 光敏(悬空为低),所以按键只取高字节,避免幽灵按键。
+### 电池与开机(18650)
+
+`src/power.cpp`,只在 `BOARD_HAS_BATTERY=1`(板 3)编译。
+
+| 事 | 做法 |
+| --- | --- |
+| 电源锁 | `setup()` 第一件事(在 NVS / 屏 / 触摸之前)调 `pwr_hold_early()`:读回 TCA9554 的 OUTPUT/CONFIG,**先**把输出锁存 bit6 写 1、**再**把方向改成输出(反过来会瞬间把 SYS_EN 拉低 = 电池供电时直接关机),日志 `[pwr] SYS_EN=1` |
+| 电压 | `analogSetPinAttenuation(4, ADC_11db)` + `analogReadMilliVolts()`(core 自带曲线校准),8 次去最高最低取平均再 x3 |
+| 电量 | 单节锂电曲线中间平两头陡,只能按表插值:3300mV=0% 3680=20% 3750=40% 3930=70% 4100=92% 4200=100% |
+| 充电 | `Serial.isPlugged()`(= `usb_serial_jtag_is_connected()`)—— USB 在位就当在充 |
+| 显示 | 状态栏网络状态后面画一颗通行样子的电池(`ui.cpp` 的 `bat_label()`):外壳 + 右端铜帽,壳内**按电量比例**填一段,充电时在壳内叠一道白色闪电。颜色:充电绿 / ≤15% 红 / ≤30% 橙 / 其余青 / 没装电池只留灰壳。总宽 28,比原来那句 `CHG 97%` 还窄 |
+| 采样 | `loop()` 里 `bat_poll()` 每 2s 一次,显示值变了才置 `g_dirty` 重绘 |
+
+> **按 PWR 不亮是这台板子的常态坑,不是坏了。** PWR(GPIO16, 原理图 SYS_OUT) 只是把电源临时接通,
+> 松开就得靠固件拉高 `SYS_EN` 维持;老固件要等 `disp_init()` 才写这一位,中间隔着 `delay(400)`
+> + 挂载 NVS + 屏初始化,短按(<0.5s)必然掉电,现象就是"按了不亮"。现在锁电排在 `setup()`
+> 第一行(写完寄存器约 0.3s)。
+> 判断电池到底装没装,**不能靠 `batt` 的电压**:座子空着、只插 USB 时那颗充电 IC 的电池端会空载浮到
+> ~4.2V,屏幕照样给你 `CHG 97%`(见下面「没有电池也显示 CHG 97%」)。硬判据只有一个:**开机后直接拔 USB**,
+> 屏幕继续亮 = 电池通路和电源锁都成立;立刻黑 = 电池根本没接通。`batt` 打出来的
+> `SYS_EN=1 (held)` 只证明锁存寄存器写进去了,证明不了电池真在供电——判据始终是拔 USB。
+>
+> **长按 PWR 关机(已实现)**:`pwr_key_poll()` 每帧读 IO16(按下=低),**按住 ≥3 秒后松手**
+> 就把 `SYS_EN` 写 0,松手瞬间 Q2 关断、整板断电;官方例程同理,文案是「长按 PWR 按键,
+> 等待屏幕显示 OFF…松开按键即可」。两条前提写在 `power.cpp` 的注释里,都是必须的:
+> ① 开机那一次长按作废(必须先见到一次松手,否则每次开机都被自己关掉);
+> ② USB 插着时直接忽略并打印提示 —— VBUS 经 D1 还在供 VSYS,写 0 不会断电,
+> 只会变成"按了没反应"。所以这条只能拔了 USB 试;重新开机是纯硬件的,长按 PWR 即可。
+
+#### 先说清楚:电池在哪、哪根线是什么
+
+**这块板上电芯只有一个去处:压在板子中间的黑色 18650 座里。** 丝印 `BAT` 旁边那两个孔是
+**没有贴塑壳座**的 MX1.25-2P 焊盘(BOM 备注 `NC/插座 直针拔插式 MX1.25-2P` = 可选不贴),
+不能拿"BAT 座空着"当"电池没装"的依据。丝印 `SPK` 上那根红黑双绞线是**外壳盖子里小喇叭的喇叭线**
+(另一端接 NS4150 功放输出),和电源通路无关,别拔也别往别处插。
+
+#### 没有电池也显示 CHG 97%(这是硬件信息缺失,不是显示 bug)
+
+`batt` 读的是 BAT_ADC 分压后的 **VBAT 母线**,不是电芯本身;而 ETA6098C1 的 STAT 只接了
+指示灯 LED1(串 R10 27K),**没有任何电池在位/充满状态脚进 MCU**,TCA9554 八个脚也全占满了。
+所以取下电芯、只插 USB 时,充电 IC 的电池端空载浮到 ~4.2V,屏幕上就必然是 `CHG 97%`。
+
+电芯在不在,只能靠"装与不装的电压差"证明(同一块板实测):
+
+| 状态 | `batt` | 说明 |
+| --- | --- | --- |
+| 电芯压在座里 | 3750~3800mV | 电芯把母线钳住了 → 电芯确实接在 VBAT 网络上,充电/采样通路是好的 |
+| 取下电芯 | 4162mV | 空载浮压 |
+
+推论:**不要用 `batt` 的电压判断电池在不在**,也不要拿它当"电芯坏了"的依据。
+硬判据只有一个:开机后直接拔 USB,屏幕继续亮 = 电池通路 + 电源锁都成立。
+
+#### 真因(已修复):TCA9554 方向寄存器地址写错,`0x02` 应为 `0x03`
+
+**先认错**:这一节之前写的是"电源锁硬件断、`P6→R43→T1` 虚焊、建议走售后/飞线",那是错的,
+而且是我自己造的错。板子没问题,是我们固件的寄存器编号写错了。
+
+**真机验证通过**:烧录修复版之后长按 PWR 开机、拔掉 USB,屏幕保持常亮;排查期临时命令
+读回的 `in=0xE2`(bit1/5/6 读回 1)是"引脚真的在输出高"的旁证,不是自己刚写进去的那个字节。
+(`pwr` / `hold` / `holdio` / `sysout` 这几条排查命令已经删掉,结论只留这一节。)
+
+TCA9554 只有 4 个寄存器,方向不在 `0x02`:
+
+| 地址 | 寄存器 | 上电默认 |
+| --- | --- | --- |
+| `0x00` | Input Port(只读) | — |
+| `0x01` | Output Port(输出锁存) | `0xFF` |
+| `0x02` | **Polarity Inversion**(输入极性反转) | `0x00` |
+| `0x03` | **Configuration**(方向,1=输入) | `0xFF` |
+
+三处独立出处:TI 手册 Table 3(`ti.com/lit/ds/symlink/tca9554.pdf`);官方 V2 仓库
+`Arduino/examples/08_Audio_Test/src/codec_board/drv/tca9554.c` 的
+`TCA9554_CONFIGURATION_PORT 0x03`;`Arduino/examples/07_BATT_PWR_Test/src/tca9554/esp_io_expander_tca9554.c`
+的 `DIRECTION_REG_ADDR 0x03`。
+
+我们 `board_config.h` 写的是 `TCA_REG_CONFIG 0x02`。**来源很好解释**:另一块板上的 16 位扩展器
+XL9555(TCA9535 兼容)里 `0x02` 确实是 P0 方向,而这里 `TCA_REG_INPUT/OUTPUT` 又用的是 8 位
+TCA9554 的编号,两张表混抄就错位了一格。后果:
+
+- 方向寄存器**从头到尾没被写过** → 上电默认 `0xFF` → 八个 EXIO 全是高阻输入;
+- 写 `OUTPUT` 只改芯片内部锁存,引脚不驱动 → `SYS_EN` **从未真正拉高过** → 拔 USB / 松手必掉电;
+- 最阴的一点:排查命令读回的就是我们刚写进 `0x02` 的那个字节,`cfg=0x9D` 看着严丝合缝,
+ 是**自证式假证据**;把八个位全拉高同样无效,因为无效的原因根本不在位映射上。
+ 由此得出的"这颗片方向=输出时不更新 input register""P6 拉不高"两条推论一并作废。
+- 附带副作用:`0x9D` 被当成极性反转写进去了,bit1/5/6 的**输入读数**会取反(只影响读,不影响功能)。
+ 正常上电复位后是 `0x00`,不用额外清。
+
+**为什么"按住 PWR 能开机、能进系统"和这个 bug 完全不矛盾**:按键支路是把 Q2 gate 直接短到 GND 的
+纯硬件通路,和 `SYS_EN` 驱动的是同一个 gate。它能亮只证明功率级(电芯/Q2/R42/VSYS/3V3)是好的,
+一点也证明不了固件写对了寄存器 —— 我当时正是把这条当成了"固件已经生效"的证据。
+
+**为什么 EXIO1(EXIO5) 浮空时屏也正常**:背光使能和复位这两条网络板上本就有偏置,屏还另有驱动自带
+的复位兜底,所以"屏能用"从来没验证过扩展器真的在输出。修好方向之后我们走的正是官方
+`lvgl_port.c` 那套:`example_lcd_exio_init()` 把 `BL_EN|LCD_RST` 设输出、`BL_EN`=1 点亮,
+`example_lcd_reset()` 高 30ms → 低 250ms → 高 30ms(我们 `panel_power_on()` 同序)。
+
+> 如果修好方向之后仍然"拔 USB 就黑",再动硬件:运行时量 TCA9554 第 11 脚(P6)≈3.3V、
+> R43 右端(T1 base)≈0.7V、Q2 gate≈0.6V。P6=3.3V 而 base≈0V = `R43/T1` 那侧断;
+> P6 本身 0V 而寄存器确实是输出+高 = 片子侧问题。这三个读数是售后判据,0402+SOT-23 不建议自己补焊。
+
+#### 网传"SYS_EN=GPIO48(V2)/GPIO47(V1) 硬锁"是假的:官方引脚表直接否掉
+
+官方手册 V1、V2 两张接口表(`docs.waveshare.net/ESP32-S3-Touch-LCD-3.49` 的「接口介绍」)里:
+
+| 脚 | 官方标注 |
+| --- | --- |
+| `IO47` | `IMU SDA` / `RTC SDA` / `Audio SDA` |
+| `IO48` | `IMU SCL` / `RTC SCL` / `Audio SCL` |
+| `IO16` | `SYS OUT` |
+| `IO4` | `BAT ADC` |
+| `EXIO6` | **`SYS EN`**(TCA9554 一列,全表只出现这一次) |
+
+47/48 在 **V1、V2 两版上都明确是 I2C**(我们固件也把它们当 SDA/SCL 用,四颗从机全部正常应答),
+根本不可能同时是电源锁;"V1=47、V2=48"是编的,官方 V1↔V2 差异清单只有四条(新增 `TP_INT`、
+锂电充电电流、`LCD_TE`↔`LCD_RESET` 互换、`LCD_BL`↔`EXIO_INT` 互换),与 47/48 无关。
+照抄那段代码只会把 I2C 时钟脚按住,锁不到电。
+
+官方 `07_BATT_PWR_Test` 的说明原文也印证机制只有一套:`tca9554_init()`「初始化锂电池控制 IO 端口」
+(`set_dir(SYS_EN, OUTPUT)` + `set_level(SYS_EN, 1)`)、「断开 USB 供电,接入锂电池,通过长按 PWR
+按键进行开机」「等待屏幕显示 ON…松开按键即可」—— 和我们的做法一致,和 GPIO 硬锁无关。
+
+> ⚠️ 顺带留档:`SYS_OUT`(GPIO16) **不是**第二条保持路,只是感知脚。它的网络是
+> `3V3 → R9 10K → IO16 → D3 → Key1 节点`,IO16 输出低只会让 D3 反偏、灌不进电流,锁不住;
+> 反过来 latch 断开时该节点被拉到 ~3.5V 使 D3 反偏、IO16 读到高,按下 PWR 才把 IO16 拖低 ——
+> 所以官方例程里 `gpio_get_level(16)==0` 表示"按键按下"。实测把 GPIO16 拉低也断不开电源,
+> 与这个网络分析一致。
+
+
+### 输入方式(长条屏):全触摸,没有按钮区
+
+172 高只有 22mm,底部按键条要吃掉半行内容,右缘抽屉也要来回开合,都别扭。所以长条屏
+**不画任何按键条**(`KEY_H 0`),内容区 `CONT_W` 就是整幅 640,页面级动作只留状态栏右上角
+**1~2 颗上下文按钮**(`header_actions()` / `header_buttons()`):需要什么就出现什么,
+不需要时那一行只有标题。
+
+| 页面 | 右起第一颗 | 第二颗 |
+| --- | --- | --- |
+| 模式页 | ⚙ `SETUP` | |
+| 天体列表 / 火箭列表 | ‹ `BACK` | |
+| 天体详情 / 火箭详情 | ‹ `BACK`(画在页头那一行) | |
+| 连接中 | ≡ `CONFIG` | |
+| 配网页 | ‹ `BACK` | |
+| 设置页 | ‹ `BACK` | ≡ `CONFIG` |
+| 配对页 | ◎ `CODE` | ≡ `CONFIG` |
+| 故障页 | ◎ `RETRY` | ≡ `CONFIG` |
+| 升级页 | ‹ `BACK`(下载中整行不画) | ⤓ `INSTALL` / ◎ `RETRY` |
+
+齿轮 ⚙ `SETUP` 进的是只读的设置页;滑杆 ≡ `CONFIG` 直接进配网门户(改 WiFi、改后端地址都在那里)。
+同一页上两颗按钮不会撞事。
+
+- 每颗按钮点下去就是 `on_key_press` 早就认识的那颗实体键(右起第一颗 = `KEY3`,第二颗 = `KEY2`),
+ 业务逻辑一行没为触摸改写。
+- **图标 + 英文**:`ui_glyph()` 用线稿画 14x14 的图标(返回箭头 / 齿轮 / 滑杆 / 环形箭头 / 下载),
+ 右边跟一个英文词。图标负责一眼认事,英文负责说清是哪件事——中文一个词 2~3 字要 34~51px,
+ 英文 4~7 个字母只要 36~63px,两颗按钮加标题才不会把 640 宽挤满。
+- 按钮宽 = `HDR_PAD`x2 + 图标 14 + `HDR_IV`(4) + 英文字宽,视觉 `HDR_BTN_H` 24px 高(文字上下各留 3px)、
+ 热区 `HDR_HIT_H` 31px
+ (整条 header 0..30 都算命中,这屏 1px≈0.13mm,只按字面那 24px≈3mm 太难点)。
+ 状态栏右端的用户名
+ 等文字用 `s_info_r` 按按钮总宽往左让位。
+- **详情页只有一层 header**:天体 / 火箭详情不再画状态栏,0..19 那一行直接是页头(标题 + 历元 /
+ `NEXT 日期`),内容区从 `TOP_Y` 起,省下的 16px 给图标格和信息栏,右栏事件行距也摊开。
+- **点内容**:列表卡、火箭卡、模式卡都注册了 `HIT()`,点哪张就选哪张,模式页点卡片直接进对应终端。
+- **详情页分页标签**也直接可点(`UI_ACT_TAB` + 页号)。
+- **滑动**翻页:上下滑 = `UP`/`DN`(列表滚动),左右滑 = 第四键(刷新 / 右栏翻页 / 回模式页)。
+- **列表页右缘的上下键**(`nav_rail()`):垂直居中两颗图标按钮,等价 `KEY0`/`KEY1`,和上下滑是同一
+ 件事——滑这块屏容易误判成卡片点击,列表页给两颗实心的更跟手。它们占的 `RAIL_W`(30) 会从
+ `CARD_W` 里扣掉,卡片不会压在按钮下面;只在天体 / 火箭列表页出现,详情页不加。
+ **列表空着或者总数不超过一页(`cnt > LIST_ROWS` 不成立)时整组禁用**:按钮照画但边框降到
+ `C_TRACE`、箭头降到 `C_CYAN_DIM`,并且不登记热区——点了没反应的东西不能还长得像能点。
+- **BOOT(GPIO0)** 等同「确认」,触摸没校准时用它兜底退出。
+- `UI_ACT_TAB` 是热区里的页面内动作,由 `tp_gesture_run()` 自己消化,不进 `on_key_press`。
+- 命中区上限 `UI_MAX_HITS 16`(两颗按钮 + 一屏卡片 + 分页标签,远够用)。
+- 版面常量在 `src/ui.cpp` 顶部(`STRIP` / `HDR_TY` / `HDR_LINE` / `TOP_Y` / `CONT_W` / `RAIL_W` / `CARD_W`),按钮那组在
+ `header_actions()` 附近(`GLYPH_SZ` / `HDR_PAD` / `HDR_IV` / `HDR_GAP` / `HDR_BTN_H` / `HDR_HIT_H`)。
+
+#### 触摸状态机:宁可丢一下,不能点错
+
+先量清楚假信号有多大,再定规矩。`touch on` 期间每次采样都进统计(`src/touch.cpp` 的
+`touch_stats_*`),每秒打一行 `[tp] poll=N true=N len1=.. len2=.. len3=.. len4+=.. max=N@(x,y) span=N`:
+
+| 场景 | 采样 | 有手指的帧 |
+| --- | --- | --- |
+| 空闲 40s | 3280 | **0** |
+| 开机 + 3 次 `reload`(HTTP 阻塞 + 整屏重绘) | ~4500 | **0** |
+
+结论:**AXS15231B 在没人碰的时候不冒假帧**,"误点"不是控制器的问题,全部出在代码怎么
+解读坐标上。所以 `touch_tick()` 定三条(`TP_*` 一组常量):
+
+| 规矩 | 常量 | 治的是 |
+| --- | --- | --- |
+| 按下要连续 2 帧才成立,落点只取**确认帧的均值**,抬手那一帧的坐标一律不用 | `TP_CONFIRM 2` / `TP_RELEASE 2` | 指尖抬起瞬间会漂几十像素,拿末帧查热区就点到隔壁卡 |
+| 滑动要连续 2 帧都压在 `TP_SWIPE_PX`(48) 之外才算,方向在确认那一刻**锁死** | `TP_SWIPE_HOLD 2` | 首末两帧之差判滑动 = 一帧坐标毛刺就自己翻一页(列表页"不稳"的真相) |
+| 一次接触超过 3s 当作卡住的假信号丢掉 | `TP_CONTACT_MS 3000` | 手指压着不动 + 网络正忙时,别让手势一直举着 |
+
+排查手法:`touch on` 之后按 `[tp] (x,y) key=0xNNNN idx=N` 对号,误点时先确认派发的坐标
+是不是手指那一处;`tap ` 用同一套结算路径注入一次点按,可以脱离手指验热区。
+若还要调手感,动 `TP_CONFIRM`(加到 3 更稳但更钝),**别动 `TP_POLL_MS`**(12ms 对应
+~82 次/秒的实测采样率,再慢就会漏快点)。
+
+> **触摸坐标→画布的映射必须和 `disp_flush()` 的软件转置严格互逆**
+> (`panel_x ← 逻辑 y`、`panel_y ← 逻辑 x`,两轴各自可镜像)。出厂映射为 `TP_SWAP_XY=1`、
+> `TP_INVERT_X=0`、`TP_INVERT_Y=1`,等价于官方 LVGL 例程里的 `point.x = rawY`、`point.y = 640 - rawX`,
+> 已在真机上用手指加串口 `tap` 逐页对过热区。若换了面板方向或出现「点左边却出在右边」,先
+> `touch on` 点四角读回报,再调 `src/touch.h` 里这三项。`dump` / `screen_shot.py` 抓的是转置
+> **之前**的逻辑帧缓冲,能验证版面但验证不了转置方向;正放 / 倒放由加速度计自动判(`flip auto`)。
+
## 构建 / 烧录
```sh
@@ -65,7 +294,19 @@ FQBN='esp32:esp32:esp32s3:PSRAM=opi,FlashSize=16M,FlashMode=dio,CDCOnBoot=defaul
~/esp-tools/arduino-cli --config-file ~/esp-tools/arduino-cli.yaml upload --fqbn "$FQBN" --port /dev/cu.usbserial-210 terminal/firmware/cosmo_terminal
```
-- `PSRAM=opi` 必须开:帧缓冲(320x240x2 = 150KB)放在 PSRAM。
+长条屏(板 3)同一份源码多一个宏,先 `--output-dir` 再 `--input-dir` 烧,只重刷变化的扇区:
+
+```sh
+FQBN='esp32:esp32:esp32s3:PSRAM=opi,FlashSize=16M,FlashMode=dio,USBMode=hwcdc,CDCOnBoot=cdc,PartitionScheme=app3M_fat9M_16MB,UploadSpeed=460800'
+~/esp-tools/arduino-cli --config-file ~/esp-tools/arduino-cli.yaml compile --fqbn "$FQBN" \
+ --build-property "compiler.cpp.extra_flags=-DCOSMO_BOARD=3" \
+ --output-dir /tmp/cosmo_fw3 terminal/firmware/cosmo_terminal
+~/esp-tools/arduino-cli --config-file ~/esp-tools/arduino-cli.yaml upload --fqbn "$FQBN" \
+ --port /dev/cu.usbmodem2101 --input-dir /tmp/cosmo_fw3 terminal/firmware/cosmo_terminal
+```
+
+- `PSRAM=opi` 必须开:帧缓冲放在 PSRAM(板 1 是 320x240x2 = 150KB,板 3 长条屏 640x172x2 = 220KB,两块都放不下内部 RAM)。
+- `COSMO_BOARD` 只切硬件抽象,版面用 `STRIP`(`LCD_HEIGHT < 200` 自动为 1)自己适配,板 1/板 2 的版面常量不受板 3 影响。板 3 当前 `Sketch uses 1524395 bytes (48%)`。
- **USB 口选哪个决定串口在哪**:`USBMode=hwcdc,CDCOnBoot=cdc` = `Serial` 走 S3 原生 USB(USB-Serial/JTAG,`/dev/cu.usbmodem2101`),
一根线同时能烧录和看日志/敲命令;换成 `CDCOnBoot=default`(=Disabled)则 `Serial` 落回 UART0/CH340,
要用 `/dev/cu.usbserial-210`。两种 FQBN 都能烧录(USB-Serial/JTAG 自带下载模式),但只有前一种能在原生口拿到日志——
@@ -136,10 +377,19 @@ FQBN='esp32:esp32:esp32s3:PSRAM=opi,FlashSize=16M,FlashMode=dio,CDCOnBoot=defaul
`clear` 把选择忘掉;`reset` 会连它一起清,只想重启用 `reboot`。
- **设置页 `SC_SETTINGS`(模式页 KEY3)**:两块切角面板,只读地把"网"和"后端"摊开——
WiFi 在线/离线 + SSID + RSSI + 局域网 IP + 热点名,以及后端 URL + 绑定用户(`BOUND`/`NOT BOUND`)
- + 设备号 + 当前模式。要**改**东西按 `KEY2 SETUP` 进配网门户(那里能同时改 WiFi 和后端地址),
- `KEY3 BACK` 回模式页。这两页都不发数据请求,所以不会被 5 分钟轮询踢走(`loop()` 只给
- LIST/DETAIL/ROCKETS/ROCKET 调 `run_tick`),但每 60s 会被 `auth_check()` 拿一次
- `GET /api/terminal/follows` 校验令牌,见「绑定与取数」。串口 `settings` 直接跳这页。
+ + 设备号 + 当前模式 + 日期时间(`TIME`,见下条)。要**改**东西按 `KEY2 SETUP` 进配网门户
+ (那里能同时改 WiFi 和后端地址),`KEY3 BACK` 回模式页。这两页都不发数据请求,所以不会被
+ 5 分钟轮询踢走(`loop()` 只给 LIST/DETAIL/ROCKETS/ROCKET 调 `run_tick`),但每 60s 会被
+ `auth_check()` 拿一次 `GET /api/terminal/follows` 校验令牌,见「绑定与取数」。
+ 串口 `settings` 直接跳这页。
+- **时钟只有一个来源:后端**(`src/clock.{h,cpp}`)。板子没有 RTC 电池,断电商 `millis()` 就归零,
+ 所以每次 `follows` / `rockets` 回来都用响应里的 `server_time`(后端 `datetime.utcnow()`,UTC)
+ 校准一次,两次校准之间按 `millis()` 走时;断网就照着手上的时间继续走,等下一轮刷新纠偏。
+ 屏上显示的是 UTC + `CLOCK_TZ_MIN`(默认 `+08:00`:后端和库里都没有用户时区,换地区改这一个常数),
+ 没同步过之前显示 `--`。**只有设置页按秒重绘**(`loop()` 里 `SC_SETTINGS` 那一支),
+ 别处不会为了一颗时钟白刷整屏。日历换算是自己写的整数运算,不用 `timegm`
+ (Arduino 的编译选项下 newlib 没暴露它的声明)也不用 `mktime`/`gmtime`(要吃本机 `TZ`),
+ 好处是这套换算能直接在 PC 上 `cc` 出来对着 Python 逐日校。
- **火箭立绘 = 后端按登记的火箭参数现画**(`backend/app/services/rocket_art.py`),和 3D
模拟页共用 `stageGeometry` 那套几何:整流罩/级间段/助推器/栅格翼的尺寸全部来自平台里
登记的型号参数。参数哈希 `art_ver` 随列表下发,**版本没变就一个字节都不重新下载**,
@@ -178,8 +428,9 @@ FQBN='esp32:esp32:esp32s3:PSRAM=opi,FlashSize=16M,FlashMode=dio,CDCOnBoot=defaul
源图照旧要求**纯黑底**(没有 alpha,灰底会把整块面板糊白)。Pillow 本来就在
`requirements.txt`(10.1.0),没新增依赖。
- **版本门控**:`/api/terminal/follows` 每个天体多返回一个 `icon_ver`(= 图标资源行的 id,
- 也是图标端点的 `ETag`)。固件只在 `icon_ver` 变化时下载,稳态零流量;实测一个天体
- 拉 40+64 两张 ~130ms。
+ 也是图标端点的 `ETag`)。固件只在 `icon_ver` 变化时下载,稳态零流量。
+ **一次 HTTPS 往返 ≈0.9~1.7s**(大头是 TLS 握手,真机 RSSI -76~-82),比当年在局域网里
+ 测的 ~130ms 慢一个数量级,所以图片一律**不挡页面**:见下面「补图与忙碌反馈」。
- **换图是覆盖语义**:同一个天体同一种资源类型只保留一行,重复上传时后端删掉旧行
并删掉旧文件(`app/api/celestial_resource.py`)。终端只在 `icon_ver` 变化时重下,
管理端预览/删除的 `items[0]` 和后端取的那一行从此指向同一张图。
@@ -187,7 +438,7 @@ FQBN='esp32:esp32:esp32s3:PSRAM=opi,FlashSize=16M,FlashMode=dio,CDCOnBoot=defaul
- **固件缓存** `src/iconstore.{h,cpp}`:一个关注天体一个槽(上限 `MAX_BODIES=6`),
点阵 `heap_caps_malloc(MALLOC_CAP_SPIRAM|MALLOC_CAP_8BIT)` 惰性分配,每槽
3200+8192=11392B,最坏 6 槽约 68KB PSRAM;取消关注的槽在下次 sync 时释放(缓冲区留着复用)。
- `stat` 会给每个槽打一行 `icon : 599 v45 cached`。
+ `stat` 会给每个槽打一行 `icon : 599 v45 40 64`(列出这个尺寸已经缓存了哪两张)。
- **字节序**:点阵按**大端**下发(和串口 `dump` 同一个约定),`api_icon()` 收完逐像素
`__builtin_bswap16()` 转回本机序——`disp_add_bitmap()` 吃的是普通 `uint16_t` RGB565 值。
忘了转会整屏颜色字节互换,`fb_check.py --raw` 实测最大逐像素误差 ~58000。
@@ -207,6 +458,73 @@ curl --noproxy '*' -H "Authorization: Bearer $TOK" -o /tmp/ic_599_40.bin \
图标底下压着面板底色和雷达刻度,所以 `--raw` 是「在每个候选底色里取误差最小的再取 max」,
命中就是 0;拿土星图去核对木星详情位会得到 ~57000,说明这把尺子有效。
+### 补图与忙碌反馈(触屏设备的响应速度)
+
+HTTP 请求是同步阻塞的,`loop()` 停在里面时 `touch_poll()` 一次都跑不到——**手指抬起时那一次
+手势直接丢掉**,这就是"点了没反应"。下面这几层一起治(`cosmo_terminal.ino` + `src/api.cpp`):
+
+- **页面先出来**:`load_rockets()` 拿到 JSON 就翻到列表,不等图;缺图只登记一个
+ `s_art_wait` 标记。详情页同理,先用内置线稿开画,64x64 补上再换掉。
+- **没有加载页**:以前首次取数要整屏切到 `SC_LOADING`(SYNCING DATA 那个窗),请求
+ 一回来又整屏换回列表,两次全屏刷新加一次"内容凭空闪一下"。现在 `load_data()` /
+ `load_rockets()` 只在**手里还没数据**时把对应的(空)列表页摆出来,取数过程全部交给
+ header 那条线表达;已经有数据时原地刷,不把人正在看的详情页踢回列表。空列表页在
+ `st.busy` 期间直接留白(`draw_list()` / `draw_rockets()` 开头 `if (st.busy) return;`),
+ 否则首次进终端会先闪一屏 `NO ACTIVE ROCKETS`,看着像后端出问题。
+- **一轮只补一张**:`art_pump()` 挂在 `run_tick()` 后面,每次 `loop()` 最多下载一张,
+ 补完一张就 `g_dirty` 重绘——两张之间有整轮 loop 处理触摸,页面点得动。
+ 详情页欠的那张优先(`s_art_code`),用户正盯着它。`*_store_sync(..., max_fetch)`
+ 的返回值是"还缺几张",`<0` 表示刚失败,别再追着重试。
+- **连接复用**(`api.cpp` 的 `Session` / `http_open`):`WiFiClientSecure` 和 `HTTPClient`
+ 合成一个常驻 `s_sess`,`setReuse(true)`,同一 host 的请求都走这条 TLS。一张 40x40
+ 立绘从 0.8~1.7s(每次重新握手)掉到 30~270ms。代价是这条 TLS 连接连同 mbedTLS
+ 的收发缓冲一直占着内部堆,所以空闲满 `API_IDLE_CLOSE_MS`(5s)由 `loop()` 调
+ `api_close()` 把它释放掉,下次请求再握手约 800ms。`Session` 里 **tls 必须声明在
+ http 前面**——成员按声明逆序析构,
+ `~HTTPClient()` 会无条件 `_client->stop()`,反了就是释放后用悬垂指针。
+- **手势排队**(`touch_tick()`):抬手时如果 `api_in_request()` 为真,就把这一次手势
+ 存进一格缓存(`TpGesture`,记着落点和当时那一页),等网络空下来第一时间的采样补发。
+ 补发前要复核「没过期(`TP_QUEUE_TTL_MS=1200`) + 页面没换 +(点按的话)落点那块热区
+ 还在原位且还是同一格」,对不上就整下丢掉——丢一下只是这一下没反应,补错一下是用户
+ 没想点的跳转。判据用 `api_in_request()` 而不是 `NetBusy` 的深度:配对轮询那条路径没标
+ 忙碌态,按深度判断会在 HTTP 里再发起一次 HTTP。
+- **请求期间也采样**:`api_set_wait_cb(ui_pulse)` 每 **25ms** 回调一次(早先是 150ms,
+ 一次轻点只压几十 ms,整下从两次回调之间漏掉 = 「点了没反应」),`ui_pulse()` 里
+ `touch_pump()` 每 25ms 采一次触摸、整屏重绘仍按 `PULSE_DRAW_MS` **150ms** 走
+ (一帧 QSPI 要 30~80ms,刷太勤会把下载挤死)。排队/派发的推进因此不依赖回到 `loop()`。
+- **触摸一律不画按下态**:以前按下要描一圈热区框、点亮那颗键,抬手再清。真机上这套
+ 东西有两个毛病——① 那圈框看起来就是"选中区多了个外框";② 它只在回到 `loop()` 时才
+ 过期,请求一卡就是 1~2s 不熄,人以为没点着会再补一下,**误触就是这么来的**。现在
+ `key_flash` 只由物理按键那条路点(`key_flash_on()`,给 320x240 那两块无触摸的板子做
+ 键位图例反馈),触摸全程不置。点着的反馈是页面自己变(切页 / 换卡 / 换标签),
+ 慢的那部分由下面那条忙碌指示(header 那条线)表示。
+- **忙碌指示 = header 那条线自己在流动**:`UiState.busy` 为真时,`ui_draw()` 在
+ `HDR_LINE` 上跑一颗 88x2 的青色彗星(`C_CYAN` 身 72px + `C_WHITE` 头 16px)。跑马区间固定
+ 是 header 线**正中**那 160px(`x0=(CONT_W-160)/2`,640 宽就是 240~400),跟页面无关,各页
+ 看到的位置一致,也不会撞上状态栏左边的电量格(约到 x=217)和右边的用户名(约从 x=485 起);
+ 彗星从区间左沿外整段进、右沿外整段出,周期约 2.0s。刻意**只比那条线本身粗 1px**(`HDR_LINE`+1 仍 < `TOP_Y`,压不到内容区),读起来
+ 是分隔线在流,不是线上盖了根进度条;配色也换回青色——金色已经被 header 按钮和列表
+ 选中卡占用,再拿来做忙碌指示就分不清"哪个能点"。相位取 `millis()`,不数重绘次数
+ (节拍一抖动画就一顿一顿)。重绘节拍两处喂:请求阻塞期由 `ui_pulse` 按
+ `PULSE_DRAW_MS` 150ms 走,回到 `loop()` 之后由那个 `busy ? 120 : 250` 的动画节拍接手
+ ——请求已经下来、只剩补图的那段没人喂 `ui_pulse`,不补这一拍线就停住不动了。
+ 补图期间 `net_begin()` 不再重画整屏(`was` 判据),省掉每帧一次全屏刷新。
+
+真机实测(公网后端 `cosmo.unisspace.com`,RSSI ≈ -78):
+
+| 场景 | 改前 | 改后 |
+| --- | --- | --- |
+| 单张 40x40 立绘 | 834~1698ms | **30~268ms**(多数 95~125ms)|
+| 详情页 64x64 立绘 | ~1.3s | **143ms** |
+| 冷缓存进火箭列表页(JSON + 9 张图全齐)| ~11s | **2.07s** |
+| 补图期间的按键响应 | 最长 1.6s | **中位 57ms** |
+| 冷握手后的第一个请求 | — | ~800ms(TLS 握手)|
+
+仍然治不了的:**单次 TLS 握手 / 弱网重连**(0.8~4s,实测偶见一张图 4.2s)这期间
+`loop()` 整个停在里面,屏幕完全冻结,只能靠 header 那条在动的线告诉用户"在等"。要彻底不冻,
+要么把 HTTP 挪进独立的 FreeRTOS 任务(得处理共享状态和显示锁),要么后端出一个
+批量立绘接口——两条都比现在这套大得多,动之前先确认。
+
## 配网
NVS 里没有 SSID,**或者存着的 WiFi 连着连不上**,终端都会自己开热点 `COSMO-SETUP-XXXX`:
@@ -402,6 +720,14 @@ $EDITOR terminal/firmware/cosmo_terminal/src/version.h
脚本只认 `version.h`,板型默认 `atk-dnesp32s3`,其余看 `--help`
(`--server` 默认 `http://127.0.0.1:8000/api`;`--skip-build --file x.bin` 传现成镜像)。
+`--board` 的三块板和 `BOARDS` 里的编译期开关一一对应,长条屏那块是
+`--board waveshare-3p49`(`-DCOSMO_BOARD=3`)。两个坑记在这儿:
+① FQBN 按板型走 `FQBN_OVERRIDES`——3.49 那块只有 ESP32-S3 原生 USB 一个口,必须
+`USBMode=hwcdc,CDCOnBoot=cdc`,用默认那条(`CDCOnBoot=default`)OTA 完 `/dev/cu.usbmodem*`
+就没了;② 板型开关只能加在 `compiler.cpp.extra_flags` 上,**不能**用 `build.extra_flags`:
+`--build-property` 是整体覆盖,而 esp32 core 的 platform.txt 把 `-DARDUINO_USB_MODE` /
+`-DARDUINO_USB_CDC_ON_BOOT` 塞在 `build.extra_flags` 里,覆盖掉之后原生 USB 那几块的
+`Serial` 会退回 UART0(`Serial.isPlugged()` 直接编译不过),FQBN 里的 `CDCOnBoot` 也一起失效。
上传走 `POST /api/admin/firmware`(multipart),后端流式落盘到 `backend/upload/firmware/`,
当场算 sha256、校验镜像首字节是 `0xE9`。不想跑脚本就在管理后台「平台管理 → 固件管理」
(`/admin/firmware`,仅管理员)上传现成的 `.bin`、停用或删除镜像;两条路都是同一个接口,
@@ -413,7 +739,7 @@ $EDITOR terminal/firmware/cosmo_terminal/src/version.h
| --- | --- |
| **先改 `version.h` 再编译发布** | 终端只比版本号,同版本永远「已是最新」;后端也按 (board, version) 唯一约束拒收 |
| **镜像文件名不许覆盖**(`firmware/-.bin` 天然带版本) | nginx 对 `/upload/` 设了 `expires 1y`,同名覆盖之后已经拿过旧包的终端永远拿不到新内容 |
-| **`--board` 必须等于终端的 `BOARD_NAME`** | 后端按上报的板型发包,不匹配直接 409,终端停在原版本。现在只出货 `atk-dnesp32s3` |
+| **`--board` 必须等于终端的 `BOARD_NAME`** | 后端按上报的板型发包,不匹配直接 409,终端停在原版本。出货板 `atk-dnesp32s3`,样机 `xingzhi-cube-1.54tft` / `waveshare-3p49` |
| **第一版仍然得用串口烧** | OTA 代码本身也在固件里,早于 1.2.0 的镜像没这段,只能用 `arduino-cli upload` 打进去 |
下载地址 = `api_base` 剥掉尾巴上的 `/api` 再拼 `/upload/`(`ota_asset_url()` 只干这一件事):
@@ -461,7 +787,8 @@ OTA 之后启动指针在 `0x310000`,而 `arduino-cli upload` 默认只烧 `0x
`help` / `wifi [pass]` / `cfg` / `api ` / `pair` / `reload` / `mode [bodies|rockets|clear]` /
`rockets` / `portal [lan]` / `scan` / `stat` / `keys` / `xlreg` / `key 0xNN` / `i2cscan` /
`selftest` / `dump` / `swap 0|1` / `bgr 0|1` / `inv 0|1` / `mir 0|1` /
-`ota` / `update [now]` / `reboot` / `reset`
+`rot [0..3]` / `imu` / `flip [0|1|auto]` / `touch [on|off]` 与 `tap `(仅触摸板) /
+`batt`(仅带电池的板) / `ota` / `update [now]` / `reboot` / `reset`
`reload` 刷的是**当前模式**那份数据;`rockets` 打印内存里的火箭快照(code/参数/art_ver/待发射数),
`stat` 末尾会把 `rocket_store_dump()` 的缓存表一起打出来(哪个型号缓存了 40 还是 40+64)。
@@ -484,6 +811,16 @@ OTA 之后启动指针在 `0x310000`,而 `arduino-cli upload` 默认只烧 `0x
点屏调色:颜色整体反了用 `inv`,红蓝互换用 `bgr`,明暗/花屏用 `swap`,左右反了用 `mir`。
`selftest` 画四条色带自检,任意按键或命令退出。
+长条屏装反了两条命令对着修,都存 NVS(`rot` 键),重启还在:
+
+```sh
+# 画面镜像 / 上下颠倒 -> 试 rot 1 2 3(改的是 disp_flush 的转置方向,UI 不用动)
+# 点的位置和反应对不上 -> touch on 逐点读 [tp] raw=... -> px=...,照回报改 touch.cpp 的开关
+~/esp-tools/pio_env/bin/python terminal/tools/serial_term.py
+```
+
+`stat` 里 `panel : 640x172 rot=0` 是长条屏的当前朝向;`touch on` 期间画面暂停刷新,`touch off` 恢复。
+
```sh
# 一个终端:既能敲串口命令,又会在 dump 后自动出图
~/esp-tools/pio_env/bin/python terminal/tools/serial_term.py # -> /tmp/fb.raw
@@ -496,7 +833,8 @@ ffmpeg -f rawvideo -pixel_format rgb565be -video_size 320x240 -i /tmp/fb.raw \
抓屏脚本把「发命令 + 等画面 + dump + 出图」串成一行,状态机保证 `[FB]` 标记不被日志冲掉:
```sh
-~/esp-tools/pio_env/bin/python terminal/tools/screen_shot.py /tmp/log \
+# 板 3 记得给尺寸,否则按 320x240 解析出来的图是花的
+COSMO_FB=640x172 ~/esp-tools/pio_env/bin/python terminal/tools/screen_shot.py /tmp/log \
"|2|-" # 先发空命令, drain 启动日志
"key 0x2000|0.8|-" # KEY2 确认 -> 进详情页
"dump|0.2|/tmp/fb_detail" # 抓详情页 -> /tmp/fb_detail.png
@@ -515,18 +853,27 @@ ffmpeg -f rawvideo -pixel_format rgb565be -video_size 320x240 -i /tmp/fb.raw \
它直接读 `src/icons.cpp` / `src/font_cjk.cpp` 的点阵反推期望像素,所以「中文画成了空心方框」
「图标走错兜底」这类问题会直接报出来;选中卡前景是 `C_WHITE`、未选中是 `C_TEXT`,别填错。
-每帧约 14s;要抓按键反色,就在发键后 250ms 内 dump。
+每帧约 14s(板 3 走 S3 原生 USB-CDC,220KB 只要 ~2s);要抓按键反色,就在发键后 250ms 内 dump。
**两个坑**:① 每个 `dump` 必须单独占一步(`"key 0x2000|1.5|-"` 之后另起一步 `"dump|1.5|/tmp/x"`),
写在同一步里抓到的是按键前的画面;② `[FB]` 标记后面的残留字节必须丢掉再写文件,
留着会让整幅图右移 2px 且末行丢 2px(脚本里 `d=bytes(buf); buf=bytearray()` 就是干这个的)。
## 已知限制
-- **没有触摸**:设计稿里所有「点击」交互都改成按键,见上面「输入方式」。
+- **板 1 没有触摸**:设计稿里所有「点击」交互都改成按键,见上面「输入方式」。
+- **长条屏的软件转置方向只能靠眼睛确认**:`dump` 读的是转置前的逻辑帧缓冲,画面镜像 / 倒置
+ 要配合 `rot` 与 `flip` 看实物。触摸映射本身已按真机校好(`TP_SWAP_XY=1`、`TP_INVERT_Y=1`)。
+- **长条屏详情页右栏只有 249px**(图标格 148 + 信息列 224 之外剩下的全部):三个标签
+ `LAUNCH n` / `STAGE` / `INFO` 靠 6px 栏距才排得下,发射任务名和日期之间只留 8px 栏距。
+ 信息栏一格 112px,装不下带空格的单位,所以是 `22700kN`、`2000KM` 这种连着写的写法。
+ 中文简介 `desc` 在长条屏是 4 行 30 字(板 1 是 2 行 23 字)。
- **中文只有 16x16 点阵**,覆盖 GB2312 一级字 + 常用标点;生僻字/二级字会画成 `□`,
同行英文不受影响。事件标题里的中文现在能显示,但仍然只截到 `ev[28]`(约 9 个汉字)。
- 后端只在**首次绑定**时下发 token。NVS 被清空但数据库仍是绑定状态时,屏幕会提示先在网页端解绑再重新要码。
-- HTTP 请求是阻塞的,拉数据时按键响应会停顿 1 秒左右;图标版本变化那一次会多两次下载(~130ms/天体)。
+- HTTP 请求是阻塞的,卡住的那段时间 `loop()` 收不到触摸。现在靠四件事兜:**页面先画**
+ (JSON 一到就显示,不等图)、**一次只补一张图**、**连接复用 + 手势排队**(抬手时网络还忙
+ 就等空下来补发,见「补图与忙碌反馈」)、**按下立刻有反馈 + header 忙碌线**。
+ 剩下唯一还会整屏冻住的是**单次 TLS 握手 / 弱网重连**(0.8~4s),期间只有 header 那条线在动。
- 动态图标要在后台维护过才有,没维护的天体用的是内置那 ~20 张线稿,水星/天王星/冥王星这类只能吃兜底图。
- 事件列表按后端返回顺序显示,包含已过期的(`is_upcoming=false` 也在列)。
- 火箭详情页右栏只有两行高度,中文简介 `desc` 截到 23 字(第二行末尾留一个字位给 `..`),
diff --git a/terminal/firmware/cosmo_terminal/cosmo_terminal.ino b/terminal/firmware/cosmo_terminal/cosmo_terminal.ino
index e8abc5c..6085f78 100644
--- a/terminal/firmware/cosmo_terminal/cosmo_terminal.ino
+++ b/terminal/firmware/cosmo_terminal/cosmo_terminal.ino
@@ -1,5 +1,5 @@
/**
- * COSMO 轨道终端(ESP32-S3 + 2.4寸横屏 320x240)
+ * COSMO 轨道终端(ESP32-S3,屏见 src/board_config.h:320x240 横 / 240x240 方 / 172x640 长条+触摸)
*
* 流程:开机 -> 有 WiFi 凭据就连接,没有就开热点配网
* -> 联网后向后端要 6 位绑定码并显示
@@ -22,10 +22,14 @@
#include "src/api.h"
#include "src/portal.h"
#include "src/ui.h"
+#include "src/touch.h"
+#include "src/imu.h"
+#include "src/power.h"
#include "src/iconstore.h"
#include "src/rocketstore.h"
#include "src/version.h"
#include "src/ota.h"
+#include "src/clock.h"
#define DEFAULT_API "https://cosmo.unisspace.com/api"
#define DEVICE_NAME "Cosmo Terminal"
@@ -67,10 +71,16 @@ static uint32_t g_next_update = 0; /* 下次问新版本的时间;0 = 开机
static bool g_dirty = true;
static bool g_ui_paused = false; /* selftest 期间不要被状态界面覆盖 */
+#if BOARD_HAS_TOUCH
+/* 触摸结算好的一次手势:x/y 是按下原点、screen 是结算时所在页,补发前拿这两样复核。
+ 定义放在文件头:Arduino 会在第一个函数之前自动补函数原型,类型得先让它看见。 */
+struct TpGesture { uint16_t bits; int idx, x, y, screen; bool swipe; };
+#endif
+
static const char *screen_name(Screen s)
{
static const char *n[] = { "SPLASH", "PROVISION", "CONNECTING", "PAIR",
- "LOADING", "MODE", "LIST", "DETAIL",
+ "MODE", "LIST", "DETAIL",
"ROCKETS", "ROCKET", "ERROR", "SETTINGS", "UPDATE" };
return (s <= SC_UPDATE) ? n[s] : "?";
}
@@ -90,11 +100,11 @@ static void start_provision(const char *why = nullptr, bool keep_sta = false);
static void wifi_connect();
static void start_pairing();
static void request_code();
-static void load_data(bool show_loading);
-static void load_rockets(bool show_loading);
+static void load_data();
+static void load_rockets();
static void open_mode();
static void enter_terminal();
-static void refresh_active(bool show_loading);
+static void refresh_active();
/* ---------------- 启动 ---------------- */
static void build_identity()
@@ -127,6 +137,71 @@ static void net_sync()
else g_ui.ip[0] = 0;
}
+/* ---------------- 忙碌反馈 / 图片懒加载 ---------------- */
+/* HTTP 请求是同步阻塞的,loop() 停在里面时触摸一次都收不到——这就是"点了没反应":
+ 一次轻点的手指只压得住几十 ms,回调要是 150ms 才来一次,整下点按就从两次回调之间
+ 漏掉了。三头缓解:① API 层每 25ms 回调 ui_pulse,触摸按 25ms 采样(一次 I2C 读
+ 不到 1ms),整屏重绘仍按 150ms 走(一帧要 30~80ms,刷太勤会把下载挤死);
+ ② 进请求先画一帧把忙碌条放上去;
+ ③ 立绘/图标不在请求线程里连着一张接一张地下(见 art_pump),loop 回到正题,屏才点得动。 */
+static int s_net_depth;
+static uint32_t s_net_idle_since;
+#define API_IDLE_CLOSE_MS 5000 /* 空转这么久才断 keep-alive:连着点几下时连接还是热的 */
+#define PULSE_DRAW_MS 150 /* 请求期间的重绘节拍:只喂忙碌条的动画 */
+static uint32_t s_pulse_draw;
+static void feedback_tick(uint32_t now);
+#if BOARD_HAS_TOUCH
+static void touch_pump();
+#else
+static inline void touch_pump() {}
+#endif
+/* 请求里的每一次回调都顺手采一次触摸:抬手时网络还忙着,手势会被排队(见 touch_tick),
+ 这里的作用是让排队/派发生在 HTTP 里也能推进,而不是只有回到 loop 才动一次。 */
+static void ui_pulse()
+{
+ const uint32_t now = millis();
+ feedback_tick(now); /* 反馈框的过期:loop 卡在 HTTP 里时只有这儿能清 */
+ touch_pump();
+ if ((int32_t)(now - s_pulse_draw) < PULSE_DRAW_MS) return;
+ s_pulse_draw = now;
+ ui_draw(g_ui);
+}
+static void net_begin()
+{
+ if (s_net_depth++) return;
+ const bool was = g_ui.busy; /* 补图期间本来就是忙,别白重画一屏 */
+ g_ui.busy = true;
+ if (!was) ui_draw(g_ui);
+}
+static void net_end() { if (!--s_net_depth) g_dirty = true; }
+struct NetBusy { NetBusy() { net_begin(); } ~NetBusy() { net_end(); } };
+
+static bool s_art_wait; /* 列表立绘/图标还缺 */
+static char s_art_code[24]; /* 详情页欠的那张 64x64 */
+static uint32_t s_art_ver;
+
+/* 一张立绘 ≈1.3s(HTTPS 握手占大头):页面先画,缺的图一轮补一张,补一张亮一张。
+ 一次只补一张是故意的——两张之间 loop 回到正题,屏幕照样点得动。 */
+static void art_pump()
+{
+ if (!g_token[0]) return;
+ if (s_art_code[0]) { /* 详情页欠的那张优先:用户正盯着它 */
+ char code[24]; strlcpy(code, s_art_code, sizeof(code));
+ const uint32_t ver = s_art_ver;
+ s_art_code[0] = 0;
+ NetBusy nb; /* 缺这个的话,排队的点按会在 HTTP 里再发起一次 HTTP */
+ rocket_store_ensure(g_ui.api, g_token, code, ver, 1);
+ g_dirty = true;
+ return;
+ }
+ if (!s_art_wait) return;
+ NetBusy nb;
+ int left = (g_mode > 0) ? rocket_store_sync(g_ui.api, g_token, &g_rsnap, 1)
+ : icon_store_sync(g_ui.api, g_token, &g_snap, 1);
+ s_art_wait = left > 0; /* <0 = 刚拉失败:别再追着重试,下次刷新再说 */
+ g_dirty = true;
+}
+
/* ---------------- 配网 ---------------- */
static void start_provision(const char *why, bool keep_sta)
{
@@ -353,10 +428,13 @@ static void pair_tick(uint32_t now)
}
/* ---------------- 数据 ---------------- */
-static void load_data(bool show_loading)
+static void load_data()
{
+ NetBusy nb; /* 多条 return,用 RAII 保证忙碌态一定退得干净 */
if (!g_token[0]) { start_pairing(); return; }
- if (show_loading || !g_snap.count) set_screen(SC_LOADING);
+ /* 没有可显示的东西就先把(还空着的)列表页摆出来,加载交给 header 那条线表达。
+ 已经有数据时原地刷,别把正在看详情页的人踢回列表。 */
+ if (!g_snap.count) set_screen(SC_LIST);
int http = 0;
if (api_follows(g_ui.api, g_token, &g_snap, &http)) {
@@ -367,8 +445,9 @@ static void load_data(bool show_loading)
net_sync();
g_api_fails = 0;
g_ui.api_fail = false;
- /* 后台换过图标才下载(每个图标两张图,只在版本变化时走一次 HTTP) */
- icon_store_sync(g_ui.api, g_token, &g_snap);
+ /* 后台换过图标才下载(每个图标两张图,只在版本变化时走一次 HTTP):
+ 这里只登记"还缺图",真正下载交给 art_pump 一张一张来 */
+ s_art_wait = true;
g_next_data = millis() + DATA_REFRESH;
/* 详情页停留时 5 分钟轮询到了别把人踢回列表 */
set_screen((g_ui.screen == SC_DETAIL) ? SC_DETAIL : SC_LIST);
@@ -397,6 +476,7 @@ static void load_data(bool show_loading)
状态栏变脸),不跳页、不动光标。60s 也在后端 360s 的在线窗口内,顺带把心跳补齐。 */
static void auth_check()
{
+ NetBusy nb; /* 多条 return,用 RAII 保证忙碌态一定退得干净 */
if (!g_token[0]) { start_pairing(); return; }
int http = 0;
@@ -431,10 +511,11 @@ static void mode_save(int m)
store_set_str(K_MODE, m ? "1" : "0");
}
-static void load_rockets(bool show_loading)
+static void load_rockets()
{
+ NetBusy nb; /* 多条 return,用 RAII 保证忙碌态一定退得干净 */
if (!g_token[0]) { start_pairing(); return; }
- if (show_loading || !g_rsnap.count) set_screen(SC_LOADING);
+ if (!g_rsnap.count) set_screen(SC_ROCKETS); /* 同 load_data:不再另开加载页 */
int http = 0;
if (api_rockets(g_ui.api, g_token, &g_rsnap, &http)) {
@@ -445,8 +526,8 @@ static void load_rockets(bool show_loading)
net_sync();
g_api_fails = 0;
g_ui.api_fail = false;
- /* 立绘按登记的参数在后端现画,只在参数版本变化时才走 HTTP */
- rocket_store_sync(g_ui.api, g_token, &g_rsnap);
+ /* 立绘按登记的参数在后端现画,只在参数版本变化时才走 HTTP:同上,交给后台补 */
+ s_art_wait = true;
g_next_data = millis() + DATA_REFRESH;
set_screen((g_ui.screen == SC_ROCKET) ? SC_ROCKET : SC_ROCKETS);
return;
@@ -468,6 +549,7 @@ static void load_rockets(bool show_loading)
/* 进详情才拉这一个型号的明细 + 64x64 立绘:型号可能很多,不做一次性全量下载 */
static void load_rocket_detail()
{
+ NetBusy nb; /* 多条 return,用 RAII 保证忙碌态一定退得干净 */
if (!g_token[0]) { start_pairing(); return; }
if (!g_rsnap.count) { set_screen(SC_ROCKETS); return; }
if (g_ui.rsel >= g_rsnap.count) g_ui.rsel = g_rsnap.count - 1;
@@ -485,8 +567,10 @@ static void load_rocket_detail()
set_screen(SC_ERROR, msg);
return;
}
- /* 拉不到立绘不算失败,画面退回固件内置线稿 */
- rocket_store_ensure(g_ui.api, g_token, code, g_rdet.base.art_ver, 1);
+ /* 立绘先不等:详情页先用内置线稿开画,64x64 交给 art_pump 补,补上就换掉。
+ 拉不到也不算失败,一直用线稿。 */
+ strlcpy(s_art_code, code, sizeof(s_art_code));
+ s_art_ver = g_rdet.base.art_ver;
g_ui.rdet = &g_rdet;
g_ui.rocket_tab = 0;
set_screen(SC_ROCKET);
@@ -503,8 +587,8 @@ static void choose_mode(int m)
{
mode_save(m);
Serial.printf("[mode] %s\n", g_mode ? "rockets" : "bodies");
- if (g_mode) load_rockets(true);
- else load_data(true);
+ if (g_mode) load_rockets();
+ else load_data();
}
/* 拿到 token 之后的落点:天体/火箭模式页永远是登录后的第一屏,
@@ -514,10 +598,10 @@ static void enter_terminal()
open_mode();
}
-static void refresh_active(bool show_loading)
+static void refresh_active()
{
- if (g_mode > 0) load_rockets(show_loading);
- else load_data(show_loading);
+ if (g_mode > 0) load_rockets();
+ else load_data();
}
/* ---------------- OTA ---------------- */
@@ -534,6 +618,7 @@ static void ota_progress_cb(size_t done, size_t total)
static void update_check(bool force)
{
if (!g_token[0] || WiFi.status() != WL_CONNECTED) return;
+ NetBusy nb;
int http = 0;
UpdateInfo up;
@@ -583,7 +668,8 @@ static void update_tick(uint32_t now)
static void run_tick(uint32_t now)
{
- if ((int32_t)(now - g_next_data) >= 0) { g_next_data = now + DATA_REFRESH; refresh_active(false); }
+ if ((int32_t)(now - g_next_data) >= 0) { g_next_data = now + DATA_REFRESH; refresh_active(); }
+ art_pump();
}
/* ---------------- 按键 ---------------- */
@@ -603,10 +689,27 @@ static uint8_t flash_slot_bits(uint16_t keys)
return f;
}
-static void on_key_press(uint16_t bits)
+/* 键位高亮的过期。loop 和请求期间的 ui_pulse 都要调一次:只在 loop 里过期的话,
+ 请求一卡就是几百 ms 到几秒,那个高亮就一直焊在屏上。 */
+static void feedback_tick(uint32_t now)
+{
+ if (!s_flash_until || (int32_t)(now - s_flash_until) < 0) return;
+ s_flash_until = 0;
+ g_ui.key_flash = 0;
+ g_dirty = true;
+}
+
+/* 高亮只给物理按键:那是底部按键条(KEY0..KEY3 图例)唯一的反馈。手指一下都不点——
+ 手势结算完页面自己会变,而那一亮要等回到 loop 才熄,卡住的 1~2s 里人以为没点着会
+ 补第二下,误触就是这么来的。慢的那部分另有忙碌亮带(g_ui.busy)负责。 */
+static void key_flash_on(uint16_t bits)
{
g_ui.key_flash = flash_slot_bits(bits);
if (g_ui.key_flash) { s_flash_until = millis() + KEY_FLASH_MS; g_dirty = true; }
+}
+
+static void on_key_press(uint16_t bits)
+{
if (g_ui_paused) { g_ui_paused = false; g_dirty = true; return; }
bool up = bits & XL_IO_KEY0;
@@ -677,13 +780,10 @@ static void on_key_press(uint16_t bits)
if (ok) update_start();
if (ref) open_mode();
break;
- case SC_LOADING:
- if (ref) refresh_active(true);
- break;
case SC_ERROR:
/* 后端地址填错/网络通但服务不通,都得能回到配网页改,不然只能拆机接串口 */
if (ok) { Serial.println("[key] reprovision from ERROR"); start_provision("MANUAL SETUP REQUESTED"); }
- if (ref) refresh_active(true);
+ if (ref) refresh_active();
break;
default:
break;
@@ -705,9 +805,158 @@ static void keys_tick(uint32_t now)
s_keys_stable = raw;
/* 打印整字变化:按键真接在别的脚上时也能一眼看到是哪一位 */
Serial.printf("[key] changed=0x%04X -> 0x%04X (raw=0x%04X)\n", prev, raw, keys_raw());
+ key_flash_on(pressed);
on_key_press(pressed);
}
+#if BOARD_HAS_TOUCH
+/* 触摸翻译成按键:上下滑 = UP/DN,横滑 = 最右那颗键(MODE/SETUP/TAB),
+ 点按 = 查 ui_draw 登记的热点(状态栏右端的按钮、列表卡、模式卡、详情页分页标签)。
+ 这样每一页的交互逻辑一行都不用改,触摸只是第二路输入。
+
+ 为什么不能"读到一帧有手指就当场算按下、抬手那帧的坐标当落点":这块屏的控制器在
+ 指尖刚碰上和刚抬手的几帧里坐标会飘,一次轻点内部的漂移就有几十像素(串口 `touch on`
+ 的 len/span 统计能直接量出来)。拿最后一帧去查热点会点到隔壁卡,拿首末两帧的差
+ 去判滑动会自己翻页。所以三条规矩:
+ ① 按下要连续 TP_CONFIRM 帧才成立,落点只取确认帧的均值,抬手位置一律不用;
+ ② 滑动要连续 TP_SWIPE_HOLD 帧都压在阈值外才算,方向在确认那一刻锁死;
+ ③ 抬手才结算;网络正忙时先存着,补发前要求"页面没换 + 落点还是同一块热区",
+ 否则宁可丢掉——丢一下只是这一下没反应,补错一下是用户没想点的跳转;
+ ④ 全程不画按下态。指尖压着时描一圈、按钮反色一下,看着像"选中区多了个外框",
+ 而它要等回到 loop 才熄灭,那 1~2s 里人以为没点着会再补一下——误触就是这么来的。
+ 点着的反馈是页面自己变(切页/换卡),慢的那部分由 header 的忙碌亮带表示。 */
+#define TP_POLL_MS 12 /* 采样间隔:快点按的手指只停留几十 ms */
+#define TP_SWIPE_PX 48 /* 滑动判定阈值:面板约 190DPI,48px ≈ 6mm */
+#define TP_CONFIRM 2 /* 连续几帧有手指才认按下:滤掉单帧毛刺,又不拖慢手感 */
+#define TP_RELEASE 2 /* 连续几帧空了才认抬手:一次 I2C 读失败不算抬手指 */
+#define TP_SWIPE_HOLD 2 /* 连续几帧压在阈值外才算滑动:单帧坐标毛刺不算 */
+#define TP_CONTACT_MS 3000 /* 一次接触超过 3s 当作卡住的假信号丢掉,别一直举着反馈框 */
+
+static uint32_t s_tp_sample = 0, s_tp_print = 0, s_tp_stat = 0, s_tp_down_at = 0;
+static bool s_tp_dbg = false, s_tp_down = false;
+static int s_tp_n = 0, s_tp_off = 0; /* 按下 / 抬手的连续帧计数 */
+static int s_tp_px[TP_CONFIRM], s_tp_py[TP_CONFIRM]; /* 确认帧坐标,均值就是落点 */
+static int s_tp_ox = 0, s_tp_oy = 0; /* 按下原点 */
+static int s_tp_cx = 0, s_tp_cy = 0; /* 最新一帧,只用来量滑动 */
+static int s_tp_slide = 0; /* 连续压在阈值外的帧数 */
+static uint16_t s_tp_slide_bits = 0; /* 确认滑动那一刻定下的方向 */
+
+static TpGesture gesture_tap(int x, int y)
+{
+ TpGesture g;
+ g.bits = ui_hit_test(x, y, &g.idx);
+ g.x = x; g.y = y; g.screen = (int)g_ui.screen; g.swipe = false;
+ return g;
+}
+
+static void tp_gesture_run(const TpGesture &g)
+{
+ Serial.printf("[tp] (%d,%d) key=0x%04X idx=%d%s\n",
+ g.x, g.y, g.bits, g.idx, g.swipe ? " slide" : "");
+ if (!g.bits) return;
+ if (g.bits == UI_ACT_TAB) { /* 详情页的分页标签:直接翻到那一页 */
+ if (g_ui.screen == SC_ROCKET) g_ui.rocket_tab = g.idx;
+ else g_ui.detail_tab = g.idx;
+ g_dirty = true;
+ return;
+ }
+ if (g.bits == XL_IO_KEY2 && g.idx >= 0) { /* 点到卡片:光标先落到那一行再确认 */
+ switch (g_ui.screen) {
+ case SC_LIST: case SC_DETAIL:
+ if (g.idx < g_snap.count) g_ui.sel = g.idx;
+ break;
+ case SC_ROCKETS: case SC_ROCKET:
+ if (g.idx < g_rsnap.count) g_ui.rsel = g.idx;
+ break;
+ case SC_MODE: g_ui.mode_sel = g.idx ? 1 : 0; break;
+ default: break;
+ }
+ }
+ on_key_press(g.bits);
+}
+
+/* 请求还在飞的时候抬的手:在 HTTP 里派发动作会嵌套出发新请求,只能等网络空下来补发。
+ 只存一格 + 有效期;判据用 api_in_request() 而不是 s_net_depth——
+ 不是每条请求路径都标了忙碌态。 */
+#define TP_QUEUE_TTL_MS 1200
+static bool s_tp_queued;
+static uint32_t s_tp_queue_at;
+static TpGesture s_tp_queue;
+
+static void touch_tick(uint32_t now)
+{
+ if (s_tp_queued && !api_in_request()) {
+ s_tp_queued = false;
+ const TpGesture &g = s_tp_queue;
+ int idx = -1;
+ bool fresh = (int32_t)(now - s_tp_queue_at) < TP_QUEUE_TTL_MS
+ && g.screen == (int)g_ui.screen;
+ if (fresh && !g.swipe) /* 点按:落点那块热区得还长在原来的位置 */
+ fresh = (ui_hit_test(g.x, g.y, &idx) == g.bits) && (g.idx < 0 || idx == g.idx);
+ Serial.printf("[tp] deferred %s (%d,%d) key=0x%04X\n",
+ fresh ? "replay" : "drop", g.x, g.y, g.bits);
+ if (fresh) tp_gesture_run(g);
+ return; /* 这轮只补账,落点交给下一次采样 */
+ }
+ if (s_tp_dbg) {
+ if (now - s_tp_print >= 100) { s_tp_print = now; touch_diag(); }
+ if (now - s_tp_stat >= 1000) { s_tp_stat = now; touch_stats_report(); }
+ }
+ if (now - s_tp_sample < TP_POLL_MS) return;
+ s_tp_sample = now;
+
+ int x, y;
+ if (!touch_poll(x, y)) { /* 这一帧没有手指 */
+ s_tp_n = 0;
+ if (!s_tp_down) return;
+ if (++s_tp_off < TP_RELEASE) return; /* 单次读失败不算抬手指 */
+ s_tp_down = false; s_tp_off = 0;
+ TpGesture g = (s_tp_slide >= TP_SWIPE_HOLD)
+ ? TpGesture{ s_tp_slide_bits, -1, s_tp_ox, s_tp_oy, (int)g_ui.screen, true }
+ : gesture_tap(s_tp_ox, s_tp_oy);
+ if (!g.bits) return;
+ if (api_in_request()) { /* 网络正忙:存下来,别让这一下白点 */
+ s_tp_queue = g; s_tp_queued = true; s_tp_queue_at = now;
+ return;
+ }
+ tp_gesture_run(g);
+ return;
+ }
+
+ if (s_tp_down) { /* 手指还在屏上:只量有没有滑出去 */
+ s_tp_cx = x; s_tp_cy = y;
+ const int dx = x - s_tp_ox, dy = y - s_tp_oy;
+ const int ax = abs(dx), ay = abs(dy);
+ if ((ay >= TP_SWIPE_PX && ay > ax) || ax >= TP_SWIPE_PX) {
+ if (++s_tp_slide == TP_SWIPE_HOLD) /* 方向在此刻锁死,后面飘回来也不改 */
+ s_tp_slide_bits = (ay > ax) ? ((dy < 0) ? XL_IO_KEY0 : XL_IO_KEY1) : XL_IO_KEY3;
+ } else if (s_tp_slide) {
+ s_tp_slide = 0;
+ }
+ if ((int32_t)(now - s_tp_down_at) > TP_CONTACT_MS) {
+ Serial.println(F("[tp] contact too long, dropped"));
+ s_tp_down = false; s_tp_n = 0;
+ }
+ return;
+ }
+
+ if (++s_tp_n < TP_CONFIRM) { /* 还没确认:先攒够连续帧 */
+ s_tp_px[s_tp_n - 1] = x; s_tp_py[s_tp_n - 1] = y;
+ return;
+ }
+ int sx = 0, sy = 0;
+ for (int i = 0; i < TP_CONFIRM - 1; i++) { sx += s_tp_px[i]; sy += s_tp_py[i]; }
+ s_tp_ox = s_tp_cx = (sx + x) / TP_CONFIRM;
+ s_tp_oy = s_tp_cy = (sy + y) / TP_CONFIRM;
+ s_tp_down = true; s_tp_down_at = now; s_tp_off = 0;
+ s_tp_slide = 0; s_tp_slide_bits = 0;
+}
+
+/* 请求阻塞期间也要采样:touch_tick 自己有 TP_POLL_MS 那道闸,多调几次不会多读 I2C。
+ 在请求里只结算、不派发(派发前要过 api_in_request() 那道判断),所以不会嵌套发请求。 */
+static void touch_pump() { touch_tick(millis()); }
+#endif
+
/* ---------------- 串口命令 ---------------- */
static void print_help()
{
@@ -725,16 +974,27 @@ static void print_help()
Serial.println(F("portal [lan] open the setup hotspot (lan: keep wifi up)"));
Serial.println(F("scan list the 2.4GHz networks this board can see"));
Serial.println(F("stat print current state"));
+#if BOARD_HAS_BATTERY
+ Serial.println(F("batt battery voltage / charge / SYS_EN latch"));
+#endif
Serial.println(F("keys print raw key bitmap (check polarity)"));
Serial.println(F("xlreg dump all XL9555 registers (input/output/config)"));
Serial.println(F("i2cscan list I2C slaves (touch controller check)"));
Serial.println(F("key 0xNN inject key bits: 0x8000=UP 0x4000=DN 0x2000=OK 0x1000=REF"));
Serial.println(F("selftest colour bars on screen; any key/command resumes"));
- Serial.println(F("dump stream current 320x240 framebuffer over serial"));
+ Serial.println(F("dump stream the whole framebuffer over serial"));
+#if BOARD_HAS_TOUCH
+ Serial.println(F("touch [on|off] read the touch panel (on: stream coords, for calibration)"));
+ Serial.println(F("tap feed one tap at logical pixel (same path as a finger)"));
+#endif
Serial.println(F("swap 0|1 SPI byte order (colors wrong -> try 0)"));
Serial.println(F("bgr 0|1 red/blue order (red<->blue -> try 1)"));
Serial.println(F("inv 0|1 panel color invert"));
Serial.println(F("mir 0|1 X mirror (layout mirrored -> try 0)"));
+ Serial.println(F("rot [0..3] logical orientation of the strip panel"));
+ Serial.println(F("imu accelerometer reading / orientation call"));
+ Serial.println(F("flip [0|1|auto] pin the strip 180 degrees, or back to accelerometer"));
+ Serial.println(F(" (picture mirrored / upside down -> try 1 2 3)"));
Serial.println(F("reboot restart, keep NVS (reset wipes it!)"));
}
@@ -755,6 +1015,7 @@ static void print_stat()
icon_store_dump();
Serial.printf("rockets : %d, sel=%d tab=%d\n", g_rsnap.count, g_ui.rsel, g_ui.rocket_tab);
rocket_store_dump();
+ Serial.printf("panel : %dx%d rot=%d\n", LCD_WIDTH, LCD_HEIGHT, disp_rot());
Serial.printf("uptime : %lus\n", (unsigned long)(millis() / 1000));
}
@@ -809,7 +1070,7 @@ static void handle_command(char *line)
store_erase(K_TOKEN);
start_pairing();
} else if (!strcmp(line, "reload")) {
- refresh_active(true);
+ refresh_active();
} else if (!strcmp(line, "mode")) {
if (!args[0]) {
Serial.printf("mode=%s\n", (g_mode < 0) ? "unset" : (g_mode ? "rockets" : "bodies"));
@@ -876,6 +1137,33 @@ static void handle_command(char *line)
xl_dump_regs();
} else if (!strcmp(line, "i2cscan")) {
xl_i2c_scan();
+ } else if (!strcmp(line, "touch")) {
+#if BOARD_HAS_TOUCH
+ if (!strcmp(args, "on")) {
+ s_tp_dbg = true;
+ Serial.println(F("[tp] streaming coordinates, tap the four corners; 'touch off' stops"));
+ return;
+ }
+ if (!strcmp(args, "off")) { s_tp_dbg = false; Serial.println(F("[tp] stopped")); return; }
+ touch_diag();
+ return;
+#else
+ Serial.println(F("this board has no touch panel"));
+ return;
+#endif
+ } else if (!strcmp(line, "tap")) {
+#if BOARD_HAS_TOUCH
+ int x, y;
+ if (sscanf(args, "%d %d", &x, &y) != 2) {
+ Serial.println(F("usage: tap logical pixel, 0..639 x 0..171"));
+ return;
+ }
+ tp_gesture_run(gesture_tap(x, y));
+ return;
+#else
+ Serial.println(F("this board has no touch panel"));
+ return;
+#endif
} else if (!strcmp(line, "selftest")) {
disp_selftest();
g_ui_paused = true;
@@ -908,6 +1196,29 @@ static void handle_command(char *line)
disp_set_invert(atoi(args)); Serial.printf("[disp] invert=%d\n", atoi(args));
} else if (!strcmp(line, "mir")) {
disp_set_mirror(atoi(args), false); Serial.printf("[disp] mirror_x=%d\n", atoi(args));
+ } else if (!strcmp(line, "rot")) {
+ if (!args[0]) { Serial.printf("[disp] rot=%d\n", disp_rot()); return; }
+ disp_set_rot(atoi(args));
+ store_set_str(K_ROT, args); /* 长条屏装反了,改一次记一次 */
+ Serial.printf("[disp] rot=%d saved\n", disp_rot());
+ } else if (!strcmp(line, "imu")) {
+#if BOARD_HAS_IMU
+ imu_diag();
+#else
+ Serial.println(F("this board has no IMU"));
+#endif
+ } else if (!strcmp(line, "flip")) {
+#if BOARD_HAS_IMU
+ imu_force(args);
+#else
+ Serial.println(F("this board has no IMU"));
+#endif
+ } else if (!strcmp(line, "batt")) {
+#if BOARD_HAS_BATTERY
+ bat_report();
+#else
+ Serial.println(F("this board has no battery"));
+#endif
} else if (!strcmp(line, "reset")) {
Serial.println(F("[cmd] wiping NVS"));
store_erase(K_SSID); store_erase(K_PASS); store_erase(K_API);
@@ -947,10 +1258,26 @@ static void serial_tick()
void setup()
{
Serial.begin(115200);
+#if BOARD_HAS_BATTERY
+ /* 电池供电时 PWR 键只是"临时接通",松手前必须靠 SYS_EN 锁住电源,所以排第一,
+ 在 NVS、屏、触摸之前——晚一百毫秒就是"按了不亮" */
+ pwr_hold_early();
+#endif
delay(400);
Serial.println(F("\n=== COSMO ORBITAL TERMINAL ==="));
Serial.printf("[board] %s fw=%s\n", BOARD_NAME, FW_VERSION);
+#if BOARD_HAS_BATTERY
+ bat_begin();
+ bat_poll(millis());
+ g_ui.bat_pct = bat_percent();
+ g_ui.bat_chg = bat_charging();
+ if (bat_present())
+ Serial.printf("[bat] %.2fV %d%% %s\n", bat_mv() / 1000.0, bat_percent(),
+ bat_charging() ? "USB charging" : "on battery");
+ else Serial.println(F("[bat] no battery on BAT_ADC"));
+#endif
+
store_begin();
ota_boot_guard(); /* 上次升级没能确认就在这里计数/回滚,可能直接重启 */
keys_begin(); /* 扩展器板: XL9555 + BOOT; 星智板: 3 颗 GPIO 键(REF 由 UP 长按) */
@@ -958,6 +1285,24 @@ void setup()
build_identity();
if (!disp_init()) Serial.println(F("[disp] init failed"));
+ {
+ char rotv[4];
+ if (store_get_str(K_ROT, rotv, sizeof(rotv))) disp_set_rot(atoi(rotv));
+#if BOARD_HAS_QSPI
+ /* NVS 里可能还存着老固件写下的镜像朝向(0/1),bit1 补回来:横屏只有 rot2/rot3 能用 */
+ if (!(disp_rot() & 2)) disp_set_rot(disp_rot() | 2);
+#endif
+ Serial.printf("[disp] rot=%d\n", disp_rot());
+ }
+#if BOARD_HAS_TOUCH
+ touch_begin();
+#endif
+#if BOARD_HAS_IMU
+ imu_begin(); /* 必须在朝向定下来之后:它从当前 rot 接管 180° 翻转 */
+#endif
+
+ /* 请求等响应的时候让 API 层有机会重绘,不然忙碌条是死的 */
+ api_set_wait_cb(ui_pulse);
g_ui.snap = &g_snap;
g_ui.rsnap = &g_rsnap;
@@ -1017,7 +1362,7 @@ void loop()
}
break;
case SC_ERROR:
- if ((int32_t)(now - g_retry_at) >= 0) { g_retry_at = now + 15000; refresh_active(true); }
+ if ((int32_t)(now - g_retry_at) >= 0) { g_retry_at = now + 15000; refresh_active(); }
break;
default:
break;
@@ -1035,17 +1380,46 @@ void loop()
keys_tick(now);
}
- /* 连接 / 加载页有动画,按 250ms 节拍重绘 */
- if ((g_ui.screen == SC_CONNECTING || g_ui.screen == SC_LOADING) && (now / 250) != (s_anim_last / 250)) {
- s_anim_last = now;
+#if BOARD_HAS_TOUCH
+ /* 放在暂停判断之外:selftest 画在屏上时也要能点一下退出 */
+ touch_tick(now);
+#endif
+
+#if BOARD_HAS_IMU
+ /* 摆位转了 180 度就换 rot:转置在 flush 里做,所以换完必须整屏重绘 */
+ if (imu_tick(now)) g_dirty = true;
+#endif
+
+#if BOARD_HAS_BATTERY
+ pwr_key_poll(now); /* 长按 PWR 关机,暂停时也要收 */
+ if (bat_poll(now)) {
+ g_ui.bat_pct = bat_percent();
+ g_ui.bat_chg = bat_charging();
g_dirty = true;
}
+#endif
+
+ /* 动画的重绘节拍:请求阻塞期间由 ui_pulse 喂,回到 loop 才轮到这儿。
+ 忙碌线 120ms 一格(请求已经下来、只剩补图的那段也得继续动),连接页 250ms。 */
+ {
+ const uint32_t step = g_ui.busy ? 120 : 250;
+ /* 设置页的时钟要跳秒。整秒判断放在节流之后:先问再丢弃的话会把那一秒的翻转吃掉,
+ 秒数就地跳两格。 */
+ const bool clock_tick = (g_ui.screen == SC_SETTINGS) && clock_second_ticked();
+ if ((clock_tick || g_ui.busy || g_ui.screen == SC_CONNECTING) && now - s_anim_last >= step) {
+ s_anim_last = now;
+ g_dirty = true;
+ }
+ }
- if (s_flash_until && (int32_t)(now - s_flash_until) >= 0) {
- s_flash_until = 0;
- g_ui.key_flash = 0;
- g_dirty = true;
- }
+ feedback_tick(now);
+
+ /* 忙碌条的开关集中在这儿算:net_begin 只负责点亮,这里负责在请求都做完、
+ 图也补齐之后把它熄掉(art_pump 只在列表页跑,别处清不掉) */
+ const bool busy = (s_net_depth > 0) || s_art_wait || s_art_code[0];
+ if (g_ui.busy != busy) { g_ui.busy = busy; s_net_idle_since = now; g_dirty = true; }
+ /* 请求之间留着 TLS 连接(省一遍握手),真闲下来了才断开把内存还回去 */
+ if (!busy && (int32_t)(now - s_net_idle_since) >= API_IDLE_CLOSE_MS) api_close();
if (g_dirty && !g_ui_paused) {
g_dirty = false;
diff --git a/terminal/firmware/cosmo_terminal/src/api.cpp b/terminal/firmware/cosmo_terminal/src/api.cpp
index 7dba71f..0c0de6f 100644
--- a/terminal/firmware/cosmo_terminal/src/api.cpp
+++ b/terminal/firmware/cosmo_terminal/src/api.cpp
@@ -6,6 +6,7 @@
#include
#include "api.h"
+#include "clock.h"
#include "board_config.h"
#include "version.h"
@@ -21,15 +22,6 @@ static std::unique_ptr tls_make(const char *url)
return tls;
}
-/* HTTPClient 只是借用这个 client,但 ~HTTPClient() 无条件 _client->stop(),而 end()
- 在连接已断开或 keep-alive 复用时不会把 _client 置空。所以 tls 必须在 HTTPClient
- 之前声明(局部变量逆序析构 = tls 比 http 活得久),否则析构时踩已释放的 client。 */
-static void http_begin(HTTPClient &http, const char *url, const std::unique_ptr &tls)
-{
- if (tls) http.begin(*tls, url);
- else http.begin(url);
-}
-
/* 中文标题被过滤空了就用 event_type 兜底:"close_approach" -> "CLOSE APPROACH" */
static void copy_upper(char *dst, size_t cap, const char *src)
{
@@ -93,22 +85,107 @@ static void copy_title(char *dst, size_t cap, const char *src)
copy_utf8(dst, cap, buf);
}
+/* 见 api.h:收包循环是唯一能把重绘插进 HTTP 的地方。
+ 限流 150ms:一帧整屏重绘 ~10ms,别让它把下载带宽吃掉。 */
+static void (*s_wait_cb)(void);
+static uint32_t s_wait_next;
+
+void api_set_wait_cb(void (*cb)(void)) { s_wait_cb = cb; }
+
+void api_wait_tick()
+{
+ if (!s_wait_cb) return;
+ const uint32_t now = millis();
+ if ((int32_t)(now - s_wait_next) < 0) return;
+ /* 25ms:回调里要采触摸,一次轻点的手指只压得住几十 ms,节拍粗了就整下漏采。
+ 贵的整屏重绘由回调自己按更粗的节拍挑着做(见 ui_pulse / PULSE_DRAW_MS)。 */
+ s_wait_next = now + 25;
+ s_wait_cb();
+}
+
+/* 一次请求进行中:wait 回调要靠它判断"现在只能记账,不能动作"。
+ http_json/http_raw 出口多,用 RAII 记进出,不逐个 return 去维护。 */
+namespace {
+struct InFlight {
+ InFlight() { depth++; }
+ ~InFlight() { depth--; }
+ static int depth;
+};
+int InFlight::depth;
+}
+bool api_in_request() { return InFlight::depth > 0; }
+
+/* ---------------- 连接复用 ----------------
+ 一次刷新要发十几个请求(快照 + 每张立绘),逐个重做 TLS 握手的话光握手就
+ 十几秒,这期间主循环停在 HTTPClient 里,触屏点了完全没反应。实测握手才是
+ 大头(40x40 和 64x64 的图耗时同量级),所以同一台服务器的连续请求走
+ keep-alive:HTTPClient 和它的 tls client 一起留在 Session 里,end() 之后
+ socket 不断开,下个请求直接复用。
+ 成员顺序不能反:~HTTPClient() 无条件 _client->stop(),所以 http 必须先于
+ tls 析构(成员逆序析构 = 先声明的后销毁,故 tls 在前)。 */
+namespace {
+struct Session {
+ std::unique_ptr tls;
+ HTTPClient http;
+};
+}
+static std::unique_ptr s_sess;
+static String s_sess_origin;
+
+/* "https://host:port/path" -> "https://host:port":origin 变了必须重连 */
+static String url_origin(const char *url)
+{
+ String s(url);
+ int p = s.indexOf("://");
+ if (p < 0) return s;
+ int slash = s.indexOf('/', p + 3);
+ return slash < 0 ? s : s.substring(0, slash);
+}
+
+/* 取一个能发请求的 HTTPClient。换服务器或上一个请求失败后会重建。 */
+static HTTPClient *http_open(const char *url)
+{
+ String origin = url_origin(url);
+ if (!s_sess || s_sess_origin != origin) {
+ s_sess.reset();
+ s_sess = std::make_unique();
+ s_sess->tls = tls_make(url);
+ s_sess->http.setReuse(true);
+ s_sess_origin = origin;
+ }
+ HTTPClient &http = s_sess->http;
+ http.setConnectTimeout(6000);
+ http.setTimeout(8000);
+ bool ok = s_sess->tls ? http.begin(*s_sess->tls, url) : http.begin(url);
+ if (!ok) { api_close(); return nullptr; }
+ return &http;
+}
+
+void api_close()
+{
+ if (!s_sess) return;
+ s_sess->http.setReuse(false);
+ s_sess->http.end();
+ s_sess.reset(); /* ~HTTPClient 先 stop(),tls 随后释放 */
+ s_sess_origin = "";
+}
+
static bool http_json(const char *url, const char *body, const char *token,
JsonDocument &doc, int *status)
{
- auto tls = tls_make(url); /* 声明在 http 之前,见 http_begin 注释 */
- HTTPClient http;
- http.setConnectTimeout(6000);
- http.setTimeout(8000);
- http_begin(http, url, tls);
+ InFlight req;
+ HTTPClient *hp = http_open(url);
+ if (!hp) return false;
+ HTTPClient &http = *hp;
http.addHeader("Content-Type", "application/json");
if (token && *token) http.addHeader("Authorization", String("Bearer ") + token);
http_add_id_headers(http);
+ api_wait_tick(); /* TLS 握手要 1s 上下:先进请求就给一帧反馈 */
int code = body ? http.POST(body) : http.GET();
if (status) *status = code;
/* 只认 2xx:401「设备已解绑」这类错误响应体同样是合法 JSON,
当成成功会让关注列表被清空成 0 个天体,掩盖掉重新配对的流程 */
- if (code < 200 || code >= 300) { http.end(); return false; }
+ if (code < 200 || code >= 300) { api_close(); return false; }
DeserializationError err = deserializeJson(doc, http.getStream());
http.end();
if (err) { Serial.printf("[api] json: %s\n", err.c_str()); return false; }
@@ -186,6 +263,7 @@ bool api_follows(const char *base, const char *token, Snapshot *out, int *http_s
memset(out, 0, sizeof(*out));
strlcpy(out->username, doc["username"] | "", sizeof(out->username));
copy_iso(out->server_time, sizeof(out->server_time), doc["server_time"] | "");
+ clock_sync_iso(doc["server_time"] | ""); /* 本机没有 RTC:这是唯一的对时来源 */
out->count = 0;
out->fetched_ms = millis();
@@ -227,29 +305,30 @@ bool api_follows(const char *base, const char *token, Snapshot *out, int *http_s
不带 alpha 的大端 RGB565,贴到帧缓冲上靠叠加混合,所以共用这一条流水线。 */
static bool http_raw(const char *url, const char *token, void *dst, size_t cap, int *http_status)
{
- auto tls = tls_make(url); /* 声明在 http 之前,见 http_begin 注释 */
- HTTPClient http;
- http.setConnectTimeout(6000);
- http.setTimeout(8000);
- http_begin(http, url, tls);
+ InFlight req;
+ HTTPClient *hp = http_open(url);
+ if (!hp) return false;
+ HTTPClient &http = *hp;
if (token && *token) http.addHeader("Authorization", String("Bearer ") + token);
http_add_id_headers(http);
+ api_wait_tick();
int code = http.GET();
if (http_status) *http_status = code;
- if (code != 200) { http.end(); return false; }
+ if (code != 200) { api_close(); return false; }
/* 后端给的是定长裸数据,Content-Length 不符就说明版本/尺寸对不上 */
int len = http.getSize();
- if (len >= 0 && (size_t)len != cap) { http.end(); return false; }
+ if (len >= 0 && (size_t)len != cap) { api_close(); return false; }
Stream &s = http.getStream();
size_t got = 0;
while (got < cap) {
+ api_wait_tick();
int n = s.readBytes((char *)dst + got, cap - got);
if (n <= 0) break;
got += (size_t)n;
}
+ if (got != cap) { api_close(); return false; }
http.end();
- if (got != cap) return false;
/* 后端按大端发(和串口 dump 同一个约定),disp_add_bitmap 要的是本机字节序 */
uint16_t *px = (uint16_t *)dst;
@@ -300,6 +379,7 @@ bool api_rockets(const char *base, const char *token, RocketSnapshot *out, int *
memset(out, 0, sizeof(*out));
strlcpy(out->username, doc["username"] | "", sizeof(out->username));
copy_iso(out->server_time, sizeof(out->server_time), doc["server_time"] | "");
+ clock_sync_iso(doc["server_time"] | ""); /* 同上:每次刷新都重新对时 */
out->count = 0;
out->fetched_ms = millis();
diff --git a/terminal/firmware/cosmo_terminal/src/api.h b/terminal/firmware/cosmo_terminal/src/api.h
index eb97cb8..7f21c73 100644
--- a/terminal/firmware/cosmo_terminal/src/api.h
+++ b/terminal/firmware/cosmo_terminal/src/api.h
@@ -105,6 +105,18 @@ bool api_rocket(const char *base, const char *token, const char *code,
bool api_rocket_art(const char *base, const char *token, const char *code, int size,
void *dst, size_t cap, int *http_status);
+/** 请求阻塞期间 loop 停着,屏上任何动画都会冻住。注册一个回调,收包循环里
+ * 每 ~150ms 调一次(调用方只做一件事:重画当前帧),忙碌条就能自己动。
+ * 顺带在每次请求开始前调一次:请求一进去屏上就有反应。 */
+void api_set_wait_cb(void (*cb)(void));
+void api_wait_tick();
+
+void api_close();
+
+/** 当前是不是正停在某次 HTTP 请求里面。回调(api_set_wait_cb)里想知道这件事:
+ * 在请求里再发起一次请求会把这条连接踩烂,界面反馈也只能等请求出来再做。 */
+bool api_in_request();
+
/* ---------------- OTA ---------------- */
struct UpdateInfo {
bool has_update;
diff --git a/terminal/firmware/cosmo_terminal/src/board_config.h b/terminal/firmware/cosmo_terminal/src/board_config.h
index d45b8b7..9c0d2cb 100644
--- a/terminal/firmware/cosmo_terminal/src/board_config.h
+++ b/terminal/firmware/cosmo_terminal/src/board_config.h
@@ -1,17 +1,21 @@
/**
- * 板型定义:编译期二选一
+ * 板型定义:编译期三选一
* 1 = 正点原子 ATK-DNESP32S3 + 2.4寸 TFTLCD(ATK-MD0240/ST7789V) 320x240 横屏
* 屏 RST/PWR/背光和 4 个按键都挂在板上 XL9555 I2C 扩展器上
* 2 = 无名科技 星智CUBE 1.54TFT(ESP32-S3-N16R8) 240x240 方屏
* 屏全部 GPIO 直连,无扩展器;GPIO21 是整板电源保持脚,必须拉高
- * 改默认值或编译时加 -DCOSMO_BOARD=2 均可切换。
+ * 3 = Waveshare ESP32-S3-Touch-LCD-3.49 172x640 竖长条 + 电容触摸
+ * 屏是 AXS15231B 走 QSPI(4 线),触摸是同一颗 IC 的 I2C 控制器;
+ * 屏复位/背光使能挂在 TCA9554 上(V1 板是 GPIO 直连,运行时探测)
+ * 改默认值或编译时加 -DCOSMO_BOARD=3 均可切换。
* 星智引脚取自官方板级定义 main/boards/nologo/xingzhi-cube-1.54tft-wifi/config.h
+ * Waveshare 引脚取自官方 ESP-IDF/Arduino 例程(AXS15231B QSPI + TCA9554)。
*/
#pragma once
#include
#ifndef COSMO_BOARD
-#define COSMO_BOARD 1 /* 默认=出货用的正点原子板;方屏样机编译时加 -DCOSMO_BOARD=2 */
+#define COSMO_BOARD 1 /* 默认=出货用的正点原子板;其他板编译时加 -DCOSMO_BOARD=2/3 */
#endif
/* XL9555 寄存器(两块板共用同一份头文件,未接扩展器时这些宏只是没人用) */
@@ -20,7 +24,32 @@
#define XL_REG_CONFIG0 0x06
#define XL9555_ADDR 0x20
-/* 按键位掩码:全固件通用,与按键物理来源无关(XL9555 或 GPIO 都映射到这四位) */
+/* 触摸:只有 3.49 那块板有;其余板靠按键条图例操作 */
+#ifndef BOARD_HAS_TOUCH
+#define BOARD_HAS_TOUCH 0
+#endif
+/* QSPI 屏(AXS15231B):没有 DC 线,命令 32bit,帧缓冲直接按行带刷 */
+#ifndef BOARD_HAS_QSPI
+#define BOARD_HAS_QSPI 0
+#endif
+/* 锂电池(18650)+ 电源锁:只有 3.49 长条板带电池座和充电芯片 */
+#ifndef BOARD_HAS_BATTERY
+#define BOARD_HAS_BATTERY 0
+#endif
+/* IMU(QMI8658):只有 3.49 长条板有,用来自动分辨正放/倒放 */
+#ifndef BOARD_HAS_IMU
+#define BOARD_HAS_IMU 0
+#endif
+
+
+/* 屏控制器名,自检页和日志用 */
+#ifndef BOARD_PANEL
+#define BOARD_PANEL "ST7789"
+#endif
+#define COSMO_STR2(x) #x
+#define COSMO_STR(x) COSMO_STR2(x)
+
+/* 按键位掩码:全固件通用,与按键物理来源无关(XL9555、GPIO 或触摸都映射到这四位) */
#define XL_IO_KEY0 0x8000
#define XL_IO_KEY1 0x4000
#define XL_IO_KEY2 0x2000
@@ -60,6 +89,77 @@
#define PIN_KEY_LONG_MS 1200 /* UP 按住超过这个时长 -> REF */
#define PIN_KEY_BOOT 0
+#elif COSMO_BOARD == 3 /* ============ Waveshare ESP32-S3-Touch-LCD-3.49 ============ */
+#define BOARD_NAME "waveshare-3p49"
+#define BOARD_HAS_XL9555 0
+#define BOARD_HAS_TOUCH 1
+#define BOARD_HAS_QSPI 1
+#define BOARD_HAS_IMU 1
+#define BOARD_HAS_BATTERY 1
+#define BOARD_PANEL "AXS15231B"
+
+/* QSPI 屏:AXS15231B,无 DC 线。D0=MOSI D1=MISO D2=WP D3=HD */
+#define PIN_SPI_SCK 10
+#define PIN_SPI_MOSI 11
+#define PIN_SPI_MISO 12
+#define PIN_SPI_WP 13
+#define PIN_SPI_HD 14
+#define LCD_SPI_HOST SPI3_HOST
+#define PIN_LCD_CS 9
+#define PIN_LCD_DC (-1)
+#define PIN_LCD_RST (-1) /* 没有 GPIO 复位脚:V2 走 TCA9554 bit5,V1 是 GPIO21 */
+#define PIN_LCD_BL (-1) /* 同上:V2 = BL_EN bit1 + PWM GPIO42,V1 = GPIO8 */
+#define LCD_SPI_MODE 3
+#define LCD_SWAP_XY 0 /* 面板原生朝向不动,横屏靠 disp_flush 软件转置 */
+#define LCD_MIRROR_X 0
+#define LCD_MIRROR_Y 0
+#define PANEL_WIDTH 172 /* 面板原生(QSPI 寻址)尺寸 */
+#define PANEL_HEIGHT 640
+#define LCD_WIDTH 640 /* 逻辑画布:长条屏横过来用,UI 只认这一对 */
+#define LCD_HEIGHT 172
+#define LCD_PCLK_HZ 40000000 /* QSPI 四线 + 官方例程同频 */
+
+/* V1 板(没有 TCA9554)的直连兜底,运行时探测不到 0x20 才用 */
+#define PIN_V1_LCD_RST 21
+#define PIN_V1_LCD_BL 8
+#define PIN_LCD_BL_PWM 42 /* V2 背光 PWM,低电平亮 */
+
+/* 系统 I2C(TCA9554/RTC/IMU/音频);TCA9554 与 XL9555 同址但只有 8 位、寄存器编号不同 */
+#define PIN_I2C_SDA 47
+#define PIN_I2C_SCL 48
+#define TCA9554_ADDR 0x20
+#define TCA_REG_INPUT 0x00
+#define TCA_REG_OUTPUT 0x01
+#define TCA_REG_CONFIG 0x03 /* 0x02 是极性反转,方向寄存器是 0x03;写成 0x02 时 8 个脚全是输入,SYS_EN 从未真正输出 */
+#define TCA_IO_BL_EN (1u << 1)
+#define TCA_IO_LCD_RST (1u << 5)
+#define TCA_IO_SYS_EN (1u << 6) /* 0 = 整板断电,绝不能拉低 */
+
+/* 触摸:AXS15231B 自带控制器,挂在第二条 I2C 上,和屏共用一片硅但总线独立 */
+#define PIN_TP_SDA 17
+#define PIN_TP_SCL 18
+#define TP_I2C_ADDR 0x3B
+
+/* IMU:QMI8658 走系统 I2C(47/48),官方例程用 0x6B,另一档 0x6A 只做兜底探测 */
+#define IMU_I2C_ADDR 0x6B
+#define IMU_I2C_ADDR_ALT 0x6A
+
+#define PIN_PWR_HOLD (-1) /* 供电话锁在板子上(PWR 键是硬件锁存),固件不碰 */
+
+/* 侧面只有 BOOT 可编程(PWR 是电源锁存,RESET 是 EN),其余交互全交给触摸 */
+#define PIN_KEY_UP (-1)
+#define PIN_KEY_DN (-1)
+#define PIN_KEY_OK (-1)
+#define PIN_KEY_REF (-1)
+#define PIN_KEY_LONG_MS 1200
+#define PIN_KEY_BOOT 0
+
+/* 电池:正极经板上 R3 200K / R15 100K 分压(÷3)进 ADC1_CH3,所以实测 mV x3 = VBAT。
+ 充电芯片 ETA6098C1 的 STAT 只接了指示灯,没有脚进 MCU;
+ PWR 键 = GPIO16(SYS_OUT),低有效,只是临时接通,真正的电源锁存在 TCA9554 bit6 */
+#define PIN_BAT_ADC 4
+#define PIN_SYS_OUT 16 /* PWR 键经电源开关后的输出,高=电池路已接通 */
+
#else /* ===================== ATK-DNESP32S3 ===================== */
#define BOARD_NAME "atk-dnesp32s3"
#define BOARD_HAS_XL9555 1
@@ -96,3 +196,18 @@
#define PIN_KEY_LONG_MS 1200
#define PIN_KEY_BOOT 0 /* BOOT 按键 = GPIO0 */
#endif
+
+/* 没有四线数据线的板子:QSPI 之外的 SPI 只用 MOSI/MISO,这两脚留空 */
+#ifndef PIN_SPI_WP
+#define PIN_SPI_WP (-1)
+#define PIN_SPI_HD (-1)
+#endif
+/* SPI 像素时钟:官方例程 40MHz,杜邦排针接的旧板降到 20MHz 更稳 */
+#ifndef LCD_PCLK_HZ
+#define LCD_PCLK_HZ 20000000
+#endif
+/* 只有软件转置的长条屏需要区分面板/逻辑尺寸,其余板子逻辑=面板 */
+#ifndef PANEL_WIDTH
+#define PANEL_WIDTH LCD_WIDTH
+#define PANEL_HEIGHT LCD_HEIGHT
+#endif
diff --git a/terminal/firmware/cosmo_terminal/src/clock.cpp b/terminal/firmware/cosmo_terminal/src/clock.cpp
new file mode 100644
index 0000000..6478784
--- /dev/null
+++ b/terminal/firmware/cosmo_terminal/src/clock.cpp
@@ -0,0 +1,80 @@
+#include
+#include
+#include
+
+#include "clock.h"
+
+static uint32_t s_epoch; /* 校准那一刻的 UTC 秒,0 = 还没同步过 */
+static uint32_t s_ms; /* 校准那一刻的 millis(),之后靠差值走时 */
+static uint32_t s_shown; /* 上一回交给界面显示的秒数,用来找整秒翻转 */
+
+/* 日历换算自己算:newlib 的 timegm 在 Arduino 的编译选项下没暴露声明,
+ mktime/gmtime 又要吃本机 TZ(板子上没设过 TZ,等于隐式依赖一个环境变量)。
+ 整数运算几十行,换来的是和库无关、能在 PC 上对着 date 命令校。 */
+
+/** 公元 y-m-d 当天 00:00 距 1970-01-01 的天数 */
+static int64_t days_from_civil(int y, int m, int d)
+{
+ y -= (m <= 2);
+ const int64_t era = ((y >= 0 ? y : y - 399) / 400);
+ const int64_t yoe = y - era * 400; /* [0, 399] */
+ const int64_t doy = (153 * (m + (m > 2 ? -3 : 9)) + 2) / 5 + d - 1; /* [0, 365] */
+ const int64_t doe = yoe * 365 + yoe / 4 - yoe / 100 + doy; /* [0, 146096] */
+ return era * 146097 + doe - 719468;
+}
+
+/** days_from_civil 的逆运算 */
+static void civil_from_days(int64_t z, int *y, int *m, int *d)
+{
+ z += 719468;
+ const int64_t era = ((z >= 0 ? z : z - 146096) / 146097);
+ const int64_t doe = z - era * 146097; /* [0, 146096] */
+ const int64_t yoe = (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365;
+ const int64_t yy = yoe + era * 400;
+ const int64_t doy = doe - (365 * yoe + yoe / 4 - yoe / 100); /* [0, 365] */
+ const int64_t mp = (5 * doy + 2) / 153; /* [0, 11] */
+ *d = (int)(doy - (153 * mp + 2) / 5 + 1);
+ *m = (int)(mp + (mp < 10 ? 3 : -9));
+ *y = (int)(yy + (*m <= 2));
+}
+
+static int num2(const char *s) { return (s[0] - '0') * 10 + (s[1] - '0'); }
+
+void clock_sync_iso(const char *iso)
+{
+ /* "2026-10-16T05:12:34.567890":定点切前 19 个字符,不引 sscanf 那套格式串解析 */
+ if (!iso || strlen(iso) < 19 || iso[4] != '-' || iso[7] != '-' || iso[10] != 'T') return;
+ const int y = (iso[0] - '0') * 1000 + (iso[1] - '0') * 100 + (iso[2] - '0') * 10 + (iso[3] - '0');
+ const int mo = num2(iso + 5), d = num2(iso + 8);
+ const int h = num2(iso + 11), mi = num2(iso + 14), se = num2(iso + 17);
+ if (mo < 1 || mo > 12 || d < 1 || d > 31) return;
+ s_epoch = (uint32_t)(days_from_civil(y, mo, d) * 86400 + h * 3600 + mi * 60 + se);
+ s_ms = millis();
+}
+
+/* 当前 UTC 秒。晶振会漂,但每次刷新都会重新校准,误差攒不起来 */
+static uint32_t utc_now()
+{
+ return s_epoch ? s_epoch + (millis() - s_ms) / 1000U : 0;
+}
+
+bool clock_ready() { return s_epoch != 0; }
+
+void clock_local(char *dst, size_t cap)
+{
+ const uint32_t t = utc_now();
+ if (!t) { strlcpy(dst, "--", cap); return; }
+ const uint32_t lt = t + (uint32_t)CLOCK_TZ_MIN * 60U;
+ int y, mo, d;
+ civil_from_days(lt / 86400U, &y, &mo, &d);
+ const int sec = (int)(lt % 86400U);
+ snprintf(dst, cap, "%04d-%02d-%02d %02d:%02d:%02d", y, mo, d, sec / 3600, (sec / 60) % 60, sec % 60);
+}
+
+bool clock_second_ticked()
+{
+ const uint32_t t = utc_now();
+ if (t == s_shown) return false;
+ s_shown = t;
+ return true;
+}
diff --git a/terminal/firmware/cosmo_terminal/src/clock.h b/terminal/firmware/cosmo_terminal/src/clock.h
new file mode 100644
index 0000000..5356235
--- /dev/null
+++ b/terminal/firmware/cosmo_terminal/src/clock.h
@@ -0,0 +1,22 @@
+/** 墙上时钟。这块板子没有 RTC 电池,断电商 millis() 就归零,所以时间只能来自服务器:
+ * 每次拉到快照都用响应里的 server_time 校准一次,两次校准之间按 millis() 走时。 */
+#pragma once
+#include
+#include
+#include
+
+/* 后端下发的是 UTC(datetime.utcnow(),不带时区),而库里没有存用户时区,
+ 所以先按机主所在地固定 +08:00。换地区只改这一个常数。 */
+#define CLOCK_TZ_MIN (8 * 60)
+
+/** 用后端下发的 server_time("2026-10-16T05:12:34.567890")校准;解析不动就当没收到 */
+void clock_sync_iso(const char *iso_utc);
+
+/** 校准过没有;没校准时时钟显示 "--" */
+bool clock_ready();
+
+/** 本地时间(UTC + CLOCK_TZ_MIN):"2026-10-16 13:45:07",没同步过写 "--" */
+void clock_local(char *dst, size_t cap);
+
+/** 每翻一秒返回一次 true:整屏重绘不便宜,只有设置页的时钟需要按秒刷新 */
+bool clock_second_ticked();
diff --git a/terminal/firmware/cosmo_terminal/src/display.cpp b/terminal/firmware/cosmo_terminal/src/display.cpp
index 537ff4e..1660bce 100644
--- a/terminal/firmware/cosmo_terminal/src/display.cpp
+++ b/terminal/firmware/cosmo_terminal/src/display.cpp
@@ -8,13 +8,15 @@
#include "esp_lcd_panel_st7789.h"
#include "board_config.h"
+#if BOARD_HAS_QSPI
+#include /* 屏电源/复位挂在 TCA9554 上 */
+#endif
#include "display.h"
#include "expander.h"
#include "font_asc2.h"
#include "font_cjk.h"
-/* 官方例程跑 40MHz,这里用 20MHz:杜邦/排针连接下更稳,整屏刷新仍只要 ~12ms */
-#define LCD_PCLK_HZ 20000000
+/* 像素时钟见 board_config.h(旧板 20MHz,QSPI 板 40MHz);每次 flush 的行带高度 */
#define FLUSH_ROWS 20
static esp_lcd_panel_io_handle_t s_io;
@@ -24,6 +26,15 @@ static uint16_t *s_fb;
static bool s_byteswap = true; /* SPI 先发高字节,帧缓冲按大端存放 */
static bool s_bgr = false; /* ST7789 红蓝序,点屏后用 swap/bgr 命令校正 */
static bool s_mx = LCD_MIRROR_X, s_my = LCD_MIRROR_Y; /* 板型决定,串口 mirror 命令仍可临时改 */
+/* 长条屏逻辑朝向 0..3,disp_flush 转置时用。QSPI 那块屏的面板基准看出厂自检页:
+ USB-C 朝下竖着拿时文字正立 => row0 在远离 USB 那头,col0 在那时的左边。
+ 竖屏转横屏必须连带镜像一次逻辑 y(bit1),少这一次就是上下颠倒;bit1=1 的
+ rot2/rot3 才是正立/转180°,rot0/rot1 是镜像,永远不该用。默认 = USB 在右摆正。 */
+#if BOARD_HAS_QSPI
+static uint8_t s_rot = 2;
+#else
+static uint8_t s_rot = 0;
+#endif
static inline uint16_t pack(uint16_t c)
{
@@ -44,12 +55,104 @@ static void lcd_gpio_reset()
}
#endif
+#if BOARD_HAS_QSPI
+/* AXS15231B 走 QSPI 没有 DC 线:命令和像素各带一个操作码前缀塞进 32bit 命令字,
+ 和 espressif/esp_lcd_axs15231b 组件里 tx_param()/tx_color() 的拼法一致。 */
+#define AXS_OP_CMD 0x02u
+#define AXS_OP_COLOR 0x32u
+#define AXS_SLPOUT 0x11
+#define AXS_MADCTL 0x36
+#define AXS_COLMOD 0x3A
+#define AXS_CASET 0x2A
+#define AXS_RAMWR 0x2C
+#define AXS_RAMWRC 0x3C
+#define AXS_DISPON 0x29
+
+static void axs_cmd(uint8_t cmd, const uint8_t *param, size_t n)
+{
+ esp_lcd_panel_io_tx_param(s_io, (int)((AXS_OP_CMD << 24) | (cmd << 8)), param, n);
+}
+
+static void axs_color(uint8_t cmd, const void *px, size_t n)
+{
+ esp_lcd_panel_io_tx_color(s_io, (int)((AXS_OP_COLOR << 24) | (cmd << 8)), px, n);
+}
+
+/* esp_lcd_panel_io_tx_color 是异步的:函数返回时 DMA 还在读 buffer,
+ 官方头文件明确要求 buffer 只能在 on_color_trans_done 回调之后回收。
+ 转置带缓冲 s_band 是复用的,所以每发一带之前必须等上一带归还,否则
+ CPU 正在写的下一带会撕碎上一带还没发完的像素(纯色块看不出来,字形必花)。 */
+static SemaphoreHandle_t s_band_free;
+
+static bool color_done_cb(esp_lcd_panel_io_handle_t io, esp_lcd_panel_io_event_data_t *edata, void *ctx)
+{
+ BaseType_t hp = pdFALSE;
+ xSemaphoreGiveFromISR(s_band_free, &hp);
+ if (hp) portYIELD_FROM_ISR();
+ return false;
+}
+
+static bool s_tca; /* 探测到 TCA9554 = V2 板;没有就是 V1 的 GPIO 直连 */
+
+static bool tca_write(uint8_t reg, uint8_t v)
+{
+ Wire.beginTransmission(TCA9554_ADDR);
+ Wire.write(reg);
+ Wire.write(v);
+ return Wire.endTransmission() == 0;
+}
+
+/* 屏电源/复位/背光。V2 全在 TCA9554 上,V1 是 GPIO 直连,靠 0x20 应答与否区分。
+ SYS_EN(bit6) 是电源锁存:写其他位之前先读回输出寄存器并保住这一位,拉低=整板断电。 */
+static void panel_power_on()
+{
+ Wire.begin(PIN_I2C_SDA, PIN_I2C_SCL, 400000);
+ Wire.beginTransmission(TCA9554_ADDR);
+ s_tca = (Wire.endTransmission() == 0);
+
+ if (!s_tca) {
+ pinMode(PIN_V1_LCD_RST, OUTPUT);
+ digitalWrite(PIN_V1_LCD_RST, HIGH); delay(20);
+ digitalWrite(PIN_V1_LCD_RST, LOW); delay(40);
+ digitalWrite(PIN_V1_LCD_RST, HIGH); delay(120);
+ pinMode(PIN_V1_LCD_BL, OUTPUT);
+ digitalWrite(PIN_V1_LCD_BL, HIGH);
+ Serial.printf("[pwr] no TCA9554 -> V1 wiring (RST=%d BL=%d)\n", PIN_V1_LCD_RST, PIN_V1_LCD_BL);
+ return;
+ }
+
+ uint8_t out = 0;
+ Wire.beginTransmission(TCA9554_ADDR);
+ Wire.write(TCA_REG_OUTPUT);
+ bool rd = Wire.endTransmission(false) == 0 &&
+ Wire.requestFrom((uint8_t)TCA9554_ADDR, (uint8_t)1) == 1;
+ if (rd) out = (uint8_t)Wire.read();
+ /* BL_EN / LCD_RST / SYS_EN 设成输出,其余(触摸/IMU/RTC 的中断脚)留输入 */
+ tca_write(TCA_REG_CONFIG, (uint8_t)~(TCA_IO_BL_EN | TCA_IO_LCD_RST | TCA_IO_SYS_EN));
+ out |= TCA_IO_SYS_EN | TCA_IO_LCD_RST;
+ tca_write(TCA_REG_OUTPUT, out);
+ delay(20);
+ /* 复位脉宽按官方驱动:低 250ms,高 30ms 以上 */
+ out &= (uint8_t)~TCA_IO_LCD_RST; tca_write(TCA_REG_OUTPUT, out); delay(250);
+ out |= TCA_IO_LCD_RST; tca_write(TCA_REG_OUTPUT, out); delay(120);
+ /* 背光:使能位 + PWM 脚(低电平亮),不用调光就固定拉低 = 满亮度 */
+ out |= TCA_IO_BL_EN; tca_write(TCA_REG_OUTPUT, out);
+ pinMode(PIN_LCD_BL_PWM, OUTPUT);
+ digitalWrite(PIN_LCD_BL_PWM, LOW);
+ Serial.printf("[pwr] TCA9554 @0x%02X (V2) out=0x%02X SYS_EN/BL_EN/RST=1\n",
+ TCA9554_ADDR, out);
+}
+#endif
+
bool disp_init()
{
s_fb = (uint16_t *)heap_caps_malloc(LCD_WIDTH * LCD_HEIGHT * 2, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
if (!s_fb) { Serial.println(F("[disp] PSRAM alloc failed")); return false; }
-#if BOARD_HAS_XL9555
+#if BOARD_HAS_QSPI
+ /* 复位/背光都在扩展器(或 V1 的 GPIO)里,先给屏上电再谈总线 */
+ panel_power_on();
+#elif BOARD_HAS_XL9555
/* 屏的 RST/PWR 由 XL9555 提供,时序照官方 spilcd_init */
xl_pin_write(XL_IO_SLCD_RST, 0); delay(100);
xl_pin_write(XL_IO_SLCD_RST, 1); delay(100);
@@ -65,8 +168,8 @@ bool disp_init()
bus.mosi_io_num = PIN_SPI_MOSI;
bus.miso_io_num = PIN_SPI_MISO;
bus.sclk_io_num = PIN_SPI_SCK;
- bus.quadwp_io_num = -1;
- bus.quadhd_io_num = -1;
+ bus.quadwp_io_num = PIN_SPI_WP;
+ bus.quadhd_io_num = PIN_SPI_HD;
bus.max_transfer_sz = LCD_WIDTH * FLUSH_ROWS * 2;
e = spi_bus_initialize(LCD_SPI_HOST, &bus, SPI_DMA_CH_AUTO);
if (e != ESP_OK) { Serial.printf("[disp] spi_bus_initialize: %d\n", e); return false; }
@@ -78,11 +181,29 @@ bool disp_init()
io_cfg.spi_mode = LCD_SPI_MODE; /* 星智官方用 mode3,正点原子用 mode0 */
io_cfg.pclk_hz = LCD_PCLK_HZ;
io_cfg.trans_queue_depth = 2;
- io_cfg.lcd_cmd_bits = 8;
+ io_cfg.lcd_cmd_bits = BOARD_HAS_QSPI ? 32 : 8; /* QSPI 的命令字里含操作码 */
io_cfg.lcd_param_bits = 8;
+#if BOARD_HAS_QSPI
+ io_cfg.flags.quad_mode = 1; /* 参数/像素走 4 线,命令仍走 1 线 */
+ s_band_free = xSemaphoreCreateBinary();
+ io_cfg.on_color_trans_done = color_done_cb;
+#endif
e = esp_lcd_new_panel_io_spi((esp_lcd_spi_bus_handle_t)LCD_SPI_HOST, &io_cfg, &s_io);
if (e != ESP_OK) { Serial.printf("[disp] new_panel_io_spi: %d\n", e); return false; }
+#if BOARD_HAS_QSPI
+ /* 这份 core 没带 esp_lcd_axs15231b 组件,初始化按官方例程实际下发的命令自己发:
+ 出厂镜像的日志就只有 SLPOUT / MADCTL=0x00 / COLMOD=0x55 / DISPON 四条。
+ 注意别用 DISPOFF 息屏——这块板上试过醒不过来,要息屏只关背光。 */
+ static const uint8_t madctl = 0x00, colmod = 0x55;
+ axs_cmd(AXS_SLPOUT, NULL, 0); delay(120);
+ axs_cmd(AXS_MADCTL, &madctl, 1);
+ axs_cmd(AXS_COLMOD, &colmod, 1);
+ axs_cmd(AXS_SLPOUT, NULL, 0); delay(120); /* 官方驱动在 DISPON 前又发了一次 */
+ axs_cmd(AXS_DISPON, NULL, 0); delay(120);
+ Serial.printf("[disp] %s AXS15231B QSPI %dx%d ok pclk=%lu fb=%p\n",
+ BOARD_NAME, LCD_WIDTH, LCD_HEIGHT, (unsigned long)LCD_PCLK_HZ, (void *)s_fb);
+#else
esp_lcd_panel_dev_config_t p_cfg;
memset(&p_cfg, 0, sizeof(p_cfg));
p_cfg.reset_gpio_num = PIN_LCD_RST; /* 旧板没有 GPIO 复位脚(-1),星智=18 */
@@ -105,6 +226,7 @@ bool disp_init()
#endif
Serial.printf("[disp] %s ST7789 %dx%d ok mode=%d swap=%d fb=%p\n",
BOARD_NAME, LCD_WIDTH, LCD_HEIGHT, LCD_SPI_MODE, LCD_SWAP_XY, (void *)s_fb);
+#endif
return true;
}
@@ -172,9 +294,10 @@ void disp_bg(void)
/* 四角电路走线:3 点折线,端点一个过孔 */
static const int tr[4][6] = {
{ 2, 34, 30, 34, 30, 52 },
- { 317, 40, 292, 40, 292, 20 },
- { 4, 208, 38, 208, 38, 200 },
- { 316, 202, 288, 202, 288, 214 },
+ { LCD_WIDTH - 3, 40, LCD_WIDTH - 28, 40, LCD_WIDTH - 28, 20 },
+ { 4, LCD_HEIGHT - 32, 38, LCD_HEIGHT - 32, 38, LCD_HEIGHT - 40 },
+ { LCD_WIDTH - 4, LCD_HEIGHT - 38, LCD_WIDTH - 28, LCD_HEIGHT - 38,
+ LCD_WIDTH - 28, LCD_HEIGHT - 26 },
};
for (int i = 0; i < 4; i++) {
int px = tr[i][0], py = tr[i][1];
@@ -238,26 +361,31 @@ static inline uint16_t unpack(uint16_t v)
return v;
}
-void disp_add_bitmap(int x, int y, int w, int h, const uint16_t *px)
+void disp_add_bitmap(int x, int y, int w, int h, const uint16_t *px, uint8_t scale)
{
- if (!px) return;
+ if (!px || !scale) return;
for (int j = 0; j < h; j++) {
- int yy = y + j;
- if ((unsigned)yy >= LCD_HEIGHT) continue;
const uint16_t *src = px + (size_t)j * w;
- uint16_t *dst = s_fb + (size_t)yy * LCD_WIDTH;
for (int i = 0; i < w; i++) {
uint16_t s = src[i];
- int xx = x + i;
- if (!s || (unsigned)xx >= LCD_WIDTH) continue; /* 黑底直接不加 */
- uint16_t d = unpack(dst[xx]);
- int r = ((d >> 11) & 0x1F) + ((s >> 11) & 0x1F);
- int g = ((d >> 5) & 0x3F) + ((s >> 5) & 0x3F);
- int b = (d & 0x1F) + (s & 0x1F);
- if (r > 31) r = 31;
- if (g > 63) g = 63;
- if (b > 31) b = 31;
- dst[xx] = pack((uint16_t)((r << 11) | (g << 5) | b));
+ if (!s) continue; /* 黑底直接不加 */
+ for (int dy = 0; dy < scale; dy++) {
+ int yy = y + j * scale + dy;
+ if ((unsigned)yy >= LCD_HEIGHT) continue;
+ uint16_t *dst = s_fb + (size_t)yy * LCD_WIDTH;
+ for (int dx = 0; dx < scale; dx++) {
+ int xx = x + i * scale + dx;
+ if ((unsigned)xx >= LCD_WIDTH) continue;
+ uint16_t d = unpack(dst[xx]);
+ int r = ((d >> 11) & 0x1F) + ((s >> 11) & 0x1F);
+ int g = ((d >> 5) & 0x3F) + ((s >> 5) & 0x3F);
+ int b = (d & 0x1F) + (s & 0x1F);
+ if (r > 31) r = 31;
+ if (g > 63) g = 63;
+ if (b > 31) b = 31;
+ dst[xx] = pack((uint16_t)((r << 11) | (g << 5) | b));
+ }
+ }
}
}
}
@@ -440,6 +568,33 @@ int disp_text_wrap(int x, int y, int maxw, const char *s, uint8_t size, uint16_t
}
while (p[tl] == ' ') { tadv += char_advance(' ', size, 1); tl++; }
}
+ if (tadv > maxw) {
+ /* 整个词比行宽还长(URL / API 地址):换行也救不了,只能按像素硬切,
+ 否则会一路画出面板外。320 横屏上从来没有这么长的词,不影响旧板。 */
+ if (n) {
+ line[n] = 0;
+ disp_text(x, y, line, size, fg, bg);
+ y += size + 3; rows++; n = 0; cur = 0;
+ }
+ int used = 0;
+ while (*p && *p != ' ' && rows < max_lines) {
+ uint32_t cp;
+ int l = utf8_next(p, &cp);
+ int adv = char_advance(cp, size, 1);
+ if (used && used + adv > maxw) {
+ line[n] = 0;
+ disp_text(x, y, line, size, fg, bg);
+ y += size + 3; rows++; n = 0; used = 0;
+ if (rows >= max_lines) break;
+ }
+ if (n < (int)sizeof(line) - 4) for (int i = 0; i < l; i++) line[n++] = p[i];
+ used += adv;
+ p += l;
+ }
+ cur = used; prev_len = 0; prev_adv = 0;
+ if (rows >= max_lines) { n = 0; line[0] = 0; break; }
+ continue;
+ }
if (cur && cur + tadv > maxw) {
uint32_t ncp = 0;
bool pull = ((uint8_t)*p >= 0x80) && prev_len && prev_adv < cur &&
@@ -471,7 +626,35 @@ const uint16_t *disp_fb_ptr() { return s_fb; }
void disp_flush()
{
- if (!s_panel) return;
+ if (!s_panel && !s_io) return;
+#if BOARD_HAS_QSPI
+ /* QSPI 模式下这块屏只认 CASET(RASET 无效),显存写指针自己往下走,
+ 所以整屏必须从面板第 0 行起按行带顺序发:头一带 RAMWR,后面的带 RAMWRC。
+ 逻辑画布是横过来的 640x172,发之前逐带转置:逻辑 x 沿面板行方向、
+ 逻辑 y 沿面板列方向,rot 的 bit0/bit1 分别是这两根的镜像。 */
+ static uint16_t s_band[PANEL_WIDTH * FLUSH_ROWS];
+ const int mv_x = s_rot & 1, mv_y = s_rot & 2;
+ const uint8_t col[4] = { 0, 0, (uint8_t)((PANEL_WIDTH - 1) >> 8), (uint8_t)(PANEL_WIDTH - 1) };
+ axs_cmd(AXS_CASET, col, 4);
+ xSemaphoreGive(s_band_free); /* 开机第一帧:缓冲本来就是空的 */
+ for (int p0 = 0; p0 < PANEL_HEIGHT; p0 += FLUSH_ROWS) {
+ int rows = (PANEL_HEIGHT - p0 < FLUSH_ROWS) ? (PANEL_HEIGHT - p0) : FLUSH_ROWS;
+ /* 先等上一带的 DMA 把 s_band 交还,再往里写下一带 */
+ if (xSemaphoreTake(s_band_free, pdMS_TO_TICKS(500)) != pdTRUE)
+ Serial.println(F("[disp] flush: DMA band timeout"));
+ for (int y = 0; y < LCD_HEIGHT; y++) {
+ int px = mv_y ? (PANEL_WIDTH - 1 - y) : y;
+ for (int c = 0; c < rows; c++) {
+ int p = p0 + c;
+ s_band[(size_t)c * PANEL_WIDTH + px] =
+ s_fb[(size_t)y * LCD_WIDTH + (mv_x ? (PANEL_HEIGHT - 1 - p) : p)];
+ }
+ }
+ axs_color(p0 == 0 ? AXS_RAMWR : AXS_RAMWRC, s_band, (size_t)rows * PANEL_WIDTH * 2);
+ }
+ xSemaphoreTake(s_band_free, pdMS_TO_TICKS(500)); /* 最后一带发完再返回 */
+ return;
+#endif
for (int y0 = 0; y0 < LCD_HEIGHT; y0 += FLUSH_ROWS) {
int rows = (LCD_HEIGHT - y0 < FLUSH_ROWS) ? (LCD_HEIGHT - y0) : FLUSH_ROWS;
esp_lcd_panel_draw_bitmap(s_panel, 0, y0, LCD_WIDTH, y0 + rows, s_fb + (size_t)y0 * LCD_WIDTH);
@@ -489,23 +672,42 @@ void disp_set_mirror(bool mx, bool my)
if (s_panel) esp_lcd_panel_mirror(s_panel, s_mx, s_my);
}
+/* QSPI 那块屏的 MADCTL 转置和显存写入顺序对不上(QSPI 模式只认 CASET),
+ 所以朝向在 flush 里软件转置,0..3 = 逻辑画布的四种摆法 */
+void disp_set_rot(int r) { s_rot = (uint8_t)(r & 3); }
+int disp_rot() { return s_rot; }
+
/* 点屏自检:4 条色带 + 边界 + 文字,拍照即可判断字节序/色序/镜像 */
void disp_selftest()
{
static const uint16_t bars[] = { C_RED, C_GREEN, C_BLUE, C_WHITE };
static const char *names[] = { "RED", "GRN", "BLU", "WHT" };
disp_clear(C_BLACK);
+#if LCD_HEIGHT > LCD_WIDTH
+ /* 竖屏:色带横着叠起来,标签写在每带里侧 */
+ for (int i = 0; i < 4; i++) {
+ int by = 26 + i * 66;
+ disp_fill(8, by, LCD_WIDTH - 16, 52, bars[i]);
+ disp_text_center(8, by + 54, LCD_WIDTH - 16, names[i], 16, C_CYAN, C_BLACK);
+ }
+ int ty = 26 + 4 * 66 + 8;
+#else
+ /* 矮屏(长条屏 172 高)色带压扁一点,标签和文字跟着往上挪 */
+ const int bh = (LCD_HEIGHT > 200) ? 90 : 52;
for (int i = 0; i < 4; i++) {
int bx = 8 + i * 78;
- disp_fill(bx, 30, 70, 90, bars[i]);
- disp_text_center(bx, 126, 70, names[i], 16, C_CYAN, C_BLACK);
+ disp_fill(bx, 30, 70, bh, bars[i]);
+ disp_text_center(bx, 30 + bh + 4, 70, names[i], 16, C_CYAN, C_BLACK);
}
+ int ty = (LCD_HEIGHT > 200) ? 150 : 102;
+#endif
disp_rect(1, 1, LCD_WIDTH - 2, LCD_HEIGHT - 2, C_ORANGE);
- disp_text_center(0, 4, LCD_WIDTH, "ATK-DNESP32S3 ST7789 320x240", 16, C_GREEN, C_BLACK);
+ disp_text_clipped(0, 4, LCD_WIDTH, BOARD_NAME " " BOARD_PANEL " "
+ COSMO_STR(LCD_WIDTH) "x" COSMO_STR(LCD_HEIGHT), 16, C_GREEN, C_BLACK);
char msg[48];
snprintf(msg, sizeof(msg), "SWAP=%d BGR=%d MX=%d", (int)s_byteswap, (int)s_bgr, (int)s_mx);
- disp_text_center(0, 150, LCD_WIDTH, msg, 16, C_WHITE, C_BLACK);
- disp_text_center(0, 172, LCD_WIDTH, "1234567890 ABCDEFGHIJKLMNOP", 16, C_ORANGE, C_BLACK);
- disp_disc(160, 214, 14, C_CYAN);
+ disp_text_center(0, ty, LCD_WIDTH, msg, 16, C_WHITE, C_BLACK);
+ disp_text_clipped(0, ty + 22, LCD_WIDTH, "1234567890 ABCDEFGHIJKLMNOP", 16, C_ORANGE, C_BLACK);
+ disp_disc(LCD_WIDTH / 2, ty + 52, 14, C_CYAN);
disp_flush();
}
diff --git a/terminal/firmware/cosmo_terminal/src/display.h b/terminal/firmware/cosmo_terminal/src/display.h
index 3d2d4ec..a028ab0 100644
--- a/terminal/firmware/cosmo_terminal/src/display.h
+++ b/terminal/firmware/cosmo_terminal/src/display.h
@@ -42,8 +42,9 @@ void disp_bg(void);
void disp_panel(int x, int y, int w, int h, int cut, uint16_t fill, uint16_t border);
/** 面板外侧再描一圈低阶色边框,模拟设计稿的辉光 */
void disp_panel_glow(int x, int y, int w, int h, int cut, uint16_t glow);
-/** 叠加混合贴内置图标(无 alpha:黑色加上去等于没画,霓虹线条自动发光) */
-void disp_add_bitmap(int x, int y, int w, int h, const uint16_t *px);
+/** 叠加混合贴内置图标(无 alpha:黑色加上去等于没画,霓虹线条自动发光)
+ * scale 把 1 个源像素放大成 scale*scale(最近邻),线稿图标放大到全高格子才不糊 */
+void disp_add_bitmap(int x, int y, int w, int h, const uint16_t *px, uint8_t scale = 1);
/** 详情页天体底纹:同心圆 + 十字 + 刻度 */
void disp_radar(int cx, int cy, int r);
@@ -63,6 +64,10 @@ const uint16_t *disp_fb_ptr();
void disp_flush();
void disp_selftest();
+/* 长条屏(640x172)的软件朝向 0..3:画面左右反了/倒了就换 1/2/3,见串口 rot 命令 */
+void disp_set_rot(int r);
+int disp_rot();
+
/* 首次点屏调试开关:不必为了字节序/色序/镜像反复重烧 */
void disp_set_byteswap(bool on);
void disp_set_invert(bool on);
diff --git a/terminal/firmware/cosmo_terminal/src/iconstore.cpp b/terminal/firmware/cosmo_terminal/src/iconstore.cpp
index 275ad70..1b9b23a 100644
--- a/terminal/firmware/cosmo_terminal/src/iconstore.cpp
+++ b/terminal/firmware/cosmo_terminal/src/iconstore.cpp
@@ -8,7 +8,8 @@
typedef struct {
char id[16]; /* 占位的天体 id,空槽为空串 */
- uint32_t ver; /* 已缓存的图标资源号,0 = 数据不可用 */
+ uint32_t ver[SLOT_ART]; /* 已缓存的图标资源号,0 = 数据不可用。两张各记各的:
+ 补图是一张一张来的,不能拿一张的版本当另一张的 */
uint16_t *px[SLOT_ART];
IconArt art[SLOT_ART];
} IconSlot;
@@ -33,7 +34,7 @@ static IconSlot *slot_claim(const char *id, const Snapshot *snap)
bool still_followed = false;
for (int n = 0; n < snap->count; n++)
if (!strcmp(snap->bodies[n].id, s->id)) { still_followed = true; break; }
- if (!still_followed) { s->id[0] = 0; s->ver = 0; }
+ if (!still_followed) { s->id[0] = 0; s->ver[0] = s->ver[1] = 0; }
}
IconSlot *free_slot = NULL;
for (int i = 0; i < MAX_BODIES; i++) {
@@ -43,28 +44,29 @@ static IconSlot *slot_claim(const char *id, const Snapshot *snap)
}
if (!free_slot) free_slot = &s_slot[0]; /* 满员(关注数超过 MAX_BODIES 才会)就抢占 */
strlcpy(free_slot->id, id, sizeof(free_slot->id));
- free_slot->ver = 0;
+ free_slot->ver[0] = free_slot->ver[1] = 0;
return free_slot;
}
+/* 一次一张:40x40 是列表页要的,64x64 是详情页要的,各走一次 HTTP */
static bool slot_fetch(IconSlot *s, const char *base, const char *token,
- const char *body_id, uint32_t ver)
+ const char *body_id, uint32_t ver, int k)
{
- for (int k = 0; k < SLOT_ART; k++) {
- if (!s->px[k]) {
- size_t bytes = (size_t)s_size[k] * s_size[k] * 2;
- s->px[k] = (uint16_t *)heap_caps_malloc(bytes, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
- if (!s->px[k]) { Serial.printf("[icon] %s no PSRAM for %dx%d\n", body_id, s_size[k], s_size[k]); return false; }
- }
- int http = 0;
- size_t bytes = (size_t)s_size[k] * s_size[k] * 2;
- if (!api_icon(base, token, body_id, s_size[k], s->px[k], bytes, &http)) {
- Serial.printf("[icon] %s %dx%d fetch failed http=%d\n", body_id, s_size[k], s_size[k], http);
- return false;
- }
- s->art[k] = IconArt{ s->px[k], s_size[k], s_size[k] };
+ size_t bytes = (size_t)s_size[k] * s_size[k] * 2;
+ if (!s->px[k]) {
+ s->px[k] = (uint16_t *)heap_caps_malloc(bytes, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
+ if (!s->px[k]) { Serial.printf("[icon] %s no PSRAM for %dx%d\n", body_id, s_size[k], s_size[k]); return false; }
}
- s->ver = ver;
+ int http = 0;
+ const uint32_t t0 = millis();
+ if (!api_icon(base, token, body_id, s_size[k], s->px[k], bytes, &http)) {
+ Serial.printf("[icon] %s %dx%d fetch failed http=%d\n", body_id, s_size[k], s_size[k], http);
+ return false;
+ }
+ s->art[k] = IconArt{ s->px[k], s_size[k], s_size[k] };
+ s->ver[k] = ver;
+ Serial.printf("[icon] %s %dx%d v%lu ok %lums\n", body_id, s_size[k], s_size[k],
+ (unsigned long)ver, (unsigned long)(millis() - t0));
return true;
}
@@ -72,24 +74,27 @@ const IconArt *icon_store_get(const BodyData *b, int detail)
{
if (!b->icon_ver || !b->id[0]) return NULL;
IconSlot *s = slot_find(b->id);
- if (!s || s->ver != b->icon_ver) return NULL;
int k = detail ? 1 : 0;
- return s->px[k] ? &s->art[k] : NULL;
+ if (!s || !s->px[k] || s->ver[k] != b->icon_ver) return NULL;
+ return &s->art[k];
}
-void icon_store_sync(const char *base, const char *token, const Snapshot *snap)
+int icon_store_sync(const char *base, const char *token, const Snapshot *snap, int max_fetch)
{
- if (!base || !base[0] || !token || !token[0] || !snap) return;
- for (int i = 0; i < snap->count; i++) {
- const BodyData &b = snap->bodies[i];
- if (!b.icon_ver || !b.id[0]) continue; /* 后台没维护图标 */
- IconSlot *s = slot_claim(b.id, snap);
- if (s->ver == b.icon_ver) continue; /* 已经是最新,一个字节都不拉 */
- uint32_t t0 = millis();
- if (slot_fetch(s, base, token, b.id, b.icon_ver))
- Serial.printf("[icon] %s v%lu ok %lums\n", b.id, (unsigned long)b.icon_ver,
- (unsigned long)(millis() - t0));
+ if (!base || !base[0] || !token || !token[0] || !snap) return 0;
+ int left = 0, failed = 0;
+ /* 外层按尺寸:先把所有列表页那一张补齐,再轮到详情页的 64x64 */
+ for (int k = 0; k < SLOT_ART; k++) {
+ for (int i = 0; i < snap->count; i++) {
+ const BodyData &b = snap->bodies[i];
+ if (!b.icon_ver || !b.id[0]) continue; /* 后台没维护图标 */
+ IconSlot *s = slot_claim(b.id, snap);
+ if (s->ver[k] == b.icon_ver && s->px[k]) continue; /* 这一张已经是最新 */
+ if (max_fetch-- > 0 && !slot_fetch(s, base, token, b.id, b.icon_ver, k)) failed = 1;
+ if (s->ver[k] != b.icon_ver || !s->px[k]) left++;
+ }
}
+ return failed ? -1 : left;
}
void icon_store_dump(void)
@@ -97,7 +102,7 @@ void icon_store_dump(void)
for (int i = 0; i < MAX_BODIES; i++) {
IconSlot *s = &s_slot[i];
if (!s->id[0]) continue;
- Serial.printf("icon : %s v%lu %s\n", s->id, (unsigned long)s->ver,
- s->ver ? "cached" : "empty");
+ Serial.printf("icon : %s v%lu %s%s\n", s->id, (unsigned long)s->ver[0],
+ s->px[0] ? "40" : "-", s->px[1] ? " 64" : "");
}
}
diff --git a/terminal/firmware/cosmo_terminal/src/iconstore.h b/terminal/firmware/cosmo_terminal/src/iconstore.h
index 76c85fb..6539992 100644
--- a/terminal/firmware/cosmo_terminal/src/iconstore.h
+++ b/terminal/firmware/cosmo_terminal/src/iconstore.h
@@ -8,8 +8,10 @@
/** 缓存里有这个天体的图就返回它,否则返回 NULL;detail!=0 要 64x64 大图 */
const IconArt *icon_store_get(const BodyData *b, int detail);
-/** 下载快照里缺的 / 版本变了的图标(走 HTTP,放在 5 分钟数据刷新里调用) */
-void icon_store_sync(const char *base, const char *token, const Snapshot *snap);
+/** 下载快照里缺的 / 版本变了的图标(走 HTTP),最多下 max_fetch 张。
+ * 一张 ≈1.3s(HTTPS 握手占大头),调用方按张切片才不会把列表页冻住:
+ * 返回值 = 还缺几张,0 = 齐了,<0 = 刚才那张拉失败(别再追着重试)。 */
+int icon_store_sync(const char *base, const char *token, const Snapshot *snap, int max_fetch);
/** 串口调试:逐槽打印 id / 版本 / 是否已缓存 */
void icon_store_dump(void);
diff --git a/terminal/firmware/cosmo_terminal/src/imu.cpp b/terminal/firmware/cosmo_terminal/src/imu.cpp
new file mode 100644
index 0000000..b3bd6c6
--- /dev/null
+++ b/terminal/firmware/cosmo_terminal/src/imu.cpp
@@ -0,0 +1,142 @@
+#include
+#include
+#include
+#include "board_config.h"
+#if BOARD_HAS_IMU
+#include "imu.h"
+#include "display.h"
+
+/* 寄存器取官方 SensorLib 的编号;CTRL 序列与 ESPHome/官方例程一致。
+ 总线由 disp_init -> panel_power_on 里的 Wire.begin(SDA,SCL) 开好,这里不重复 begin。 */
+#define QMI_WHOAMI 0x00
+#define QMI_WHOAMI_OK 0x05
+#define QMI_CTRL1 0x02
+#define QMI_CTRL2 0x03
+#define QMI_CTRL5 0x06
+#define QMI_CTRL7 0x08
+#define QMI_AX_L 0x35
+#define QMI_RESET 0x60
+#define QMI_RESET_V 0xB0
+
+#define IMU_PERIOD 200 /* ms,够用来判"人把桌子转了半圈",又不会跟着手抖跳 */
+#define IMU_EMA 0.25f /* 一秒钟左右收敛到新的摆位 */
+#define IMU_TH 0.12f /* g:短轴分量超过这个才认,两侧各一条 = 自带迟滞 */
+
+static uint8_t s_addr;
+static bool s_present;
+static float s_ema[3];
+static int s_flip = -1; /* 0 = 正放 1 = 转了 180° */
+static int s_force = -1; /* -1 = 自动,0/1 = 串口手动钉住 */
+static uint32_t s_next;
+
+static bool im_wr(uint8_t reg, uint8_t v)
+{
+ Wire.beginTransmission(s_addr);
+ Wire.write(reg);
+ Wire.write(v);
+ return Wire.endTransmission() == 0;
+}
+
+static bool im_rd(uint8_t reg, uint8_t *b, uint8_t n)
+{
+ Wire.beginTransmission(s_addr);
+ Wire.write(reg);
+ if (Wire.endTransmission(false) != 0) return false;
+ if (Wire.requestFrom((uint8_t)s_addr, (uint8_t)n) != n) return false;
+ for (int i = 0; i < n; i++) b[i] = (uint8_t)Wire.read();
+ return true;
+}
+
+/* 小端连续六个字节 = AX/AY/AZ,±8g 满量程 */
+static bool im_acc(float g[3])
+{
+ uint8_t b[6];
+ if (!im_rd(QMI_AX_L, b, 6)) return false;
+ const float k = 8.0f / 32768.0f;
+ g[0] = (int16_t)((b[1] << 8) | b[0]) * k;
+ g[1] = (int16_t)((b[3] << 8) | b[2]) * k;
+ g[2] = (int16_t)((b[5] << 8) | b[4]) * k;
+ return true;
+}
+
+/* 长条屏横过来用只有两种合法摆法:rot2 正立、rot3 转 180°(bit1 必须为 1,
+ bit0/1 全 0 那两种是镜像,永远不能用),所以翻转就是换 rot 的 bit0 */
+static bool apply_flip(int f)
+{
+ if (f == s_flip) return false;
+ int r = 2 | (f ? 1 : 0);
+ s_flip = f;
+ disp_set_rot(r);
+ Serial.printf("[imu] %s -> rot=%d\n", f ? "UpsideDown" : "Upright", r);
+ return true;
+}
+
+void imu_begin()
+{
+ const uint8_t cand[2] = { IMU_I2C_ADDR, IMU_I2C_ADDR_ALT };
+ s_addr = 0;
+ for (int i = 0; i < 2 && !s_addr; i++) {
+ uint8_t id = 0;
+ s_addr = cand[i];
+ if (!im_rd(QMI_WHOAMI, &id, 1) || id != QMI_WHOAMI_OK) s_addr = 0;
+ }
+ if (!s_addr) {
+ Serial.printf("[imu] QMI8658 not found @0x%02X/0x%02X\n", cand[0], cand[1]);
+ return;
+ }
+ Wire.beginTransmission(s_addr);
+ Wire.write(QMI_RESET);
+ Wire.write(QMI_RESET_V);
+ Wire.endTransmission();
+ delay(15);
+ im_wr(QMI_CTRL1, 0x40); /* 寄存器地址自增 */
+ im_wr(QMI_CTRL2, (2 << 4) | 0x06); /* CTRL2 FS=2(±8g) | ODR=6(125Hz) */
+ im_wr(QMI_CTRL5, 0x00); /* 内置 LPF 关掉,自己做 EMA */
+ im_wr(QMI_CTRL7, 0x01); /* 只开加速度计,陀螺用不上 */
+ s_present = true;
+ s_flip = disp_rot() & 1; /* 从当前朝向接管,别一上来就翻一下 */
+ Serial.printf("[imu] QMI8658 @0x%02X ok (acc only, ±8g/125Hz) flip=%d\n", s_addr, s_flip);
+}
+
+bool imu_tick(uint32_t now)
+{
+ if (!s_present || (int32_t)(now - s_next) < 0) return false;
+ s_next = now + IMU_PERIOD;
+
+ float g[3];
+ if (!im_acc(g)) return false;
+ for (int i = 0; i < 3; i++) s_ema[i] += IMU_EMA * (g[i] - s_ema[i]);
+
+ if (s_force >= 0) return apply_flip(s_force);
+
+ /* 屏幕朝上平放时短轴分量 ≈ 0,落在迟滞带里 -> 保持上一次判定 */
+ float ay = IMU_Y_SIGN * s_ema[IMU_AXIS_Y];
+ if (ay > IMU_TH) return apply_flip(1);
+ if (ay < -IMU_TH) return apply_flip(0);
+ return false;
+}
+
+void imu_diag()
+{
+ if (!s_present) { Serial.println(F("[imu] QMI8658 not present")); return; }
+ float g[3];
+ if (!im_acc(g)) { Serial.println(F("[imu] read failed")); return; }
+ char ax = 'X' + IMU_AXIS_Y;
+ Serial.printf("[imu] raw %+0.2f %+0.2f %+0.2f g ema %+0.2f %+0.2f %+0.2f\n",
+ g[0], g[1], g[2], s_ema[0], s_ema[1], s_ema[2]);
+ Serial.printf("[imu] short-ax=%c%+0.2f th=%+0.2f -> flip=%d rot=%d (%s)\n",
+ ax, IMU_Y_SIGN * s_ema[IMU_AXIS_Y], IMU_TH, s_flip, disp_rot(),
+ s_force < 0 ? "auto" : "forced");
+}
+
+void imu_force(const char *arg)
+{
+ if (!s_present) { Serial.println(F("[imu] QMI8658 not present")); return; }
+ if (!arg || !*arg || !strcmp(arg, "auto")) s_force = -1;
+ else if (!strcmp(arg, "0")) s_force = 0;
+ else if (!strcmp(arg, "1")) s_force = 1;
+ else { Serial.println(F("flip [0|1|auto]")); return; }
+ Serial.printf("[imu] flip=%s\n", s_force < 0 ? "auto" : (s_force ? "1 (180)" : "0 (upright)"));
+ if (s_force >= 0) apply_flip(s_force);
+}
+#endif
diff --git a/terminal/firmware/cosmo_terminal/src/imu.h b/terminal/firmware/cosmo_terminal/src/imu.h
new file mode 100644
index 0000000..ac93286
--- /dev/null
+++ b/terminal/firmware/cosmo_terminal/src/imu.h
@@ -0,0 +1,30 @@
+/**
+ * QMI8658 加速度计(系统 I2C,和 TCA9554 同一条总线):
+ * 只用它分辨"屏幕这条短轴哪一头朝上",也就是设备是正放还是转了 180° 放,
+ * 决定长条屏用 rot2 还是 rot3。
+ *
+ * 物理限制:设备完全平放(屏幕朝上/朝下)时重力全落在法线方向,
+ * 短轴上分不出左右,这时保持上一次判定不动——加速度计天生测不出来的东西不硬猜。
+ */
+#pragma once
+#include
+#include "board_config.h"
+
+#if BOARD_HAS_IMU
+
+/* ---- 标定旋钮:把设备摆成正放(USB 在右、长边水平)时,
+ 读数落在屏幕短轴(逻辑 y,指向 UI 下边缘为正)上的那根轴和它的符号。
+ 串口 `imu` 打印三个轴的实测值,实测后定这两个宏。 ---- */
+#ifndef IMU_AXIS_Y
+#define IMU_AXIS_Y 1 /* 0=X 1=Y 2=Z */
+#endif
+#ifndef IMU_Y_SIGN
+#define IMU_Y_SIGN 1 /* +1 / -1 */
+#endif
+
+void imu_begin();
+bool imu_tick(uint32_t now); /* loop 里调:判定变化并已换 rot 时返回 true(调用方负责重绘) */
+void imu_diag(); /* 串口 `imu` */
+void imu_force(const char *arg); /* 串口 `flip [0|1|auto]` */
+
+#endif
diff --git a/terminal/firmware/cosmo_terminal/src/keys.cpp b/terminal/firmware/cosmo_terminal/src/keys.cpp
index 99f1803..b6b1b13 100644
--- a/terminal/firmware/cosmo_terminal/src/keys.cpp
+++ b/terminal/firmware/cosmo_terminal/src/keys.cpp
@@ -8,6 +8,10 @@ void keys_begin()
#if BOARD_HAS_XL9555
if (!xl_begin()) Serial.println(F("[xl] XL9555 not responding (keys/LCD power may fail)"));
pinMode(PIN_KEY_BOOT, INPUT_PULLUP);
+#elif COSMO_BOARD == 3
+ /* 侧面三颗键里只有 BOOT(GPIO0) 可编程:PWR 是电源锁存,RESET 是 EN。
+ 其余交互全交给触摸,这里这颗键当 OK 用。 */
+ pinMode(PIN_KEY_BOOT, INPUT_PULLUP);
#else
pinMode(PIN_KEY_UP, INPUT_PULLUP);
pinMode(PIN_KEY_DN, INPUT_PULLUP);
@@ -19,6 +23,10 @@ uint16_t keys_read()
{
#if BOARD_HAS_XL9555
return xl_keys_read();
+#elif COSMO_BOARD == 3
+ uint16_t k = 0;
+ if (digitalRead(PIN_KEY_BOOT) == LOW) k |= XL_IO_KEY2;
+ return k;
#else
uint16_t k = 0;
if (digitalRead(PIN_KEY_UP) == LOW) k |= XL_IO_KEY0;
@@ -47,6 +55,11 @@ uint16_t keys_raw()
{
#if BOARD_HAS_XL9555
return xl_keys_raw();
+#else
+#if COSMO_BOARD == 3
+ uint16_t v = 0xFFFF;
+ if (digitalRead(PIN_KEY_BOOT) == LOW) v &= (uint16_t)~XL_IO_KEY2;
+ return v;
#else
uint16_t v = 0xFFFF; /* 当作 XL 输入寄存器来看:按下=0 */
if (digitalRead(PIN_KEY_UP) == LOW) v &= (uint16_t)~XL_IO_KEY0;
@@ -54,4 +67,5 @@ uint16_t keys_raw()
if (digitalRead(PIN_KEY_OK) == LOW) v &= (uint16_t)~XL_IO_KEY2;
return v;
#endif
+#endif
}
diff --git a/terminal/firmware/cosmo_terminal/src/power.cpp b/terminal/firmware/cosmo_terminal/src/power.cpp
new file mode 100644
index 0000000..f42d87f
--- /dev/null
+++ b/terminal/firmware/cosmo_terminal/src/power.cpp
@@ -0,0 +1,175 @@
+#include
+#include
+#include "board_config.h"
+#if BOARD_HAS_BATTERY
+#include "power.h"
+
+/* 总线由这里第一个 begin:电池/电源锁必须比屏、触摸、IMU 都早。
+ 后面 disp_init 再 begin 一次只是 no-op + 一条 warning。 */
+
+#define BAT_SAMPLES 8
+
+static int s_mv = -1;
+static int s_pct = -1;
+static bool s_chg;
+static uint32_t s_next;
+
+static bool tca_write8(uint8_t reg, uint8_t v)
+{
+ Wire.beginTransmission(TCA9554_ADDR);
+ Wire.write(reg);
+ Wire.write(v);
+ return Wire.endTransmission() == 0;
+}
+
+static bool tca_read8(uint8_t reg, uint8_t *v)
+{
+ Wire.beginTransmission(TCA9554_ADDR);
+ Wire.write(reg);
+ if (Wire.endTransmission(false) != 0) return false;
+ if (Wire.requestFrom((uint8_t)TCA9554_ADDR, (uint8_t)1) != 1) return false;
+ *v = (uint8_t)Wire.read();
+ return true;
+}
+
+static bool sys_en_held()
+{
+ uint8_t out = 0;
+ return tca_read8(TCA_REG_OUTPUT, &out) && (out & TCA_IO_SYS_EN);
+}
+
+void pwr_hold_early()
+{
+ Wire.begin(PIN_I2C_SDA, PIN_I2C_SCL, 400000);
+ /* 只按 PWR 冷启动时 TCA9554 刚得电,第一次 I2C 往往还没 ready。
+ 这里放弃等于松手就掉电,所以反复碰直到成功(最多约 300ms,远小于按住不放的时间)。 */
+ bool found = false;
+ for (int i = 0; i < 20; i++) {
+ Wire.beginTransmission(TCA9554_ADDR);
+ if (Wire.endTransmission() == 0) { found = true; break; }
+ delay(15);
+ }
+ if (!found) {
+ Serial.println(F("[pwr] no TCA9554 -> V1 wiring, nothing to latch"));
+ return;
+ }
+ uint8_t out = 0, cfg = 0xFF;
+ tca_read8(TCA_REG_OUTPUT, &out);
+ tca_read8(TCA_REG_CONFIG, &cfg);
+ /* 只动 SYS_EN 这一位:其余脚留给 disp_init(背光/复位)和中断输入。
+ 顺序不能反:先把输出锁存写高(这时方向还是输入,不会驱动引脚),
+ 再把方向改成输出。反过来会有一瞬间把 SYS_EN 拉低,电池供电时那就是直接关机。 */
+ for (int i = 0; i < 4 && !sys_en_held(); i++) {
+ tca_write8(TCA_REG_OUTPUT, (uint8_t)(out | TCA_IO_SYS_EN));
+ tca_write8(TCA_REG_CONFIG, (uint8_t)(cfg & ~TCA_IO_SYS_EN));
+ delay(2);
+ }
+ /* PWR 键的另一头在 IO16(SYS_OUT):按下时经 D3 把这一脚拖低,松开被 R9 10K
+ 拉回 3V3。官方例程 button_bsp.c 同样把 IO16 当按键读(INPUT + 上拉)。 */
+ pinMode(PIN_SYS_OUT, INPUT_PULLUP);
+ Serial.printf("[pwr] SYS_EN=%d (out=0x%02X cfg=0x%02X)\n",
+ sys_en_held(), out | TCA_IO_SYS_EN, cfg & (uint8_t)~TCA_IO_SYS_EN);
+}
+
+/* ---------------- 长按 PWR 关机 ----------------
+ 按住 PWR 时 Key1 节点直接短到 GND,Q2(AO3401) 的 gate 被拉低 → 电池硬接通,
+ 这一段纯硬件,固件拦不住;固件能关的只有"松手之后靠什么维持"那一半:
+ SYS_EN 写 0,松手瞬间 Q2 关断 → 整板断电。所以官方文案是
+ 「长按 PWR 按键,等待屏幕显示 OFF…松开按键即可」。
+ 两条前提:
+ 1) 开机那次长按不算关机:按住开机期间 IO16 一直是低,必须先看到一次高(松手)
+ 才开始计时,否则每次开机都会被自己关掉。
+ 2) USB 插着时写 0 不会断电(VBUS 经 D1 直接供 VSYS),只会变成"按了没反应",
+ 所以 USB 在位直接忽略。 */
+#define PWR_OFF_MS 3000
+
+static uint32_t s_press; /* 本次按下的起始时刻,0 = 没按 */
+static bool s_boot_hold = true; /* 开机那一次长按,作废 */
+
+void pwr_key_poll(uint32_t now)
+{
+ if (digitalRead(PIN_SYS_OUT) == LOW) {
+ if (!s_press) s_press = now;
+ return;
+ }
+ const uint32_t held = s_press ? (now - s_press) : 0;
+ s_press = 0;
+ if (s_boot_hold) { s_boot_hold = false; return; }
+ if (held < PWR_OFF_MS) return;
+ if (bat_charging()) {
+ Serial.printf("[pwr] PWR held %lums ignored: USB powered, SYS_EN=0 cannot cut VBUS\n",
+ (unsigned long)held);
+ return;
+ }
+ uint8_t out = 0;
+ if (!tca_read8(TCA_REG_OUTPUT, &out)) {
+ Serial.println(F("[pwr] long press: TCA9554 read failed, refuse to cut power"));
+ return;
+ }
+ Serial.printf("[pwr] PWR held %lums -> SYS_EN=0, power off\n", (unsigned long)held);
+ tca_write8(TCA_REG_OUTPUT, (uint8_t)(out & (uint8_t)~TCA_IO_SYS_EN));
+}
+
+void bat_begin()
+{
+ analogSetPinAttenuation(PIN_BAT_ADC, ADC_11db);
+}
+
+/* 单节锂电的放电曲线是中间平、两头陡,只能按表插值 */
+static const uint16_t kMv[] = {3300, 3500, 3600, 3680, 3750, 3830, 3930, 4020, 4100, 4150, 4200};
+static const uint8_t kPct[] = {0, 5, 13, 20, 40, 55, 70, 85, 92, 97, 100};
+
+static int pct_of(int mv)
+{
+ if (mv <= kMv[0]) return 0;
+ for (unsigned i = 1; i < sizeof(kMv) / sizeof(kMv[0]); i++) {
+ if (mv <= (int)kMv[i]) {
+ int span = kMv[i] - kMv[i - 1];
+ return kPct[i - 1] + (mv - kMv[i - 1]) * (kPct[i] - kPct[i - 1]) / span;
+ }
+ }
+ return 100;
+}
+
+bool bat_poll(uint32_t now)
+{
+ if ((int32_t)(now - s_next) < 0) return false;
+ s_next = now + 2000;
+
+ int lo = 1 << 30, hi = 0, sum = 0;
+ for (int i = 0; i < BAT_SAMPLES; i++) {
+ int v = analogReadMilliVolts(PIN_BAT_ADC);
+ if (v < lo) lo = v;
+ if (v > hi) hi = v;
+ sum += v;
+ }
+ /* 去掉一个最高一个最低再平均,躲开屏和背光开关时的尖峰 */
+ /* R3 200K / R15 100K 串分压,脚上电压 x3 才是电池电压 */
+ const int mv = (sum - lo - hi) * 3 / (BAT_SAMPLES - 2);
+
+ const int op = s_pct;
+ s_mv = mv;
+ s_pct = bat_present() ? pct_of(mv) : -1;
+ bool chg = bat_charging();
+ bool changed = (s_pct != op) || (chg != s_chg);
+ s_chg = chg;
+ return changed;
+}
+
+int bat_mv() { return s_mv < 0 ? 0 : s_mv; }
+int bat_percent() { return s_pct; }
+bool bat_present() { return s_mv >= 2500; }
+bool bat_charging() { return Serial.isPlugged(); }
+
+void bat_report()
+{
+ uint8_t out = 0;
+ bool latched = tca_read8(TCA_REG_OUTPUT, &out) && (out & TCA_IO_SYS_EN);
+ Serial.printf("[bat] %d mV %s usb=%s charging=%s\n",
+ bat_mv(),
+ bat_present() ? "battery present" : "NO BATTERY (node floating)",
+ bat_charging() ? "plugged" : "absent",
+ bat_charging() ? "yes" : "no(usb absent)");
+ Serial.printf("[bat] TCA9554 out=0x%02X SYS_EN=%s\n", out, latched ? "1 (held)" : "0/off");
+}
+#endif
diff --git a/terminal/firmware/cosmo_terminal/src/power.h b/terminal/firmware/cosmo_terminal/src/power.h
new file mode 100644
index 0000000..1d3cdad
--- /dev/null
+++ b/terminal/firmware/cosmo_terminal/src/power.h
@@ -0,0 +1,42 @@
+/**
+ * 18650 锂电池与整板电源锁(只有 Waveshare 3.49 长条板带电池座)。
+ *
+ * 硬件(官方 V2 原理图 POWER 页):
+ * BAT_ADC = GPIO4 = ADC1_CH3,R3 200K / R15 100K 分压,所以 VBAT = 实测 x3;
+ * 电芯就在板上的 18650 座里(丝印 BAT 那两个焊盘是未贴片的可选座,没有塑壳);
+ * 电源锁是高侧 P-MOS Q2(AO3401,source=VBAT),gate 由 R42 10K 上拉到 VBAT=关,
+ * 拉低它只有一条出路:Key1(PWR) 节点 -> GND。两条支路汇到那个节点:
+ * 按键:Key1 闭合直接短到 GND(纯硬件,按住才有)
+ * 固件:TCA9554 EXIO6(=P6=pin11) -> R43 1K -> T1(8050) -> gate ← 唯一能保持的手段
+ * GPIO16(SYS_OUT) 只是感知脚,不能保持:D3 和 D4 的阴极都朝向 Key1 节点,
+ * IO16 拉低只会让 D3 反偏(latch 断开时该节点被 R42/D4 抬到 ~3.5V,D3 反偏 → IO16 读到高;
+ * 按下 PWR 才把 IO16 拖低,所以官方用 gpio_get_level(16)==0 判按键)。
+ * 充电芯片 ETA6098C1 的 STAT 只接指示灯 LED,没有进 MCU,扩展器 8 位也全被占用,
+ * 所以"是否在充电"只能按"USB 插着"近似;也没有电池在位检测,
+ * 座子空着时 BAT_ADC 会空载浮到 ~4.2V,所以电压不能用来判断电池在不在。
+ * 曾经"寄存器看着=1、拔 USB 仍立刻黑屏"的真因是方向寄存器地址写错(0x02 应为 0x03),
+ * 已修复并真机验证:拔掉 USB 屏幕保持常亮;长按 PWR 3 秒松手 = 断电关机。
+ * 排查期用过的 pwr / hold / holdio / sysout 四条串口命令已经删掉,结论留在 README。
+ */
+#pragma once
+#include
+#include "board_config.h"
+
+#if BOARD_HAS_BATTERY
+
+/* setup() 第一件事:把 SYS_EN 拉高锁住电源。必须在任何耗时动作之前。 */
+void pwr_hold_early();
+
+void bat_begin();
+/* loop 里调:约 2 秒采一次;显示值变了返回 true(调用方负责重绘) */
+bool bat_poll(uint32_t now);
+
+int bat_mv(); /* 电池电压 mV */
+int bat_percent(); /* 0..100,-1 = 没测到电池 */
+bool bat_present(); /* 电压高到像是真接了一节电池 */
+bool bat_charging(); /* USB 在位就当作在充 */
+void bat_report(); /* 串口 batt:现场判断电池到底装没装上 */
+/* loop 里调:长按 PWR 3 秒后松手 = SYS_EN 写 0 = 断电关机(只在电池供电时生效) */
+void pwr_key_poll(uint32_t now);
+
+#endif
diff --git a/terminal/firmware/cosmo_terminal/src/rocketstore.cpp b/terminal/firmware/cosmo_terminal/src/rocketstore.cpp
index 52353ab..96db409 100644
--- a/terminal/firmware/cosmo_terminal/src/rocketstore.cpp
+++ b/terminal/firmware/cosmo_terminal/src/rocketstore.cpp
@@ -59,12 +59,16 @@ static bool slot_fetch(RocketSlot *s, const char *base, const char *token, int k
if (!s->px[k]) { Serial.printf("[art] %s no PSRAM for %dx%d\n", s->code, s_size[k], s_size[k]); return false; }
}
int http = 0;
+ const uint32_t t0 = millis();
if (!api_rocket_art(base, token, s->code, s_size[k], s->px[k], bytes, &http)) {
Serial.printf("[art] %s %dx%d fetch failed http=%d\n", s->code, s_size[k], s_size[k], http);
return false;
}
s->art[k] = IconArt{ s->px[k], s_size[k], s_size[k] };
s->ver[k] = ver;
+ /* 两条补图路径都走这里,成不成都要看得见:一次列表同步要连发好几张 */
+ Serial.printf("[art] %s %dx%d v%lu %s%lums\n", s->code, s_size[k], s_size[k],
+ (unsigned long)ver, "ok ", (unsigned long)(millis() - t0));
return true;
}
@@ -89,24 +93,23 @@ bool rocket_store_ensure(const char *base, const char *token,
RocketSlot *s = slot_claim(code);
int k = detail ? 1 : 0;
if (slot_ready(s, k, art_ver)) return true;
- uint32_t t0 = millis();
- if (!slot_fetch(s, base, token, k, art_ver)) return false;
- Serial.printf("[art] %s %dx%d v%lu ok %lums\n", code, s_size[k], s_size[k],
- (unsigned long)art_ver, (unsigned long)(millis() - t0));
- return true;
+ return slot_fetch(s, base, token, k, art_ver);
}
-void rocket_store_sync(const char *base, const char *token, const RocketSnapshot *snap)
+int rocket_store_sync(const char *base, const char *token, const RocketSnapshot *snap, int max_fetch)
{
- if (!base || !base[0] || !token || !token[0] || !snap) return;
+ if (!base || !base[0] || !token || !token[0] || !snap) return 0;
slot_prune(snap);
+ int left = 0, failed = 0;
for (int i = 0; i < snap->count; i++) {
const RocketData &r = snap->rockets[i];
if (!r.art_ver || !r.code[0]) continue;
RocketSlot *s = slot_claim(r.code);
if (slot_ready(s, 0, r.art_ver)) continue; /* 列表图已经是最新 */
- slot_fetch(s, base, token, 0, r.art_ver);
+ if (max_fetch-- > 0 && !slot_fetch(s, base, token, 0, r.art_ver)) failed = 1;
+ if (!slot_ready(s, 0, r.art_ver)) left++;
}
+ return failed ? -1 : left;
}
void rocket_store_dump(void)
diff --git a/terminal/firmware/cosmo_terminal/src/rocketstore.h b/terminal/firmware/cosmo_terminal/src/rocketstore.h
index f041efb..7f984d4 100644
--- a/terminal/firmware/cosmo_terminal/src/rocketstore.h
+++ b/terminal/firmware/cosmo_terminal/src/rocketstore.h
@@ -7,8 +7,10 @@
/** 缓存里有这个型号的图就返回它,否则返回 NULL(版本对不上也算没有) */
const IconArt *rocket_store_get(const char *code, uint32_t art_ver, int detail);
-/** 补齐快照里所有型号缺的 40x40(版本没变的型号一个字节都不拉) */
-void rocket_store_sync(const char *base, const char *token, const RocketSnapshot *snap);
+/** 补齐快照里缺的 40x40(版本没变的型号一个字节都不拉),最多下 max_fetch 张。
+ * 一张 ≈1.3s(HTTPS 握手占大头),调用方按张切片才不会把列表页冻住:
+ * 返回值 = 还缺几张,0 = 齐了,<0 = 刚才那张拉失败(别再追着重试)。 */
+int rocket_store_sync(const char *base, const char *token, const RocketSnapshot *snap, int max_fetch);
/** 补齐某个型号的某个尺寸;进详情页时拉 64x64 用。失败返回 false,画面退回内置线稿 */
bool rocket_store_ensure(const char *base, const char *token,
diff --git a/terminal/firmware/cosmo_terminal/src/store.h b/terminal/firmware/cosmo_terminal/src/store.h
index 050ce99..6847d9c 100644
--- a/terminal/firmware/cosmo_terminal/src/store.h
+++ b/terminal/firmware/cosmo_terminal/src/store.h
@@ -14,6 +14,7 @@ void store_erase(const char *key);
#define K_TOKEN "token"
#define K_USER "user"
#define K_MODE "mode"
+#define K_ROT "rot" /* 长条屏软件朝向:装反了不用重烧固件 */
/* OTA 确认标记:切启动分区前写上新版本,首屏画出后清掉;见 src/ota.cpp */
#define K_OTA_PENDING "ota_pend"
#define K_OTA_TRIES "ota_try"
diff --git a/terminal/firmware/cosmo_terminal/src/touch.cpp b/terminal/firmware/cosmo_terminal/src/touch.cpp
new file mode 100644
index 0000000..e432442
--- /dev/null
+++ b/terminal/firmware/cosmo_terminal/src/touch.cpp
@@ -0,0 +1,118 @@
+#include
+#include
+#include "board_config.h"
+#if BOARD_HAS_TOUCH
+#include "touch.h"
+#include "display.h"
+
+/* 官方例程固定这条查询:写 11 字节触发一次采样,再读 32 字节。
+ buff[1] = 手指数(1..4),X/Y 各 12bit 藏在两个字节里。 */
+#define TP_CMD_LEN 11
+#define TP_RD_LEN 32
+
+static const uint8_t k_cmd[TP_CMD_LEN] = {
+ 0xB5, 0xAB, 0xA5, 0x5A, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00
+};
+
+static bool s_present;
+
+/* ---- 采样质量统计(串口 `touch on` 每秒打一行) ----
+ 电容屏在没有手指时也会偶发冒出一两帧假坐标,光看"这一下有没有手指"分不出来;
+ 一次接触的**连续真帧长度**和**坐标漂移**能分:假帧通常只冒 1~2 帧、坐标乱跳,
+ 指尖哪怕点得再快也压得住 4 帧以上。这组计数是滤波参数的唯一依据。 */
+#define TP_STAT_HIST 4 /* 连续真帧长度分布: 1 / 2 / 3 / >=4 */
+static uint32_t s_st_polls, s_st_true;
+static uint16_t s_st_hist[TP_STAT_HIST], s_st_maxrun;
+static int16_t s_st_span, s_st_ux, s_st_uy; /* 最长那次接触的漂移跨度、起点 */
+static int s_run;
+static int s_ru_x0, s_ru_y0, s_ru_minx, s_ru_miny, s_ru_maxx, s_ru_maxy;
+
+static void run_close()
+{
+ if (s_run > 0) {
+ int span = s_ru_maxx - s_ru_minx, t = s_ru_maxy - s_ru_miny;
+ if (span < t) span = t;
+ s_st_hist[s_run >= TP_STAT_HIST ? TP_STAT_HIST - 1 : s_run - 1]++;
+ if (s_run > s_st_maxrun) { s_st_maxrun = s_run; s_st_span = span; s_st_ux = s_ru_x0; s_st_uy = s_ru_y0; }
+ }
+ s_run = 0;
+}
+
+/* 打一行统计并清零:调用方决定节拍 */
+void touch_stats_report()
+{
+ /* 正在按着的那次不结算:半截接触会在边界上多算出一个 len1,污染分布 */
+ Serial.printf("[tp] poll=%lu true=%lu len1=%u len2=%u len3=%u len4+=%u max=%u@(%d,%d) span=%d\n",
+ (unsigned long)s_st_polls, (unsigned long)s_st_true,
+ s_st_hist[0], s_st_hist[1], s_st_hist[2], s_st_hist[3],
+ s_st_maxrun, s_st_ux, s_st_uy, s_st_span);
+ s_st_polls = s_st_true = 0; s_st_maxrun = 0; s_st_span = 0;
+ memset(s_st_hist, 0, sizeof(s_st_hist));
+}
+
+static bool tp_read(uint8_t *b)
+{
+ if (!s_present) return false;
+ Wire1.beginTransmission(TP_I2C_ADDR);
+ Wire1.write(k_cmd, TP_CMD_LEN);
+ if (Wire1.endTransmission() != 0) return false;
+ if (Wire1.requestFrom((uint8_t)TP_I2C_ADDR, (uint8_t)TP_RD_LEN) != TP_RD_LEN) return false;
+ for (int i = 0; i < TP_RD_LEN; i++) b[i] = (uint8_t)Wire1.read();
+ return b[1] >= 1 && b[1] <= 4;
+}
+
+void touch_begin()
+{
+ Wire1.begin(PIN_TP_SDA, PIN_TP_SCL, 300000);
+ Wire1.beginTransmission(TP_I2C_ADDR);
+ s_present = (Wire1.endTransmission() == 0);
+ Serial.printf("[tp] AXS15231B touch @0x%02X %s (SDA=%d SCL=%d) raw=%dx%d swap=%d inv=%d%d\n",
+ TP_I2C_ADDR, s_present ? "ok" : "NOT FOUND", PIN_TP_SDA, PIN_TP_SCL,
+ TP_RAW_W, TP_RAW_H, TP_SWAP_XY, TP_INVERT_X, TP_INVERT_Y);
+}
+
+bool touch_present() { return s_present; }
+
+static int clampi(int v, int hi) { return v < 0 ? 0 : (v >= hi ? hi - 1 : v); }
+
+bool touch_poll(int &x, int &y)
+{
+ uint8_t b[TP_RD_LEN];
+ s_st_polls++;
+ if (!tp_read(b)) { run_close(); return false; }
+ int rx = ((b[2] & 0x0F) << 8) | b[3];
+ int ry = ((b[4] & 0x0F) << 8) | b[5];
+ /* 先还原成面板坐标(横屏画布是软件转置出来的,触摸控制器只认原生 172x640),
+ 再按 disp_flush 同一套 rot 位换算到逻辑坐标,两边才不会左右手反着走 */
+ int pc = TP_SWAP_XY ? ry : rx; /* 面板列 0..PANEL_WIDTH-1 */
+ int pr = TP_SWAP_XY ? rx : ry; /* 面板行 0..PANEL_HEIGHT-1 */
+ pc = pc * PANEL_WIDTH / TP_RAW_W;
+ pr = pr * PANEL_HEIGHT / TP_RAW_H;
+ if (TP_INVERT_X) pc = PANEL_WIDTH - 1 - pc;
+ if (TP_INVERT_Y) pr = PANEL_HEIGHT - 1 - pr;
+ x = clampi((disp_rot() & 1) ? (PANEL_HEIGHT - 1 - pr) : pr, LCD_WIDTH);
+ y = clampi((disp_rot() & 2) ? (PANEL_WIDTH - 1 - pc) : pc, LCD_HEIGHT);
+ if (!s_run) {
+ s_ru_x0 = x; s_ru_y0 = y; s_ru_minx = s_ru_maxx = x; s_ru_miny = s_ru_maxy = y;
+ } else {
+ if (x < s_ru_minx) s_ru_minx = x;
+ if (x > s_ru_maxx) s_ru_maxx = x;
+ if (y < s_ru_miny) s_ru_miny = y;
+ if (y > s_ru_maxy) s_ru_maxy = y;
+ }
+ s_run++; s_st_true++;
+ return true;
+}
+
+void touch_diag()
+{
+ uint8_t b[TP_RD_LEN];
+ if (!s_present) { Serial.println(F("[tp] controller not responding")); return; }
+ if (!tp_read(b)) { Serial.println(F("[tp] -")); return; }
+ int x, y;
+ touch_poll(x, y);
+ int rx = ((b[2] & 0x0F) << 8) | b[3];
+ int ry = ((b[4] & 0x0F) << 8) | b[5];
+ Serial.printf("[tp] n=%d raw=%4d,%4d -> px=%3d,%3d rot=%d\n", b[1], rx, ry, x, y, disp_rot());
+}
+#endif
diff --git a/terminal/firmware/cosmo_terminal/src/touch.h b/terminal/firmware/cosmo_terminal/src/touch.h
new file mode 100644
index 0000000..4678734
--- /dev/null
+++ b/terminal/firmware/cosmo_terminal/src/touch.h
@@ -0,0 +1,39 @@
+/**
+ * 电容触摸:3.49 长条屏的触摸控制器就是屏驱动 IC(AXS15231B)自带的,
+ * 但走的是**第二条** I2C(SDA17/SCL18,地址 0x3B),没有中断脚,只能轮询。
+ * 坐标先按编译期开关映射成面板像素:出厂只知它是 12bit 原始值,
+ * 真实量程/方向要靠串口 `touch` 命令点四个角标定,标定完改下面的宏重编译。
+ */
+#pragma once
+#include
+#include "board_config.h"
+
+#if BOARD_HAS_TOUCH
+
+/* ---- 标定:按厂方 LVGL 例程定死(10_LVGL_V9_Test/lvgl_port.c) ----
+ 它把一次采样写成 indev.point.x = rawY、indev.point.y = 640 - rawX,
+ 也就是原始 X 走的是**长边**(0..640,方向和面板行相反)、原始 Y 走的是**短边**
+ (0..172)。和本模块"面板列=X / 面板行=Y"的约定正好对调,所以必须 swap + 行镜像。 */
+#ifndef TP_SWAP_XY
+#define TP_SWAP_XY 1 /* 1 = 原始 XY 和面板 XY 对调 */
+#endif
+#ifndef TP_INVERT_X
+#define TP_INVERT_X 0 /* 1 = X 镜像 */
+#endif
+#ifndef TP_INVERT_Y
+#define TP_INVERT_Y 1 /* 1 = Y 镜像 */
+#endif
+#ifndef TP_RAW_W
+#define TP_RAW_W 172 /* 映射到面板列那一轴的满量程(原始 Y) */
+#endif
+#ifndef TP_RAW_H
+#define TP_RAW_H 640 /* 映射到面板行那一轴的满量程(原始 X) */
+#endif
+
+void touch_begin();
+bool touch_present();
+bool touch_poll(int &x, int &y); /* 有手指 -> true,坐标已映射并夹到面板内 */
+void touch_diag(); /* 一行原始值 + 映射值,标定量程/镜像用 */
+void touch_stats_report(); /* 采样质量统计:连续真帧长度分布,诊断误点用 */
+
+#endif
diff --git a/terminal/firmware/cosmo_terminal/src/ui.cpp b/terminal/firmware/cosmo_terminal/src/ui.cpp
index 8b4c620..0c99ed3 100644
--- a/terminal/firmware/cosmo_terminal/src/ui.cpp
+++ b/terminal/firmware/cosmo_terminal/src/ui.cpp
@@ -10,14 +10,96 @@
#include "icons.h"
#include "board_config.h"
#include "ota.h"
+#include "clock.h"
#include
-/* 版面:状态栏 0..19 / 内容区 22..212 / 按键条 216..235(切角金色按钮=板上物理按键图例) */
-#define TOP_Y 22
-#define BOT_Y 212
-#define KEY_Y 216
+/* 版面:header 那行 0..HDR_LINE / 内容区 TOP_Y..BOT_Y / 按键条。
+ 320x240 横屏就是设计稿原尺寸:内容区占满整宽,底部一条四个按键的图例。
+ 640x172 长条屏(带触摸)整屏横向布局:没有按钮条——上下滑翻页、卡片和分页标签直接点,
+ 页面级动作只剩 header 右端那 1~2 颗按钮(见 header_buttons)。
+ header 那行的留白:长条屏 1px ≈ 0.13mm,按钮文字上下各 3px、header 与内容区之间 3px,
+ 横屏那版的几个常量维持原值,设计稿尺寸不动。 */
+#if LCD_HEIGHT < 200
+#define STRIP 1 /* 长条屏 */
+#else
+#define STRIP 0
+#endif
+#define HDR_TY (STRIP ? 5 : 2) /* header 那行文字的 y */
+#define HDR_LINE (STRIP ? 27 : 19) /* header 与内容区之间的分隔线 */
+#define TOP_Y (STRIP ? 31 : 22) /* 内容区顶 */
+#define CONT_W LCD_WIDTH
+#if STRIP
+#define KEY_H 0
+#define BOT_Y (LCD_HEIGHT - 1)
+#else
#define KEY_H 20
-#define LIST_ROWS 3 /* 3 张卡:y=22+n*65,h=60,正好铺到 212 */
+#define BOT_Y (LCD_HEIGHT - KEY_H - 8)
+#define KEY_Y (LCD_HEIGHT - KEY_H - 4)
+#endif
+
+/* 右端那一列右对齐文字(状态栏右端的用户名、详情页标题行右端的日期)共同的右边界。
+ 长条屏的 header 按钮就画在右上角,它得先按按钮宽度往左让。 */
+static int s_info_r = CONT_W - 4;
+#define LIST_ROWS (STRIP ? 2 : 3) /* 长条屏 2 张卡 y=31/101,h=66,铺到 167 */
+#define CARD_H (STRIP ? 66 : 60)
+#define CARD_X 3
+#define RAIL_W (STRIP ? 30 : 0) /* 长条屏列表页右缘那一竖条(上/下键)占的列宽 */
+#define CARD_W (CONT_W - 6 - RAIL_W)
+#define CARD_PITCH (STRIP ? 70 : 65)
+#define SB_X (CONT_W - 3) /* 右缘滚动条 */
+#define SPLASH_PAD 52
+#define CARD_TY (STRIP ? 14 : 8) /* 卡内标题行 / 副行的 y 偏移 */
+#define CARD_SY (STRIP ? 42 : 34)
+
+/* ---------------- 触摸热区 ----------------
+ 画每一页时顺手把可点的矩形登记进来(ui_draw 重绘前清空)。一次按下落在哪个矩形,
+ 就等于按下那颗按键:bits 是 XL_IO_KEY*,index 顺带告诉调用方选中的是第几行。 */
+#define UI_MAX_HITS 16
+
+struct UiHit { int16_t x, y, w, h; uint16_t bits; int8_t index; };
+static UiHit s_hits[UI_MAX_HITS];
+static uint8_t s_nhits;
+
+void ui_hits_reset() { s_nhits = 0; }
+
+void ui_hit_add(int x, int y, int w, int h, uint16_t bits, int index)
+{
+ if (s_nhits >= UI_MAX_HITS) return;
+ s_hits[s_nhits].x = (int16_t)x; s_hits[s_nhits].y = (int16_t)y;
+ s_hits[s_nhits].w = (int16_t)w; s_hits[s_nhits].h = (int16_t)h;
+ s_hits[s_nhits].bits = bits; s_hits[s_nhits].index = (int8_t)index;
+ s_nhits++;
+}
+
+/* 后登记的盖在先登记的上面,所以倒着找 */
+static const UiHit *hit_find(int x, int y)
+{
+ for (int i = s_nhits - 1; i >= 0; i--) {
+ const UiHit &r = s_hits[i];
+ if (x >= r.x && x < r.x + r.w && y >= r.y && y < r.y + r.h) return &r;
+ }
+ return NULL;
+}
+
+uint16_t ui_hit_test(int x, int y, int *index)
+{
+ const UiHit *r = hit_find(x, y);
+ if (index) *index = r ? r->index : -1;
+ return r ? r->bits : 0;
+}
+
+#if BOARD_HAS_TOUCH
+#define HIT(x, y, w, h, bits, idx) ui_hit_add(x, y, w, h, bits, idx)
+#else
+#define HIT(x, y, w, h, bits, idx)
+#endif
+
+/* 窄屏上写死的行距会撞车:文字先按行宽折行,再把光标推到最后一行下面 */
+static int flow(int x, int y, int w, const char *s, uint16_t fg, uint16_t bg, int gap = 6)
+{
+ if (!s || !s[0]) return y;
+ return disp_text_wrap(x, y, w, s, 16, fg, bg, 3) + gap;
+}
static void text_right(int x_right, int y, const char *s, uint8_t size, uint16_t fg, uint16_t bg)
{
@@ -90,9 +172,13 @@ static void text_elided(int x, int y, int maxw, const char *s, uint16_t fg, uint
while (q > 0 && ((unsigned char)s[q] & 0xC0) == 0x80) q--;
int n = len - q;
if (n >= (int)sizeof(tail)) break;
- memcpy(tail, s + q, n); tail[n] = 0;
- int ww = disp_text_width(tail, 16, 1);
+ /* 先量再收:直接写进 tail 的话,超宽那一轮 break 时 tail 已经变长了,
+ 而 tw 还停在上一轮,尾巴就会比预留多出一个中文字格,压到右边的日期列 */
+ char cand[64];
+ memcpy(cand, s + q, n); cand[n] = 0;
+ int ww = disp_text_width(cand, 16, 1);
if (ww > room / 2) break;
+ memcpy(tail, cand, n + 1);
tw = ww; cut = q; p = q;
}
}
@@ -132,30 +218,83 @@ static const IconArt *body_art(const BodyData &b, int detail)
return dyn ? dyn : icon_for(b.name, b.name_zh, b.type, detail);
}
+#if BOARD_HAS_BATTERY
+/* 电池:跟在网络状态后面,画成通行的电池形——外壳 + 右端铜帽,壳内按电量比例填一段,
+ 充电时中间压一道闪电。颜色照手机那套:充电=绿,≤15% 红、≤30% 橙,其余用状态栏常态青;
+ 没装电池只留个灰壳。总宽 28,比原来那句 "CHG 97%" 还窄。 */
+#define BAT_W 26 /* 外壳宽,不含铜帽 */
+#define BAT_H 15 /* header 那行是 5..20,取 6..20 正好嵌进去 */
+#define BAT_TY 6
+#define BAT_PAD 2 /* 外壳到填充区的间距,四周各留 1px 缝 */
+
+/* 闪电:逐行填横条就够,不值得为它写个多边形填充。{ 起列, 止列 } 含端点,7 列 11 行 */
+static const uint8_t kBolt[11][2] = {
+ { 2, 5 }, { 1, 5 }, { 1, 4 }, { 0, 3 }, { 0, 5 }, { 2, 5 },
+ { 2, 5 }, { 2, 4 }, { 2, 3 }, { 2, 3 }, { 2, 2 }
+};
+
+static void bat_label(int x, const UiState &st)
+{
+ uint16_t c;
+ if (st.bat_pct < 0) c = C_DIM;
+ else if (st.bat_chg) c = C_GREEN;
+ else if (st.bat_pct <= 15) c = C_RED;
+ else if (st.bat_pct <= 30) c = C_ORANGE;
+ else c = C_CYAN;
+ disp_rect(x, BAT_TY, BAT_W, BAT_H, c);
+ disp_fill(x + BAT_W, BAT_TY + 5, 2, 5, c); /* 铜帽 */
+ disp_fill(x + 1, BAT_TY + 1, BAT_W - 2, BAT_H - 2, C_BG); /* 垫掉背景星点 */
+ const int iw = BAT_W - 2 * BAT_PAD, ih = BAT_H - 2 * BAT_PAD;
+ int w = st.bat_pct > 0 ? (iw * st.bat_pct + 50) / 100 : 0;
+ if (w > iw) w = iw;
+ if (w > 0) disp_fill(x + BAT_PAD, BAT_TY + BAT_PAD, w, ih, c);
+ if (st.bat_chg) {
+ const int bx = x + (BAT_W - 7) / 2, by = BAT_TY + (BAT_H - 11) / 2;
+ for (int i = 0; i < 11; i++)
+ disp_fill(bx + kBolt[i][0], by + i, kBolt[i][1] - kBolt[i][0] + 1, 1, C_WHITE);
+ }
+}
+#endif
+
static void status_bar(const UiState &st, const char *right)
{
+ char sig[28];
+ uint16_t net_c = C_CYAN;
if (st.wifi_up) {
- char sig[28];
/* 连着热点不等于通网:后端连续取不到数据时这里得变脸,否则旧数据看着像在线 */
if (st.api_fail) snprintf(sig, sizeof(sig), "NET:ONLINE API FAIL");
else snprintf(sig, sizeof(sig), "NET:ONLINE RSSI:%d", st.rssi);
- disp_text(4, 2, sig, 16, st.api_fail ? C_ORANGE : C_CYAN, C_BG);
+ net_c = st.api_fail ? C_ORANGE : C_CYAN;
} else {
- disp_text(4, 2, "NET:OFFLINE", 16, C_RED, C_BG);
+ strlcpy(sig, "NET:OFFLINE", sizeof(sig));
+ net_c = C_RED;
}
- if (right && right[0]) text_right(LCD_WIDTH - 4, 2, right, 16, C_CYAN, C_BG);
- disp_hline(0, 19, LCD_WIDTH, C_CYAN_DIM);
+ disp_text(4, HDR_TY, sig, 16, net_c, C_BG);
+#if STRIP && BOARD_HAS_BATTERY
+ bat_label(4 + disp_text_width(sig, 16, 1) + 12, st);
+#endif
+ if (right && right[0]) text_right(s_info_r, HDR_TY, right, 16, C_CYAN, C_BG);
+ disp_hline(0, HDR_LINE, CONT_W, C_CYAN_DIM);
}
-/* 这块屏没有触摸层,底部四条是板上物理按键的说明,按下时整块反色做反馈 */
+/* 底部按键条:只有带物理按键的板子需要——它是 KEY0..KEY3 的图例,按下时整块反色做反馈。
+ 长条屏上没有这排东西,页面级动作在状态栏右端,所以那一版直接不画。 */
static void key_bar(const char *const *labels, uint8_t flash)
{
+#if STRIP
+ (void)labels; (void)flash;
+#else
+#if BOARD_HAS_TOUCH
+ static const uint16_t SLOT[4] = { XL_IO_KEY0, XL_IO_KEY1, XL_IO_KEY2, XL_IO_KEY3 };
+#endif
const int x0 = 3, gap = 2, right = LCD_WIDTH - x0;
+ const char *t[4];
int w[4], sum = 0;
for (int i = 0; i < 4; i++) {
+ t[i] = labels[i];
/* 没定义的槽位只留个窄条。按真实文字宽度等分的话,故障页这种
「两个空槽 + 两个带字」的组合会把文字挤出自己的按钮,压到隔壁上。 */
- w[i] = labels[i][0] ? disp_text_width(labels[i], 16, 1) + 14 : 26;
+ w[i] = t[i][0] ? disp_text_width(t[i], 16, 1) + 14 : 26;
sum += w[i];
}
int avail = (right - x0) - 3 * gap, x = x0;
@@ -164,9 +303,13 @@ static void key_bar(const char *const *labels, uint8_t flash)
bool hit = flash & (1 << i);
uint16_t bg = hit ? C_GOLD : C_PANEL;
disp_panel(x, KEY_Y, bw, KEY_H, 5, bg, hit ? C_GOLD_LT : C_GOLD);
- if (labels[i][0]) disp_text_center(x, KEY_Y + 2, bw, labels[i], 16, hit ? C_GOLD_DK : C_GOLD, bg);
+ if (t[i][0]) {
+ disp_text_center(x, KEY_Y + (KEY_H - 16) / 2, bw, t[i], 16, hit ? C_GOLD_DK : C_GOLD, bg);
+ HIT(x, KEY_Y, bw, KEY_H, SLOT[i], -1);
+ }
x += bw + gap;
}
+#endif
}
static const char *const KEYS_NAV[] = { "KEY0 UP", "KEY1 DN", "KEY2 OK", "KEY3 MODE" };
@@ -183,6 +326,20 @@ static const char *const KEYS_SETUP[] = { "", "", "", "KEY3 RETRY" };
static const char *const KEYS_SETTINGS[] = { "", "", "KEY2 SETUP", "KEY3 BACK" };
static const char *const KEYS_UPDATE[] = { "", "", "KEY2 INSTALL", "KEY3 BACK" };
+#if BOARD_HAS_TOUCH
+/* 提示语里别再说 KEY2/KEY3:这板上只有 BOOT 一颗可编程键,其余全靠点屏幕。
+ 方括号里那两个字就是状态栏右上角那颗按钮上的字,两边得对得上。 */
+#define TXT_SETUP_HOTSPOT2 "右上角点 [CONFIG]"
+#define TXT_SETUP_HOTSPOT3 "右上角点 [CONFIG]"
+#define TXT_PRESS_INSTALL "点 [INSTALL] 开始下载"
+#define TXT_PRESS_BACK "点 [BACK] 退出"
+#else
+#define TXT_SETUP_HOTSPOT2 "KEY2 OPENS THE SETUP HOTSPOT"
+#define TXT_SETUP_HOTSPOT3 "KEY3 OPENS THE SETUP HOTSPOT"
+#define TXT_PRESS_INSTALL "PRESS KEY2 TO INSTALL"
+#define TXT_PRESS_BACK "KEY3 BACK"
+#endif
+
static void fmt_au(char *buf, size_t cap, float v)
{
if (v >= 100.0f) snprintf(buf, cap, "%.1f", v);
@@ -192,39 +349,64 @@ static void fmt_au(char *buf, size_t cap, float v)
static void draw_splash(const UiState &st)
{
- /* 两条程序化轨道打底,面板压在轨道之上 */
+ /* 两条程序化轨道打底,面板压在轨道之上。轨道按屏宽等比缩放,320x240 时就是原稿的 150/58;
+ 长条屏横着有的是宽度,卡的是 172 的高度,所以按高度收一份再取小的 */
+ const int cx = CONT_W / 2, cy = LCD_HEIGHT / 2;
+ const int rx = min(LCD_WIDTH / 2 - 10, (LCD_HEIGHT / 2 - 12) * 150 / 58);
+ const int ry = rx * 58 / 150, rx2 = rx * 116 / 150, ry2 = rx * 40 / 150;
for (int i = 0; i < 180; i++) {
float a = i * 3.1415926f / 90.0f;
- disp_pixel(160 + (int)(cosf(a) * 150), 120 + (int)(sinf(a) * 58), C_TRACE);
- disp_pixel(160 + (int)(cosf(a) * 116), 120 + (int)(sinf(a) * 40), C_TRACE);
+ disp_pixel(cx + (int)(cosf(a) * rx), cy + (int)(sinf(a) * ry), C_TRACE);
+ disp_pixel(cx + (int)(cosf(a) * rx2), cy + (int)(sinf(a) * ry2), C_TRACE);
}
- disp_disc(160 + (int)(cosf(3.6f) * 150), 120 + (int)(sinf(3.6f) * 58), 2, C_CYAN_DIM);
- disp_disc(160 + (int)(cosf(0.7f) * 116), 120 + (int)(sinf(0.7f) * 40), 2, C_GOLD_DIM);
+ disp_disc(cx + (int)(cosf(3.6f) * rx), cy + (int)(sinf(3.6f) * ry), 2, C_CYAN_DIM);
+ disp_disc(cx + (int)(cosf(0.7f) * rx2), cy + (int)(sinf(0.7f) * ry2), 2, C_GOLD_DIM);
- disp_panel_glow(52, 52, 216, 76, 12, C_CYAN_DIM);
- disp_panel(52, 52, 216, 76, 12, C_PANEL, C_CYAN);
+#if STRIP
+ const int pw = 240, px = (CONT_W - pw) / 2;
+#else
+ const int px = SPLASH_PAD, pw = LCD_WIDTH - 2 * SPLASH_PAD;
+#endif
+ const int py = cy - 68;
+ disp_panel_glow(px, py, pw, 76, 12, C_CYAN_DIM);
+ disp_panel(px, py, pw, 76, 12, C_PANEL, C_CYAN);
/* 辉光 = 同一字模向四个方向用低阶色先印一遍,最后覆盖亮色 */
static const int off[4][2] = { { -1, 0 }, { 1, 0 }, { 0, -1 }, { 0, 1 } };
for (int i = 0; i < 4; i++)
- disp_text_center(52 + off[i][0], 58 + off[i][1], 216, "COSMO", 32, C_CYAN_DIM, C_PANEL, 2);
- disp_text_center(52, 58, 216, "COSMO", 32, C_GREEN, C_PANEL, 2);
- disp_text_center(0, 140, LCD_WIDTH, "ORBITAL TERMINAL", 16, C_CYAN, C_BG);
- disp_text_center(0, 164, LCD_WIDTH, st.device_id, 16, C_DIM, C_BG);
+ disp_text_center(px + off[i][0], py + 6 + off[i][1], pw, "COSMO", 32, C_CYAN_DIM, C_PANEL, 2);
+ disp_text_center(px, py + 6, pw, "COSMO", 32, C_GREEN, C_PANEL, 2);
+ disp_text_center(0, cy + 20, CONT_W, "ORBITAL TERMINAL", 16, C_CYAN, C_BG);
+ disp_text_center(0, cy + 44, CONT_W, st.device_id, 16, C_DIM, C_BG);
if (st.ssid[0]) {
char msg[48];
snprintf(msg, sizeof(msg), "WIFI %s", st.ssid);
- disp_text_center(0, 186, LCD_WIDTH, msg, 16, C_DIM, C_BG);
+ disp_text_center(0, cy + 66, CONT_W, msg, 16, C_DIM, C_BG);
}
}
static void draw_provision(const UiState &st)
{
- const int px = 8, py = 22, pw = LCD_WIDTH - 16, ph = 176;
+ const int px = 8, py = TOP_Y, pw = CONT_W - 16;
+ const int ph = STRIP ? (BOT_Y - py + 1) : 176;
disp_panel_glow(px, py, pw, ph, 10, C_CYAN_DIM);
disp_panel(px, py, pw, ph, 10, C_PANEL, C_GOLD);
disp_text(px + 12, py + 6, "NETWORK SETUP", 16, C_GOLD, C_PANEL);
char msg[96];
+#if STRIP
+ /* 够两栏:左边是"连哪个热点、开哪个地址"的操作步骤,右边是当前状态 */
+ const int rw = 200, rx = px + pw - 12 - rw, lw = rx - px - 24;
+ int y = py + 24;
+ disp_text(px + 12, y, "1. JOIN THIS HOTSPOT", 16, C_DIM, C_PANEL);
+ disp_text_clipped(px + 12, y + 18, lw, st.ap_ssid, 16, C_GOLD, C_PANEL);
+ disp_text(px + 12, y + 40, "2. OPEN IN BROWSER", 16, C_DIM, C_PANEL);
+ disp_text(px + 12, y + 58, "http://192.168.4.1", 16, C_CYAN, C_PANEL);
+ disp_text_wrap(px + 12, y + 80, lw, "3. SAVE, THEN BIND ON THE WEB", 16, C_DIM, C_PANEL, 2);
+ y = flow(rx, py + 10, rw, st.reason[0] ? st.reason : "NO SAVED WIFI CREDENTIALS",
+ C_ORANGE, C_PANEL, 8);
+ snprintf(msg, sizeof(msg), "API %s", st.api);
+ disp_text_wrap(rx, y, rw, msg, 16, C_CYAN_DIM, C_PANEL, 3);
+#else
/* 首次开机是没存凭据,跑着用是连不上,都落到这一页,原因写第一行 */
disp_text_clipped(px + 12, py + 26, pw - 24,
st.reason[0] ? st.reason : "NO SAVED WIFI CREDENTIALS", 16, C_ORANGE, C_PANEL);
@@ -239,22 +421,41 @@ static void draw_provision(const UiState &st)
disp_text(px + 12, py + 134, "http://192.168.4.1", 16, C_CYAN, C_PANEL);
disp_text(px + 12, py + 156, "3. SAVE, THEN BIND ON THE WEB", 16, C_DIM, C_PANEL);
+#endif
}
static void draw_connecting(const UiState &st)
{
- const int px = 24, py = 40, pw = LCD_WIDTH - 48, ph = 158;
+ const int px = STRIP ? 8 : 24, py = STRIP ? TOP_Y : 40, pw = CONT_W - 2 * px;
+ const int ph = STRIP ? (BOT_Y - py + 1) : 158;
disp_panel(px, py, pw, ph, 10, C_PANEL, C_CYAN);
disp_text_center(px, py + 6, pw, "CONNECTING", 16, C_CYAN, C_PANEL);
- /* 环形进度:一圈刻度 + 随 millis 转动的指针 */
- disp_ring(160, py + 36, 14, C_CYAN_DIM);
+ /* 环形进度:一圈刻度 + 随 millis 转动的指针。长条屏这页只有 150 高,
+ 圆盘挪到左边、文字整列排在右边,不然圆盘旋着会把下面几行顶出面板 */
+#if STRIP
+ const int dgx = px + 24, dgy = py + 70;
+#else
+ const int dgx = LCD_WIDTH / 2, dgy = py + 36;
+#endif
+ disp_ring(dgx, dgy, 14, C_CYAN_DIM);
float a = (millis() % 1600) / 1600.0f * 2 * 3.1415926f;
- disp_disc(160 + (int)(cosf(a) * 14), py + 36 + (int)(sinf(a) * 14), 3, C_GREEN);
+ disp_disc(dgx + (int)(cosf(a) * 14), dgy + (int)(sinf(a) * 14), 3, C_GREEN);
char msg[64];
uint32_t dots = (millis() / 400) % 4;
snprintf(msg, sizeof(msg), "%s%.*s", st.ssid, (int)dots, "...");
+#if STRIP
+ int y = py + 26;
+ const int tx = px + 52, tw = pw - 64;
+ y = flow(tx, y, tw, msg, C_GREEN, C_PANEL, 4);
+ /* 连不上的话先说清楚为什么,再告诉用户它不会一直卡在这 */
+ if (st.reason[0]) y = flow(tx, y, tw, st.reason, C_ORANGE, C_PANEL, 4);
+ if (st.hint[0]) y = flow(tx, y, tw, st.hint, C_DIM, C_PANEL, 4);
+ snprintf(msg, sizeof(msg), "API %s", st.api);
+ y = flow(tx, y, tw, msg, C_DIM, C_PANEL, 8);
+ flow(tx, y, tw, TXT_SETUP_HOTSPOT3, C_CYAN_DIM, C_PANEL, 4);
+#else
disp_text_clipped(px + 10, py + 62, pw - 20, msg, 16, C_GREEN, C_PANEL);
/* 连不上的话先说清楚为什么,再告诉用户它不会一直卡在这 */
if (st.reason[0])
@@ -263,71 +464,76 @@ static void draw_connecting(const UiState &st)
disp_text_clipped(px + 10, py + 100, pw - 20, st.hint, 16, C_DIM, C_PANEL);
snprintf(msg, sizeof(msg), "API %s", st.api);
disp_text_clipped(px + 10, py + 118, pw - 20, msg, 16, C_DIM, C_PANEL);
- disp_text_clipped(px + 10, py + 136, pw - 20, "KEY3 OPENS THE SETUP HOTSPOT", 16, C_CYAN_DIM, C_PANEL);
+ disp_text_clipped(px + 10, py + 136, pw - 20, TXT_SETUP_HOTSPOT3, 16, C_CYAN_DIM, C_PANEL);
+#endif
}
static void draw_pair(const UiState &st)
{
- const int px = 8, py = 28, pw = LCD_WIDTH - 16, ph = 180;
+ const int px = 8, pw = CONT_W - 16, ph = STRIP ? (BOT_Y - TOP_Y + 1) : 180;
+ const int py = STRIP ? TOP_Y : 28;
disp_panel_glow(px, py, pw, ph, 10, C_CYAN_DIM);
disp_panel(px, py, pw, ph, 10, C_PANEL, C_GREEN);
- disp_text_center(px, py + 8, pw, "DEVICE BINDING", 16, C_GREEN, C_PANEL);
+ disp_text_center(px, py + (STRIP ? 6 : 8), pw, "DEVICE BINDING", 16, C_GREEN, C_PANEL);
if (!st.code[0]) {
/* 拿不到码多半是换了网段/后端地址填错,这一页必须给出配网出口 */
- disp_text_wrap(px + 14, py + 40, pw - 28, st.message, 16, C_ORANGE, C_PANEL, 4);
+ disp_text_wrap(px + 14, py + 40, pw - 28, st.message, 16, C_ORANGE, C_PANEL, STRIP ? 3 : 4);
char line[96];
snprintf(line, sizeof(line), "API %s", st.api);
disp_text_clipped(px + 10, py + ph - 42, pw - 20, line, 16, C_DIM, C_PANEL);
- disp_text_clipped(px + 10, py + ph - 24, pw - 20, "KEY2 OPENS THE SETUP HOTSPOT", 16, C_CYAN_DIM, C_PANEL);
+ disp_text_clipped(px + 10, py + ph - 24, pw - 20, TXT_SETUP_HOTSPOT2, 16, C_CYAN_DIM, C_PANEL);
return;
}
+#if STRIP
+ /* 长条屏横着够宽:左边放大验证码和有效期条,右边写"这码在哪输、这台设备是谁" */
+ const int bx = px + 16, bw = 220;
+#else
const int bx = px + 22, bw = pw - 44;
- disp_panel(bx, py + 28, bw, 76, 6, C_BG, C_CYAN_DIM);
- int adv = 34; /* 16x32 字模放大 2 倍 = 32x64 */
+#endif
+ /* 长条屏 header 占得高,验证码面板、倒计时条、"EXPIRES IN" 整体往上挪 4px */
+ const int cp = STRIP ? 26 : 28, cby = STRIP ? 108 : 112, cty = STRIP ? 120 : 126;
+ disp_panel(bx, py + cp, bw, 76, 6, C_BG, C_CYAN_DIM);
+ /* 16x32 字模放大 2 倍(每字 34px),6 位码 202px,两种版面都放得下 */
+ const int adv = 34, gs = 2;
int cw = (int)strlen(st.code) * adv - 2;
- int x = (LCD_WIDTH - cw) / 2;
- for (const char *p = st.code; *p; p++, x += adv) disp_text(x, py + 34, p, 32, C_GREEN, C_BG, 2);
+ int x = STRIP ? bx + (bw - cw) / 2 : (LCD_WIDTH - cw) / 2;
+ for (const char *p = st.code; *p; p++, x += adv) disp_text(x, py + cp + 6, p, 32, C_GREEN, C_BG, gs);
/* 有效期倒计时条:最后 15 秒转红 */
int fill = 0;
if (st.code_total > 0) fill = bw * st.code_left / st.code_total;
- disp_fill(bx + 12, py + 112, bw - 24, 6, C_TRACE);
- disp_fill(bx + 12, py + 112, (bw - 24) * fill / (bw ? bw : 1), 6, st.code_left < 15 ? C_RED : C_GOLD);
+ disp_fill(bx + 12, py + cby, bw - 24, 6, C_TRACE);
+ disp_fill(bx + 12, py + cby, (bw - 24) * fill / (bw ? bw : 1), 6, st.code_left < 15 ? C_RED : C_GOLD);
char msg[48];
snprintf(msg, sizeof(msg), "EXPIRES IN %ds", st.code_left);
- disp_text_center(px, py + 126, pw, msg, 16, st.code_left < 15 ? C_RED : C_GOLD, C_PANEL);
+ disp_text_center(STRIP ? bx : px, py + cty, STRIP ? bw : pw, msg,
+ 16, st.code_left < 15 ? C_RED : C_GOLD, C_PANEL);
+#if STRIP
+ const int rx = bx + bw + 24, rw = px + pw - 12 - rx;
+ disp_text(rx, py + 32, "ENTER CODE ON WEB", 16, C_TEXT, C_PANEL);
+ snprintf(msg, sizeof(msg), "USER: %s", st.owner[0] ? st.owner : "?");
+ disp_text_clipped(rx, py + 56, rw, msg, 16, C_GREEN, C_PANEL);
+ disp_text(rx, py + 80, "DEVICE", 16, C_DIM, C_PANEL);
+ disp_text_clipped(rx, py + 98, rw, st.device_id, 16, C_CYAN_DIM, C_PANEL);
+#else
snprintf(msg, sizeof(msg), "ENTER CODE ON WEB / USER: %s", st.owner[0] ? st.owner : "?");
disp_text_clipped(px + 10, py + 146, pw - 20, msg, 16, C_TEXT, C_PANEL);
snprintf(msg, sizeof(msg), "DEV %s", st.device_id);
disp_text_clipped(px + 10, py + 164, pw - 20, msg, 16, C_CYAN_DIM, C_PANEL);
+#endif
}
-static void draw_loading(const UiState &st)
-{
- const int px = 40, py = 68, pw = 240, ph = 100;
- disp_panel(px, py, pw, ph, 10, C_PANEL, C_CYAN);
- uint32_t tick = (millis() / 200) % 8;
- char msg[56];
- snprintf(msg, sizeof(msg), "SYNCING DATA");
- disp_text_center(px, py + 12, pw, msg, 16, C_CYAN, C_PANEL);
- /* 8 格跑马刻度 */
- for (int i = 0; i < 8; i++)
- disp_fill(px + 40 + i * 20, py + 42, 14, 8, ((i + tick) % 8 < 3) ? C_CYAN : C_CYAN_DIM);
- snprintf(msg, sizeof(msg), "USER: %s", st.owner[0] ? st.owner : "?");
- disp_text_clipped(px + 10, py + 62, pw - 20, msg, 16, C_GREEN, C_PANEL);
- snprintf(msg, sizeof(msg), "API %s", st.api);
- disp_text_clipped(px + 10, py + 80, pw - 20, msg, 16, C_DIM, C_PANEL);
-}
static void draw_list(const UiState &st)
{
const Snapshot *s = st.snap;
if (!s || !s->count) {
- disp_text_center(0, 84, LCD_WIDTH, "NO FOLLOWED BODIES", 16, C_ORANGE, C_BG);
- disp_text_center(0, 108, LCD_WIDTH, "FOLLOW ONE ON THE WEB UI", 16, C_DIM, C_BG);
+ if (st.busy) return; /* 还在取:留着空白 + header 那条动线,别误报"没关注天体" */
+ disp_text_center(0, 84, CONT_W, "NO FOLLOWED BODIES", 16, C_ORANGE, C_BG);
+ disp_text_center(0, 108, CONT_W, "FOLLOW ONE ON THE WEB UI", 16, C_DIM, C_BG);
return;
}
int scroll = st.sel;
@@ -336,37 +542,63 @@ static void draw_list(const UiState &st)
for (int i = scroll; i < s->count && i < scroll + LIST_ROWS; i++) {
const BodyData &b = s->bodies[i];
- int y = TOP_Y + (i - scroll) * 65;
+ int y = TOP_Y + (i - scroll) * CARD_PITCH;
bool sel = (i == st.sel);
uint16_t bg = sel ? C_SEL : C_PANEL;
- if (sel) disp_panel_glow(3, y, 314, 60, 8, C_CYAN_DIM);
- disp_panel(3, y, 314, 60, 8, bg, sel ? C_CYAN : C_CYAN_DIM);
- disp_fill(6, y + 9, 3, 42, sel ? C_GOLD : C_TRACE);
+ if (sel) disp_panel_glow(CARD_X, y, CARD_W, CARD_H, 8, C_CYAN_DIM);
+ disp_panel(CARD_X, y, CARD_W, CARD_H, 8, bg, sel ? C_CYAN : C_CYAN_DIM);
+ disp_fill(CARD_X + 3, y + (CARD_H - 42) / 2, 3, 42, sel ? C_GOLD : C_TRACE);
const IconArt *ic = body_art(b, 0);
- if (ic) disp_add_bitmap(13, y + 10, ic->w, ic->h, ic->px);
+ if (ic) disp_add_bitmap(CARD_X + 10, y + (CARD_H - ic->h) / 2, ic->w, ic->h, ic->px);
char title[56];
body_title(b, title, sizeof(title));
- disp_text_clipped(60, y + 8, 188, title, 16, sel ? C_WHITE : C_TEXT, bg);
+ disp_text_clipped(CARD_X + 57, y + CARD_TY, STRIP ? CARD_W - 70 : 188,
+ title, 16, sel ? C_WHITE : C_TEXT, bg);
char line[32], v[16];
fmt_au(v, sizeof(v), b.dist);
snprintf(line, sizeof(line), "DIST: %s AU", v);
- disp_text(60, y + 34, line, 16, sel ? C_GOLD : C_CYAN_DIM, bg);
+ disp_text(60, y + CARD_SY, line, 16, sel ? C_GOLD : C_CYAN_DIM, bg);
+ HIT(CARD_X, y, CARD_W, CARD_H, XL_IO_KEY2, i);
}
/* 右缘滚动条取代原来的 v+N 文字 */
int sbh = BOT_Y - TOP_Y + 1;
- disp_fill(317, TOP_Y, 2, sbh, C_TRACE);
+ disp_fill(SB_X, TOP_Y, 2, sbh, C_TRACE);
int th = sbh * LIST_ROWS / s->count;
if (th > sbh) th = sbh;
if (th < 12) th = 12;
int span = s->count - LIST_ROWS;
int ty = TOP_Y + (span > 0 ? (sbh - th) * scroll / span : 0);
- disp_fill(317, ty, 2, th, C_CYAN);
+ disp_fill(SB_X, ty, 2, th, C_CYAN);
}
+/* 数据面板里的一项:标签靠左、数值右对齐到 ir */
+struct Kv { const char *l; char v[20]; };
+
+static void kv_cell(int lx, int ir, int y, const char *l, const char *v, uint16_t lc, uint16_t vc)
+{
+ disp_text(lx, y, l, 16, lc, C_PANEL);
+ text_right(ir, y, v, 16, vc, C_PANEL);
+}
+
+#if STRIP
+/* 长条屏的信息栏改成竖排,每块只剩 65 高:四项排成 2x2,
+ 一格净宽 112,所以标签一律用三四个字母的缩写(见调用处) */
+static void kv_grid(int x, int y, int w, int h, const Kv k[4], uint16_t lc, int hl)
+{
+ const int gy[2] = { y + 24, y + h - 20 };
+ const int cw = w / 2;
+ for (int i = 0; i < 4; i++) {
+ int cx = x + (i & 1) * cw;
+ kv_cell(cx + 8, cx + cw - 8, gy[i >> 1], k[i].l, k[i].v, lc,
+ (i == hl) ? C_WHITE : C_TEXT);
+ }
+}
+#endif
+
static void draw_detail(const UiState &st)
{
const Snapshot *s = st.snap;
@@ -376,57 +608,91 @@ static void draw_detail(const UiState &st)
/* 标题:中文名 + 英文名 + 类型,右端是位置历元(年份省掉,屏太窄) */
char time_s[16];
strlcpy(time_s, (strlen(b.pos_time) >= 10) ? b.pos_time + 5 : b.pos_time, sizeof(time_s));
- int timew = disp_text_width(time_s, 16, 1);
char title[72], name[56], typ[17];
body_title(b, name, sizeof(name));
int tn = 0;
for (; b.type[tn] && tn < (int)sizeof(typ) - 1; tn++) typ[tn] = toupper((unsigned char)b.type[tn]);
typ[tn] = 0;
snprintf(title, sizeof(title), "%s (%s)", name, typ);
- disp_text_clipped(4, 20, LCD_WIDTH - 8 - timew - 8, title, 16, C_CYAN, C_BG);
- text_right(LCD_WIDTH - 4, 20, time_s, 16, C_DIM, C_BG);
+ int timew = disp_text_width(time_s, 16, 1);
+#if STRIP
+ /* 长条屏这页不再画状态栏:0..19 那一行留给页头本身(标题 + 历元),
+ 不然 172 高的屏上会叠出两层 header */
+ disp_text_clipped(4, HDR_TY, s_info_r - timew - 12, title, 16, C_CYAN, C_BG);
+ text_right(s_info_r, HDR_TY, time_s, 16, C_DIM, C_BG);
+ disp_hline(0, HDR_LINE, CONT_W, C_CYAN_DIM);
+#else
+ disp_text_clipped(4, 20, s_info_r - timew - 12, title, 16, C_CYAN, C_BG);
+ text_right(s_info_r, 20, time_s, 16, C_DIM, C_BG);
+#endif
+#if STRIP
+ /* 长条屏(640 宽)三栏:图标独占一列全高格,两组信息竖着排一列,
+ 剩下的整块宽度全给事件面板——图标和事件才是这页的核心 */
+ const int iy = TOP_Y, ih = BOT_Y - iy + 1; /* 页头只剩一行,内容区顶到 TOP_Y */
+ const int ix = 2, iw = 148, icr = 59;
+ const int mx = ix + iw + 7, mw = 224, mh = (ih - 3) / 2;
+ const int qx = mx + mw + 7, qw = CONT_W - qx - 3;
+ const int by = iy, by2 = iy + mh + 3;
+ const int pw = mw, ph = mh, lx = mx, rx = mx;
+#else
const int pw = 156, ph = 88, by = 40;
- const int lx = 3, rx = 161;
+ const int lx = 3, rx = 161, by2 = by;
+ const int iy = 132, ih = BOT_Y - iy + 1, iw = 88, icr = 34;
+ const int ix = 3, qx = 95, qw = 222;
+#endif
+ const int py = iy, bh = ih;
disp_panel(lx, by, pw, ph, 6, C_PANEL, C_CYAN);
- disp_panel(rx, by, pw, ph, 6, C_PANEL, C_GOLD);
+ disp_panel(rx, by2, pw, ph, 6, C_PANEL, C_GOLD);
disp_text(lx + 8, by + 4, "POS (AU)", 16, C_GOLD, C_PANEL);
- disp_text(rx + 8, by + 4, "VEL (KM/S)", 16, C_GOLD, C_PANEL);
+ disp_text(rx + 8, by2 + 4, "VEL (KM/S)", 16, C_GOLD, C_PANEL);
- char v[20];
- const int rows[4] = { by + 21, by + 37, by + 53, by + 69 };
+ Kv L[4], R[4];
const char *lp[4] = { "X", "Y", "Z", "DIST" };
float lv[4] = { b.x, b.y, b.z, b.dist };
const char *rp[4] = { "VX", "VY", "VZ", "SPEED" };
float rv[4] = { b.vx, b.vy, b.vz, b.speed };
for (int i = 0; i < 4; i++) {
- disp_text(lx + 8, rows[i], lp[i], 16, C_CYAN_DIM, C_PANEL);
- fmt_au(v, sizeof(v), lv[i]);
- text_right(lx + pw - 8, rows[i], v, 16, (i == 3) ? C_WHITE : C_TEXT, C_PANEL);
- disp_text(rx + 8, rows[i], rp[i], 16, C_GOLD_DIM, C_PANEL);
- if (b.has_vel) snprintf(v, sizeof(v), "%.1f", rv[i]);
- else snprintf(v, sizeof(v), "--");
- text_right(rx + pw - 8, rows[i], v, 16, (i == 3) ? C_WHITE : C_TEXT, C_PANEL);
+ L[i].l = lp[i]; R[i].l = rp[i];
+ fmt_au(L[i].v, sizeof(L[i].v), lv[i]);
+ if (b.has_vel) snprintf(R[i].v, sizeof(R[i].v), "%.1f", rv[i]);
+ else strlcpy(R[i].v, "--", sizeof(R[i].v));
+ }
+#if STRIP
+ kv_grid(lx, by, pw, ph, L, C_CYAN_DIM, 3);
+ kv_grid(rx, by2, pw, ph, R, C_GOLD_DIM, 3);
+#else
+ const int rows[4] = { by + 21, by + 37, by + 53, by + 69 };
+ for (int i = 0; i < 4; i++) {
+ kv_cell(lx + 8, lx + pw - 8, rows[i], L[i].l, L[i].v, C_CYAN_DIM, (i == 3) ? C_WHITE : C_TEXT);
+ kv_cell(rx + 8, rx + pw - 8, rows[i], R[i].l, R[i].v, C_GOLD_DIM, (i == 3) ? C_WHITE : C_TEXT);
+ }
+#endif
+
+ /* 霓虹线稿天体图标 + 雷达底纹:横屏是左边一竖条,长条屏是通高一格,
+ 64 的线稿按格子放大到最近邻的整数倍,小图放大才不糊 */
+ disp_panel(ix, iy, iw, ih, 6, C_PANEL, C_CYAN_DIM);
+ disp_radar(ix + iw / 2, iy + ih / 2, icr);
+ const IconArt *ic = body_art(b, 1);
+ if (ic) {
+ int sc = 1;
+ while (ic->w * (sc + 1) <= iw - 12 && ic->h * (sc + 1) <= ih - 6) sc++;
+ disp_add_bitmap(ix + (iw - ic->w * sc) / 2, iy + (ih - ic->h * sc) / 2,
+ ic->w, ic->h, ic->px, (uint8_t)sc);
}
- const int py = 132, bh = BOT_Y - py + 1;
- /* 左:霓虹线稿天体图标 + 雷达底纹 */
- disp_panel(3, py, 88, bh, 6, C_PANEL, C_CYAN_DIM);
- disp_radar(47, py + bh / 2, 34);
- const IconArt *ic = body_art(b, 1);
- if (ic) disp_add_bitmap(47 - ic->w / 2, py + bh / 2 - ic->h / 2, ic->w, ic->h, ic->px);
-
- /* 右:EVENTS / INFO 分页,KEY3 切换 */
- const int qx = 95, qw = 222;
+ /* EVENTS / INFO 分页:点标签直接跳页 */
disp_panel_glow(qx, py, qw, bh, 6, C_CYAN_DIM);
disp_panel(qx, py, qw, bh, 6, C_PANEL, C_CYAN);
const char *tabs[2] = { "[EVENTS]", "[INFO]" };
int tx = qx + 8;
for (int i = 0; i < 2; i++) {
bool on = (st.detail_tab == i);
+ int tw = disp_text_width(tabs[i], 16, 1);
disp_text(tx, py + 4, tabs[i], 16, on ? C_GOLD : C_DIM, C_PANEL);
- if (on) disp_hline(tx, py + 22, disp_text_width(tabs[i], 16, 1) - 1, C_GOLD);
- tx += disp_text_width(tabs[i], 16, 1) + 12;
+ if (on) disp_hline(tx, py + 22, tw - 1, C_GOLD);
+ HIT(tx, py + 2, tw + 8, 24, UI_ACT_TAB, i);
+ tx += tw + 12;
}
if (st.detail_tab == 0) {
@@ -434,8 +700,9 @@ static void draw_detail(const UiState &st)
disp_text(qx + 8, py + 24, "NO EVENTS", 16, C_DIM, C_PANEL);
return;
}
+ const int evr = STRIP ? 24 : 18; /* 栏高了 16px,三行事件摊开一点 */
for (int i = 0; i < b.ev_count && i < MAX_EVENTS; i++) {
- int y = py + 24 + i * 18;
+ int y = py + 24 + i * evr;
char ds[8];
snprintf(ds, sizeof(ds), "%.5s ", (strlen(b.ev_date[i]) >= 10) ? b.ev_date[i] + 5 : b.ev_date[i]);
disp_text(qx + 8, y, ds, 16, C_CYAN_DIM, C_PANEL);
@@ -449,10 +716,11 @@ static void draw_detail(const UiState &st)
disp_text(qx + 8, py + 44, "NO DESCRIPTION", 16, C_DIM, C_PANEL);
return;
}
- char desc[96];
- /* 两行 12 字:留一个字位给 clip_chars 补的 "..",否则截断标记会被行宽吃掉 */
- clip_chars(desc, sizeof(desc), b.desc, 23);
- disp_text_wrap(qx + 8, py + 44, qw - 16, desc, 16, C_TEXT, C_PANEL, 2);
+ /* 两行 12 字:留一个字位给 clip_chars 补的 "..",否则截断标记会被行宽吃掉。
+ 长条屏那栏窄但高,四行 8 字 */
+ char desc[STRIP ? 136 : 96];
+ clip_chars(desc, sizeof(desc), b.desc, STRIP ? 30 : 23);
+ disp_text_wrap(qx + 8, py + 44, qw - 16, desc, 16, C_TEXT, C_PANEL, STRIP ? 4 : 2);
}
}
@@ -476,14 +744,23 @@ static void rocket_title(const RocketData &r, char *dst, size_t cap)
/* 入口页:两块面板,图标是 96x96 的大图(gen_assets.py 烘进固件) */
static void draw_mode(const UiState &st)
{
+#if !STRIP
disp_text_center(0, TOP_Y, LCD_WIDTH, "SELECT TERMINAL MODE", 16, C_CYAN, C_BG);
+#endif
const char *zh[2] = { "天体", "火箭" };
const char *en[2] = { "CELESTIAL", "LAUNCHER" };
const IconArt *art[2] = { &ic_mode_planet_96, &ic_mode_rocket_96 };
for (int i = 0; i < 2; i++) {
+#if STRIP
+ /* 面板铺满内容区:96 的图标 + 两行标签,两张卡左右并排平分整宽 */
+ const int w = (CONT_W - 24) / 2, x = 8 + i * (w + 8), y = TOP_Y, h = BOT_Y - TOP_Y + 1;
+ const int iy = y + 4, ty = y + 104;
+#else
const int x = 8 + i * 154, y = 42, w = 150, h = 146;
+ const int iy = y + 6, ty = y + 108;
+#endif
bool sel = (st.mode_sel == i);
uint16_t bg = sel ? C_SEL : C_PANEL;
if (sel) disp_panel_glow(x, y, w, h, 10, C_CYAN_DIM);
@@ -491,9 +768,10 @@ static void draw_mode(const UiState &st)
if (sel) disp_fill(x + 3, y + 14, 3, h - 28, C_GOLD);
const IconArt *ic = art[i];
/* 图标往上提一点,两行标签才不会被面板下沿的切角吃掉 */
- disp_add_bitmap(x + (w - ic->w) / 2, y + 6, ic->w, ic->h, ic->px);
- disp_text_center(x, y + 108, w, zh[i], 16, sel ? C_WHITE : C_TEXT, bg);
- disp_text_center(x, y + 126, w, en[i], 16, sel ? C_GOLD : C_CYAN_DIM, bg);
+ disp_add_bitmap(x + (w - ic->w) / 2, iy, ic->w, ic->h, ic->px);
+ disp_text_center(x, ty, w, zh[i], 16, sel ? C_WHITE : C_TEXT, bg);
+ disp_text_center(x, ty + 18, w, en[i], 16, sel ? C_GOLD : C_CYAN_DIM, bg);
+ HIT(x, y, w, h, XL_IO_KEY2, i);
}
}
@@ -502,8 +780,9 @@ static void draw_rockets(const UiState &st)
{
const RocketSnapshot *s = st.rsnap;
if (!s || !s->count) {
- disp_text_center(0, 84, LCD_WIDTH, "NO ACTIVE ROCKETS", 16, C_ORANGE, C_BG);
- disp_text_center(0, 108, LCD_WIDTH, "ENABLE ONE IN ADMIN", 16, C_DIM, C_BG);
+ if (st.busy) return; /* 同 draw_list:取数途中不报"没有火箭" */
+ disp_text_center(0, 84, CONT_W, "NO ACTIVE ROCKETS", 16, C_ORANGE, C_BG);
+ disp_text_center(0, 108, CONT_W, "ENABLE ONE IN ADMIN", 16, C_DIM, C_BG);
return;
}
int scroll = st.rsel;
@@ -512,38 +791,46 @@ static void draw_rockets(const UiState &st)
for (int i = scroll; i < s->count && i < scroll + LIST_ROWS; i++) {
const RocketData &r = s->rockets[i];
- int y = TOP_Y + (i - scroll) * 65;
+ int y = TOP_Y + (i - scroll) * CARD_PITCH;
bool sel = (i == st.rsel);
uint16_t bg = sel ? C_SEL : C_PANEL;
- if (sel) disp_panel_glow(3, y, 314, 60, 8, C_CYAN_DIM);
- disp_panel(3, y, 314, 60, 8, bg, sel ? C_CYAN : C_CYAN_DIM);
- disp_fill(6, y + 9, 3, 42, sel ? C_GOLD : C_TRACE);
+ if (sel) disp_panel_glow(CARD_X, y, CARD_W, CARD_H, 8, C_CYAN_DIM);
+ disp_panel(CARD_X, y, CARD_W, CARD_H, 8, bg, sel ? C_CYAN : C_CYAN_DIM);
+ disp_fill(CARD_X + 3, y + (CARD_H - 42) / 2, 3, 42, sel ? C_GOLD : C_TRACE);
const IconArt *ic = rocket_art(r, 0);
- disp_add_bitmap(13, y + 10, ic->w, ic->h, ic->px);
+ disp_add_bitmap(CARD_X + 10, y + (CARD_H - ic->h) / 2, ic->w, ic->h, ic->px);
char title[56], line[40];
rocket_title(r, title, sizeof(title));
- disp_text_clipped(60, y + 8, 186, title, 16, sel ? C_WHITE : C_TEXT, bg);
+ disp_text_clipped(CARD_X + 57, y + CARD_TY, STRIP ? CARD_W - 100 : 186,
+ title, 16, sel ? C_WHITE : C_TEXT, bg);
snprintf(line, sizeof(line), "H %d.%dM PAY %d.%dT",
(int)r.height_m, ((int)(r.height_m * 10)) % 10,
(int)(r.payload_kg / 1000.0f), ((int)(r.payload_kg / 100.0f)) % 10);
- disp_text_clipped(60, y + 34, 186, line, 16, sel ? C_GOLD : C_CYAN_DIM, bg);
+ disp_text_clipped(60, y + CARD_SY, STRIP ? CARD_W - 130 : 186, line, 16, sel ? C_GOLD : C_CYAN_DIM, bg);
char nb[8];
snprintf(nb, sizeof(nb), (r.upcoming > 0) ? "%u" : "--", (unsigned)r.upcoming);
+#if STRIP
+ /* 次数那一列贴右缘,长条屏的卡片够宽,不用再居中一个 LAUNCH 标签 */
+ text_right(CARD_X + CARD_W - 8, y + CARD_TY, nb, 16, r.upcoming ? C_GOLD : C_DIM, bg);
+ text_right(CARD_X + CARD_W - 8, y + CARD_SY, "LAUNCH", 16, r.upcoming ? C_GOLD_DIM : C_DIM, bg);
+#else
text_right(308, y + 8, nb, 16, r.upcoming ? C_GOLD : C_DIM, bg);
disp_text_center(250, y + 34, 58, "LAUNCH", 16, r.upcoming ? C_GOLD_DIM : C_DIM, bg);
+#endif
+ HIT(CARD_X, y, CARD_W, CARD_H, XL_IO_KEY2, i);
}
int sbh = BOT_Y - TOP_Y + 1;
- disp_fill(317, TOP_Y, 2, sbh, C_TRACE);
+ disp_fill(SB_X, TOP_Y, 2, sbh, C_TRACE);
int th = sbh * LIST_ROWS / s->count;
if (th > sbh) th = sbh;
if (th < 12) th = 12;
int span = s->count - LIST_ROWS;
int ty = TOP_Y + (span > 0 ? (sbh - th) * scroll / span : 0);
- disp_fill(317, ty, 2, th, C_CYAN);
+ disp_fill(SB_X, ty, 2, th, C_CYAN);
}
static void draw_rocket(const UiState &st)
@@ -560,67 +847,92 @@ static void draw_rocket(const UiState &st)
else
strlcpy(next, "NO LAUNCH", sizeof(next));
int nextw = disp_text_width(next, 16, 1);
- disp_text_clipped(4, 20, LCD_WIDTH - 8 - nextw - 8, title, 16, C_CYAN, C_BG);
- text_right(LCD_WIDTH - 4, 20, next, 16, d->event_total ? C_CYAN_DIM : C_DIM, C_BG);
+#if STRIP
+ disp_text_clipped(4, HDR_TY, s_info_r - nextw - 12, title, 16, C_CYAN, C_BG);
+ text_right(s_info_r, HDR_TY, next, 16, d->event_total ? C_CYAN_DIM : C_DIM, C_BG);
+ disp_hline(0, HDR_LINE, CONT_W, C_CYAN_DIM);
+#else
+ disp_text_clipped(4, 20, s_info_r - nextw - 12, title, 16, C_CYAN, C_BG);
+ text_right(s_info_r, 20, next, 16, d->event_total ? C_CYAN_DIM : C_DIM, C_BG);
+#endif
+#if STRIP
+ /* 和天体详情页同构:左边通高图标格,中间一列两组参数,右边整块给任务面板 */
+ const int iy = TOP_Y, ih = BOT_Y - iy + 1;
+ const int ix = 2, iw = 148, icr = 59;
+ const int mx = ix + iw + 7, mw = 224, mh = (ih - 3) / 2;
+ const int qx = mx + mw + 7, qw = CONT_W - qx - 3;
+ const int by = iy, by2 = iy + mh + 3;
+ const int pw = mw, ph = mh, lx = mx, rx = mx;
+ /* 一格净宽 112,标签一律缩写 */
+ const char *lp[4] = { "LEN", "DIA", "PAY", "ORB" };
+ const char *rp[4] = { "THR", "ISP", "ENG", "BST" };
+ const int tp = 26; /* 面板高了,三行任务/分级摊开 */
+#else
const int pw = 156, ph = 88, by = 40;
- const int lx = 3, rx = 161;
+ const int lx = 3, rx = 161, by2 = by;
+ const int iy = 132, ih = BOT_Y - iy + 1, iw = 88, icr = 34;
+ const int ix = 3, qx = 95, qw = 222;
+ const char *lp[4] = { "HEIGHT", "DIAMETER", "PAYLOAD", "ORBIT" };
+ const char *rp[4] = { "THRUST", "ISP", "ENGINES", "BOOSTERS" };
+ const int tp = 18;
+#endif
+ const int py = iy, bh = ih;
disp_panel(lx, by, pw, ph, 6, C_PANEL, C_CYAN);
- disp_panel(rx, by, pw, ph, 6, C_PANEL, C_GOLD);
+ disp_panel(rx, by2, pw, ph, 6, C_PANEL, C_GOLD);
disp_text(lx + 8, by + 4, "SPECS", 16, C_GOLD, C_PANEL);
- disp_text(rx + 8, by + 4, "PERFORMANCE", 16, C_GOLD, C_PANEL);
+ disp_text(rx + 8, by2 + 4, "PERFORMANCE", 16, C_GOLD, C_PANEL);
char v[20];
+ Kv L[4], R[4];
+ for (int i = 0; i < 4; i++) { L[i].l = lp[i]; R[i].l = rp[i]; }
+ snprintf(L[0].v, sizeof(L[0].v), "%.1f M", r.height_m);
+ snprintf(L[1].v, sizeof(L[1].v), "%.1f M", r.diameter_m);
+ snprintf(L[2].v, sizeof(L[2].v), "%.1f T", r.payload_kg / 1000.0f);
+ /* 长条屏一格放不下 "ORBIT 2000 KM",单位和数字连着写 */
+ snprintf(L[3].v, sizeof(L[3].v), STRIP ? "%.0fKM" : "%.0f KM", r.orbit_km);
+ /* 长条屏这块板窄,"22700 KN" 会顶到标签,省掉中间那个空格 */
+ snprintf(R[0].v, sizeof(R[0].v), (r.thrust_kn > 0) ? (STRIP ? "%.0fkN" : "%.0f KN") : "--", r.thrust_kn);
+ snprintf(R[1].v, sizeof(R[1].v), (d->s1_isp > 0) ? "%.0f S" : "--", d->s1_isp);
+ snprintf(R[2].v, sizeof(R[2].v), "%u", (unsigned)r.engines);
+ snprintf(R[3].v, sizeof(R[3].v), (r.boosters > 0) ? "x%u" : "--", (unsigned)r.boosters);
+#if STRIP
+ kv_grid(lx, by, pw, ph, L, C_CYAN_DIM, 0);
+ kv_grid(rx, by2, pw, ph, R, C_GOLD_DIM, 0);
+#else
const int rows[4] = { by + 21, by + 37, by + 53, by + 69 };
- const char *lp[4] = { "HEIGHT", "DIAMETER", "PAYLOAD", "ORBIT" };
- snprintf(v, sizeof(v), "%.1f M", r.height_m);
- disp_text(lx + 8, rows[0], lp[0], 16, C_CYAN_DIM, C_PANEL);
- text_right(lx + pw - 8, rows[0], v, 16, C_WHITE, C_PANEL);
- snprintf(v, sizeof(v), "%.1f M", r.diameter_m);
- disp_text(lx + 8, rows[1], lp[1], 16, C_CYAN_DIM, C_PANEL);
- text_right(lx + pw - 8, rows[1], v, 16, C_TEXT, C_PANEL);
- snprintf(v, sizeof(v), "%.1f T", r.payload_kg / 1000.0f);
- disp_text(lx + 8, rows[2], lp[2], 16, C_CYAN_DIM, C_PANEL);
- text_right(lx + pw - 8, rows[2], v, 16, C_WHITE, C_PANEL);
- snprintf(v, sizeof(v), "%.0f KM", r.orbit_km);
- disp_text(lx + 8, rows[3], lp[3], 16, C_CYAN_DIM, C_PANEL);
- text_right(lx + pw - 8, rows[3], v, 16, C_TEXT, C_PANEL);
+ const uint16_t lvc[4] = { C_WHITE, C_TEXT, C_WHITE, C_TEXT };
+ const uint16_t rvc[4] = { C_WHITE, C_TEXT, C_TEXT, C_TEXT };
+ for (int i = 0; i < 4; i++) {
+ kv_cell(lx + 8, lx + pw - 8, rows[i], L[i].l, L[i].v, C_CYAN_DIM, lvc[i]);
+ kv_cell(rx + 8, rx + pw - 8, rows[i], R[i].l, R[i].v, C_GOLD_DIM, rvc[i]);
+ }
+#endif
- const char *rp[4] = { "THRUST", "ISP", "ENGINES", "BOOSTERS" };
- snprintf(v, sizeof(v), (r.thrust_kn > 0) ? "%.0f KN" : "--", r.thrust_kn);
- disp_text(rx + 8, rows[0], rp[0], 16, C_GOLD_DIM, C_PANEL);
- text_right(rx + pw - 8, rows[0], v, 16, C_WHITE, C_PANEL);
- snprintf(v, sizeof(v), (d->s1_isp > 0) ? "%.0f S" : "--", d->s1_isp);
- disp_text(rx + 8, rows[1], rp[1], 16, C_GOLD_DIM, C_PANEL);
- text_right(rx + pw - 8, rows[1], v, 16, C_TEXT, C_PANEL);
- snprintf(v, sizeof(v), "%u", (unsigned)r.engines);
- disp_text(rx + 8, rows[2], rp[2], 16, C_GOLD_DIM, C_PANEL);
- text_right(rx + pw - 8, rows[2], v, 16, C_TEXT, C_PANEL);
- snprintf(v, sizeof(v), (r.boosters > 0) ? "x%u" : "--", (unsigned)r.boosters);
- disp_text(rx + 8, rows[3], rp[3], 16, C_GOLD_DIM, C_PANEL);
- text_right(rx + pw - 8, rows[3], v, 16, C_TEXT, C_PANEL);
-
- const int py = 132, bh = BOT_Y - py + 1;
- /* 左:参数画出来的立面图 + 雷达底纹。可回收/有无整流罩这些标记画在图里,不再单列 */
- disp_panel(3, py, 88, bh, 6, C_PANEL, C_CYAN_DIM);
- disp_radar(47, py + bh / 2, 34);
+ /* 参数画出来的立面图 + 雷达底纹。可回收/有无整流罩这些标记画在图里,不再单列 */
+ disp_panel(ix, iy, iw, ih, 6, C_PANEL, C_CYAN_DIM);
+ disp_radar(ix + iw / 2, iy + ih / 2, icr);
const IconArt *ic = rocket_art(r, 1);
- disp_add_bitmap(47 - ic->w / 2, py + bh / 2 - ic->h / 2, ic->w, ic->h, ic->px);
+ int isc = 1;
+ while (ic->w * (isc + 1) <= iw - 12 && ic->h * (isc + 1) <= ih - 6) isc++;
+ disp_add_bitmap(ix + (iw - ic->w * isc) / 2, iy + (ih - ic->h * isc) / 2,
+ ic->w, ic->h, ic->px, (uint8_t)isc);
- /* 右:LAUNCH / STAGE / INFO 三页,KEY3 循环 */
- const int qx = 95, qw = 222;
+ /* LAUNCH / STAGE / INFO 三页,KEY3 或点底部 TAB 循环 */
disp_panel_glow(qx, py, qw, bh, 6, C_CYAN_DIM);
disp_panel(qx, py, qw, bh, 6, C_PANEL, C_CYAN);
- const int ry[3] = { py + 26, py + 44, py + 62 };
+ const int ry[3] = { py + 26, py + 26 + tp, py + 26 + 2 * tp };
char tab[16];
snprintf(tab, sizeof(tab), "LAUNCH %u", (unsigned)d->event_total);
const char *tabs[3] = { tab, "STAGE", "INFO" };
int tx = qx + 8;
for (int i = 0; i < 3; i++) {
bool on = (st.rocket_tab == i);
+ int tw = disp_text_width(tabs[i], 16, 1);
disp_text(tx, py + 4, tabs[i], 16, on ? C_GOLD : C_DIM, C_PANEL);
- if (on) disp_hline(tx, py + 22, disp_text_width(tabs[i], 16, 1) - 1, C_GOLD);
- tx += disp_text_width(tabs[i], 16, 1) + 12;
+ if (on) disp_hline(tx, py + 22, tw - 1, C_GOLD);
+ HIT(tx, py + 2, tw + 6, 24, UI_ACT_TAB, i);
+ tx += tw + (STRIP ? 6 : 12); /* 带上任务数的 LAUNCH 最长约 100px,栏距再放大 INFO 就顶到右边框 */
}
if (st.rocket_tab == 0) {
@@ -651,7 +963,13 @@ static void draw_rocket(const UiState &st)
strlcpy(val[2], "NONE", sizeof(val[2]));
for (int i = 0; i < 3; i++) {
disp_text(qx + 8, ry[i], lab[i], 16, C_CYAN_DIM, C_PANEL);
+#if STRIP
+ /* "22700KN ISP311 x27" 右对齐会盖住 S1/S2 标签,改成省中间留尾巴 */
+ int lw2 = disp_text_width(lab[i], 16, 1);
+ text_elided(qx + 16 + lw2, ry[i], qw - 24 - lw2, val[i], C_TEXT, C_PANEL);
+#else
text_right(qx + qw - 8, ry[i], val[i], 16, C_TEXT, C_PANEL);
+#endif
}
} else {
char name[56];
@@ -661,19 +979,20 @@ static void draw_rocket(const UiState &st)
disp_text(qx + 8, ry[1], "NO DESCRIPTION", 16, C_DIM, C_PANEL);
return;
}
- char desc[96];
- clip_chars(desc, sizeof(desc), d->desc, 23);
- disp_text_wrap(qx + 8, ry[1], qw - 16, desc, 16, C_TEXT, C_PANEL, 2);
+ char desc[STRIP ? 136 : 96];
+ clip_chars(desc, sizeof(desc), d->desc, STRIP ? 30 : 23);
+ disp_text_wrap(qx + 8, ry[1], qw - 16, desc, 16, C_TEXT, C_PANEL, STRIP ? 4 : 2);
}
}
static void draw_error(const UiState &st)
{
- const int px = 8, py = 32, pw = LCD_WIDTH - 16, ph = 168;
+ const int px = 8, pw = CONT_W - 16, ph = STRIP ? (BOT_Y - TOP_Y + 1) : 168;
+ const int py = STRIP ? TOP_Y : 32;
disp_panel_glow(px, py, pw, ph, 10, C_RED);
disp_panel(px, py, pw, ph, 10, C_PANEL, C_RED);
disp_text_center(px, py + 10, pw, "FAULT", 32, C_RED, C_PANEL, 1);
- disp_text_wrap(px + 14, py + 56, pw - 28, st.message, 16, C_ORANGE, C_PANEL, 5);
+ disp_text_wrap(px + 14, py + 56, pw - 28, st.message, 16, C_ORANGE, C_PANEL, STRIP ? 3 : 5);
char msg[96];
snprintf(msg, sizeof(msg), "API %s", st.api);
disp_text_clipped(px + 14, py + ph - 24, pw - 28, msg, 16, C_DIM, C_PANEL);
@@ -684,7 +1003,8 @@ static void draw_error(const UiState &st)
/* OTA 页:只有"要不要装"这一个决定,进度条复用同页,失败也停在这页显示原因 */
static void draw_update(const UiState &st)
{
- const int px = 8, py = 22, pw = LCD_WIDTH - 16, ph = 176;
+ const int px = 8, pw = CONT_W - 16, ph = STRIP ? (BOT_Y - TOP_Y + 1) : 176;
+ const int py = STRIP ? TOP_Y : 22;
const bool failed = (st.fw_progress == -2);
const uint16_t edge = failed ? C_RED : C_GOLD;
@@ -694,98 +1014,321 @@ static void draw_update(const UiState &st)
char msg[80];
snprintf(msg, sizeof(msg), "FROM %s TO %s", st.fw_version, st.fw_new);
- disp_text_clipped(px + 10, py + 52, pw - 20, msg, 16, C_CYAN, C_PANEL);
+ disp_text_clipped(px + 10, py + (STRIP ? 48 : 52), pw - 20, msg, 16, C_CYAN, C_PANEL);
if (st.fw_notes[0])
- disp_text_wrap(px + 14, py + 74, pw - 28, st.fw_notes, 16, C_TEXT, C_PANEL, 2);
+ disp_text_wrap(px + 14, py + (STRIP ? 66 : 74), pw - 28, st.fw_notes, 16, C_TEXT, C_PANEL, 2);
- const int bx = px + 20, bw = pw - 40, by = py + 126;
+ const int bx = px + 20, bw = pw - 40, by = py + (STRIP ? 104 : 126);
if (st.fw_progress < 0) {
- disp_text_center(px, st.fw_notes[0] ? py + 100 : py + 90, pw,
- failed ? "KEY3 BACK" : "PRESS KEY2 TO INSTALL",
+ disp_text_center(px, py + (STRIP ? 104 : (st.fw_notes[0] ? 100 : 90)), pw,
+ failed ? TXT_PRESS_BACK : TXT_PRESS_INSTALL,
16, failed ? C_ORANGE : C_GREEN, C_PANEL);
} else {
disp_rect(bx, by, bw, 12, C_CYAN_DIM);
int fill = (bw - 4) * st.fw_progress / 100;
if (fill > 0) disp_fill(bx + 2, by + 2, fill, 8, C_GREEN);
snprintf(msg, sizeof(msg), "%d%%", st.fw_progress);
- disp_text_center(px, by + 20, pw, msg, 16, C_CYAN, C_PANEL);
+ disp_text_center(px, by + (STRIP ? 18 : 20), pw, msg, 16, C_CYAN, C_PANEL);
}
if (st.fw_error[0])
disp_text_clipped(px + 14, py + ph - 22, pw - 28, st.fw_error, 16, C_RED, C_PANEL);
}
+/* 设置页一行:左标签 +(可选)右对齐值。
+ 长条屏一行塞不下两栏,右值落到标签下面一行整宽显示。 */
+static void s_row(int ix, int ir, int y, const char *l, uint16_t lc, int lw,
+ const char *r = nullptr, uint16_t rc = C_TEXT)
+{
+ if (!r) { disp_text_clipped(ix, y, lw, l, 16, lc, C_PANEL); return; }
+ /* 标签的预算还要给右对齐的值让路,否则长热点名会直接从底下压过值 */
+ int avail = ir - ix - disp_text_width(r, 16, 1) - 6;
+ if (avail < 0) avail = 0;
+ if (lw > avail) lw = avail;
+ disp_text_clipped(ix, y, lw, l, 16, lc, C_PANEL);
+ text_right(ir, y, r, 16, rc, C_PANEL);
+}
+
+#if STRIP
+/* 172 高放不下三张横卡:左右两张长卡,左网络右本机。行距 22,最后一行才不会压到卡片底边 */
+static void draw_settings_strip(const UiState &st)
+{
+ const int ch = BOT_Y - TOP_Y + 1;
+ const int lw = (CONT_W - 14) / 2; /* 两栏等宽,中间留 6 */
+ const int lx = 4, lix = 14, lir = lx + lw - 10;
+ const int rx = lx + lw + 6, rw = lw, rix = rx + 10, rir = rx + rw - 10;
+ char val[64], rv[32];
+
+ disp_panel_glow(lx, TOP_Y, lw, ch, 10, C_CYAN_DIM);
+ disp_panel(lx, TOP_Y, lw, ch, 10, C_PANEL, C_CYAN);
+ s_row(lix, lir, TOP_Y + 6, "WIFI", C_CYAN, 130,
+ st.wifi_up ? "ONLINE" : "OFFLINE", st.wifi_up ? C_GREEN : C_RED);
+ rv[0] = 0;
+ if (st.wifi_up) snprintf(rv, sizeof(rv), "RSSI %d", st.rssi);
+ s_row(lix, lir, TOP_Y + 28, st.ssid[0] ? st.ssid : "NO SSID SAVED",
+ st.ssid[0] ? C_TEXT : C_DIM, 130, rv[0] ? rv : nullptr, C_CYAN_DIM);
+ if (st.ip[0]) snprintf(val, sizeof(val), "IP %s", st.ip);
+ else strlcpy(val, "IP --", sizeof(val));
+ s_row(lix, lir, TOP_Y + 50, val, st.ip[0] ? C_CYAN : C_DIM, 200);
+ disp_hline(lix, TOP_Y + 72, lir - lix, C_TRACE);
+ const char *link = st.api_fail ? "API FAIL" : (st.owner[0] ? "BOUND" : "NOT BOUND");
+ uint16_t link_c = st.api_fail ? C_RED : (st.owner[0] ? C_GREEN : C_ORANGE);
+ s_row(lix, lir, TOP_Y + 80, "SERVER", C_GOLD, 100, link, link_c);
+ disp_text_wrap(lix, TOP_Y + 100, lir - lix, st.api, 16, C_CYAN, C_PANEL, 2);
+
+ disp_panel_glow(rx, TOP_Y, rw, ch, 10, C_GOLD_DIM);
+ disp_panel(rx, TOP_Y, rw, ch, 10, C_PANEL, C_GOLD);
+ s_row(rix, rir, TOP_Y + 6, "MODE", C_GOLD, 80,
+ (st.mode < 0) ? "NOT CHOSEN" : (st.mode ? "LAUNCHER" : "CELESTIAL"), C_CYAN_DIM);
+ snprintf(val, sizeof(val), "USER %s", st.owner[0] ? st.owner : "--");
+ s_row(rix, rir, TOP_Y + 28, val, st.owner[0] ? C_TEXT : C_DIM, 200);
+ s_row(rix, rir, TOP_Y + 50, st.device_id, C_TEXT, 200);
+ bool pending = ota_pending();
+ if (st.fw_version[0]) snprintf(rv, sizeof(rv), pending ? "%s PENDING" : "%s", st.fw_version);
+ else snprintf(rv, sizeof(rv), pending ? "PENDING" : "--");
+ s_row(rix, rir, TOP_Y + 72, "FIRMWARE", C_GOLD, 100, rv, pending ? C_ORANGE : C_GOLD);
+ s_row(rix, rir, TOP_Y + 94, "BOARD", C_GOLD, 100, BOARD_NAME, C_TEXT);
+ clock_local(rv, sizeof(rv)); /* 服务器同步来的本地时间,没同步过时是 "--" */
+ s_row(rix, rir, TOP_Y + 116, "TIME", C_GOLD, 100, rv, C_TEXT);
+}
+#endif
+
static void draw_settings(const UiState &st)
{
- const int pw = 304, ix = 20, ir = 300; /* 面板左右内壁 */
- /* 三张等高卡:y=22/86/150,h=62 间距 2,正好铺到内容区下沿 212。
+#if STRIP
+ draw_settings_strip(st);
+ return;
+#endif
+ const int px = 8, pw = CONT_W - 16, ix = px + 12, ir = px + pw - 12;
+ /* 三张等高卡:横屏 y=22/86/150,h=62 间距 2,正好铺到内容区下沿 212,
行距 18(行首 y = 卡顶 +6/+24/+42),16px 字模上下各留 2~4px。 */
- char val[48];
+ const int ch = 62, gap = 2, rp = 18;
+ const int c0 = TOP_Y, c1 = TOP_Y + ch + gap, c2 = TOP_Y + 2 * (ch + gap);
+ char val[48], rv[32];
/* ---- WiFi ---- */
- disp_panel_glow(8, 22, pw, 62, 10, C_CYAN_DIM);
- disp_panel(8, 22, pw, 62, 10, C_PANEL, C_CYAN);
- disp_text(ix, 28, "WIFI", 16, C_CYAN, C_PANEL);
- text_right(ir, 28, st.wifi_up ? "ONLINE" : "OFFLINE", 16,
- st.wifi_up ? C_GREEN : C_RED, C_PANEL);
- if (st.ssid[0]) disp_text_clipped(ix, 46, 190, st.ssid, 16, C_TEXT, C_PANEL);
- else disp_text(ix, 46, "NO SSID SAVED", 16, C_DIM, C_PANEL);
- if (st.wifi_up) {
- snprintf(val, sizeof(val), "RSSI %d", st.rssi);
- text_right(ir, 46, val, 16, C_CYAN_DIM, C_PANEL);
- }
+ disp_panel_glow(px, c0, pw, ch, 10, C_CYAN_DIM);
+ disp_panel(px, c0, pw, ch, 10, C_PANEL, C_CYAN);
+ s_row(ix, ir, c0 + 6, "WIFI", C_CYAN, 190,
+ st.wifi_up ? "ONLINE" : "OFFLINE", st.wifi_up ? C_GREEN : C_RED);
/* 热点名要去配网时才需要,那一页第 1 步就写着,这里腾给 IP */
- if (st.ip[0]) { snprintf(val, sizeof(val), "IP %s", st.ip); disp_text_clipped(ix, 64, 280, val, 16, C_CYAN, C_PANEL); }
- else disp_text(ix, 64, "IP --", 16, C_DIM, C_PANEL);
+ rv[0] = 0;
+ if (st.wifi_up) snprintf(rv, sizeof(rv), "RSSI %d", st.rssi);
+ s_row(ix, ir, c0 + 6 + rp, st.ssid[0] ? st.ssid : "NO SSID SAVED",
+ st.ssid[0] ? C_TEXT : C_DIM, 190, rv[0] ? rv : nullptr, C_CYAN_DIM);
+ if (st.ip[0]) snprintf(val, sizeof(val), "IP %s", st.ip);
+ else strlcpy(val, "IP --", sizeof(val));
+ s_row(ix, ir, c0 + 6 + 2 * rp, val, st.ip[0] ? C_CYAN : C_DIM, 280);
/* ---- 后端 ---- */
- disp_panel_glow(8, 86, pw, 62, 10, C_GOLD_DIM);
- disp_panel(8, 86, pw, 62, 10, C_PANEL, C_GOLD);
- disp_text(ix, 92, "SERVER", 16, C_GOLD, C_PANEL);
- if (st.api_fail) text_right(ir, 92, "API FAIL", 16, C_RED, C_PANEL);
- else if (st.owner[0]) text_right(ir, 92, "BOUND", 16, C_GREEN, C_PANEL);
- else text_right(ir, 92, "NOT BOUND", 16, C_ORANGE, C_PANEL);
- disp_text_clipped(ix, 110, 280, st.api, 16, C_CYAN, C_PANEL);
+ disp_panel_glow(px, c1, pw, ch, 10, C_GOLD_DIM);
+ disp_panel(px, c1, pw, ch, 10, C_PANEL, C_GOLD);
+ const char *link_st = st.api_fail ? "API FAIL" : (st.owner[0] ? "BOUND" : "NOT BOUND");
+ uint16_t link_c = st.api_fail ? C_RED : (st.owner[0] ? C_GREEN : C_ORANGE);
+ s_row(ix, ir, c1 + 6, "SERVER", C_GOLD, 190, link_st, link_c);
+ s_row(ix, ir, c1 + 6 + rp, st.api, C_CYAN, 280);
snprintf(val, sizeof(val), "USER %s", st.owner[0] ? st.owner : "--");
- disp_text_clipped(ix, 128, 140, val, 16, C_TEXT, C_PANEL);
- text_right(ir, 128,
- (st.mode < 0) ? "MODE NOT CHOSEN" : (st.mode ? "MODE LAUNCHER" : "MODE CELESTIAL"),
- 16, C_CYAN_DIM, C_PANEL);
+ s_row(ix, ir, c1 + 6 + 2 * rp, val, C_TEXT, 140,
+ (st.mode < 0) ? "MODE NOT CHOSEN" : (st.mode ? "MODE LAUNCHER" : "MODE CELESTIAL"),
+ C_CYAN_DIM);
/* ---- 本机:设备号 / 板型 / 固件版本(后两项就是后端 terminal_devices 里那两个字段) ---- */
- disp_panel_glow(8, 150, pw, 62, 10, C_CYAN_DIM);
- disp_panel(8, 150, pw, 62, 10, C_PANEL, C_CYAN);
- disp_text(ix, 156, "DEVICE", 16, C_CYAN, C_PANEL);
+ disp_panel_glow(px, c2, pw, ch, 10, C_CYAN_DIM);
+ disp_panel(px, c2, pw, ch, 10, C_PANEL, C_CYAN);
/* 升级写完了但还没画出首屏确认,版本行标成 PENDING,免得看着像没升上去 */
bool pending = ota_pending();
- if (st.fw_version[0]) snprintf(val, sizeof(val), pending ? "FW %s PENDING" : "FW %s", st.fw_version);
- else snprintf(val, sizeof(val), pending ? "PENDING" : "FW --");
- text_right(ir, 156, val, 16, pending ? C_ORANGE : C_GOLD, C_PANEL);
+ if (st.fw_version[0]) snprintf(rv, sizeof(rv), pending ? "FW %s PENDING" : "FW %s", st.fw_version);
+ else snprintf(rv, sizeof(rv), pending ? "PENDING" : "FW --");
+ s_row(ix, ir, c2 + 6, "DEVICE", C_CYAN, 190, rv, pending ? C_ORANGE : C_GOLD);
snprintf(val, sizeof(val), "DEV %s", st.device_id);
- disp_text_clipped(ix, 174, 220, val, 16, C_TEXT, C_PANEL);
const esp_partition_t *slot = esp_ota_get_running_partition();
- text_right(ir, 174, slot ? slot->label : "APP", 16, C_CYAN_DIM, C_PANEL);
- disp_text_clipped(ix, 192, 200, "BOARD " BOARD_NAME, 16, C_TEXT, C_PANEL);
- if (psramFound()) snprintf(val, sizeof(val), "PSRAM %uMB", (unsigned)(ESP.getPsramSize() / (1024 * 1024)));
- else snprintf(val, sizeof(val), "NO PSRAM");
- text_right(ir, 192, val, 16, C_CYAN_DIM, C_PANEL);
+ s_row(ix, ir, c2 + 6 + rp, val, C_TEXT, 220, slot ? slot->label : "APP", C_CYAN_DIM);
+ if (psramFound()) snprintf(rv, sizeof(rv), "PSRAM %uMB", (unsigned)(ESP.getPsramSize() / (1024 * 1024)));
+ else snprintf(rv, sizeof(rv), "NO PSRAM");
+ s_row(ix, ir, c2 + 6 + 2 * rp, "BOARD " BOARD_NAME, C_TEXT, 200, rv, C_CYAN_DIM);
}
+#if STRIP
+/* ---------------- 长条屏:状态栏右端的上下文按钮 ----------------
+ 这块板子上只有触摸:翻页靠上下滑或列表页右缘那两颗键,卡片和详情页的分页标签直接点,
+ 剩下的页面级动作(返回/设置/配网/换码/重试/安装)满打满算两颗,画在状态栏右端。
+ 屏一共 172 高,按钮画成 14x14 线稿图标 + 一个英文词:图标好认,英文比中文省一半宽度。
+ 点它等价于按下 on_key_press 早就认识的那颗键,所以每一页的业务逻辑一行都不用改。 */
+enum Glyph { G_BACK, G_GEAR, G_TUNE, G_REDO, G_DL, G_UP, G_DOWN };
+struct HdrBtn { Glyph g; const char *label; uint16_t bits; };
+
+#define GLYPH_SZ 14 /* 线稿图标的方框边长 */
+#define HDR_PAD 7 /* 按钮左右各让出的留白 */
+#define HDR_IV 4 /* 图标和英文标签之间的缝 */
+#define HDR_GAP 8 /* 两颗按钮之间的缝(含热区不重叠的余量) */
+#define HDR_BTN_H 24 /* 按钮面板高:16px 的文字上下各留 3px */
+#define HDR_HIT_H 31 /* 热区盖住整条 header,但不吃到内容区 */
+
+static int hdr_w(const char *label)
+{
+ return 2 * HDR_PAD + GLYPH_SZ + HDR_IV + disp_text_width(label, 16, 1);
+}
+
+/* 按角度描弧:0° 在正右方,逆时针为正。逐度打点再往下补 1px 加粗,1px 的线在这块屏上太细 */
+static void arc_px(int cx, int cy, int r, int a0, int a1, uint16_t c)
+{
+ for (int a = a0; a <= a1; a++) {
+ float rad = a * 0.0174533f;
+ int px = cx + (int)lroundf(r * cosf(rad));
+ int py = cy - (int)lroundf(r * sinf(rad));
+ disp_pixel(px, py, c);
+ disp_pixel(px, py + 1, c);
+ }
+}
+
+static void ui_glyph(int x, int y, Glyph g, uint16_t c)
+{
+ const int cx = x + 7, cy = y + 7;
+ switch (g) {
+ case G_BACK: /* 返回:朝左的尖角 */
+ for (int i = 0; i < 6; i++) {
+ disp_fill(x + 7 - i, y + 1 + i, 2, 2, c);
+ disp_fill(x + 2 + i, y + 6 + i, 2, 2, c);
+ }
+ break;
+ case G_UP: case G_DOWN: /* 列表页上/下:人字形 */
+ for (int i = 0; i < 6; i++) {
+ int yy = (g == G_UP) ? (y + 4 + i) : (y + 9 - i);
+ disp_fill(x + 6 - i, yy, 2, 2, c);
+ disp_fill(x + 6 + i, yy, 2, 2, c);
+ }
+ break;
+ case G_GEAR: /* 设置:圆环 + 四齿 + 轴心 */
+ disp_ring(cx, cy, 4, c);
+ disp_disc(cx, cy, 1, c);
+ disp_fill(x + 6, y + 1, 2, 2, c);
+ disp_fill(x + 6, y + 11, 2, 2, c);
+ disp_fill(x + 1, y + 6, 2, 2, c);
+ disp_fill(x + 11, y + 6, 2, 2, c);
+ break;
+ case G_TUNE: /* 配网门户:三条滑轨 + 错开的滑块 */
+ for (int i = 0; i < 3; i++) {
+ int yy = y + 2 + 4 * i;
+ disp_fill(x + 1, yy, 12, 1, c);
+ disp_fill(x + (i == 0 ? 3 : (i == 1 ? 9 : 6)), yy - 1, 2, 3, c);
+ }
+ break;
+ case G_REDO: /* 换码/重试:顶部缺口的圆环 + 两头箭头 */
+ arc_px(cx, cy, 5, 115, 425, c);
+ for (int i = 0; i < 3; i++) {
+ disp_fill(x + 2 + i, y + 3 - i, 1, 1 + 2 * i, c);
+ disp_fill(x + 11 - i, y + 3 - i, 1, 1 + 2 * i, c);
+ }
+ break;
+ case G_DL: /* 安装:向下箭头 + 托盘 */
+ disp_fill(x + 6, y + 1, 2, 8, c);
+ for (int i = 0; i < 4; i++) {
+ disp_fill(x + 6 - i, y + 8 - i, 2, 2, c);
+ disp_fill(x + 6 + i, y + 8 - i, 2, 2, c);
+ }
+ disp_fill(x + 2, y + 12, 10, 2, c);
+ break;
+ }
+}
+
+/* 每一页右上角放哪几颗,顺序 = 从右往左;语义照 on_key_press。
+ 齿轮 SETUP 进的是只读的设置页,滑杆 CONFIG 直接进配网门户(改 WiFi、改后端地址都在那里)。 */
+static int header_actions(const UiState &st, HdrBtn *b)
+{
+ int n = 0;
+ switch (st.screen) {
+ case SC_MODE: b[n++] = { G_GEAR, "SETUP", XL_IO_KEY3 }; break;
+ case SC_LIST: case SC_ROCKETS:
+ case SC_PROVISION: b[n++] = { G_BACK, "BACK", XL_IO_KEY3 }; break;
+ case SC_DETAIL: case SC_ROCKET:
+ b[n++] = { G_BACK, "BACK", XL_IO_KEY2 }; break;
+ case SC_CONNECTING: b[n++] = { G_TUNE, "CONFIG", XL_IO_KEY3 }; break;
+ case SC_SETTINGS: b[n++] = { G_BACK, "BACK", XL_IO_KEY3 };
+ b[n++] = { G_TUNE, "CONFIG", XL_IO_KEY2 }; break;
+ case SC_PAIR: b[n++] = { G_REDO, "CODE", XL_IO_KEY3 };
+ b[n++] = { G_TUNE, "CONFIG", XL_IO_KEY2 }; break;
+ case SC_ERROR: b[n++] = { G_REDO, "RETRY", XL_IO_KEY3 };
+ b[n++] = { G_TUNE, "CONFIG", XL_IO_KEY2 }; break;
+ case SC_UPDATE:
+ /* 下载已经阻塞在 loop 里,这期间按了也没用,别画出来骗人 */
+ if (st.fw_progress >= 0) break;
+ b[n++] = { G_BACK, "BACK", XL_IO_KEY3 };
+ b[n++] = { (st.fw_progress == -2) ? G_REDO : G_DL,
+ (st.fw_progress == -2) ? "RETRY" : "INSTALL", XL_IO_KEY2 };
+ break;
+ default: break;
+ }
+ return n;
+}
+
+static void header_buttons(const HdrBtn *b, int n, uint8_t flash)
+{
+ int x = CONT_W - 4;
+ for (int i = 0; i < n; i++) {
+ int w = hdr_w(b[i].label);
+ x -= w;
+ int slot = (b[i].bits == XL_IO_KEY2) ? 2 : 3; /* 这板上只用得上这两颗键 */
+ bool fl = (flash & (1 << slot)) != 0;
+ uint16_t bg = fl ? C_GOLD : C_PANEL;
+ disp_panel(x, 1, w, HDR_BTN_H, 4, bg, fl ? C_GOLD_LT : C_GOLD_DIM);
+ ui_glyph(x + HDR_PAD, HDR_TY + 1, b[i].g, fl ? C_GOLD_DK : C_GOLD);
+ disp_text(x + HDR_PAD + GLYPH_SZ + HDR_IV, HDR_TY, b[i].label, 16, fl ? C_GOLD_DK : C_GOLD, bg);
+ HIT(x - 4, 0, w + 8, HDR_HIT_H, b[i].bits, -1);
+ x -= HDR_GAP;
+ }
+}
+
+/* 列表页右缘那一竖条:上/下两颗图标键,等价 KEY0/KEY1(和上下滑是同一个动作)。
+ 卡片已经靠 RAIL_W 往左让过,不会压在按钮下面。
+ enabled=false(列表空着、或者总共就一页翻无可翻)时按钮照画但整组压暗,
+ 并且**不登记热区**——点了没反应的东西不能还长得像能点。 */
+static void nav_rail(uint8_t flash, bool enabled)
+{
+ const int bw = 24, bh = 26;
+ const int x = CONT_W - RAIL_W + (RAIL_W - bw) / 2;
+ const int mid = (TOP_Y + BOT_Y) / 2;
+ const uint16_t key[2] = { XL_IO_KEY0, XL_IO_KEY1 };
+ const Glyph gl[2] = { G_UP, G_DOWN };
+ for (int i = 0; i < 2; i++) {
+ int y = mid + (i ? 4 : -4 - bh);
+ bool fl = enabled && (flash & (1 << i)) != 0; /* KEY0=bit0 KEY1=bit1 */
+ uint16_t bg = fl ? C_GOLD : C_PANEL;
+ disp_panel(x, y, bw, bh, 5, bg,
+ fl ? C_GOLD_LT : (enabled ? C_CYAN_DIM : C_TRACE));
+ ui_glyph(x + (bw - GLYPH_SZ) / 2, y + (bh - GLYPH_SZ) / 2, gl[i],
+ fl ? C_GOLD_DK : (enabled ? C_CYAN : C_CYAN_DIM));
+ if (enabled) HIT(x - 6, y - 4, bw + 12, bh + 8, key[i], -1);
+ }
+}
+#endif
+
void ui_draw(const UiState &st)
{
disp_bg();
+ ui_hits_reset();
+
+#if STRIP
+ /* 右上角那几颗先量宽度:状态栏右端的用户名、详情页标题行右端的日期都要让开它 */
+ HdrBtn hb[2];
+ int nhb = header_actions(st, hb);
+ int wrow = 0;
+ for (int i = 0; i < nhb; i++) wrow += hdr_w(hb[i].label) + (i ? HDR_GAP : 0);
+ s_info_r = CONT_W - 14 - (nhb ? wrow : 0);
+#endif
const char *right = "COSMO";
if (st.screen == SC_LIST || st.screen == SC_DETAIL || st.screen == SC_ROCKETS
- || st.screen == SC_ROCKET || st.screen == SC_MODE || st.screen == SC_LOADING
+ || st.screen == SC_ROCKET || st.screen == SC_MODE
|| st.screen == SC_SETTINGS || st.screen == SC_UPDATE) right = st.owner;
- if (st.screen != SC_SPLASH) status_bar(st, right);
+ /* 详情页把 0..19 那一行让给自己的页头(标题 + 日期),状态栏不再画,
+ 否则这块矮屏上会叠出两层 header;其它页照旧 */
+ const bool own_hdr = STRIP && (st.screen == SC_DETAIL || st.screen == SC_ROCKET);
+ if (st.screen != SC_SPLASH && !own_hdr) status_bar(st, right);
switch (st.screen) {
case SC_SPLASH: draw_splash(st); break;
case SC_PROVISION: draw_provision(st); break;
case SC_CONNECTING: draw_connecting(st); break;
case SC_PAIR: draw_pair(st); break;
- case SC_LOADING: draw_loading(st); break;
case SC_MODE: draw_mode(st); break;
case SC_LIST: draw_list(st); break;
case SC_DETAIL: draw_detail(st); break;
@@ -810,6 +1353,31 @@ void ui_draw(const UiState &st)
else if (st.screen == SC_UPDATE)
keys = (st.fw_progress < 0) ? KEYS_UPDATE : KEYS_EMPTY; /* 下载中按了也没用,别画出来骗人 */
if (st.screen != SC_SPLASH) key_bar(keys, st.key_flash);
+#if STRIP
+ if (st.screen == SC_LIST || st.screen == SC_ROCKETS) {
+ const int cnt = (st.screen == SC_ROCKETS) ? (st.rsnap ? st.rsnap->count : 0)
+ : (st.snap ? st.snap->count : 0);
+ nav_rail(st.key_flash, cnt > LIST_ROWS); /* 空列表或不足一页:翻无可翻,整组禁用 */
+ }
+ header_buttons(hb, nhb, st.key_flash); /* 画在页面之后:热区后登记的才压得住卡片 */
+#endif
+
+ /* 最后这层是操作反馈,得盖在按钮自己之上。全站只有这一种加载表达:请求在飞或立绘
+ 还在补时,header 那条分隔线上有一截青色亮段横向流过(不再另开加载页)。
+ 画在页面之后才压得住卡片;每一页都自己画 HDR_LINE,带头部标题的详情页也让得开。
+ 亮段只在 header 线**正中**那 160px 区间里跑(区间本身跟页面无关,各页看到的
+ 位置一致,也不会撞上状态栏左边的电量格和右边的用户名),出区间就整段消失再从头
+ 进,是标准的不定长进度跑马。2px 高刚好压在内容区之上(HDR_LINE+1 < TOP_Y),
+ 只比线本身粗 1px,读起来是"这条线在流动"而不是"线上盖了根进度条";
+ 相位取 millis(),重绘就自己在动。 */
+ if (st.busy) {
+ const int span = 160; /* 居中跑马区的宽度 */
+ const int x0 = (CONT_W - span) / 2;
+ const int tail = 72, head = 16, bw = tail + head;
+ const int x = x0 - bw + (int)((millis() / 8) % (unsigned)(span + bw));
+ disp_fill(x, HDR_LINE, tail, 2, C_CYAN);
+ disp_fill(x + tail, HDR_LINE, head, 2, C_WHITE);
+ }
disp_flush();
}
diff --git a/terminal/firmware/cosmo_terminal/src/ui.h b/terminal/firmware/cosmo_terminal/src/ui.h
index 2fa0102..4a4d245 100644
--- a/terminal/firmware/cosmo_terminal/src/ui.h
+++ b/terminal/firmware/cosmo_terminal/src/ui.h
@@ -7,7 +7,6 @@ enum Screen {
SC_PROVISION, /* 无 WiFi 凭据,开热点配网 */
SC_CONNECTING, /* 正在连接 WiFi */
SC_PAIR, /* 显示 6 位配对码,等待网页端绑定 */
- SC_LOADING, /* 正在拉取订阅数据 */
SC_MODE, /* 进入哪一种终端:天体 / 火箭 */
SC_LIST, /* 关注天体列表 */
SC_DETAIL, /* 单个天体的位置/速度/事件 */
@@ -44,8 +43,11 @@ struct UiState {
int rocket_tab = 0; /* 火箭详情页右栏分页:0=LAUNCH 1=STAGE 2=INFO */
int rssi = 0;
bool wifi_up = false;
+ int bat_pct = -1; /* 电池电量 -1 = 没装电池/没测到 */
+ bool bat_chg = false; /* 充电中(这板的充电芯片没有状态脚,按 USB 在位近似)*/
bool api_fail = false; /* WiFi 连着但后端取不到数据,状态栏要标出来 */
uint8_t key_flash = 0; /* 底部按键条:bit0..bit3 = 被按下的槽位(含 BOOT) */
+ int busy = false; /* 有请求在飞或图还在补:header 那条分隔线上扫一条亮带 */
/* OTA:fw_progress 是这一页的状态机,省掉另开一个 enum */
char fw_version[16] = ""; /* 本机正在跑的版本(FW_VERSION) */
char fw_new[32] = ""; /* 后端建议升级到的版本 */
@@ -55,3 +57,12 @@ struct UiState {
};
void ui_draw(const UiState &st);
+
+/* 触摸热区:ui_draw 每帧重建(进来先 reset),按键条/列表卡/模式卡都会登记自己。
+ ui_hit_test 返回命中的按键位掩码(XL_IO_KEY*),index 带出选中的行号,没命中返回 0。 */
+void ui_hits_reset();
+void ui_hit_add(int x, int y, int w, int h, uint16_t bits, int index);
+uint16_t ui_hit_test(int x, int y, int *index);
+
+/* 热区里混在按键位之外的动作:不是按键,tap_at 自己消化,不进 on_key_press */
+#define UI_ACT_TAB 0x0040 /* 面板内的分页标签,index = 目标页 */
diff --git a/terminal/firmware/cosmo_terminal/src/version.h b/terminal/firmware/cosmo_terminal/src/version.h
index 397eb3f..7563fe2 100644
--- a/terminal/firmware/cosmo_terminal/src/version.h
+++ b/terminal/firmware/cosmo_terminal/src/version.h
@@ -2,4 +2,4 @@
* 发 OTA 包必须先改这里再编译:终端拿它和后端版本号比,
* 版本号没变的话新包会被当成"已是最新"而永不安装。 */
#pragma once
-#define FW_VERSION "1.2.2"
+#define FW_VERSION "1.5.4"
diff --git a/terminal/tools/fb_check.py b/terminal/tools/fb_check.py
index 8e822d5..c5ae2d3 100644
--- a/terminal/tools/fb_check.py
+++ b/terminal/tools/fb_check.py
@@ -165,9 +165,13 @@ def main():
rc = 0
for path in args:
raw = open(path, 'rb').read()
- if len(raw) != 320 * 240 * 2:
- print('%s: %d 字节,不是整屏(应为 153600)' % (path, len(raw))); rc = 1; continue
- img = np.frombuffer(raw, '>u2').reshape(240, 320).astype(np.uint16)
+ # 整屏裸数据按长度反推尺寸,换板子不用加参数
+ W, H = next(((w, h) for w, h in ((320, 240), (240, 240), (172, 640), (640, 172))
+ if len(raw) == w * h * 2), (0, 0))
+ if not W:
+ print('%s: %d 字节,不是任何一款屏的整屏' % (path, len(raw))); rc = 1; continue
+ print('%s: %dx%d' % (path, W, H))
+ img = np.frombuffer(raw, '>u2').reshape(H, W).astype(np.uint16)
top = sorted(((int((img == c).sum()), c) for c in np.unique(img)), reverse=True)[:8]
print('%s 非背景像素 %d' % (path, int((~np.isin(img, list(BG))).sum())))
print(' 主色:', ' '.join('%04X:%d' % (c, n) for n, c in top))
diff --git a/terminal/tools/release_firmware.py b/terminal/tools/release_firmware.py
index b8d91a6..b76fa54 100644
--- a/terminal/tools/release_firmware.py
+++ b/terminal/tools/release_firmware.py
@@ -33,6 +33,14 @@ VERSION_H = SKETCH_DIR / SKETCH / "src" / "version.h"
# /dev/cu.usbserial-210 跑到原生 usbmodem 口上,看着像设备死了。
FQBN = ("esp32:esp32:esp32s3:PSRAM=opi,FlashSize=16M,FlashMode=dio,CDCOnBoot=default,"
"PartitionScheme=app3M_fat9M_16MB,UploadSpeed=460800")
+# 上面那条是按 atk 那块写的:它板载 CH340 之类的 USB-UART,控制台走串口芯片,
+# CDCOnBoot=default 不影响。waveshare-3p49 只有 ESP32-S3 原生 USB 一个口,
+# 必须 USBMode=hwcdc + CDCOnBoot=cdc,配错 OTA 之后 /dev/cu.usbmodem* 直接消失。
+FQBN_OVERRIDES = {
+ "waveshare-3p49":
+ "esp32:esp32:esp32s3:PSRAM=opi,FlashSize=16M,FlashMode=dio,USBMode=hwcdc,"
+ "CDCOnBoot=cdc,PartitionScheme=app3M_fat9M_16MB,UploadSpeed=460800",
+}
CLI = Path.home() / "esp-tools" / "arduino-cli"
CLI_CFG = Path.home() / "esp-tools" / "arduino-cli.yaml"
@@ -40,6 +48,7 @@ CLI_CFG = Path.home() / "esp-tools" / "arduino-cli.yaml"
BOARDS = {
"atk-dnesp32s3": [], # 出货用的 320x240 横屏(默认板型)
"xingzhi-cube-1.54tft": ["-DCOSMO_BOARD=2"], # 1.54 寸 240x240 方屏样机
+ "waveshare-3p49": ["-DCOSMO_BOARD=3"], # 640x172 长条触摸屏,原生 USB
}
@@ -59,12 +68,17 @@ def read_version():
def build(board, out_dir):
"""编译并把 .bin 落到 out_dir,返回 bin 路径。"""
cmd = [str(CLI), "--config-file", str(CLI_CFG), "compile",
- "--fqbn", FQBN, "--warnings", "none",
+ "--fqbn", FQBN_OVERRIDES.get(board, FQBN), "--warnings", "none",
"--build-path", str(out_dir / "build"),
"--output-dir", str(out_dir)]
flags = BOARDS[board]
if flags:
- cmd += ["--build-property", "build.extra_flags=" + " ".join(flags)]
+ # 只能用 compiler.cpp.extra_flags:esp32 core 的 platform.txt 把 USB 那几个
+ # -D(ARDUINO_USB_MODE / ARDUINO_USB_CDC_ON_BOOT)塞在 build.extra_flags 里,
+ # --build-property 是整体覆盖而不是追加,覆盖掉之后原生 USB 那几块板的
+ # Serial 会退回 UART0(少 isPlugged() 之类),FQBN 里的 CDCOnBoot 也一并失效。
+ cmd += ["--build-property", "compiler.cpp.extra_flags=" + " ".join(flags)]
+ cmd.append(str(SKETCH_DIR / SKETCH)) # arduino-cli 认位置参数,缺它就是在编译 cwd 下的空目录
env = {k: v for k, v in os.environ.items()
if k.lower() not in ("http_proxy", "https_proxy", "all_proxy")}
print(f"[release] compiling {board} ...")
diff --git a/terminal/tools/screen_shot.py b/terminal/tools/screen_shot.py
index 6127cb0..9413dee 100644
--- a/terminal/tools/screen_shot.py
+++ b/terminal/tools/screen_shot.py
@@ -13,7 +13,10 @@ def _pick_port():
if m: return m[0]
return '/dev/cu.usbserial-210'
-PORT = _pick_port(); BAUD=115200; N=320*240*2
+PORT = _pick_port(); BAUD=115200
+#: 屏尺寸跟着板子走(320x240 / 240x240 / 172x640):COSMO_FB=172x640 python3 ...
+W,H = [int(v) for v in os.environ.get('COSMO_FB','320x240').lower().split('x')]
+N=W*H*2
log=open(sys.argv[1],'ab',buffering=0)
steps=[a.split('|') for a in sys.argv[2:]]
s=serial.Serial(PORT,BAUD,timeout=0.1,write_timeout=10)
@@ -46,7 +49,8 @@ def pump(dur, path=None):
f.close(); log.write(d[take:])
print('[fb] %s %d bytes'%(path,got),flush=True)
os.system('/usr/local/bin/ffmpeg -y -loglevel error -f rawvideo -pixel_format rgb565be '
- '-video_size 320x240 -i %s -frames:v 1 -vf "scale=960:720:flags=neighbor" %s.png'%(path,path))
+ '-video_size %dx%d -i %s -frames:v 1 -vf "scale=%d:%d:flags=neighbor" %s.png'
+ %(W,H,path,W*3,H*3,path))
print('[fb] rendered %s.png'%(path,),flush=True)
buf=bytearray(); return True
if f is not None: