main
mula.liu 2026-10-10 18:49:10 +08:00
parent 700f74c4a1
commit 0a7e6e2a8e
37 changed files with 4527 additions and 726 deletions

View File

@ -33,7 +33,7 @@ class RocketStage(BaseModel):
class RocketAppearance(BaseModel):
"""纯外观特征(可选):只登记无法从参数推导的特征件。
构型(助推器数量、各自的发动机数量与直径)一律在 boosters 里登记,
构型(助推器数量、各自的发动机数量与直径比、长度比)一律在 boosters 里登记,
栅格翼长在可回收的那一级上,因此由 stage_1 / boosters 的 recoverable 决定,
这里不重复存放,否则同一件事会有两处数值。
"""
@ -42,7 +42,7 @@ class RocketAppearance(BaseModel):
class RocketBoosters(BaseModel):
"""捆绑助推器组(可选):数量、发动机、直径比与推进参数都登记在助推器自己身上。
"""捆绑助推器组(可选):数量、发动机、直径比、长度比与推进参数都登记在助推器自己身上。
stage_1 自此只描述芯级,起飞推力 = stage_1.max_thrust_n + boosters.thrust_n,
不再用「一级合计减去助推器」的口径。
@ -56,6 +56,9 @@ class RocketBoosters(BaseModel):
diameter_ratio: float | None = Field(
default=None, gt=0, le=1, description="助推器直径 / 芯级直径,留空按 0.45 绘制"
)
length_ratio: float | None = Field(
default=None, gt=0, le=1, description="助推器长度 / 芯级一级长度,留空按 0.86 绘制"
)
thrust_n: float | None = Field(default=None, gt=0, description="全部助推器合计推力")
specific_impulse_s: float | None = Field(default=None, gt=0, description="助推器比冲")
dry_mass_kg: float | None = Field(default=None, gt=0, description="全部助推器合计干重")

View File

@ -66,6 +66,9 @@ async def list_rocket_events(
offset: int = Query(0, ge=0),
):
now = datetime.now(timezone.utc).replace(tzinfo=None)
# net 存的是无时区 UTC,带时区的入参先转 UTC 再去掉时区,否则与 net 比较会报错
start = start.astimezone(timezone.utc).replace(tzinfo=None) if start and start.tzinfo else start
end = end.astimezone(timezone.utc).replace(tzinfo=None) if end and end.tzinfo else end
filters = []
if upcoming is True:

View File

@ -1,17 +1,21 @@
"""
System Settings API Routes
"""
from pathlib import Path
from fastapi import APIRouter, HTTPException, Query, Depends, status
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select, func
from sqlalchemy import select, func, text
from typing import Optional, Dict, Any, List
from datetime import datetime
import logging
from pydantic import BaseModel
from app.config import settings
from app.services.system_settings_service import system_settings_service
from app.services.redis_cache import redis_cache
from app.services.cache import cache_service
from app.services.auth_deps import require_admin
from app.database import get_db
from app.models.db import Position, CelestialBody, User
@ -391,3 +395,61 @@ async def get_dashboard_statistics(
detail=f"Failed to retrieve statistics: {str(e)}"
)
# 数据量口径:只统计科研/业务数据表,账号与任务等运行期表不计入
DATA_RECORD_TABLES = (
"positions",
"celestial_bodies",
"celestial_events",
"orbits",
"star_systems",
"static_data",
"nasa_cache",
"resources",
"rocket_configs",
"rocket_events",
)
@router.get("/storage/stats")
async def get_storage_stats(
db: AsyncSession = Depends(get_db),
_: User = Depends(require_admin),
):
"""
控制台系统状态用的容量指标:数据库体积与记录规模、上传目录(资源文件)占用。
- database.size_bytes:整库体积,等价 pg_database_size()
- database.records:各数据表行数,位置数据是主要增量
- uploads:上传目录的文件数与字节数,容器里指向挂载的 upload 卷
"""
size_bytes = await db.scalar(select(func.pg_database_size(func.current_database()))) or 0
table_count = await db.scalar(text("select count(*) from pg_stat_user_tables")) or 0
projections = ", ".join(
f"(select count(*) from {name}) as {name}" for name in DATA_RECORD_TABLES
)
records = dict((await db.execute(text(f"select {projections}"))).mappings().one())
# main.py 把 upload 挂在 backend/upload,容器内是挂载卷,这里按同一口径统计
upload_root = Path(__file__).resolve().parents[2] / settings.upload_dir
upload_files = 0
upload_bytes = 0
if upload_root.is_dir():
for item in upload_root.rglob("*"):
if item.is_file():
upload_files += 1
upload_bytes += item.stat().st_size
return {
"database": {
"size_bytes": int(size_bytes),
"tables": int(table_count),
"records": {key: int(value or 0) for key, value in records.items()},
"records_total": sum(int(value or 0) for value in records.values()),
},
"uploads": {
"files": upload_files,
"size_bytes": int(upload_bytes),
},
}

View File

@ -16,7 +16,10 @@ from app.models.schemas.terminal import (
PairCodeResponse,
PairStatusResponse,
TerminalFollowsResponse,
TerminalRocketDetail,
TerminalRocketsResponse,
)
from app.services import rocket_art
from app.services.auth import decode_access_token
from app.services.terminal_icon import icon_file, render_rgb565
from app.services.terminal_service import PairingError, terminal_service
@ -172,3 +175,71 @@ async def get_body_icon(
# the resource id is the version the terminal caches on
headers={"ETag": str(icon.id)},
)
# ----------------------------------------------------------------------
# Rockets: 平台管理 -> 火箭型号 里启用的那些,所有人都看同一份
# ----------------------------------------------------------------------
@router.get("/rockets", response_model=TerminalRocketsResponse)
async def get_rockets(
ctx: TerminalContext = Depends(get_terminal_context),
db: AsyncSession = Depends(get_db),
):
"""Enabled launch vehicles with their upcoming launch count, compact for a TFT."""
ctx.device.last_seen_at = datetime.utcnow()
await db.commit()
rockets = await terminal_service.build_rocket_snapshot(db)
return TerminalRocketsResponse(
username=ctx.user.username,
device_id=ctx.device.id,
server_time=datetime.utcnow(),
rocket_count=len(rockets),
rockets=rockets,
)
@router.get("/rockets/{code}", response_model=TerminalRocketDetail)
async def get_rocket(
code: str,
ctx: TerminalContext = Depends(get_terminal_context),
db: AsyncSession = Depends(get_db),
):
"""Spec sheet of one rocket plus its nearest launches. 404 when disabled or unknown."""
ctx.device.last_seen_at = datetime.utcnow()
await db.commit()
rocket = await terminal_service.get_rocket(db, code)
if rocket is None:
raise HTTPException(status_code=404, detail="没有这个运载型号")
return rocket
@router.get("/rockets/{code}/art")
async def get_rocket_art(
code: str,
size: int = Query(64, description="Edge length in pixels: 40 (list) or 64 (detail)"),
ctx: TerminalContext = Depends(get_terminal_context),
db: AsyncSession = Depends(get_db),
):
"""
按火箭参数画出来的霓虹线稿立面图,裸 RGB565 大端点阵(size * size * 2 字节)。
和天体图标那条流水线同一套约定(纯黑底、无 alpha、终端叠加混合),区别只是
图不用人维护:参数即图形,ETag 是参数哈希,改身高/直径/助推器才会让终端重下。
"""
if size not in ICON_SIZES:
raise HTTPException(status_code=400, detail="size must be 40 or 64")
art = await terminal_service.get_rocket_art(db, code)
if art is None:
raise HTTPException(status_code=404, detail="没有这个运载型号")
art_ver, params = art
try:
blob = rocket_art.render_rgb565(params, size)
except Exception as exc: # 参数脏数据(缺 stage_1 之类)不该把终端拖成 500 循环
logger.error(f"Cannot draw rocket {code}: {exc}")
raise HTTPException(status_code=502, detail="火箭参数无法绘制")
return Response(content=blob, media_type="application/octet-stream", headers={"ETag": str(art_ver)})

View File

@ -98,3 +98,62 @@ class TerminalFollowsResponse(BaseModel):
server_time: datetime
follow_count: int
bodies: List[TerminalBody]
# --- Rockets (terminal -> backend, terminal token) ---
class TerminalRocket(BaseModel):
"""One launch vehicle as the terminal list shows it.
字段是"扁平"的:消费方是 320x240 的 MCU 固件,它按定长结构体解析,
与其在这里镜像数据库的 JSONB 嵌套,不如直接把要显示的量摊平。
"""
code: str
name: str
name_zh: Optional[str] = None
manufacturer: Optional[str] = None
country: Optional[str] = None
height_m: float
diameter_m: float
payload_mass_kg: Optional[float] = None
target_orbit_km: Optional[float] = None
thrust_kn: Optional[float] = Field(None, description="起飞推力(芯级+助推器)")
engines: Optional[int] = Field(None, description="芯级发动机数")
boosters: Optional[int] = Field(None, description="捆绑助推器数量")
upcoming: int = Field(0, description="待发射任务数")
art_ver: int = Field(..., description="程序化立绘图标的参数版本,终端按它缓存点阵")
class TerminalRocketsResponse(BaseModel):
username: str
device_id: str
server_time: datetime
rocket_count: int
rockets: List[TerminalRocket]
class TerminalRocketEvent(BaseModel):
name: str
net: datetime = Field(..., description="发射时间 T-0(UTC)")
orbit: Optional[str] = None
status: Optional[str] = None
launch_site_name: Optional[str] = None
class TerminalRocketDetail(TerminalRocket):
description: Optional[str] = None
target_velocity_mps: Optional[float] = None
s1_name: Optional[str] = None
s1_thrust_kn: Optional[float] = None
s1_isp_s: Optional[float] = None
s1_engines: Optional[int] = None
s1_recoverable: Optional[bool] = None
s2_name: Optional[str] = None
s2_thrust_kn: Optional[float] = None
s2_isp_s: Optional[float] = None
s2_engines: Optional[int] = None
fairing: bool = Field(True, description="False = 无整流罩(星舰/电子号这类带暴露头锥)")
booster_thrust_kn: Optional[float] = None
booster_recoverable: Optional[bool] = None
events: List[TerminalRocketEvent] = []
event_total: int = 0
next_net: Optional[datetime] = None

View File

@ -3,7 +3,7 @@ Event Service - Manages celestial events
"""
import logging
from typing import List, Optional
from datetime import datetime, timedelta
from datetime import datetime, timedelta, timezone
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select, delete, func, desc
from sqlalchemy.orm import selectinload
@ -13,6 +13,14 @@ from app.models.db.celestial_body import CelestialBody
logger = logging.getLogger(__name__)
def _as_naive_utc(value: Optional[datetime]) -> Optional[datetime]:
"""event_time 存的是无时区的 UTC,带时区的查询入参先转 UTC 再去掉时区。"""
if value is None or value.tzinfo is None:
return value
return value.astimezone(timezone.utc).replace(tzinfo=None)
class EventService:
async def create_event(self, event_data: CelestialEventCreate, db: AsyncSession) -> CelestialEvent:
"""Create a new celestial event"""
@ -38,6 +46,8 @@ class EventService:
offset: int = 0
) -> List[CelestialEvent]:
"""Get a list of celestial events, with optional filters"""
start_time = _as_naive_utc(start_time)
end_time = _as_naive_utc(end_time)
query = select(CelestialEvent).options(selectinload(CelestialEvent.body))
if body_id:
query = query.where(CelestialEvent.body_id == body_id)

View File

@ -0,0 +1,314 @@
"""按火箭登记参数绘制终端用的霓虹线稿立面图。
和天体图标同一条流水线(纯黑底、无 alpha、终端叠加混合),区别是这张图不用人
维护:形状全部来自 rocket_configs 里的身高/直径/级长比/助推器/可回收标记,
所以参数一改图形就跟着改,参数没改图形哈希就不变。
比例沿用 frontend/src/features/rocket-simulator/sceneMath.ts 的 stageGeometry(),
这样终端图标和网页端 3D 模型是同一台火箭,不会长成两个样子。
"""
from __future__ import annotations
import hashlib
import json
import math
from array import array
from typing import List, Tuple
from PIL import Image, ImageChops, ImageDraw, ImageFilter
from app.services.terminal_icon import BLACK_FLOOR
#: 画布四周留白(比例),给栅格翼和喷管留出位置
MARGIN = 0.06
#: 长细比压缩:drawn_aspect = GIRTH_K * 真实长细比 ** GIRTH_POW。
#: 真实的猎鹰 9 是 19:1,照画到 40px 上只剩一根针;开方压缩后既认得出是火箭,
#: 又保留"电子号细、长征五号粗"的相对关系
GIRTH_K = 1.72
GIRTH_POW = 0.45
#: 一台箭体最多画几个喷管,40px 上再多就糊成一条线
MAX_BELLS = 5
#: 超采样倍数:1px 的线在 40px 画布上直接画会发灰,先放大画再 LANCZOS 缩回来
SS = 4
DEFAULT_BOOSTER_DIAMETER_RATIO = 0.45
DEFAULT_BOOSTER_LENGTH_RATIO = 0.86
def _num(value, default: float = 0.0) -> float:
try:
return float(value)
except (TypeError, ValueError):
return default
def _clamp(value: float, lo: float, hi: float) -> float:
return max(lo, min(hi, value))
def _ink(color: str) -> Tuple[int, int, int]:
"""#rrggbb -> 最亮通道归一化到 255 的 RGB。
电子号登记的是 #242a30 这种接近纯黑的涂装,直接当线条画到黑底上等于没画,
叠加混合看不见;这里按线稿的习惯只保留色调,亮度由线稿自己决定。
"""
raw = (color or "").strip().lstrip("#")
if len(raw) != 6:
return (235, 245, 255)
try:
rgb = tuple(int(raw[i : i + 2], 16) for i in (0, 2, 4))
except ValueError:
return (235, 245, 255)
peak = max(rgb)
if peak < 1:
return (235, 245, 255)
return tuple(min(255, round(c * 255 / peak)) for c in rgb)
def art_params(cfg: dict) -> dict:
"""rocket_configs 的外观字段 -> 可直接绘制的米制几何(可序列化、可哈希)。
只收"画面上看得见"的键:改介绍、厂商不会让终端重新下载点阵。
数值统一 round,避免 0.45 和 0.45000000001 产生两个版本。
"""
height = max(1.0, _num(cfg.get("height_m"), 1.0))
diameter = max(0.5, _num(cfg.get("diameter_m"), 1.0))
stage_1 = cfg.get("stage_1") or {}
stage_2 = cfg.get("stage_2") or {}
boosters = cfg.get("boosters") or {}
appearance = cfg.get("appearance") or {}
# appearance.fairing 缺省 = 有整流罩;false 表示二级自己带头锥(星舰、电子号)
has_fairing = appearance.get("fairing") is not False
fairing_d = diameter * 1.4 if has_fairing else diameter * 0.97
fairing_d = min(fairing_d, 5.4) if has_fairing else fairing_d
fairing_h = _clamp(fairing_d * 2.5, height * 0.13, height * 0.27) if has_fairing else height * 0.11
fairing_cone_h = fairing_h * (0.62 if has_fairing else 1.0)
interstage_h = _clamp(4.6, height * 0.035, height * 0.085)
stack_h = height - fairing_h - interstage_h
ratio1 = _clamp(_num(stage_1.get("length_ratio"), 0.65), 0.2, 0.9)
ratio2 = _clamp(_num(stage_2.get("length_ratio"), 0.35), 0.1, 0.8)
stage1_h = stack_h * ratio1 / (ratio1 + ratio2)
stage2_h = stack_h * ratio2 / (ratio1 + ratio2)
booster_count = max(0, int(round(_num(boosters.get("count")))))
b_diam = _clamp(_num(boosters.get("diameter_ratio"), DEFAULT_BOOSTER_DIAMETER_RATIO), 0.2, 1.0)
b_len = _clamp(_num(boosters.get("length_ratio"), DEFAULT_BOOSTER_LENGTH_RATIO), 0.2, 1.0)
params = {
"color": "#%02x%02x%02x" % _ink(cfg.get("color")),
"height": round(height, 3),
"diameter": round(diameter, 3),
"fairing": has_fairing,
"fairing_d": round(fairing_d, 3),
"fairing_h": round(fairing_h, 3),
"fairing_cone_h": round(fairing_cone_h, 3),
"interstage_h": round(interstage_h, 3),
"stage1_h": round(stage1_h, 3),
"stage2_h": round(stage2_h, 3),
"booster_count": booster_count,
"booster_d": round(diameter * b_diam, 3) if booster_count else 0.0,
"booster_len": round(stage1_h * b_len, 3) if booster_count else 0.0,
"booster_engines": max(1, int(round(_num(boosters.get("engine_count"), 1)))) if booster_count else 0,
"core_engines": max(0, int(round(_num(stage_1.get("engine_count"))))),
"stage2_engines": max(1, int(round(_num(stage_2.get("engine_count"), 1)))),
"core_recoverable": bool(stage_1.get("recoverable")),
"booster_recoverable": bool(boosters.get("recoverable")) if booster_count else False,
}
return params
def params_version(params: dict) -> int:
"""图形参数的稳定版本号(同一个参数在任何进程/机器上算出同一个数)"""
blob = json.dumps(params, sort_keys=True, separators=(",", ":")).encode("utf-8")
return int(hashlib.sha1(blob).hexdigest()[:8], 16)
# ----------------------------------------------------------------------
# 绘制
# ----------------------------------------------------------------------
def _bell(draw: ImageDraw.ImageDraw, cx: float, top: float, out: float, height: float, width: int, color) -> None:
"""一个喷管:上窄下宽的梯形(立面图里就是喉部到扩张段)"""
throat = out * 0.55
draw.polygon(
[(cx - throat, top), (cx + throat, top), (cx + out, top + height), (cx - out, top + height)],
outline=color,
width=width,
)
def _bells(
draw: ImageDraw.ImageDraw,
cx: float,
top: float,
half_w: float,
count: int,
bell_h: float,
lw: int,
color,
) -> None:
if count <= 0:
return
shown = min(count, MAX_BELLS)
bell_out = max(1.0 * SS, half_w / math.ceil(shown / 2.0) * 0.62)
span = max(0.0, half_w - bell_out)
if shown == 1:
xs = [cx]
else:
step = 2 * span / (shown - 1)
xs = [cx - span + step * i for i in range(shown)]
for x in xs:
_bell(draw, x, top, bell_out, bell_h, lw, color)
def _nose(
draw: ImageDraw.ImageDraw,
cx: float,
base: float,
half_w: float,
height: float,
lw: int,
color,
ogive: float = 0.75,
) -> None:
"""头锥/鼻锥:底边到顶点的一条尖拱曲线(两侧对称折线)"""
steps = 10
left: List[Tuple[float, float]] = []
right: List[Tuple[float, float]] = []
for i in range(steps + 1):
t = i / steps
dx = half_w * (1.0 - t) ** ogive
y = base - height * t
left.append((cx - dx, y))
right.append((cx + dx, y))
draw.line(left, fill=color, width=lw, joint="curve")
draw.line(right, fill=color, width=lw, joint="curve")
def _tube(
draw: ImageDraw.ImageDraw,
cx: float,
bottom: float,
top: float,
half_w: float,
lw: int,
color,
) -> None:
draw.line([(cx - half_w, bottom), (cx - half_w, top)], fill=color, width=lw)
draw.line([(cx + half_w, bottom), (cx + half_w, top)], fill=color, width=lw)
draw.line([(cx - half_w, top), (cx + half_w, top)], fill=color, width=lw)
def render(params: dict, size: int) -> Image.Image:
"""参数 -> size x size 的黑底霓虹线稿(RGB,无 alpha)
画布是方的、火箭是细长条:按真实长细比画到 40px 上就只剩一根针,所以把长细比
做一次开方压缩(drawn_aspect = GIRTH_K * a ** GIRTH_POW)。压缩之后仍然保持
"电子号比猎鹰 9 细、猎鹰 9 比长征五号细"的相对关系,只是没那么极端。
"""
size = max(16, int(size))
canvas = size * SS
height = params["height"]
diameter = params["diameter"]
core_r = diameter / 2
booster_count = params["booster_count"]
booster_r = params["booster_d"] / 2
fairing_r = params["fairing_d"] / 2
widest = max(params["fairing_d"], diameter + (2 * params["booster_d"] if booster_count else 0.0))
aspect = _clamp(GIRTH_K * (height / widest) ** GIRTH_POW, 3.0, 8.5)
avail = canvas * (1 - 2 * MARGIN)
sy = avail / height
sx = avail / aspect / widest
ink = _ink(params["color"])
body = ink
dim = tuple(round(c * 0.6) for c in ink)
core_px = diameter * sx / SS # 芯级在目标画布上的像素宽,线宽按它取
lw = max(SS, int(round(_clamp(core_px * 0.17, 1.0, core_px * 0.35))) * SS)
lw_fine = max(SS, lw - SS if lw <= 2 * SS else int(round(lw * 0.6 / SS)) * SS)
img = Image.new("RGB", (canvas, canvas), (0, 0, 0))
d = ImageDraw.Draw(img)
cx = canvas / 2.0
base = canvas * (1 - MARGIN) # 一级尾端所在的像素行
def X(m: float) -> float:
return cx + m * sx
def Y(m: float) -> float:
return base - m * sy
s1_top = params["stage1_h"]
ist_top = s1_top + params["interstage_h"]
s2_top = ist_top + params["stage2_h"]
core_r_px = core_r * sx
bell_h = max(1.2 * SS, params["stage1_h"] * 0.08 * sy)
# --- 一级 / 级间段 / 二级 ---
_tube(d, cx, base, Y(s1_top), core_r_px, lw, body)
_tube(d, cx, Y(s1_top), Y(ist_top), core_r_px * 0.84, lw_fine, dim)
_tube(d, cx, Y(ist_top), Y(s2_top), core_r_px * (1.0 if not params["fairing"] else 0.9), lw, body)
# --- 头锥:有罩是"粗罩体 + 尖拱",没罩就是二级自带的等径短头锥(星舰、电子号)---
if params["fairing"]:
cone_base = s2_top + params["fairing_h"] - params["fairing_cone_h"]
_tube(d, cx, Y(s2_top), Y(cone_base), fairing_r * sx, lw, body)
_nose(d, cx, Y(cone_base), fairing_r * sx, params["fairing_cone_h"] * sy, lw, body)
else:
_nose(d, cx, Y(s2_top), core_r_px * 0.97, params["fairing_h"] * sy, lw, body, ogive=0.95)
flap_x = core_r_px * 1.3
flap_y = Y(s2_top - params["stage2_h"] * 0.16)
for side in (-1, 1):
d.line([(cx + side * core_r_px * 0.97, flap_y), (cx + side * flap_x, flap_y - core_r_px * 0.5)],
fill=dim, width=lw_fine)
d.line([(cx + side * flap_x, flap_y - core_r_px * 0.5), (cx + side * flap_x, flap_y + core_r_px * 0.35)],
fill=dim, width=lw_fine)
# --- 一级喷管 ---
_bells(d, cx, base, core_r_px, params["core_engines"], bell_h, lw_fine, dim)
# --- 捆绑助推器 / 侧芯级:立面图上左右对称的一对,粗细长短全部来自登记值 ---
if booster_count:
b_r_px = booster_r * sx
b_top = base - params["booster_len"] * sy
b_fin = max(1.5 * SS, params["booster_len"] * 0.1 * sy)
for side in (-1, 1):
bx = X(side * (core_r + booster_r))
_tube(d, bx, base, b_top, b_r_px, lw, body)
_nose(d, bx, b_top, b_r_px, b_fin, lw, body, ogive=0.9)
_bells(d, bx, base, b_r_px, params["booster_engines"], bell_h, lw_fine, body)
if params["booster_recoverable"]:
fy = b_top + b_fin * 0.9
d.line([(bx + side * b_r_px, fy), (bx + side * (b_r_px + b_r_px * 0.8), fy)], fill=body, width=lw)
# --- 栅格翼:可回收一级顶部外侧的两块小板子 ---
if params["core_recoverable"]:
# 栅格翼按箭体粗细封顶,否则 9m 级直径的星舰会长出一对机翼
fin = max(1.5 * SS, core_r_px * 0.5)
fy = Y(s1_top) + max(1.5 * SS, fin * 0.4)
for side in (-1, 1):
x0 = X(side * core_r)
d.line([(x0, fy), (x0 + side * fin, fy)], fill=body, width=lw)
d.line([(x0 + side * fin, fy), (x0 + side * fin, fy + fin * 0.8)], fill=body, width=lw)
im = img.resize((size, size), Image.LANCZOS)
# 辉光:叠一层自己的模糊,叠加混合到深底上才有设计稿那种霓虹感
return ImageChops.add(im, im.filter(ImageFilter.GaussianBlur(1.0)).point(lambda v: v // 2))
def render_rgb565(params: dict, size: int) -> bytes:
"""参数 -> size*size*2 字节的大端 RGB565 裸点阵(黑像素归零,交给终端叠加混合)"""
im = render(params, size)
out = array("H")
for r, g, b in im.getdata():
if (r * 299 + g * 587 + b * 114) // 1000 <= BLACK_FLOOR:
out.append(0)
else:
out.append(((r >> 3) << 11) | ((g >> 2) << 5) | (b >> 3))
out.byteswap()
return out.tobytes()

View File

@ -330,33 +330,39 @@ ROCKET_RECOVERY: dict[str, dict[str, bool]] = {
# 因此助推器推进剂登记得比单枚一级少,中心级余量更多,分离与 MECO 时序才对得上;
# - 助推器粗细登记为直径比(助推器直径 / 芯级直径):长征五号与长征七号 / 八号都是
# 0.67(3.35/5.0、2.25/3.35)、猎鹰重型 1.0(三枚同款一级等粗)、联盟 2 的侧级 0.91,
# 留空则按 0.45 推断。用比值而不是米数,箭体改粗时不会连带失真。
# 留空则按 0.45 推断。用比值而不是米数,箭体改粗时不会连带失真;
# - 助推器长短登记为长度比(助推器长度 / 芯级一级长度),与直径比同一口径:长征五号的
# 助推器只有芯一级一半多、猎鹰重型的侧芯级与中心级等高,只给直径比会一律画成
# 芯一级的 86% 长。留空按 0.86 绘制,标注「估算」的是按公开长度推算,可在管理端校正。
ROCKET_BOOSTERS: dict[str, dict[str, Any]] = {
# 两枚 F9 一级作侧芯级:2×7.607 MN、2×25.6 t 干重、各 9 台梅林
# 两枚 F9 一级作侧芯级:2×7.607 MN、2×25.6 t 干重、各 9 台梅林;
# 侧芯级与中心级是同款一级,等粗也等高(42.6 m / 41.2 m ≈ 1)
"falcon-heavy": {
"count": 2, "engine_count": 9, "diameter_ratio": 1.0,
"count": 2, "engine_count": 9, "diameter_ratio": 1.0, "length_ratio": 1.0,
"thrust_n": 15214000, "specific_impulse_s": 282, "dry_mass_kg": 51200, "fuel_mass_kg": 780000,
},
# 4 枚 3.35 m 助推器,各 2 台 YF-100、推进剂 142.8 t、干重 13.8 t
# 4 枚 3.35 m 助推器,各 2 台 YF-100、推进剂 142.8 t、干重 13.8 t;
# 助推器 18.975 m、芯一级约 33 m(估算 0.57)
"long-march-5": {
"count": 4, "engine_count": 2, "diameter_ratio": 0.67,
"count": 4, "engine_count": 2, "diameter_ratio": 0.67, "length_ratio": 0.57,
"thrust_n": 9600000, "specific_impulse_s": 300, "dry_mass_kg": 55200, "fuel_mass_kg": 571200,
},
# 联盟 2 的四个侧级(Blok B/V/G/D),各 1 台 RD-107
# 联盟 2 的四个侧级(Blok B/V/G/D),各 1 台 RD-107;侧级 19.8 m、芯一级 27.1 m
"soyuz-2": {
"count": 4, "engine_count": 1, "diameter_ratio": 0.91,
"count": 4, "engine_count": 1, "diameter_ratio": 0.91, "length_ratio": 0.73,
"thrust_n": 3352000, "specific_impulse_s": 255, "dry_mass_kg": 12000, "fuel_mass_kg": 166000,
},
# 长征二号 F:4 个 2.25 m 助推器各 1 台 YF-100,芯级 4 台
# 长征二号 F:4 个 2.25 m 助推器各 1 台 YF-100,芯级 4 台;助推器约 15.7 m(估算 0.75)
"long-march-2f": {
"count": 4, "engine_count": 1, "diameter_ratio": 0.67,
"count": 4, "engine_count": 1, "diameter_ratio": 0.67, "length_ratio": 0.75,
"thrust_n": 2979000, "specific_impulse_s": 263, "dry_mass_kg": 12000, "fuel_mass_kg": 150000,
},
# 长征七号:4 个 2.25 m 助推器各 1 台 YF-100,芯级 2 台
# 长征七号:4 个 2.25 m 助推器各 1 台 YF-100,芯级 2 台;助推器 18.975 m(估算 0.68)
"long-march-7": {
"count": 4, "engine_count": 1, "diameter_ratio": 0.67,
"count": 4, "engine_count": 1, "diameter_ratio": 0.67, "length_ratio": 0.68,
"thrust_n": 4716000, "specific_impulse_s": 300, "dry_mass_kg": 20000, "fuel_mass_kg": 200000,
},
# 长征八号:公开资料只查得到助推器直径(2.25 m),长度口径不一,长度比留默认
"long-march-8": {
"count": 2, "engine_count": 2, "diameter_ratio": 0.67,
"thrust_n": 4796000, "specific_impulse_s": 300, "dry_mass_kg": 12000, "fuel_mass_kg": 165000,
@ -368,9 +374,10 @@ ROCKET_BOOSTERS: dict[str, dict[str, Any]] = {
# 芯级推力各家说法不一),强行拆分会算出撑不起起飞的芯级推重比,因此推进参数留空 ——
# 物理仍按一级整段计算,boosters 只决定「画几个助推器、每个几台机、多粗」。
ROCKET_BOOSTER_GEOMETRY: dict[str, dict[str, Any]] = {
# 阿丽亚娜 6:4 枚 P120C 捆在 EPC 芯级两侧(3.05 / 5.43 ≈ 0.56),各 1 台固体发动机
"ariane-6": {"count": 4, "engine_count": 1, "diameter_ratio": 0.56},
# 长征六号甲:芯一级 2 台 YF-100 + 4 台固体助推器
# 阿丽亚娜 6:4 枚 P120C 捆在 EPC 芯级两侧(3.05 / 5.43 ≈ 0.56),各 1 台固体发动机;
# P120C 21.8 m、EPC 30.5 m
"ariane-6": {"count": 4, "engine_count": 1, "diameter_ratio": 0.56, "length_ratio": 0.71},
# 长征六号甲:芯一级 2 台 YF-100 + 4 台固体助推器(长度比口径不明,留默认)
"long-march-6a": {"count": 4, "engine_count": 2, "diameter_ratio": 0.75},
}
@ -579,6 +586,18 @@ async def ensure_booster_groups(db: AsyncSession) -> list[str]:
changed = True
logger.info("火箭 %s 的助推器补上直径比 %s", rocket.code, boosters["diameter_ratio"])
if boosters and boosters.get("length_ratio") is None:
# 长度比是后加的 key:已有行的 boosters 里没有它,前端只能退回默认 0.86,
# 于是长征五号这类型号把只有一半长的助推器画成了快齐平芯一级。只补绘制用的
# 长度比,不参与推进参数,因此重复执行不会再减一遍助推器。
preset = ROCKET_BOOSTERS.get(rocket.code) or ROCKET_BOOSTER_GEOMETRY.get(rocket.code) or {}
length_ratio = preset.get("length_ratio")
if length_ratio is not None:
boosters["length_ratio"] = round(float(length_ratio), 2)
rocket.boosters = boosters
changed = True
logger.info("火箭 %s 的助推器补上长度比 %s", rocket.code, boosters["length_ratio"])
correction = CORE_ENGINE_CORRECTIONS.get(rocket.code)
if correction and stage_1.get("engine_count") == correction["from"]:
stage_1["engine_count"] = correction["to"]

View File

@ -22,9 +22,19 @@ from sqlalchemy.dialects.postgresql import insert as pg_insert
from sqlalchemy.ext.asyncio import AsyncSession
from app.config import settings
from app.models.db import CelestialBody, Position, Resource, TerminalDevice, User, UserFollow
from app.models.db import (
CelestialBody,
Position,
Resource,
RocketConfig,
RocketEvent,
TerminalDevice,
User,
UserFollow,
)
from app.models.db.celestial_event import CelestialEvent
from app.services.auth import create_access_token
from app.services.rocket_art import art_params, params_version
logger = logging.getLogger(__name__)
@ -397,6 +407,173 @@ class TerminalService:
for event, upcoming_flag in picked
]
# ------------------------------------------------------------------
# Rockets (平台管理 -> 火箭型号 里启用的那些)
# ------------------------------------------------------------------
#: 详情页右栏一次最多列几条发射任务,屏宽只放得下三行
_ROCKET_EVENT_LIMIT = 3
@staticmethod
def _kn(newtons) -> Optional[float]:
"""N -> kN。库里登记的是牛,屏幕上 7607000 这种数字放不下。"""
if not newtons:
return None
return round(float(newtons) / 1000.0, 1)
@classmethod
def _rocket_item(cls, cfg: RocketConfig, upcoming) -> dict:
"""One rocket_configs row as the terminal expects it (flat on purpose).
立绘图标是后端按参数画的,art_ver 就是参数的哈希:改涂装/身高会让终端
重新拉一次点阵,改介绍、厂商这些不影响画面的字段则不会。
"""
stage_1 = cfg.stage_1 or {}
boosters = cfg.boosters or {}
count = int(boosters.get("count") or 0)
# types.ts 的登记约定:stage_1 只算芯级,boosters.thrust_n 是助推器合计,
# 起飞推力要把两者相加(backend/app/models/db/rocket.py 上那条注释是旧的)。
lift = float(stage_1.get("max_thrust_n") or 0) + float(boosters.get("thrust_n") or 0)
n_upcoming, next_net = upcoming or (0, None)
return {
"code": cfg.code,
"name": cfg.name,
"name_zh": cfg.name_zh,
"manufacturer": cfg.manufacturer,
"country": cfg.country,
"height_m": cfg.height_m,
"diameter_m": cfg.diameter_m,
"payload_mass_kg": cfg.payload_mass_kg,
"target_orbit_km": cfg.target_orbit_km,
"thrust_kn": cls._kn(lift),
"engines": stage_1.get("engine_count"),
"boosters": count,
"upcoming": n_upcoming,
"art_ver": params_version(art_params(cls._art_cfg(cfg))),
}
@staticmethod
def _art_cfg(cfg: RocketConfig) -> dict:
"""rocket_art 只吃画面上看得见的东西,别把描述之类的文案塞进版本号里"""
return {
"code": cfg.code,
"color": cfg.color,
"height_m": cfg.height_m,
"diameter_m": cfg.diameter_m,
"stage_1": cfg.stage_1,
"stage_2": cfg.stage_2,
"boosters": cfg.boosters,
"appearance": cfg.appearance,
}
async def build_rocket_snapshot(self, db: AsyncSession) -> List[dict]:
"""Enabled launch vehicles, in admin sort order, with their upcoming count."""
rockets = (
await db.execute(
select(RocketConfig)
.where(RocketConfig.is_active)
.order_by(RocketConfig.sort_order, RocketConfig.code)
)
).scalars().all()
if not rockets:
return []
upcoming = await self._rocket_upcoming(db, [r.id for r in rockets])
return [self._rocket_item(r, upcoming.get(r.id)) for r in rockets]
async def get_rocket(self, db: AsyncSession, code: str) -> Optional[dict]:
"""Full spec sheet of one enabled rocket plus its nearest launches."""
cfg = (
await db.execute(
select(RocketConfig)
.where(RocketConfig.code == code, RocketConfig.is_active)
)
).scalars().first()
if cfg is None:
return None
now = datetime.utcnow()
events = (
await db.execute(
select(RocketEvent)
.where(RocketEvent.rocket_config_id == cfg.id, RocketEvent.net >= now)
.order_by(RocketEvent.net)
.limit(self._ROCKET_EVENT_LIMIT)
)
).scalars().all()
total = (
await db.execute(
select(func.count())
.select_from(RocketEvent)
.where(RocketEvent.rocket_config_id == cfg.id, RocketEvent.net >= now)
)
).scalar() or 0
item = self._rocket_item(cfg, (total, events[0].net if events else None))
stage_1, stage_2 = cfg.stage_1 or {}, cfg.stage_2 or {}
boosters = cfg.boosters or {}
appearance = cfg.appearance or {}
item.update(
{
"description": cfg.description,
"target_velocity_mps": cfg.target_velocity_mps,
"s1_name": stage_1.get("name"),
"s1_thrust_kn": self._kn(stage_1.get("max_thrust_n")),
"s1_isp_s": stage_1.get("specific_impulse_s"),
"s1_engines": stage_1.get("engine_count"),
"s1_recoverable": stage_1.get("recoverable"),
"s2_name": stage_2.get("name"),
"s2_thrust_kn": self._kn(stage_2.get("max_thrust_n")),
"s2_isp_s": stage_2.get("specific_impulse_s"),
"s2_engines": stage_2.get("engine_count"),
# 没登记 = 按前端默认带整流罩,只有明确写 false 才是星舰/电子号那种裸头锥
"fairing": appearance.get("fairing") is not False,
"booster_thrust_kn": self._kn(boosters.get("thrust_n")),
"booster_recoverable": boosters.get("recoverable"),
"events": [
{
# 数据源的 name 是「型号 | 任务名」,而型号已经是这页的标题,
# 屏幕上再念一遍只会把真正的任务名挤出边界,所以优先给 mission_name
"name": e.mission_name or e.name,
"net": e.net,
"orbit": e.orbit,
"status": e.status,
"launch_site_name": e.launch_site_name,
}
for e in events
],
"event_total": total,
"next_net": events[0].net if events else None,
}
)
return item
async def get_rocket_art(self, db: AsyncSession, code: str) -> Optional[tuple]:
"""(art_ver, drawing params) of one enabled rocket, None when it is not usable."""
cfg = (
await db.execute(
select(RocketConfig).where(RocketConfig.code == code, RocketConfig.is_active)
)
).scalars().first()
if cfg is None:
return None
params = art_params(self._art_cfg(cfg))
return params_version(params), params
@staticmethod
async def _rocket_upcoming(db: AsyncSession, rocket_ids: List[int]) -> dict:
"""{rocket_config_id: (待发射数, 最近一次发射时间)}"""
now = datetime.utcnow()
result = await db.execute(
select(
RocketEvent.rocket_config_id,
func.count().label("n"),
func.min(RocketEvent.net).label("next_net"),
)
.where(RocketEvent.rocket_config_id.in_(rocket_ids), RocketEvent.net >= now)
.group_by(RocketEvent.rocket_config_id)
)
return {row.rocket_config_id: (row.n, row.next_net) for row in result}
# ------------------------------------------------------------------
# Helpers
# ------------------------------------------------------------------

View File

@ -9,7 +9,8 @@ import type { ReactNode } from 'react';
import { useAdminPrefs } from '../../pages/admin/AdminPrefsContext';
interface AdminPageProps {
title: string;
/** 页面标题;整页不需要 Header 时(如控制台)可不传,此时 Header 整块不渲染 */
title?: string;
description?: string;
/** 标题左侧的图标,通常与该页在菜单中的图标一致 */
icon?: ReactNode;
@ -21,20 +22,23 @@ interface AdminPageProps {
export function AdminPage({ title, description, icon, meta, actions, children }: AdminPageProps) {
const { t } = useAdminPrefs();
const hasHead = Boolean(title || description || icon || meta || actions);
return (
<div className="adm-page">
<header className="adm-page-head">
<div className="adm-page-head-main">
{icon ? <span className="adm-page-icon">{icon}</span> : null}
<div>
<h1 className="adm-page-title">{t(title)}</h1>
{description ? <p className="adm-page-desc">{t(description)}</p> : null}
{meta ? <div className="adm-page-meta">{meta}</div> : null}
{hasHead ? (
<header className="adm-page-head">
<div className="adm-page-head-main">
{icon ? <span className="adm-page-icon">{icon}</span> : null}
<div>
{title ? <h1 className="adm-page-title">{t(title)}</h1> : null}
{description ? <p className="adm-page-desc">{t(description)}</p> : null}
{meta ? <div className="adm-page-meta">{meta}</div> : null}
</div>
</div>
</div>
{actions ? <div className="adm-page-actions">{actions}</div> : null}
</header>
{actions ? <div className="adm-page-actions">{actions}</div> : null}
</header>
) : null}
<div className="adm-page-body">{children}</div>
</div>
);

View File

@ -451,6 +451,9 @@ function GridFins({
* group 是它在一级发动机分组里的那一项(stage1EngineGroups 产出),
* radius / offset 分别是它与芯级的直径比和圆心距(芯级半径的倍数),
* 两者相切布置,因此猎鹰重型能画出真实的「三根并排芯级」。
* height 是助推器自己的长度(芯级一级长度 × 登记的长度比),底面与芯级一级底面齐平。
* 头锥高度按粗细收口:粗助推器(猎鹰重型这种等粗侧芯级)不能按细长助推器的
* 比例长出尖头,否则箭头会戳进芯级二级里。
* 尾焰放在助推器节点内,分离散开时会跟着一起翻滚。
*/
function StrapOnBooster({
@ -476,7 +479,7 @@ function StrapOnBooster({
}) {
const bodyRadius = radius * group.radius;
const offset = radius * group.offset;
const noseHeight = height * 0.22;
const noseHeight = Math.min(height * 0.22, bodyRadius * 1.5);
return (
<group position={[Math.cos(group.angle) * offset, 0, Math.sin(group.angle) * offset]}>
{/* 助推器箭体 */}
@ -1013,7 +1016,7 @@ export function RocketModel({ rocket, state }: RocketModelProps) {
<group key={index}>
<StrapOnBooster
radius={geo.radius}
height={geo.stage1Height * 0.86}
height={geo.stage1Height * geo.boosterLengthRatio}
color={shade(rocket.color, -0.06)}
group={group}
throttle={state.throttle}

View File

@ -13,6 +13,9 @@ export type VehicleLayout = 'single-core' | 'boosters';
/** 未登记助推器直径比时的默认粗细(约 45%)。 */
const DEFAULT_BOOSTER_DIAMETER_RATIO = 0.45;
/** 未登记助推器长度比时的默认长度(芯级一级长度的 86%)。 */
const DEFAULT_BOOSTER_LENGTH_RATIO = 0.86;
export interface VehicleLayoutInfo {
layout: VehicleLayout;
/** 助推器数量(单芯级为 0) */
@ -27,6 +30,8 @@ export interface VehicleLayoutInfo {
boosterRecoverable: boolean;
/** 助推器直径 / 芯级直径 */
boosterDiameterRatio: number;
/** 助推器长度 / 芯级一级长度 */
boosterLengthRatio: number;
}
export interface StageGeometry extends VehicleLayoutInfo {
@ -47,7 +52,7 @@ export interface StageGeometry extends VehicleLayoutInfo {
}
/**
* 构型全部来自登记值:助推器的数量 / 每台的发动机数 / 直径比在 boosters 里,
* 构型全部来自登记值:助推器的数量 / 每台的发动机数 / 直径比 / 长度比在 boosters 里,
* 芯级机数就是 stage_1.engine_count(一组机数记 0 的型号就是纯助推器组合),
* 栅格翼长在可回收的那一级上,因此芯级取一级的 recoverable、助推器取助推器的。
*/
@ -69,6 +74,7 @@ export function resolveVehicleLayout(
coreRecoverable,
boosterRecoverable,
boosterDiameterRatio: DEFAULT_BOOSTER_DIAMETER_RATIO,
boosterLengthRatio: DEFAULT_BOOSTER_LENGTH_RATIO,
};
}
@ -80,6 +86,7 @@ export function resolveVehicleLayout(
coreRecoverable,
boosterRecoverable,
boosterDiameterRatio: clamp(boosters!.diameter_ratio ?? DEFAULT_BOOSTER_DIAMETER_RATIO, 0.2, 1),
boosterLengthRatio: clamp(boosters!.length_ratio ?? DEFAULT_BOOSTER_LENGTH_RATIO, 0.2, 1),
};
}
@ -233,7 +240,7 @@ export interface EnginePlacement {
/**
* 按真实发动机数量排布喷管:
* 1 台居中;2~4 台对称;6 台按星舰飞船构型(2 外侧摇摆 + 2 内侧固定 + 2 台真空型居中);
* 1 台居中;2~4 台对称;6 台按星舰飞船构型(后缘 3 台海平面 + 纵轴 3 台真空型);
* 其余 5~9 台为「1 台中心 + 外圈」,10 台以上再加中心机,
* 20 台以上按超重型构型排三圈(外圈 20 摇摆 / 中圈 10 固定 / 中心 3 固定)。
* count 是「一组(芯级或某个助推器)」的机数,不是整箭总数。
@ -272,18 +279,18 @@ export function engineLayout(count: number, radius: number): EnginePlacement[] {
});
}
// 星舰飞船 6 台:外侧 2 台海平面型可摇摆(沿 X 轴),内侧 2 台海平面型固定(沿 Z 轴),
// 中间 2 台真空型(RV)并排,喷管放大加长以体现真空延伸段。
// 星舰飞船 6 台:3 台海平面型沿后缘横排(左右 2 台可摇摆、中间 1 台固定),
// 3 台真空型沿纵轴排成一列(真空喷管带延伸段,因此前后间距按各自的出口半径留足)。
if (total === 6) {
const seaLevel = radius * 0.155;
const vacuum = radius * 0.22;
const vacuum = radius * 0.2;
return [
make(-radius * 0.68, 0, seaLevel, 0.1),
make(radius * 0.68, 0, seaLevel, 0.1),
make(0, -radius * 0.42, seaLevel),
make(0, radius * 0.42, seaLevel),
make(-radius * 0.24, 0, vacuum, 0, 3.4),
make(radius * 0.24, 0, vacuum, 0, 3.4),
make(-radius * 0.56, radius * 0.58, seaLevel, 0.09),
make(0, radius * 0.58, seaLevel),
make(radius * 0.56, radius * 0.58, seaLevel, 0.09),
make(0, radius * 0.16, vacuum, 0, 3.4),
make(0, -radius * 0.28, vacuum, 0, 3.4),
make(0, -radius * 0.72, vacuum, 0, 3.4),
];
}

View File

@ -22,7 +22,7 @@ export interface RocketAppearance {
}
/**
* 捆绑助推器组(可选):数量、发动机、直径比与推进参数都登记在助推器自己身上。
* 捆绑助推器组(可选):数量、发动机、直径比、长度比与推进参数都登记在助推器自己身上。
*
* stage_1 只描述芯级(engine_count 不含助推器),起飞推力 = stage_1 + boosters。
* 四个推进参数要么整体登记、要么整体留空:留空表示该型号只登记了助推器构型
@ -36,6 +36,8 @@ export interface RocketBoosters {
engine_count: number;
/** 助推器直径 / 芯级直径,留空按 0.45 绘制 */
diameter_ratio?: number | null;
/** 助推器长度 / 芯级一级长度,留空按 0.86 绘制 */
length_ratio?: number | null;
/** 全部助推器合计推力 */
thrust_n?: number | null;
/** 助推器比冲 */

View File

@ -145,8 +145,9 @@ function StackDiagram({ rocket }: { rocket: RocketConfig }) {
{/* 助推器 / 侧芯级:按登记的直径比例画在芯级两侧(与芯级相切) */}
{geo.layout === 'boosters' &&
[-1, 1].map((direction) => {
const boosterH = s1H * 0.86;
const boosterTop = s1Top + s1H * 0.1;
// 长度按登记的长度比,底面与芯级一级底面齐平(与 3D 模型同一口径)
const boosterH = s1H * geo.boosterLengthRatio;
const boosterTop = s1Top + s1H - boosterH;
const br = r1 * geo.boosterDiameterRatio;
const bx = CX + direction * (r1 + br);
return (
@ -419,6 +420,11 @@ function FlightData({ state, history, totalFuelPct, stage1FuelPct, stage2FuelPct
/* Small mission-control widgets */
/* ------------------------------------------------------------------ */
/** 最外圈发动机圆心所在的半径占圆环内壁的比例,剩下的就是与圆环之间恒定留出的空隙 */
const OUTER_RING_FILL = 0.72;
/** 单台发动机点位的直径占所在圆环直径的比例,同一屏内所有发动机按此比例等大 */
const ENGINE_DOT_RATIO = 0.15;
/**
* 仪表组的排列顺序:芯级放在正中,助推器平均分成左右两组挂在两侧,
* 与 3D 箭体的 boosterAngle(左右均分)同一口径,扫一眼就能对上号。
@ -455,21 +461,34 @@ function EngineBank({
const isLit = (group: EngineGroup) => (group.kind === 'core' ? lit : boostersLit);
const total = groups.reduce((sum, group) => sum + group.engines, 0);
const firing = groups.filter(isLit).reduce((sum, group) => sum + group.engines, 0);
// 直径以芯级为基准(radius = 1),按左侧栏可用宽度整体缩放,四助推器也放得下
// 直径以芯级为基准(radius = 1),放大到底栏放得下的最大尺寸:
// 宽度预算 380 在最窄的可见宽度(约 1050px,再窄整组隐藏)也放得下,
// 高度上限 104 不超过中间计时器那一列,圆环变大不会把底栏顶高。
const gap = 10;
const diameterSum = units.reduce((sum, group) => sum + group.radius, 0);
const base = Math.max(18, Math.min(58, (268 - gap * (units.length - 1)) / diameterSum));
const base = Math.max(18, Math.min(104, (380 - gap * (units.length - 1)) / diameterSum));
return (
<div className="sx-engine-bank" aria-label={`${label} ${firing}/${total} 台点火`}>
<div className="sx-engine-row">
{units.map((group, index) => {
const unit = base * group.radius;
// 机数多的舱室缩小点位,避免十几个点糊成一团
const orbit = unit * 0.28;
const dot = group.engines > 4
? Math.min(8, Math.max(3, (Math.PI * 2 * orbit) / (group.engines * 1.7)))
: Math.min(9, Math.max(4, unit * 0.2));
// 点位沿用 3D 模型的归一化布局,只把最外圈的发动机圆心固定在圆环内壁的 72% 处,
// 这样不管一个舱里是 1 台还是 33 台,最外圈与圆环之间都恒定留出一圈空隙。
const placements = engineLayout(group.engines, 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));
return (
<div
key={`${group.kind}-${index}`}
@ -477,16 +496,21 @@ function EngineBank({
style={
{
'--unit': `${unit}px`,
'--engine-radius': `${orbit}px`,
'--dot': `${dot}px`,
'--engine-radius': `${scale}px`,
} as CSSProperties
}
>
{engineLayout(group.engines, 1).map((placement, dotIndex) => (
{placements.map((placement, dotIndex) => (
<i
key={dotIndex}
className="sx-engine-dot"
style={{ '--dx': placement.x, '--dy': placement.z } as CSSProperties}
style={
{
'--dx': placement.x,
'--dy': placement.z,
'--dot': `${dot}px`,
} as CSSProperties
}
/>
))}
</div>

View File

@ -1,22 +1,27 @@
/**
* 控制台
*
* 顶部为关键指标,下面三个内容面板:近期任务、系统状态、即将发生的天象。
* 数据分别来自 /system/statistics、/tasks、/system/cache/stats、
* /system/data-cutoff-date、/star-systems/statistics 与 /events。
* 无页面 Header:第一行是系统状态(容量与缓存指标,图形 + 数字,含整页刷新),
* 第二行是关键指标卡片,第三行左右两栏分别是 30 天内即将发生的天象与即将开始的火箭发射任务。
* 数据分别来自 /system/cache/stats、/system/storage/stats、/system/statistics、
* /star-systems/statistics、/rockets/admin、/events 与 /rocket-events。
*/
import { useCallback, useEffect, useState } from 'react';
import { Badge, Button, Card, Col, Empty, Row, Space, Table, Tag, Tooltip } from 'antd';
import type { BadgeProps } from 'antd';
import type { ReactNode } from 'react';
import { Badge, Button, Card, Col, Empty, Progress, Row, Space, Table, Tag } from 'antd';
import type { ColumnsType } from 'antd/es/table';
import {
DashboardOutlined,
CloudServerOutlined,
DatabaseOutlined,
FolderOpenOutlined,
GlobalOutlined,
PieChartOutlined,
ProfileOutlined,
ReloadOutlined,
RocketOutlined,
StarOutlined,
SyncOutlined,
TeamOutlined,
ThunderboltOutlined,
} from '@ant-design/icons';
import { useNavigate } from 'react-router-dom';
@ -25,6 +30,10 @@ import { useToast } from '../../contexts/ToastContext';
import { AdminPage, StatCard } from '../../components/admin/AdminPage';
import { useAdminPrefs } from './AdminPrefsContext';
/** 两个「即将」面板统一只看未来 30 天,各取前 8 条 */
const WINDOW_DAYS = 30;
const PANEL_LIMIT = 8;
interface SystemStatistics {
total_bodies: number;
total_probes: number;
@ -43,19 +52,30 @@ interface CacheStats {
redis: {
connected: boolean;
used_memory_human: string;
connected_clients: number;
keyspace_hits: number;
keyspace_misses: number;
total_commands_processed: number;
};
}
interface TaskItem {
id: number;
task_type: string;
status: string;
progress: number;
description: string;
created_at: string;
interface RocketSummary {
total: number;
active: number;
}
/** /system/storage/stats:整库体积、数据表行数与上传目录占用 */
interface StorageStats {
database: {
size_bytes: number;
tables: number;
records: Record<string, number>;
records_total: number;
};
uploads: {
files: number;
size_bytes: number;
};
}
interface EventItem {
@ -66,13 +86,17 @@ interface EventItem {
body?: { id: string; name: string; name_zh?: string | null };
}
const TASK_STATUS: Record<string, { badge: BadgeProps['status']; label: string }> = {
pending: { badge: 'default', label: '等待中' },
running: { badge: 'processing', label: '执行中' },
completed: { badge: 'success', label: '已完成' },
failed: { badge: 'error', label: '失败' },
cancelled: { badge: 'warning', label: '已取消' },
};
interface LaunchItem {
id: number;
name: string;
mission_name: string | null;
rocket_name: string | null;
launch_site_name: string | null;
location_name: string | null;
net: string;
status: string;
rocket: { code: string; name: string; name_zh: string | null } | null;
}
const EVENT_TYPE_LABELS: Record<string, string> = {
approach: '接近',
@ -101,40 +125,94 @@ function formatTime(value: string) {
});
}
/**
* 天象的 event_time 与发射事件的 net 存的都是不带时区的 UTC,
* 补上 Z 浏览器才会按本地时区换算,否则会把 UTC 当成本地时间显示。
*/
function formatUtcTime(value: string) {
const iso = /Z|[+-]\d{2}:?\d{2}$/.test(value) ? value : `${value}Z`;
return formatTime(iso);
}
/** 体积按 1024 进位,三位以内留一位小数,够覆盖 KB / MB / GB。 */
function formatBytes(bytes?: number | null) {
if (!bytes || bytes <= 0) return '—';
const units = ['B', 'KB', 'MB', 'GB', 'TB'];
const index = Math.min(Math.floor(Math.log(bytes) / Math.log(1024)), units.length - 1);
const value = bytes / 1024 ** index;
return `${value >= 100 ? value.toFixed(0) : value.toFixed(1)} ${units[index]}`;
}
/** 系统状态面板里的单个指标块:图标 + 名称 + 数值(或图形)+ 补充说明。 */
function Metric({ icon, label, value, foot }: {
icon: ReactNode;
label: string;
value: ReactNode;
foot?: ReactNode;
}) {
return (
<div className="adm-metric">
<div className="adm-metric-head">
<span className="adm-metric-icon">{icon}</span>
{label}
</div>
<div className="adm-metric-value">{value}</div>
{foot ? <div className="adm-metric-foot">{foot}</div> : null}
</div>
);
}
export function Dashboard() {
const [stats, setStats] = useState<SystemStatistics | null>(null);
const [systemStats, setSystemStats] = useState<StarSystemStatistics | null>(null);
const [cacheStats, setCacheStats] = useState<CacheStats | null>(null);
const [cutoffDate, setCutoffDate] = useState<string | null>(null);
const [tasks, setTasks] = useState<TaskItem[]>([]);
const [rocketStats, setRocketStats] = useState<RocketSummary | null>(null);
const [storage, setStorage] = useState<StorageStats | null>(null);
const [events, setEvents] = useState<EventItem[]>([]);
const [launches, setLaunches] = useState<LaunchItem[]>([]);
const [loading, setLoading] = useState(true);
const toast = useToast();
const navigate = useNavigate();
const { t } = useAdminPrefs();
const fetchAll = useCallback(async () => {
const now = new Date().toISOString();
const now = new Date();
const until = new Date(now.getTime() + WINDOW_DAYS * 24 * 60 * 60 * 1000).toISOString();
return Promise.allSettled([
request.get('/system/statistics'),
request.get('/star-systems/statistics'),
request.get('/system/cache/stats'),
request.get('/system/data-cutoff-date'),
request.get('/tasks', { params: { limit: 5 } }),
request.get('/events', { params: { start_time: now, limit: 5 } }),
request.get('/system/storage/stats'),
request.get('/rockets/admin', { params: { limit: 100 } }),
request.get('/events', {
params: { start_time: now.toISOString(), end_time: until, limit: PANEL_LIMIT },
}),
request.get('/rocket-events', {
params: { upcoming: true, end: until, limit: PANEL_LIMIT },
}),
]);
}, []);
type FetchResults = Awaited<ReturnType<typeof fetchAll>>;
const applyResults = useCallback((results: FetchResults) => {
const [statsRes, systemRes, cacheRes, cutoffRes, tasksRes, eventsRes] = results;
const [statsRes, systemRes, cacheRes, storageRes, rocketsRes, eventsRes, launchesRes] = results;
if (statsRes.status === 'fulfilled') setStats(statsRes.value.data);
if (systemRes.status === 'fulfilled') setSystemStats(systemRes.value.data);
if (cacheRes.status === 'fulfilled') setCacheStats(cacheRes.value.data);
if (cutoffRes.status === 'fulfilled') setCutoffDate(cutoffRes.value.data.cutoff_date);
if (tasksRes.status === 'fulfilled') setTasks(tasksRes.value.data || []);
if (storageRes.status === 'fulfilled') setStorage(storageRes.value.data);
if (rocketsRes.status === 'fulfilled') {
const payload = rocketsRes.value.data as {
total?: number;
rockets?: { is_active: boolean }[];
};
setRocketStats({
total: payload.total ?? payload.rockets?.length ?? 0,
active: payload.rockets?.filter((item) => item.is_active).length ?? 0,
});
}
if (eventsRes.status === 'fulfilled') setEvents(eventsRes.value.data || []);
if (launchesRes.status === 'fulfilled') setLaunches(launchesRes.value.data?.events || []);
if (results.every((item) => item.status === 'rejected')) {
toast.error('无法获取控制台数据');
@ -154,37 +232,6 @@ export function Dashboard() {
})();
}, [applyResults, fetchAll]);
const taskColumns: ColumnsType<TaskItem> = [
{
title: t('状态'),
dataIndex: 'status',
width: 96,
render: (status: string) => {
const meta = TASK_STATUS[status] ?? { badge: 'default' as BadgeProps['status'], label: status };
return <Badge status={meta.badge} text={meta.label} />;
},
},
{
title: t('任务'),
dataIndex: 'description',
ellipsis: true,
render: (description: string, record) => (
<Tooltip title={description}>
<div>
<div className="adm-cell-strong">任务 #{record.id}</div>
<div className="adm-cell-sub">{description}</div>
</div>
</Tooltip>
),
},
{
title: t('时间'),
dataIndex: 'created_at',
width: 120,
render: (value: string) => <span className="adm-cell-sub">{formatTime(value)}</span>,
},
];
const eventColumns: ColumnsType<EventItem> = [
{
title: t('事件'),
@ -200,7 +247,7 @@ export function Dashboard() {
{
title: t('类型'),
dataIndex: 'event_type',
width: 130,
width: 120,
render: (type: string) => (
<Tag color={EVENT_TYPE_COLORS[type] || 'default'}>{EVENT_TYPE_LABELS[type] || type}</Tag>
),
@ -208,32 +255,113 @@ export function Dashboard() {
{
title: t('时间'),
dataIndex: 'event_time',
width: 160,
render: (value: string) => new Date(value).toLocaleString('zh-CN'),
width: 120,
render: (value: string) => <span className="adm-cell-sub">{formatUtcTime(value)}</span>,
},
];
const launchColumns: ColumnsType<LaunchItem> = [
{
title: t('发射任务'),
dataIndex: 'name',
ellipsis: true,
render: (name: string, record) => (
<div>
<div className="adm-cell-strong">{record.mission_name || name}</div>
<div className="adm-cell-sub">{record.launch_site_name || record.location_name || '-'}</div>
</div>
),
},
{
title: t('型号'),
dataIndex: 'rocket_name',
width: 140,
render: (value: string | null, record) => (
<Tag color={record.rocket ? 'blue' : 'default'}>
{record.rocket?.name_zh || record.rocket?.name || value || '-'}
</Tag>
),
},
{
title: t('发射时间'),
dataIndex: 'net',
width: 120,
render: (value: string) => <span className="adm-cell-sub">{formatUtcTime(value)}</span>,
},
];
const redis = cacheStats?.redis;
const hitRate = redis && redis.keyspace_hits + redis.keyspace_misses > 0
? (redis.keyspace_hits / (redis.keyspace_hits + redis.keyspace_misses) * 100).toFixed(1)
: '—';
const queries = redis ? (redis.keyspace_hits ?? 0) + (redis.keyspace_misses ?? 0) : 0;
const hitRate = queries > 0 ? Math.round(((redis?.keyspace_hits ?? 0) / queries) * 100) : 0;
const records = storage?.database.records;
const windowLabel = t(`${WINDOW_DAYS} 天内`);
return (
<AdminPage
icon={<DashboardOutlined />}
title="控制台"
description="平台数据总览"
meta={
cutoffDate ? (
<Tag color="green">{t('数据截止日期')}:{cutoffDate}</Tag>
) : undefined
}
actions={
<Button icon={<ReloadOutlined />} onClick={() => void loadData()} loading={loading}>
刷新
</Button>
}
>
<AdminPage>
<Card
className="adm-panel"
title={<span className="adm-section-title">{t('系统状态')}</span>}
extra={
<Button
type="text"
size="small"
icon={<ReloadOutlined />}
loading={loading}
onClick={() => void loadData()}
>
{t('刷新')}
</Button>
}
styles={{ body: { padding: '18px 22px' } }}
>
<div className="adm-metric-grid">
<Metric
icon={<CloudServerOutlined />}
label={t('Redis 缓存')}
value={
<span className="adm-metric-status">
<Badge status={redis?.connected ? 'success' : 'error'} />
{redis?.connected ? t('已连接') : t('未连接')}
</span>
}
foot={`${t('内存')} ${redis?.used_memory_human ?? '—'}`}
/>
<Metric
icon={<PieChartOutlined />}
label={t('缓存命中率')}
value={queries > 0
? <Progress type="circle" size={54} strokeWidth={12} percent={hitRate} />
: '—'}
foot={`${t('总查询')} ${queries.toLocaleString()}`}
/>
<Metric
icon={<ThunderboltOutlined />}
label={t('累计命令数')}
value={redis?.total_commands_processed?.toLocaleString() ?? '—'}
foot={`${redis?.connected_clients ?? '—'} ${t('个连接')}`}
/>
<Metric
icon={<DatabaseOutlined />}
label={t('数据库')}
value={formatBytes(storage?.database.size_bytes)}
foot={`${storage?.database.tables ?? '—'} ${t('张表')}`}
/>
<Metric
icon={<ProfileOutlined />}
label={t('数据记录')}
value={storage?.database.records_total.toLocaleString() ?? '—'}
foot={`${t('位置数据')} ${records?.positions?.toLocaleString() ?? '—'}`}
/>
<Metric
icon={<FolderOpenOutlined />}
label={t('资源文件')}
value={formatBytes(storage?.uploads.size_bytes)}
foot={`${storage?.uploads.files ?? '—'} ${t('个文件')}`}
/>
</div>
</Card>
<Row gutter={[16, 16]}>
<Col xs={24} sm={12} xl={6}>
<StatCard
@ -248,10 +376,10 @@ export function Dashboard() {
<Col xs={24} sm={12} xl={6}>
<StatCard
icon={<RocketOutlined />}
label="探测器"
value={stats?.total_probes ?? 0}
label="火箭型号"
value={rocketStats?.total ?? 0}
unit="个"
footnote="NASA Horizons 实时位置追踪"
footnote={`${t('启用')} ${rocketStats?.active ?? 0} / ${rocketStats?.total ?? 0}`}
loading={loading}
/>
</Col>
@ -278,102 +406,65 @@ export function Dashboard() {
</Row>
<Row gutter={[16, 16]}>
<Col xs={24} xl={14} className="adm-col-stretch">
<Col xs={24} xl={12} className="adm-col-stretch">
<Card
className="adm-panel"
title={<span className="adm-section-title">{t('近期任务')}</span>}
title={<span className="adm-section-title">{t('即将发生的天象')}</span>}
extra={
<Button type="link" size="small" onClick={() => navigate('/admin/tasks')}>
{t('查看全部')}
</Button>
<Space size={8}>
<span className="adm-cell-sub">{windowLabel}</span>
<Button type="link" size="small" onClick={() => navigate('/admin/celestial-events')}>
{t('查看全部')}
</Button>
</Space>
}
styles={{ body: { padding: 0 } }}
>
<Table
className="adm-table"
columns={taskColumns}
dataSource={tasks}
columns={eventColumns}
dataSource={events}
rowKey="id"
size="small"
loading={loading}
pagination={false}
locale={{
emptyText: <Empty image={Empty.PRESENTED_IMAGE_SIMPLE} description={t('暂无任务记录')} />,
emptyText: <Empty image={Empty.PRESENTED_IMAGE_SIMPLE} description={t('暂无即将发生的天象事件')} />,
}}
/>
</Card>
</Col>
<Col xs={24} xl={10} className="adm-col-stretch">
<Card className="adm-panel" title={<span className="adm-section-title">{t('系统状态')}</span>} loading={loading}>
<div className="adm-status-list">
<div className="adm-status-row">
<span>{t('Redis 缓存')}</span>
<b>
<Badge status={redis?.connected ? 'success' : 'error'} />
{redis?.connected ? t('已连接') : t('未连接')}
</b>
</div>
<div className="adm-status-row">
<span>{t('缓存内存占用')}</span>
<b>{redis?.used_memory_human ?? '—'}</b>
</div>
<div className="adm-status-row">
<span>{t('缓存命中率')}</span>
<b>{hitRate === '—' ? '—' : `${hitRate}%`}</b>
</div>
<div className="adm-status-row">
<span>{t('累计命令数')}</span>
<b>{redis?.total_commands_processed?.toLocaleString() ?? '—'}</b>
</div>
<div className="adm-status-divider" />
<div className="adm-status-row">
<span>{t('数据截止日期')}</span>
<b>{cutoffDate ?? '—'}</b>
</div>
<div className="adm-status-row">
<span>{t('太阳系行星')}</span>
<b>{systemStats?.solar_system_planets ?? '—'} {t('颗')}</b>
</div>
<div className="adm-status-row">
<span>{t('系外行星')}</span>
<b>{systemStats?.exo_planets ?? '—'} {t('颗')}</b>
</div>
<div className="adm-status-row">
<span>{t('星系总数')}</span>
<b>{systemStats?.total_planets ?? '—'} {t('颗')}</b>
</div>
</div>
<Col xs={24} xl={12} className="adm-col-stretch">
<Card
className="adm-panel"
title={<span className="adm-section-title">{t('即将开始的火箭发射任务')}</span>}
extra={
<Space size={8}>
<span className="adm-cell-sub">{windowLabel}</span>
<Button type="link" size="small" onClick={() => navigate('/admin/rocket-events')}>
{t('查看全部')}
</Button>
</Space>
}
styles={{ body: { padding: 0 } }}
>
<Table
className="adm-table"
columns={launchColumns}
dataSource={launches}
rowKey="id"
size="small"
loading={loading}
pagination={false}
locale={{
emptyText: <Empty image={Empty.PRESENTED_IMAGE_SIMPLE} description={t('暂无即将开始的发射任务')} />,
}}
/>
</Card>
</Col>
</Row>
<Card
className="adm-panel"
title={<span className="adm-section-title">{t('即将发生的天象')}</span>}
extra={
<Space size={8}>
<SyncOutlined className="adm-cell-sub" />
<Button type="link" size="small" onClick={() => navigate('/admin/celestial-events')}>
{t('查看全部')}
</Button>
</Space>
}
styles={{ body: { padding: 0 } }}
>
<Table
className="adm-table"
columns={eventColumns}
dataSource={events}
rowKey="id"
size="small"
loading={loading}
pagination={false}
locale={{
emptyText: <Empty image={Empty.PRESENTED_IMAGE_SIMPLE} description={t('暂无即将发生的天象事件')} />,
}}
/>
</Card>
</AdminPage>
);
}

View File

@ -296,7 +296,7 @@ function RocketDetail({ rocket }: { rocket: RocketConfig }) {
<Descriptions.Item label="助推器" span={2}>
{boosters ? (
<>
{boosters.count} × {boosters.engine_count} 台 · 直径比 {boosters.diameter_ratio ?? 0.45}
{boosters.count} × {boosters.engine_count} 台 · 直径比 {boosters.diameter_ratio ?? 0.45} · 长度比 {boosters.length_ratio ?? 0.86}
{boosters.thrust_n
? ` · 合计 ${MN(boosters.thrust_n)} · 比冲 ${boosters.specific_impulse_s} s`
: ' · 仅登记构型(不参与物理)'}

View File

@ -62,7 +62,7 @@ function AppearanceFields() {
/**
* 助推器参数(可选)。
*
* 助推器自己带数量、每台的发动机数与直径比;一级参数只描述芯级,
* 助推器自己带数量、每台的发动机数、直径比与长度比;一级参数只描述芯级,
* 起飞推力 = 一级推力 + 助推器合计推力,因此捆绑构型的火箭能算出
* 真实的助推器分离与一级关机时序。
* 推进参数(推力 / 比冲 / 干重 / 推进剂)要么整体登记、要么整体留空:
@ -75,6 +75,7 @@ function BoosterFields() {
<Col xs={24} md={12}><Form.Item name={['boosters', 'count']} label="助推器数量" tooltip="捆绑的助推器 / 侧芯级个数"><InputNumber min={1} max={8} style={{ width: '100%' }} placeholder="无助推器" /></Form.Item></Col>
<Col xs={24} md={12}><Form.Item name={['boosters', 'engine_count']} label="每台助推器发动机数" tooltip="单个助推器自己的喷管数量,决定助推器尾焰规模"><InputNumber min={1} max={33} style={{ width: '100%' }} placeholder="例如 2" /></Form.Item></Col>
<Col xs={24} md={12}><Form.Item name={['boosters', 'diameter_ratio']} label="助推器直径比" tooltip="助推器直径 / 芯级直径,例如长征五号 3.35m / 5.0m 填 0.67、猎鹰重型三枚等粗一级填 1;留空按 0.45 绘制"><InputNumber min={0.05} max={1} step={0.01} style={{ width: '100%' }} placeholder="0.45" /></Form.Item></Col>
<Col xs={24} md={12}><Form.Item name={['boosters', 'length_ratio']} label="助推器长度比" tooltip="助推器长度 / 芯级一级长度,例如猎鹰重型侧芯级与中心级等高填 1、长征五号助推器只有芯一级一半多填 0.57;留空按 0.86 绘制"><InputNumber min={0.05} max={1} step={0.01} style={{ width: '100%' }} placeholder="0.86" /></Form.Item></Col>
<Col xs={24} md={12}><Form.Item name={['boosters', 'recoverable']} label="助推器可回收" tooltip="设计为可回收的助推器会在自己顶部画栅格翼(上升段收拢,分离后展开);芯级回收、助推器不回收的型号只勾「一级可回收」" valuePropName="checked"><Switch /></Form.Item></Col>
<Col xs={24} md={12}><Form.Item name={['boosters', 'thrust_n']} label="合计推力" tooltip="全部助推器加起来的推力,不含芯级"><InputNumber min={1} style={{ width: '100%' }} suffix="N" placeholder="仅构型可留空" /></Form.Item></Col>
<Col xs={24} md={12}><Form.Item name={['boosters', 'specific_impulse_s']} label="比冲" tooltip="助推器自己的比冲;芯级比冲沿用一级参数的值"><InputNumber min={1} style={{ width: '100%' }} suffix="s" placeholder="仅构型可留空" /></Form.Item></Col>
@ -182,7 +183,7 @@ export function Rockets() {
<div>
<div className="adm-cell-strong">芯级 {record.stage_1.engine_count} 台 / {(record.stage_1.max_thrust_n / 1_000_000).toFixed(2)} MN</div>
{record.boosters?.count
? <div className="adm-cell-sub">助推器 {record.boosters.count}×{record.boosters.engine_count ?? '-'} 台 · 直径比 {record.boosters.diameter_ratio ?? '-'}</div>
? <div className="adm-cell-sub">助推器 {record.boosters.count}×{record.boosters.engine_count ?? '-'} 台 · 直径比 {record.boosters.diameter_ratio ?? '-'} · 长度比 {record.boosters.length_ratio ?? '-'}</div>
: null}
</div>
),

View File

@ -692,39 +692,54 @@ html[data-adm-theme='dark'] {
}
/* 控制台系统状态面板 */
.adm-status-list {
display: flex;
flex-direction: column;
gap: 2px;
.adm-metric-grid {
display: grid;
grid-template-columns: repeat(auto-fit, minmax(160px, 1fr));
gap: 18px 24px;
}
.adm-status-row {
.adm-metric {
display: flex;
min-width: 0;
flex-direction: column;
justify-content: center;
gap: 6px;
}
.adm-metric-head {
display: flex;
align-items: center;
justify-content: space-between;
gap: 12px;
padding: 9px 2px;
font-size: 13px;
gap: 8px;
font-size: 12px;
color: var(--adm-text-secondary);
border-bottom: 1px dashed var(--adm-border);
}
.adm-status-row:last-child {
border-bottom: none;
}
.adm-status-row b {
.adm-metric-icon {
display: inline-flex;
align-items: center;
gap: 6px;
font-size: 14px;
color: var(--adm-primary-text);
}
.adm-metric-value {
display: flex;
min-height: 28px;
align-items: center;
font-size: 20px;
font-weight: 600;
line-height: 1.2;
color: var(--adm-text);
}
.adm-status-divider {
height: 1px;
margin: 6px 0;
background: var(--adm-border);
.adm-metric-status {
display: inline-flex;
align-items: center;
gap: 8px;
}
.adm-metric-foot {
font-size: 12px;
color: var(--adm-text-muted);
}
/* 统计卡片(控制台) */

View File

@ -40,9 +40,16 @@ const EN: Record<string, string> = {
'包含管理员与普通用户': 'Includes administrators and regular users',
'恒星系统': 'Star systems',
'含太阳系与系外星系': 'Solar and exoplanetary systems',
'火箭型号': 'Launch vehicles',
'启用': 'Active',
// 控制台内容面板
'近期任务': 'Recent tasks',
'即将开始的火箭发射任务': 'Upcoming launches',
'暂无即将开始的发射任务': 'No upcoming launches',
'30 天内': 'Next 30 days',
'发射任务': 'Mission',
'发射时间': 'Launch time',
'型号': 'Vehicle',
'系统状态': 'System status',
'即将发生的天象': 'Upcoming events',
'查看全部': 'View all',
@ -50,15 +57,19 @@ const EN: Record<string, string> = {
'暂无即将发生的天象事件': 'No upcoming events',
'数据截止日期': 'Data cutoff',
'Redis 缓存': 'Redis cache',
'缓存内存占用': 'Cache memory',
'内存': 'Memory',
'缓存命中率': 'Cache hit rate',
'总查询': 'Queries',
'累计命令数': 'Total commands',
'太阳系行星': 'Solar system planets',
'系外行星': 'Exoplanets',
'星系总数': 'Total planets',
'个连接': 'clients',
'数据库': 'Database',
'张表': 'tables',
'数据记录': 'Records',
'位置数据': 'Positions',
'资源文件': 'Uploads',
'个文件': 'files',
'已连接': 'Connected',
'未连接': 'Disconnected',
'颗': 'planets',
'任务': 'Task',
'事件': 'Event',
'类型': 'Type',

View File

@ -1,7 +1,11 @@
# COSMO 轨道终端固件(ESP32-S3)
正点原子 ATK-DNESP32S3 + 2.4 寸 TFTLCD(ST7789V,横屏 320x240)上运行的终端固件。
联网后显示 6 位绑定码,网页端输入完成绑定,之后开机直接用长期 token 拉取该用户关注的天体。
联网后显示 6 位绑定码,网页端输入完成绑定,之后开机直接用长期 token 鉴权。
绑定完先落**模式选择页**:`天体`(该用户关注的天体 + 位置/速度/事件)或 `火箭`
(平台启用的运载火箭型号 + 参数 + 关联发射任务)。**这一页永远是登录后的第一屏**:
上次选的那一个会从高亮处记住(NVS 键 `mode`),但要再按一次 `KEY2` 才真正进去——
换环境时先看清网络/后端地址再进去,比直接掉进一个空列表有用。同一页 `KEY3` 进**设置页**。
## 硬件
@ -55,9 +59,10 @@
```sh
unset HTTP_PROXY HTTPS_PROXY http_proxy https_proxy # 本地代理端口是死的,会拖死下载
FQBN='esp32:esp32:esp32s3:PSRAM=opi,FlashSize=16M,FlashMode=dio,USBMode=hwcdc,CDCOnBoot=cdc,PartitionScheme=app3M_fat9M_16MB,UploadSpeed=460800'
# 当前这块板子插的是 CH340 那根线 -> CDCOnBoot=default,控制台在 /dev/cu.usbserial-210
FQBN='esp32:esp32:esp32s3:PSRAM=opi,FlashSize=16M,FlashMode=dio,CDCOnBoot=default,PartitionScheme=app3M_fat9M_16MB,UploadSpeed=460800'
~/esp-tools/arduino-cli --config-file ~/esp-tools/arduino-cli.yaml compile --fqbn "$FQBN" terminal/firmware/cosmo_terminal
~/esp-tools/arduino-cli --config-file ~/esp-tools/arduino-cli.yaml upload --fqbn "$FQBN" --port /dev/cu.usbmodem2101 terminal/firmware/cosmo_terminal
~/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。
@ -66,7 +71,8 @@ FQBN='esp32:esp32:esp32s3:PSRAM=opi,FlashSize=16M,FlashMode=dio,USBMode=hwcdc,CD
要用 `/dev/cu.usbserial-210`。两种 FQBN 都能烧录(USB-Serial/JTAG 自带下载模式),但只有前一种能在原生口拿到日志——
后面那种配 `tools/*.py` 得先把 `PORT` 改回 `usbserial-210`。
- 烧录速率用 460800;921600 在这块 CH340 上会 `Unable to verify flash chip connection`。
- 分区表 `app3M_fat9M_16MB`:app 3MB,当前 `Sketch uses 1456603 bytes (46%)`(含内置图标 189KB + 中文字库 125KB)。
- 分区表 `app3M_fat9M_16MB`:app 3MB,当前 `Sketch uses 1503518 bytes (47%)`
(内置兜底图标 + 模式页 96x96 大图 + 中文字库 125KB)。
- 依赖:Arduino 核 `esp32:esp32 3.3.12` + `ArduinoJson 7.4.3`,其余都是核心自带库。
## 界面:设计稿语言与离线资源
@ -78,6 +84,13 @@ FQBN='esp32:esp32:esp32s3:PSRAM=opi,FlashSize=16M,FlashMode=dio,USBMode=hwcdc,CD
右侧 `222x81` 分页面板,`[EVENTS]` / `[INFO]` 由 KEY3 循环切换(INFO 页 = 中文名 + 中文简介,
12 字/行 x 2 行,第二行末尾留一个字位给截断标记 `..`;面板高度放不下设计稿里的 3 行)。配色取自设计稿取色,见 `src/display.h` 的注释。
新增的两页沿用同一套常量:模式选择页 = 两张 `150x146` 面板(`x = 8 + i*154`、`y=42`、
`cut=10`,96x96 大图标 + 中文名 + 英文标签,选中的亮青边 + 左侧 3px 金条);火箭列表和
天体列表同为 3 张 `314x60` 卡,右列火箭是"还有几次发射"、天体留白(设计稿那个 ON/OFF
胶囊只是后端 `is_active` 的只读镜像:按不动,也改不了订阅,画成开关只会让人一直想按,
已去掉);火箭详情上半 `156x88` 两块(`SPECS` 青 / `PERFORMANCE` 金),下方左 `88x81`
立绘(雷达底纹 + 64x64 叠加)、右 `222x81` 三页面板 `LAUNCH / STAGE / INFO`。
面板统一用**切角(chamfer)**图元 `disp_panel(x,y,w,h,cut,fill,border)`,需要辉光时先
`disp_panel_glow()` 在外侧描一圈低阶色。背景 `disp_bg()` = `C_BG` + 固定伪随机星点 +
角落电路走线,纯程序化,不占 flash。
@ -95,6 +108,10 @@ FQBN='esp32:esp32:esp32s3:PSRAM=opi,FlashSize=16M,FlashMode=dio,USBMode=hwcdc,CD
否则灰底会把整块面板糊白。`icon_for(name, name_zh, type, detail)` 先按名字小写子串匹配,
命不中再按后端 6 种 `type` 兜底,最后 `planet`。没有专属图的天体(水星/天王星/冥王星系)
就用 `行星小.jpeg`,**不做假色相**。后台没维护图标的天体走的就是这张表,见下一节。
- 模式选择页两张 96x96 大图和火箭兜底图也是这个脚本出的:`ic_mode_planet_96` /
`ic_mode_rocket_96` / `ic_rocket_list` / `ic_rocket_detail`。火箭那张不是画死的,
是脚本直接调后端的 `app.services.rocket_art` 用一组合成参数现画再降采样,
所以**终端的兜底立绘和后端按登记参数画的立绘是同一套几何**。
- `src/font_cjk.{h,cpp}`:16x16 点阵,GB2312 一级字 3755 + 常用中文标点和 `°×℃` =
**3775 字**(点阵 118KB + 索引 7.4KB)。STHeiti Medium 160pt 渲染 → 取 em 见方 158px 裁切
(字身中心下移 4px 找齐)→ BILINEAR 降到 16x16 → 阈值 130 二值化;
@ -104,6 +121,45 @@ FQBN='esp32:esp32:esp32s3:PSRAM=opi,FlashSize=16M,FlashMode=dio,USBMode=hwcdc,CD
`size=32` 时中文按 2x2 块放大。截断一律走 `disp_text_clipped()` / `clip_chars()`,
保证不切断 UTF-8 序列。
## 双模式:天体 / 火箭
```
绑定完成 / 开机拿到 token -> SC_MODE 模式选择(KEY0/KEY1 选,KEY2 进,KEY3 -> SC_SETTINGS)
天体 -> GET /api/terminal/follows 列表 -> 详情(EVENTS / INFO)
火箭 -> GET /api/terminal/rockets 列表 -> 详情(LAUNCH / STAGE / INFO)
GET /api/terminal/rockets/{code} 参数 + 关联发射任务
GET /api/terminal/rockets/{code}/art?size= 按参数画的立面图点阵
```
- **模式是持久化的**:NVS 键 `mode`,值 `0`=天体 / `1`=火箭,只用来决定模式页高亮哪一个
(不再"直达列表"——登录后一定先停在模式页)。串口 `mode bodies|rockets|clear` 可以免按键改,
`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` 直接跳这页。
- **火箭立绘 = 后端按登记的火箭参数现画**(`backend/app/services/rocket_art.py`),和 3D
模拟页共用 `stageGeometry` 那套几何:整流罩/级间段/助推器/栅格翼的尺寸全部来自平台里
登记的型号参数。参数哈希 `art_ver` 随列表下发,**版本没变就一个字节都不重新下载**,
列表只缺 40x40、进详情才拉 64x64(`src/rocketstore.{h,cpp}`,PSRAM 里一个型号一个槽)。
拉不到(后端不通/型号没有)就退回固件内置那张线稿,版面不空。
- **`LAUNCH` 页那一行显示的是任务名,不是型号名**:`rocket_events.name` 来自数据源,形如
`Falcon 9 Block 5 | Starlink Group 15-25`,型号已经是这页的标题了,前缀只会把真正的任务名
挤出面板边界,所以 `build_rocket_detail()` 下发的是 `mission_name or name`。
发射日期改成**行尾右对齐**成一列,"什么时候打什么"还是同一行读完。
- **长任务名用中间省略,不用尾部省略**(`ui.cpp::text_elided`):Starlink 这一类名字的区别
全在结尾的编号上,`disp_text_clipped` 那种掐尾巴会把 `Starlink Group 15-25` 打成
`Starlink Group ..`,等于三行都长成一样。所以先按整词把**后缀**收进右半边宽度,
剩下的宽度全部给开头,`..` 夹在中间连成一串(`Starlink G..15-25`)——头和尾之间刻意
不留白,留白了 `..15-25` 会被读成右边那一列发射日期;一个词都塞不下(超长词/中文)
才退到按字符收后缀。
- **按键**:列表页 `KEY0/KEY1` 光标、`KEY2` 进详情、`KEY3` 回模式选择页(天体列表原来
的"手动刷新"让给了模式页,刷新由进入时 + 5 分钟轮询覆盖);详情页 `KEY0/KEY1` 换上下
一个型号(火箭详情必须重新拉一次明细)、`KEY2` 回列表、`KEY3` 右栏翻页。
5 分钟轮询到人停留在详情页时**不会把他踢回列表**。
## 天体图标:后台维护,运行时动态拉取
设计稿里的天体图标不是编译死的:**平台管理 -> 天体信息 -> 资源配置 -> 图标** 里换一张图,
@ -153,14 +209,90 @@ curl --noproxy '*' -H "Authorization: Bearer $TOK" -o /tmp/ic_599_40.bin \
## 配网
首次开机或 NVS 里没有 SSID 时,终端开一个热点 `COSMO-SETUP-XXXX`:
NVS 里没有 SSID,**或者存着的 WiFi 连着连不上**,终端都会自己开热点 `COSMO-SETUP-XXXX`:
1. 手机/电脑连这个热点;
1. 手机/电脑连这个热点(开放网络,无密码);
2. 浏览器打开 `http://192.168.4.1`(多数系统会自动弹出强制门户);
3. 选 SSID、填密码和后端地址(默认 `https://cosmo.unisspace.com/api`),保存后自动重启。
3. 选 SSID、填密码和后端地址(预填**当前生效**的地址),保存后自动重启。
下拉框第一项是**「不改 WiFi,只保存后端地址」**:换开发机/换服务器时不用重输密码。
选回当前网络时密码留空 = 沿用 NVS 里存的那份;三项都没动就回「没有需要保存的改动」,不重启。
密码框故意做成明文 `type=text`,配网失败一多半是密码打错。
下拉列表下面还有一个「手动输入 SSID」,填了就覆盖下拉框的选择:新环境里路由器只开 5GHz
(ESP32-S3 只收 2.4GHz)或 SSID 被隐藏时,一个热点都扫不到,没有这个输入框配网就是死路;
这时下拉里还会把**存过的 SSID**放回来,至少不用手打原名。页面底部也标了「仅支持 2.4GHz WiFi」。
进了配网页不是只能重输:**配网页 KEY3 RETRY** = 关掉热点、拿 NVS 里的旧凭据再连一次。
从设置页进来时按的是 `keep_sta=true`:热点照开,但现有 WiFi 不断,门户同时挂在设备的局域网 IP 上
(和串口 `portal lan` 一样),改错了还能从局域网那一侧 `curl` 上去看。
串口 `wifi` / `api` / `reload` / `pair` 改了配置也顺手关热点——热点只属于配网页,
这件事统一收在 `set_screen()` 里(离开 `SC_PROVISION` 就 `portal_stop()`)。
> **坑:`portal_stop()` 里的 `close()` 只关监听,路由是留着下次用的。** 所以 `portal_start()`
> 里的 `s_server.begin()` 不能跟「注册路由」待在同一个 `if (!s_routed)` 里——否则第二次及以后
> 开的热点会变成「手机连得上、页面死活打不开」,而这恰好是换环境时最常撞的那一幕
> (第一次自动进配网 → 密码敲错 → 又自动回到配网页)。
> **别拿「板子自己 GET 自己」当证据。** 试过加一条串口命令让板子当客户端去连
> `http://192.168.4.1/`,永远回 `connection refused`,看着像门户死了;实际是 lwIP 走
> 自身地址那条路径不可靠。同一时刻同网段的电脑 `curl` 拿到的是 **200 / 4.5s**。
> 要验证门户在服务就用下面这个真的外部客户端:串口 `portal lan`。
凭据、后端地址、token 都存在 NVS 命名空间 `cosmo`。
### 无网是怎么判出来的(换了环境不用接串口也能进配网)
`wifi_tick()` 给每一轮连接两类预算,用完就往下走,不会停在 CONNECTING 死等:
| 现象 | `WiFi.status()` | 屏上原因 | 一轮预算 |
| --- | --- | --- | --- |
| 扫不到这个 SSID | `WL_NO_SSID_AVAIL` | `SSID NOT IN RANGE` | 6s(`WIFI_GIVEUP`,已定性不用等满) |
| 密码/AP 拒绝接入 | `WL_CONNECT_FAILED` | `LOGIN REJECTED (PASSWORD)` | 6s |
| 关联上了但拿不到 IP | 其它 | `NO IP ADDRESS` | 20s(`WIFI_TIMEOUT`) |
| 用着用着掉线 | 非连接/配网页且掉线满 10s | — | `net_watch()` 回连接页重来 |
同一份凭据连着失败 `WIFI_TRIES=2` 轮就自动开热点。SSID 不在范围时现场实测 **13~26s**:
第二轮一定被判成 `SSID NOT IN RANGE` 只花 6s,但开机第一轮有时要到断开事件都收齐了才定性,
会吃满 20s(屏上原因显示 `NO IP ADDRESS`)。连接页同时显示原因和 `TRY 1/2 HOTSPOT IN 7s`
倒计时,配网页第一行显示失败原因;首次开机没存凭据则显示 `NO SAVED WIFI CREDENTIALS`。
不想等倒计时也能手动进配网:**CONNECTING 页 KEY3**、**PAIR 页 KEY2**、**ERROR 页 KEY2**。
PAIR 页那条是给「WiFi 连上了但后端不通」留的出口——换了网段、`api` 还指着上一套环境的内网
地址时,终端只会停在配对页反复报拿不到码,没有这个键就只能拆机接串口;按下时串口同时打印
`dev/api/user/token` 四个值,方便一眼看出是哪个填错了。反过来在配网页上想改回重试旧凭据,
按 **KEY3 RETRY**。
> 实测(MAC `E8:06:90:9B:58:7C`,`Hammond-2015` 已不在现场):复位后热点 `COSMO-SETUP-587C`
> 自动出现,Mac 连上拿到 `192.168.4.2`/网关 `192.168.4.1`,`GET http://192.168.4.1/` 返回
> 200、下拉里 20 个热点、后端地址预填正式服务。配网页首响应约 **4s**,慢在
> `handle_root()` 里那次同步 `WiFi.scanNetworks()`——用手机扫码进门户时别急着关页面。
### 搬到新场地之后怎么查
S3 只有 **2.4GHz** 射频,「我手机能连上」不算判据(大概率连的是 5G)。三步,都在串口上:
```sh
~/esp-tools/pio_env/bin/python terminal/tools/serial_term.py
# scan 板子眼里的 2.4G 网络全列表;目标 SSID 不在里面就是射频层的事
# cfg 把 NVS 里存的 ssid/pass/api 抄下来——搬家前先抄一次
# wifi <ssid> <pass> 换凭据(测别的网络前,先把上面抄的原样填回去就行)
# api <url> 换后端地址,见下一节
# settings 跳到设置页(WiFi / 后端地址 / 绑定用户 / 当前模式)
# portal lan 开热点但不断现有 WiFi:门户同时挂在设备局域网 IP 上,
# 同一网段的电脑 curl http://<设备IP>/ 就能看到配网页
```
「无网」有两层,屏幕上分得出来:
| 情况 | 屏上表现 | 出路 |
| --- | --- | --- |
| WiFi 连不上 | 连接页写原因 + `TRY 1/2 HOTSPOT IN 7s`,用完预算自动开热点 | 配网页 / KEY3 |
| WiFi 连着、后端不通 | 状态栏从 `NET:ONLINE RSSI:-56` 变橙色 `NET:ONLINE API FAIL`;连着 `API_FAIL_LIMIT=3` 次取不到数据自动翻故障页 | 故障页 `KEY2 SETUP` |
第二层是换环境最常见的一种:连上了新 WiFi,`api` 还指着上一套环境的地址。
旧数据会继续显示(比空白有用),但状态栏必须先变脸,否则旧数据看着像在线;
故障页上写着 `DATA FETCH FAILED (HTTP -1) FROM ...`,那里才有配网出口。
### 后端地址(换服务器 / 上 https 只看这一节)
地址存 NVS 键 `api`,**只有 NVS 里还没有这个键时**才用编译期的默认值:
@ -208,13 +340,50 @@ curl --noproxy '*' -H "Authorization: Bearer $TOK" -o /tmp/ic_599_40.bin \
防抢绑靠后端,不靠终端:码只能由已登录用户在 `/api/devices/bind` 消费,同码并发只有 1 个成功;码 10 分钟过期,剩余不足 10s 时终端主动换新码;换绑会轮换 token,解绑后旧 token 立即 401,终端自动回到配对页。
### 设备行就是吊销表:终端多久发现一次
`get_terminal_context()` 每次请求都回查 `terminal_devices`——`status != bound`、`user_id` 对不上、
或 JWT 里的 `bnd`(绑定时刻)与 `bound_at` 不是同一轮,一律 401。**后端不需要吊销列表,
网页端解绑/换绑即刻生效**,剩下的问题只是终端什么时候会去问一次:
| 停在哪个页面 | 谁去问 | 发现解绑的延迟 |
| --- | --- | --- |
| 列表 / 详情 / 火箭列表 / 火箭详情 | `run_tick()` 的 5 分钟数据轮询 | ≤5 分钟 |
| 模式页 / 设置页 | `auth_check()` 每 60s(`IDLE_CHECK_MS`,独立钟 `g_next_idle`) | ≤60s,且进这两页先复核一次 |
| 故障页 | 15s 重试 | ≤15s |
首屏改成模式页之后,这两页一度**一个请求都不发**:网页端解绑之后终端还挂着上一轮缓存在
NVS 里的用户名、设置页照旧写 `BOUND`,`last_seen_at` 也不再更新,网页端看它像掉线了。
`auth_check()` 只取结论不跳页(成功就刷新用户名/信号/快照并把 `api_fail` 抹掉,
后端不通只让状态栏变脸),60s 也落在 `app/api/device.py` 的 `ONLINE_WINDOW_SECONDS = 360`
之内,顺带把"设备在线"的那颗心跳补齐。
清 token 的动作四个取数入口共用 `token_revoked()`:抹掉 `K_TOKEN` **和** `K_USER`
(否则配对页顶上会挂着个早就解绑的账号)再 `start_pairing()` 要新码。
## 串口命令(115200)
`help` / `wifi <ssid> [pass]` / `api <url>` / `pair` / `reload` / `portal` / `stat` /
`keys` / `xlreg` / `key 0xNN` / `i2cscan` / `selftest` / `dump` / `swap 0|1` / `bgr 0|1` / `inv 0|1` / `mir 0|1` / `reset`
`help` / `wifi <ssid> [pass]` / `cfg` / `api <url>` / `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` / `reboot` / `reset`
`reload` 刷的是**当前模式**那份数据;`rockets` 打印内存里的火箭快照(code/参数/art_ver/待发射数),
`stat` 末尾会把 `rocket_store_dump()` 的缓存表一起打出来(哪个型号缓存了 40 还是 40+64)。
换环境最常用的三条:`scan`(板子能看到哪些 2.4G 网络)、`cfg`(NVS 里存的 ssid/pass/api)、
`portal lan`(配网门户在不在服务,顺带能在同网段直接改后端地址,不用先连热点)。
`key 0x8000|0x4000|0x2000|0x1000` 注入一次按键(上/下/确认/刷新),不接按键也能翻页;
`dump` 把当前 320x240 帧缓冲按 RGB565 大端从串口回传(约 14s),用来在电脑上看屏幕内容:
`dump` 把当前 320x240 帧缓冲按 RGB565 大端从串口回传(约 14s),用来在电脑上看屏幕内容。
**同一时刻只留一个串口读者**:`dump` 抓到一半时再来第二个程序读同一个口,两个程序会分掉
这 15 万字节,抓屏停在半截、`stat` 也像没了回显(实测停在 94204/153600 字节)。
> **线要插对,`CDCOnBoot` 决定控制台在哪个口**:`cdc` = `Serial` 走 S3 原生 USB
> (USB-Serial/JTAG,`/dev/cu.usbmodemXXXX`);`default`(=Disabled)= `Serial` 落回
> UART0/CH340(`/dev/cu.usbserial-210`),此时原生口只剩 `ESP-ROM.../entry 0x...` 这些
> ROM 打印,`stat` 敲下去一个字都不回。反过来插错线也是同一个症状:**口在,但不是控制台**。
> 当前这台机器上实测的是 CH340 那根线,所以固件按 `CDCOnBoot=default` 编、命令走
> `/dev/cu.usbserial-210`。`tools/*.py` 挑口时 `usbserial*` 优先,换线用 `COSMO_PORT=` 指定。
点屏调色:颜色整体反了用 `inv`,红蓝互换用 `bgr`,明暗/花屏用 `swap`,左右反了用 `mir`。
`selftest` 画四条色带自检,任意按键或命令退出。
@ -264,4 +433,10 @@ ffmpeg -f rawvideo -pixel_format rgb565be -video_size 320x240 -i /tmp/fb.raw \
- HTTP 请求是阻塞的,拉数据时按键响应会停顿 1 秒左右;图标版本变化那一次会多两次下载(~130ms/天体)。
- 动态图标要在后台维护过才有,没维护的天体用的是内置那 ~20 张线稿,水星/天王星/冥王星这类只能吃兜底图。
- 事件列表按后端返回顺序显示,包含已过期的(`is_upcoming=false` 也在列)。
- 火箭详情页右栏只有两行高度,中文简介 `desc` 截到 23 字(第二行末尾留一个字位给 `..`),
比后端登记的完整简介短;换行遵守"中文标点不许顶行"(`disp_text_wrap()` 会把标点和它
前一个字一起挪到下一行)。
- 火箭立绘是**立面图**,只画一对助推器(登记 4 个也用一对表示),长细比按真实高/宽比
做了一次 `1.72 * a^0.45` 的压缩并夹在 3.0~8.5:完全不缩在 40px 上就是一根针。
所以"瘦火箭显得比实际瘦"是刻意的,同屏内的相对粗细仍然可比。
- 未做:频道消息页、设置页、OTA、设计稿里的 STATUS 数据格(表面温度、自转周期等后端没有数据源)。

View File

@ -22,6 +22,7 @@
#include "src/portal.h"
#include "src/ui.h"
#include "src/iconstore.h"
#include "src/rocketstore.h"
#define DEFAULT_API "https://cosmo.unisspace.com/api"
#define DEVICE_NAME "Cosmo Terminal"
@ -29,7 +30,12 @@
#define TOKEN_CAP 320 /* 后端下发的 terminal token 约 200 字符 */
#define POLL_MS 2000 /* 后端 pair/status 建议 poll_interval=2s */
#define DATA_REFRESH 300000UL /* 天体数据 5 分钟刷新一次 */
#define WIFI_TIMEOUT 20000UL
#define IDLE_CHECK_MS 60000UL /* 停在首屏/设置页时多久校验一次 token,须 < 后端 ONLINE_WINDOW_SECONDS=360 */
#define WIFI_TIMEOUT 20000UL /* 一轮连接最多等多久(拿不到任何结论时) */
#define WIFI_GIVEUP 6000UL /* 已经定性失败(SSID 不存在/密码错)时不必等满 */
#define WIFI_TRIES 2 /* 连着失败这么多轮就自己开热点,不死等 */
#define NET_LOST_MS 10000UL /* 运行中掉线多久算掉网,回到连接页重来 */
#define API_FAIL_LIMIT 3 /* 连着这么多次取不到数据就从列表翻到故障页 */
#define CODE_RENEW 10 /* 配对码剩余不足 10 秒主动换新 */
#define KEY_DEBOUNCE 20
#define KEY_FLASH_MS 250 /* 底部按键条按下反馈时长 */
@ -37,38 +43,52 @@
/* ---------------- 全局状态 ---------------- */
static UiState g_ui;
static Snapshot g_snap;
static RocketSnapshot g_rsnap;
static RocketDetail g_rdet;
static int g_mode = -1; /* 终端模式:-1=没选过 0=天体 1=火箭 */
static char g_token[TOKEN_CAP];
static char g_ap_ssid[24];
static uint32_t g_deadline = 0; /* 配对码到期时刻 */
static uint32_t g_next_poll = 0;
static uint32_t g_next_data = 0;
static uint32_t g_next_idle = 0; /* 首屏/设置页的鉴权校验节拍,独立于 g_next_data */
static uint32_t g_retry_at = 0; /* 无码时的下次重试时刻 */
static uint32_t g_wifi_since = 0;
static uint8_t g_wifi_try = 0; /* 本轮凭据已经连失败的次数 */
static uint32_t g_net_lost = 0; /* 运行中掉线的起始时刻,0 = 在线 */
static int g_api_fails = 0; /* 连着几次取不到数据(WiFi 通、后端不通) */
static bool g_dirty = true;
static bool g_ui_paused = false; /* selftest 期间不要被状态界面覆盖 */
static const char *screen_name(Screen s)
{
static const char *n[] = { "SPLASH", "PROVISION", "CONNECTING", "PAIR",
"LOADING", "LIST", "DETAIL", "ERROR" };
return (s <= SC_ERROR) ? n[s] : "?";
"LOADING", "MODE", "LIST", "DETAIL",
"ROCKETS", "ROCKET", "ERROR", "SETTINGS" };
return (s <= SC_SETTINGS) ? n[s] : "?";
}
static void set_screen(Screen s, const char *msg = nullptr)
{
if (msg) strlcpy(g_ui.message, msg, sizeof(g_ui.message));
/* 热点只属于配网页:按键退出、串口改了凭据/地址,离开这一步就把 AP 和门户关掉 */
if (g_ui.screen == SC_PROVISION && s != SC_PROVISION) portal_stop();
if (g_ui.screen != s) Serial.printf("[ui] %s -> %s\n", screen_name(g_ui.screen), screen_name(s));
g_ui.screen = s;
g_dirty = true;
}
/* ---------------- 前向声明 ---------------- */
static void start_provision();
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 open_mode();
static void enter_terminal();
static void refresh_active(bool show_loading);
/* ---------------- 启动 ---------------- */
static void build_identity()
@ -90,15 +110,30 @@ static void build_identity()
Serial.printf("[dev] id=%s ap=%s api=%s\n", g_ui.device_id, g_ap_ssid, g_ui.api);
}
/* 网络状态同步给界面:状态栏和设置页都读这几个字段,别在各处各写各的 */
static void net_sync()
{
bool up = (WiFi.status() == WL_CONNECTED);
g_ui.wifi_up = up;
g_ui.rssi = up ? WiFi.RSSI() : 0;
if (up) strlcpy(g_ui.ip, WiFi.localIP().toString().c_str(), sizeof(g_ui.ip));
else g_ui.ip[0] = 0;
}
/* ---------------- 配网 ---------------- */
static void start_provision()
static void start_provision(const char *why, bool keep_sta)
{
/* 预填 NVS 里当前生效的地址:填 DEFAULT_API 的话,重开配网页直接点保存
会把后端地址刷回编译期那个局域网 IP */
portal_start(g_ap_ssid, g_ui.api);
g_ui.wifi_up = false; /* 配网时 STA 已断开,状态栏不能再显示 NET:ONLINE */
portal_start(g_ap_ssid, g_ui.api, keep_sta);
/* 配网默认断 STA,状态栏不能再显示 NET:ONLINE;keep_sta 是调试用,网还活着 */
g_ui.wifi_up = keep_sta && (WiFi.status() == WL_CONNECTED);
g_ui.hint[0] = 0;
g_ui.reason[0] = 0;
if (why) strlcpy(g_ui.reason, why, sizeof(g_ui.reason));
set_screen(SC_PROVISION);
Serial.printf("[portal] AP=%s -> http://192.168.4.1\n", g_ap_ssid);
Serial.printf("[portal] AP=%s -> http://192.168.4.1 (%s)\n", g_ap_ssid,
why ? why : "no credentials");
}
static void wifi_connect()
@ -108,30 +143,113 @@ static void wifi_connect()
store_get_str(K_PASS, pass, sizeof(pass));
strlcpy(g_ui.ssid, ssid, sizeof(g_ui.ssid));
g_ui.wifi_up = false;
g_ui.ip[0] = 0;
g_ui.reason[0] = 0;
g_ui.hint[0] = 0;
WiFi.mode(WIFI_STA);
WiFi.setSleep(false);
WiFi.begin(ssid, pass);
g_wifi_since = millis();
set_screen(SC_CONNECTING);
Serial.printf("[wifi] connecting %s\n", ssid);
Serial.printf("[wifi] connecting %s (try %d/%d)\n", ssid, g_wifi_try + 1, WIFI_TRIES);
}
/* core 在 ARDUINO_EVENT_WIFI_STA_DISCONNECTED 里就是这么映射 wl_status 的,
这里照抄它的分类,别把 "没扫到 SSID" 说成 "密码错" */
static const char *wifi_fail_reason()
{
switch (WiFi.status()) {
case WL_NO_SSID_AVAIL: return "SSID NOT IN RANGE";
case WL_CONNECT_FAILED: return "LOGIN REJECTED (PASSWORD)";
case WL_CONNECTION_LOST: return "AP STOPPED RESPONDING";
default: return "NO IP ADDRESS";
}
}
/* 扫不到网络 / 账号被拒 已经能定性,继续等只是浪费时间 */
static bool wifi_hopeless()
{
wl_status_t st = WiFi.status();
return st == WL_NO_SSID_AVAIL || st == WL_CONNECT_FAILED;
}
/* 连不上就自己开热点,不许一直停在 CONNECTING 装死 */
static void provision_no_net()
{
const char *why = wifi_fail_reason(); /* 必须在 disconnect 前取,断了就只剩 WL_DISCONNECTED */
g_wifi_try = 0;
WiFi.disconnect();
/* 屏上只放原因:SSID 在连接页已经显示过,两个都放配网页会被裁字 */
start_provision(why);
}
/* 用户从配网页退出:拿 NVS 里的旧凭据再连一次(热点由 set_screen 关掉);
真没凭据 wifi_connect() 会自己把热点开回来 */
static void provision_quit()
{
g_wifi_try = 0;
g_net_lost = 0;
wifi_connect();
}
static void wifi_tick()
{
if (WiFi.status() == WL_CONNECTED) {
g_ui.wifi_up = true;
g_ui.rssi = WiFi.RSSI();
g_wifi_try = 0;
g_net_lost = 0;
net_sync();
g_ui.reason[0] = 0;
g_ui.hint[0] = 0;
Serial.printf("[wifi] online ip=%s rssi=%d\n",
WiFi.localIP().toString().c_str(), g_ui.rssi);
if (g_token[0]) load_data(true);
if (g_token[0]) enter_terminal();
else start_pairing();
return;
}
if (millis() - g_wifi_since > WIFI_TIMEOUT) {
Serial.println("[wifi] timeout, retrying");
WiFi.disconnect();
wifi_connect();
uint32_t spent = millis() - g_wifi_since;
uint32_t limit = wifi_hopeless() ? WIFI_GIVEUP : WIFI_TIMEOUT;
if (spent < limit) {
/* 扫不到网络 / 密码被拒 当场就能定性,立刻写到连接页上 */
if (wifi_hopeless() && !g_ui.reason[0]) {
strlcpy(g_ui.reason, wifi_fail_reason(), sizeof(g_ui.reason));
g_dirty = true;
}
/* 连接页写清楚还剩几秒开热点,别让人以为死机(同一秒内不重复刷) */
static uint32_t s_last_left = 0xFFFFFFFF;
uint32_t left = (limit - spent + 999) / 1000;
if (left != s_last_left) {
s_last_left = left;
snprintf(g_ui.hint, sizeof(g_ui.hint), "TRY %d/%d HOTSPOT IN %lus",
g_wifi_try + 1, WIFI_TRIES, (unsigned long)left);
g_dirty = true;
}
return;
}
g_wifi_try++;
Serial.printf("[wifi] attempt %d/%d failed: %s (ssid=%s)\n",
g_wifi_try, WIFI_TRIES, wifi_fail_reason(), g_ui.ssid);
if (g_wifi_try >= WIFI_TRIES) { provision_no_net(); return; }
WiFi.disconnect();
wifi_connect();
}
/* 跑着跑着网没了(路由器关了/搬离现场):回到连接页,按同一套预算决定重连还是开热点 */
static void net_watch(uint32_t now)
{
if (g_ui.screen == SC_CONNECTING || g_ui.screen == SC_PROVISION || g_ui.screen == SC_SPLASH) {
g_net_lost = 0;
return;
}
if (WiFi.status() == WL_CONNECTED) { g_net_lost = 0; return; }
if (!g_net_lost) { g_net_lost = now; return; }
if ((int32_t)(now - g_net_lost) < (int32_t)NET_LOST_MS) return;
Serial.println("[wifi] link lost, going back to connect");
g_net_lost = 0;
g_wifi_try = 0;
g_ui.wifi_up = false;
wifi_connect();
}
/* ---------------- 绑定 ---------------- */
@ -142,6 +260,19 @@ static void start_pairing()
request_code();
}
/* 后端回 401/403 = 这台设备已经不在绑定表里(网页端解绑/删除、或重新绑过一次)。
本地那份 token 和用户名一起作废,回配对页重新要码。取数入口共用这一条规则,
免得有的页面清了用户名、有的没清,配对页顶上挂着个早就解绑的账号。 */
static void token_revoked()
{
Serial.println("[api] token rejected, unbinding locally and asking for a new code");
g_token[0] = 0;
store_erase(K_TOKEN);
g_ui.owner[0] = 0;
store_erase(K_USER);
start_pairing();
}
static void request_code()
{
char code[8];
@ -173,7 +304,9 @@ static void request_code()
}
char msg[140];
snprintf(msg, sizeof(msg), "CANNOT GET CODE FROM %s. CHECK THE BACKEND, THEN PRESS [CODE].", g_ui.api);
snprintf(msg, sizeof(msg),
"NO CODE FROM %s. NETWORK OR API MAY HAVE CHANGED: [SETUP] RECONFIGURES, [CODE] RETRIES.",
g_ui.api);
strlcpy(g_ui.message, msg, sizeof(g_ui.message));
g_ui.code[0] = 0;
g_retry_at = millis() + 5000;
@ -204,7 +337,7 @@ static void pair_tick(uint32_t now)
store_set_str(K_USER, g_ui.owner);
g_ui.code[0] = 0;
Serial.printf("[pair] bound as %s (token %d bytes)\n", g_ui.owner, (int)strlen(g_token));
load_data(true);
enter_terminal();
} else if (r == PR_EXPIRED || r == PR_INVALID) {
Serial.printf("[pair] code %s -> new code\n", (r == PR_EXPIRED) ? "expired" : "stale");
request_code();
@ -224,32 +357,165 @@ static void load_data(bool show_loading)
store_set_str(K_USER, g_ui.owner);
g_ui.snap = &g_snap;
if (g_ui.sel >= g_snap.count) g_ui.sel = (g_snap.count ? g_snap.count - 1 : 0);
g_ui.rssi = WiFi.RSSI();
g_ui.wifi_up = (WiFi.status() == WL_CONNECTED);
net_sync();
g_api_fails = 0;
g_ui.api_fail = false;
/* 后台换过图标才下载(每个图标两张图,只在版本变化时走一次 HTTP) */
icon_store_sync(g_ui.api, g_token, &g_snap);
g_next_data = millis() + DATA_REFRESH;
set_screen(SC_LIST);
/* 详情页停留时 5 分钟轮询到了别把人踢回列表 */
set_screen((g_ui.screen == SC_DETAIL) ? SC_DETAIL : SC_LIST);
return;
}
if (http == 401 || http == 403) {
Serial.println("[api] token rejected, go back to pairing");
g_token[0] = 0;
store_erase(K_TOKEN);
start_pairing();
token_revoked();
return;
}
/* WiFi 还连着但后端不通(换环境最常见的一种"无网"):旧数据继续显示,
但状态栏要变脸;连着失败几次就翻到故障页,那里写着原因也有 [KEY2 SETUP] 出口 */
g_api_fails++;
g_ui.api_fail = true;
char msg[140];
snprintf(msg, sizeof(msg), "DATA FETCH FAILED (HTTP %d), API %s. [REF] RETRIES.", http, g_ui.api);
snprintf(msg, sizeof(msg), "DATA FETCH FAILED (HTTP %d) FROM %s. [SETUP] RECONFIGURES, [REF] RETRIES.", http, g_ui.api);
g_next_data = millis() + 15000; /* 有旧数据时后台定时重试 */
set_screen(g_snap.count ? SC_LIST : SC_ERROR, msg);
set_screen((g_snap.count && g_api_fails < API_FAIL_LIMIT) ? SC_LIST : SC_ERROR, msg);
}
/* 首屏和设置页以前一个请求都不发:网页端一解绑,终端还停在"已登录"的假象里
——状态栏沿用 NVS 里缓存的用户名,设置页照旧写着 BOUND,网页端那边连
last_seen_at 都不再更新,看起来像设备掉了。这两页恰恰是设备挂墙上停留最久的地方,
所以按固定节拍拿天体接口做一次鉴权校验:只取结论(解绑就翻配对页、后端不通就让
状态栏变脸),不跳页、不动光标。60s 也在后端 360s 的在线窗口内,顺带把心跳补齐。 */
static void auth_check()
{
if (!g_token[0]) { start_pairing(); return; }
int http = 0;
if (api_follows(g_ui.api, g_token, &g_snap, &http)) {
strlcpy(g_ui.owner, g_snap.username, sizeof(g_ui.owner));
store_set_str(K_USER, g_ui.owner);
g_ui.snap = &g_snap;
g_api_fails = 0;
g_ui.api_fail = false;
net_sync();
g_dirty = true;
return;
}
if (http == 401 || http == 403) { token_revoked(); return; }
if (!g_ui.api_fail) { g_ui.api_fail = true; g_dirty = true; }
}
/* ---------------- 火箭模式 ---------------- */
/* 模式选择是持久化的:换了环境/重刷固件不用重选一次 */
static int mode_load()
{
char v[4];
if (!store_get_str(K_MODE, v, sizeof(v))) return -1;
return (v[0] == '1') ? 1 : 0;
}
static void mode_save(int m)
{
g_mode = m;
g_ui.mode = m;
store_set_str(K_MODE, m ? "1" : "0");
}
static void load_rockets(bool show_loading)
{
if (!g_token[0]) { start_pairing(); return; }
if (show_loading || !g_rsnap.count) set_screen(SC_LOADING);
int http = 0;
if (api_rockets(g_ui.api, g_token, &g_rsnap, &http)) {
strlcpy(g_ui.owner, g_rsnap.username, sizeof(g_ui.owner));
store_set_str(K_USER, g_ui.owner);
g_ui.rsnap = &g_rsnap;
if (g_ui.rsel >= g_rsnap.count) g_ui.rsel = (g_rsnap.count ? g_rsnap.count - 1 : 0);
net_sync();
g_api_fails = 0;
g_ui.api_fail = false;
/* 立绘按登记的参数在后端现画,只在参数版本变化时才走 HTTP */
rocket_store_sync(g_ui.api, g_token, &g_rsnap);
g_next_data = millis() + DATA_REFRESH;
set_screen((g_ui.screen == SC_ROCKET) ? SC_ROCKET : SC_ROCKETS);
return;
}
if (http == 401 || http == 403) {
token_revoked();
return;
}
g_api_fails++;
g_ui.api_fail = true;
char msg[140];
snprintf(msg, sizeof(msg), "ROCKET LIST FETCH FAILED (HTTP %d) FROM %s. [SETUP] RECONFIGURES, [REF] RETRIES.", http, g_ui.api);
g_next_data = millis() + 15000;
set_screen((g_rsnap.count && g_api_fails < API_FAIL_LIMIT) ? SC_ROCKETS : SC_ERROR, msg);
}
/* 进详情才拉这一个型号的明细 + 64x64 立绘:型号可能很多,不做一次性全量下载 */
static void load_rocket_detail()
{
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;
const char *code = g_rsnap.rockets[g_ui.rsel].code;
int http = 0;
if (!api_rocket(g_ui.api, g_token, code, &g_rdet, &http)) {
if (http == 401 || http == 403) {
token_revoked();
return;
}
char msg[140];
snprintf(msg, sizeof(msg), "ROCKET DETAIL FETCH FAILED (HTTP %d) FROM %s. [REF] RETRIES.", http, g_ui.api);
g_retry_at = millis() + 15000;
set_screen(SC_ERROR, msg);
return;
}
/* 拉不到立绘不算失败,画面退回固件内置线稿 */
rocket_store_ensure(g_ui.api, g_token, code, g_rdet.base.art_ver, 1);
g_ui.rdet = &g_rdet;
g_ui.rocket_tab = 0;
set_screen(SC_ROCKET);
}
/* 模式选择页:两个模式大图标,选完落 NVS,以后开机直达对应列表 */
static void open_mode()
{
g_ui.mode_sel = (g_mode >= 0) ? g_mode : 0;
set_screen(SC_MODE);
}
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);
}
/* 拿到 token 之后的落点:天体/火箭模式页永远是登录后的第一屏,
在这里 KEY2 选进哪个终端、KEY3 进设置页,不再由 NVS 里的旧选择直接跳列表 */
static void enter_terminal()
{
open_mode();
}
static void refresh_active(bool show_loading)
{
if (g_mode > 0) load_rockets(show_loading);
else load_data(show_loading);
}
static void run_tick(uint32_t now)
{
if ((int32_t)(now - g_next_data) >= 0) { g_next_data = now + DATA_REFRESH; load_data(false); }
if ((int32_t)(now - g_next_data) >= 0) { g_next_data = now + DATA_REFRESH; refresh_active(false); }
}
/* ---------------- 按键 ---------------- */
@ -281,19 +547,41 @@ static void on_key_press(uint16_t bits)
bool ref = bits & XL_IO_KEY3;
switch (g_ui.screen) {
case SC_PROVISION:
/* 配网页是单向门的话,误按一下就只能重输密码或拔电,这里留个出口 */
if (ref) { Serial.println("[key] leave setup, retry saved credentials"); provision_quit(); }
break;
case SC_CONNECTING:
if (ref) { Serial.println("[key] reprovision from CONNECTING"); start_provision(); }
if (ref) { Serial.println("[key] reprovision from CONNECTING"); provision_no_net(); }
break;
case SC_PAIR:
if (ok) Serial.printf("[info] dev=%s api=%s user=%s token=%d\n",
g_ui.device_id, g_ui.api, g_ui.owner, (int)strlen(g_token));
/* WiFi 连上但后端不通(换了网段、地址填错)时,配对页是唯一停留点,
没有配网出口就只能拆机接串口,这里把 KEY2 让给它 */
if (ok) {
Serial.printf("[info] dev=%s api=%s user=%s token=%d\n",
g_ui.device_id, g_ui.api, g_ui.owner, (int)strlen(g_token));
Serial.println("[key] reprovision from PAIR");
start_provision("MANUAL SETUP REQUESTED");
}
if (ref) request_code();
break;
case SC_MODE:
if (up && g_ui.mode_sel > 0) { g_ui.mode_sel--; g_dirty = true; }
if (dn && g_ui.mode_sel < 1) { g_ui.mode_sel++; g_dirty = true; }
if (ok) choose_mode(g_ui.mode_sel);
if (ref) { Serial.println("[key] open settings"); set_screen(SC_SETTINGS); }
break;
case SC_SETTINGS:
/* 这页只读;要改还是去配网门户。keep_sta:调试时 STA 不断,
门户同时挂在局域网那一侧,同一网段还能 curl http://<设备IP>/ */
if (ok) { Serial.println("[key] open setup portal from SETTINGS"); start_provision("MANUAL SETUP REQUESTED", true); }
if (ref) open_mode();
break;
case SC_LIST:
if (up && g_ui.sel > 0) { g_ui.sel--; g_dirty = true; }
if (dn && g_snap.count && g_ui.sel < g_snap.count - 1) { g_ui.sel++; g_dirty = true; }
if (ok) { g_ui.screen = SC_DETAIL; g_ui.detail_tab = 0; g_dirty = true; }
if (ref) load_data(true);
if (ref) open_mode(); /* KEY3 换成回模式选择页 */
break;
case SC_DETAIL:
/* 详情页 KEY3 改成右栏分页;刷新由进入列表时的 5 分钟轮询覆盖 */
@ -302,9 +590,26 @@ static void on_key_press(uint16_t bits)
if (ok) { g_ui.screen = SC_LIST; g_dirty = true; }
if (ref) { g_ui.detail_tab ^= 1; g_dirty = true; }
break;
case SC_ERROR:
case SC_ROCKETS:
if (up && g_ui.rsel > 0) { g_ui.rsel--; g_dirty = true; }
if (dn && g_rsnap.count && g_ui.rsel < g_rsnap.count - 1) { g_ui.rsel++; g_dirty = true; }
if (ok) load_rocket_detail();
if (ref) open_mode();
break;
case SC_ROCKET:
/* 上下直接换型号:明细只有一个型号的在内存里,换型号必须重新拉 */
if (up && g_ui.rsel > 0) { g_ui.rsel--; load_rocket_detail(); }
if (dn && g_rsnap.count && g_ui.rsel < g_rsnap.count - 1) { g_ui.rsel++; load_rocket_detail(); }
if (ok) { g_ui.screen = SC_ROCKETS; g_dirty = true; }
if (ref) { g_ui.rocket_tab = (g_ui.rocket_tab + 1) % 3; g_dirty = true; }
break;
case SC_LOADING:
if (ref) load_data(true);
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);
break;
default:
break;
@ -335,9 +640,14 @@ static void print_help()
Serial.println(F("help this text"));
Serial.println(F("wifi <ssid> [pass] set credentials and connect"));
Serial.println(F("api <url> backend base url, e.g. http://192.168.31.2:8000/api"));
Serial.println(F("cfg print saved ssid/pass/api (before moving the board)"));
Serial.println(F("pair drop token and request a new binding code"));
Serial.println(F("reload refetch followed bodies"));
Serial.println(F("portal open the setup hotspot"));
Serial.println(F("reload refetch the active mode (bodies or rockets)"));
Serial.println(F("mode [bodies|rockets|clear] show / switch / forget the terminal mode"));
Serial.println(F("rockets dump the cached rocket snapshot"));
Serial.println(F("settings show the wifi / server settings screen"));
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"));
Serial.println(F("keys print raw key bitmap (check polarity)"));
Serial.println(F("xlreg dump all XL9555 registers (input/output/config)"));
@ -349,7 +659,7 @@ static void print_help()
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("reset wipe NVS and reboot"));
Serial.println(F("reboot restart, keep NVS (reset wipes it!)"));
}
static void print_stat()
@ -364,11 +674,31 @@ static void print_stat()
Serial.printf("token : %d bytes user=%s\n", (int)strlen(g_token), g_ui.owner);
if (g_ui.code[0]) Serial.printf("pair code : %s (%ds left)\n", g_ui.code, g_ui.code_left);
else Serial.println(F("pair code : -"));
Serial.printf("mode : %s\n", (g_mode < 0) ? "not chosen" : (g_mode ? "rockets" : "bodies"));
Serial.printf("bodies : %d, sel=%d\n", g_snap.count, g_ui.sel);
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("uptime : %lus\n", (unsigned long)(millis() / 1000));
}
/* 换环境第一步:先问板子它眼里有哪些网络。S3 只有 2.4G 射频,
5G SSID 在它这里根本不存在,别拿"手机能连"当判据。 */
static void wifi_scan_print()
{
Serial.println(F("[scan] scanning all 2.4GHz channels ..."));
int n = WiFi.scanNetworks(false, true, true);
if (n == WIFI_SCAN_FAILED) { Serial.println(F("[scan] scan failed (radio busy?)")); return; }
if (n == 0) { Serial.println(F("[scan] NO NETWORK VISIBLE - check antenna/2.4GHz band")); return; }
for (int i = 0; i < n; i++) {
Serial.printf("%2d ch%-2d rssi=%-4d %-8s %s\n", i + 1, WiFi.channel(i), WiFi.RSSI(i),
WiFi.encryptionType(i) == WIFI_AUTH_OPEN ? "open" : "locked",
WiFi.SSID(i).c_str());
}
Serial.printf("[scan] %d network(s) visible\n", n);
WiFi.scanDelete();
}
static void handle_command(char *line)
{
while (*line == ' ') line++;
@ -380,6 +710,8 @@ static void handle_command(char *line)
if (!strcmp(line, "help")) {
print_help();
} else if (!strcmp(line, "scan")) {
wifi_scan_print();
} else if (!strcmp(line, "wifi")) {
char *pass = strchr(args, ' ');
if (pass) { *pass++ = 0; while (*pass == ' ') pass++; }
@ -387,6 +719,7 @@ static void handle_command(char *line)
store_set_str(K_SSID, args);
store_set_str(K_PASS, pass ? pass : "");
Serial.printf("[cmd] wifi ssid=%s pass=%d chars\n", args, pass ? (int)strlen(pass) : 0);
g_wifi_try = 0;
WiFi.disconnect();
wifi_connect();
} else if (!strcmp(line, "api")) {
@ -394,15 +727,57 @@ static void handle_command(char *line)
store_set_str(K_API, args);
strlcpy(g_ui.api, args, sizeof(g_ui.api));
Serial.printf("[cmd] api=%s\n", g_ui.api);
if (g_token[0]) load_data(true); else start_pairing();
if (g_token[0]) enter_terminal(); else start_pairing();
} else if (!strcmp(line, "pair")) {
g_token[0] = 0;
store_erase(K_TOKEN);
start_pairing();
} else if (!strcmp(line, "reload")) {
load_data(true);
refresh_active(true);
} else if (!strcmp(line, "mode")) {
if (!args[0]) {
Serial.printf("mode=%s\n", (g_mode < 0) ? "unset" : (g_mode ? "rockets" : "bodies"));
} else if (!strcmp(args, "bodies")) {
choose_mode(0);
} else if (!strcmp(args, "rockets")) {
choose_mode(1);
} else if (!strcmp(args, "clear")) {
g_mode = -1;
g_ui.mode = -1;
store_erase(K_MODE);
open_mode();
} else {
Serial.println(F("usage: mode [bodies|rockets|clear]"));
}
} else if (!strcmp(line, "rockets")) {
for (int i = 0; i < g_rsnap.count; i++) {
const RocketData &r = g_rsnap.rockets[i];
Serial.printf("%2d %-14s %-12s H%-6.1f PAY%-8.0f THR%-8.0f art=%u up=%u\n",
i, r.code, r.name, r.height_m, r.payload_kg, r.thrust_kn,
(unsigned)r.art_ver, (unsigned)r.upcoming);
}
if (!g_rsnap.count) Serial.println(F("(no rocket snapshot yet)"));
} else if (!strcmp(line, "settings")) {
set_screen(SC_SETTINGS);
} else if (!strcmp(line, "portal")) {
start_provision();
if (!strcmp(args, "lan")) {
/* 热点照开,但 STA 不断:门户同时挂在局域网那一侧,
同一网段的电脑直接 curl http://<设备IP> 就能验证门户在不在服务 */
start_provision("MANUAL SETUP REQUESTED (LAN)", true);
if (WiFi.status() == WL_CONNECTED)
Serial.printf("[portal] 同一网段也可用 http://%s/\n",
WiFi.localIP().toString().c_str());
return;
}
start_provision("MANUAL SETUP REQUESTED");
} else if (!strcmp(line, "cfg")) {
/* 换环境前先把板子里存的凭据抄下来:拿不存在的网络试完配网还能原样填回去 */
char ssid[33], pass[65], api[96];
if (!store_get_str(K_SSID, ssid, sizeof(ssid))) strlcpy(ssid, "(none)", sizeof(ssid));
if (!store_get_str(K_PASS, pass, sizeof(pass))) strlcpy(pass, "(none)", sizeof(pass));
if (!store_get_str(K_API, api, sizeof(api))) strlcpy(api, DEFAULT_API, sizeof(api));
Serial.printf("ssid=%s" "\n" "pass=%s" "\n" "api=%s" "\n", ssid, pass, api);
Serial.println(F("restore with: wifi <ssid> <pass> then api <url>"));
} else if (!strcmp(line, "stat")) {
print_stat();
} else if (!strcmp(line, "keys")) {
@ -447,7 +822,12 @@ static void handle_command(char *line)
} else if (!strcmp(line, "reset")) {
Serial.println(F("[cmd] wiping NVS"));
store_erase(K_SSID); store_erase(K_PASS); store_erase(K_API);
store_erase(K_TOKEN); store_erase(K_USER);
store_erase(K_TOKEN); store_erase(K_USER); store_erase(K_MODE);
delay(200);
ESP.restart();
} else if (!strcmp(line, "reboot")) {
/* 只是重启:调试时别手滑用 reset,那个把 ssid/api/token 一起清了 */
Serial.println(F("[cmd] rebooting"));
delay(200);
ESP.restart();
} else {
@ -489,6 +869,13 @@ void setup()
if (!disp_init()) Serial.println(F("[disp] init failed"));
g_ui.snap = &g_snap;
g_ui.rsnap = &g_rsnap;
g_ui.rdet = &g_rdet;
g_mode = mode_load();
g_ui.mode = g_mode;
Serial.printf("[store] mode=%s\n", g_mode < 0 ? "unset" : (g_mode ? "rockets" : "bodies"));
bool has_token = store_get_str(K_TOKEN, g_token, sizeof(g_token));
if (!has_token) g_token[0] = 0;
Serial.printf("[store] token=%s\n", g_token[0] ? "loaded" : "none");
@ -508,6 +895,7 @@ void loop()
uint32_t now = millis();
if (!g_ui_paused) {
net_watch(now);
switch (g_ui.screen) {
case SC_PROVISION:
portal_loop();
@ -525,10 +913,20 @@ void loop()
break;
case SC_LIST:
case SC_DETAIL:
case SC_ROCKETS:
case SC_ROCKET:
run_tick(now);
break;
case SC_MODE:
case SC_SETTINGS:
/* 单独一个钟:从列表页退回来时它是过去时刻,所以进这两页先复核一次 */
if ((int32_t)(now - g_next_idle) >= 0) {
g_next_idle = now + IDLE_CHECK_MS;
auth_check();
}
break;
case SC_ERROR:
if ((int32_t)(now - g_retry_at) >= 0) { g_retry_at = now + 15000; load_data(true); }
if ((int32_t)(now - g_retry_at) >= 0) { g_retry_at = now + 15000; refresh_active(true); }
break;
default:
break;

View File

@ -212,15 +212,15 @@ bool api_follows(const char *base, const char *token, Snapshot *out, int *http_s
return true;
}
bool api_icon(const char *base, const char *token, const char *body_id, int size,
void *dst, size_t cap, int *http_status)
/* 定长裸点阵下载。天体图标和火箭立绘拿到的是同一种东西:size*size*2 字节、
不带 alpha 的大端 RGB565,贴到帧缓冲上靠叠加混合,所以共用这一条流水线。 */
static bool http_raw(const char *url, const char *token, void *dst, size_t cap, int *http_status)
{
String url = String(base) + "/terminal/bodies/" + body_id + "/icon?size=" + size;
auto tls = tls_make(url.c_str()); /* 声明在 http 之前,见 http_begin 注释 */
auto tls = tls_make(url); /* 声明在 http 之前,见 http_begin 注释 */
HTTPClient http;
http.setConnectTimeout(6000);
http.setTimeout(8000);
http_begin(http, url.c_str(), tls);
http_begin(http, url, tls);
if (token && *token) http.addHeader("Authorization", String("Bearer ") + token);
int code = http.GET();
if (http_status) *http_status = code;
@ -244,3 +244,94 @@ bool api_icon(const char *base, const char *token, const char *body_id, int size
for (size_t i = 0; i < cap / 2; i++) px[i] = __builtin_bswap16(px[i]);
return true;
}
bool api_icon(const char *base, const char *token, const char *body_id, int size,
void *dst, size_t cap, int *http_status)
{
String url = String(base) + "/terminal/bodies/" + body_id + "/icon?size=" + size;
return http_raw(url.c_str(), token, dst, cap, http_status);
}
bool api_rocket_art(const char *base, const char *token, const char *code, int size,
void *dst, size_t cap, int *http_status)
{
String url = String(base) + "/terminal/rockets/" + code + "/art?size=" + size;
return http_raw(url.c_str(), token, dst, cap, http_status);
}
/* ---------------- 火箭列表 / 详情 ---------------- */
static void read_rocket_core(JsonVariant r, RocketData &d)
{
strlcpy(d.code, r["code"] | "", sizeof(d.code));
d.art_ver = r["art_ver"] | 0u;
strlcpy(d.name, r["name"] | "?", sizeof(d.name));
copy_utf8(d.name_zh, sizeof(d.name_zh), r["name_zh"] | "");
d.height_m = r["height_m"] | 0.0f;
d.diameter_m = r["diameter_m"] | 0.0f;
d.payload_kg = r["payload_mass_kg"] | 0.0f;
d.orbit_km = r["target_orbit_km"] | 0.0f;
d.thrust_kn = r["thrust_kn"] | 0.0f;
d.engines = (uint8_t)(r["engines"] | 0);
d.boosters = (uint8_t)(r["boosters"] | 0);
d.upcoming = (uint16_t)(r["upcoming"] | 0);
}
bool api_rockets(const char *base, const char *token, RocketSnapshot *out, int *http_status)
{
String url = String(base) + "/terminal/rockets";
JsonDocument doc;
if (!http_json(url.c_str(), NULL, token, doc, http_status)) {
Serial.printf("[api] rockets http=%d\n", http_status ? *http_status : 0);
return false;
}
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"] | "");
out->count = 0;
out->fetched_ms = millis();
for (JsonVariant r : doc["rockets"].as<JsonArray>()) {
if (out->count >= MAX_ROCKETS) break;
read_rocket_core(r, out->rockets[out->count++]);
}
Serial.printf("[api] rockets user=%s n=%d\n", out->username, out->count);
return true;
}
bool api_rocket(const char *base, const char *token, const char *code,
RocketDetail *out, int *http_status)
{
String url = String(base) + "/terminal/rockets/" + code;
JsonDocument doc;
if (!http_json(url.c_str(), NULL, token, doc, http_status)) {
Serial.printf("[api] rocket http=%d\n", http_status ? *http_status : 0);
return false;
}
memset(out, 0, sizeof(*out));
read_rocket_core(doc, out->base);
copy_utf8(out->desc, sizeof(out->desc), doc["description"] | "");
out->s1_thrust_kn = doc["s1_thrust_kn"] | 0.0f;
out->s1_isp = doc["s1_isp_s"] | 0.0f;
out->s2_thrust_kn = doc["s2_thrust_kn"] | 0.0f;
out->s2_isp = doc["s2_isp_s"] | 0.0f;
out->booster_thrust_kn = doc["booster_thrust_kn"] | 0.0f;
out->s1_engines = (uint8_t)(doc["s1_engines"] | 0);
out->s2_engines = (uint8_t)(doc["s2_engines"] | 0);
out->s1_recoverable = doc["s1_recoverable"].as<bool>();
out->booster_recoverable = doc["booster_recoverable"].as<bool>();
out->fairing = doc["fairing"].as<bool>();
out->event_total = (uint16_t)(doc["event_total"] | 0);
copy_iso(out->next_date, sizeof(out->next_date), doc["next_net"] | "");
for (JsonVariant e : doc["events"].as<JsonArray>()) {
if (out->ev_count >= MAX_ROCKET_EV) break;
copy_title(out->ev[out->ev_count].name, sizeof(out->ev[0].name), e["name"] | "");
copy_iso(out->ev[out->ev_count].date, sizeof(out->ev[0].date), e["net"] | "");
if (strlen(out->ev[out->ev_count].date) > 16) out->ev[out->ev_count].date[16] = 0;
out->ev_count++;
}
Serial.printf("[api] rocket %s ev=%d/%d\n", out->base.code, out->ev_count, out->event_total);
return true;
}

View File

@ -51,3 +51,56 @@ bool api_follows(const char *base, const char *token, Snapshot *out, int *http_s
* 字节序),可直接喂给 disp_add_bitmap。尺寸不符或读不满都算失败(404=没维护图标) */
bool api_icon(const char *base, const char *token, const char *body_id, int size,
void *dst, size_t cap, int *http_status);
/* ---------------- 火箭模式 ---------------- */
#define MAX_ROCKETS 12
#define MAX_ROCKET_EV 3
struct RocketData {
char code[24]; /* 后端型号 code,拉取立绘要用 */
uint32_t art_ver; /* 参数哈希:变了才重新下载立绘点阵,0=没拿到 */
char name[24];
char name_zh[24];
float height_m, diameter_m;
float payload_kg, orbit_km, thrust_kn;
uint8_t engines, boosters; /* 芯级发动机数 / 捆绑助推器数 */
uint16_t upcoming; /* 待发射任务数 */
};
struct RocketSnapshot {
char username[24];
char server_time[20];
uint8_t count;
uint32_t fetched_ms;
RocketData rockets[MAX_ROCKETS];
};
struct RocketEvent {
char name[44]; /* 任务名(后端 mission_name),超宽由 text_elided 中间省略 */
char date[16]; /* "2026-10-15 14:30" */
};
struct RocketDetail {
RocketData base; /* code/art_ver/名称/主要参数都在这 */
char desc[108];
float s1_thrust_kn, s1_isp;
float s2_thrust_kn, s2_isp;
float booster_thrust_kn;
uint8_t s1_engines, s2_engines;
bool s1_recoverable, booster_recoverable, fairing;
RocketEvent ev[MAX_ROCKET_EV];
uint8_t ev_count;
uint16_t event_total;
char next_date[16];
};
/** 拉取平台启用的火箭列表;失败返回 false,http 非 0 时为状态码 */
bool api_rockets(const char *base, const char *token, RocketSnapshot *out, int *http_status);
/** 拉取单个型号的详细参数 + 最近的发射任务 */
bool api_rocket(const char *base, const char *token, const char *code,
RocketDetail *out, int *http_status);
/** 拉取后端按参数画出来的火箭立绘:size x size 的 RGB565 裸点阵(大端 -> 本机字节序) */
bool api_rocket_art(const char *base, const char *token, const char *code, int size,
void *dst, size_t cap, int *http_status);

View File

@ -385,11 +385,24 @@ void disp_text_clipped(int x, int y, int maxw, const char *s, uint8_t size, uint
disp_text(x + used, y, "..", size, fg, bg);
}
/* 这些中文标点按排版规矩不能出现在行首(","顶格最难看) */
static bool cjk_no_lead(uint32_t cp)
{
switch (cp) {
case 0x3002: case 0xFF0C: case 0x3001: case 0xFF1B: case 0xFF1A:
case 0xFF1F: case 0xFF01: case 0xFF09: case 0x300B: case 0x3011:
case 0x201D: case 0x2019: case 0xFF05:
return true;
default: return false;
}
}
int disp_text_wrap(int x, int y, int maxw, const char *s, uint8_t size, uint16_t fg, uint16_t bg, int max_lines)
{
if (!s) return y;
char line[192];
int n = 0, cur = 0, rows = 0;
int prev_len = 0, prev_adv = 0; /* 上一个 token 的字节数/宽度,标点换行要把它带下去 */
const char *p = s;
while (*p && rows < max_lines) {
int tl = 0, tadv = 0;
@ -405,16 +418,26 @@ 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 (cur && cur + tadv > maxw) {
uint32_t ncp = 0;
bool pull = ((uint8_t)*p >= 0x80) && prev_len && prev_adv < cur &&
utf8_next(p, &ncp) && cjk_no_lead(ncp);
if (pull) { n -= prev_len; cur -= prev_adv; } /* 行首留标点 -> 连前一个字一起换行 */
line[n] = 0;
disp_text(x, y, line, size, fg, bg);
y += size + 3;
rows++;
n = 0; cur = 0;
if (pull) {
for (int i = 0; i < prev_len; i++) line[n++] = p[0 - prev_len + i];
cur = prev_adv;
} else {
n = 0; cur = 0;
}
if (rows >= max_lines) break;
}
for (int i = 0; i < tl && n < (int)sizeof(line) - 4; i++) line[n++] = p[i];
cur += tadv;
p += tl;
prev_len = tl; prev_adv = tadv;
}
line[n] = 0;
if (n) { disp_text(x, y, line, size, fg, bg); y += size + 3; }

File diff suppressed because it is too large Load Diff

View File

@ -14,7 +14,7 @@ extern const IconArt ic_planet_list; /* 行星小.jpeg */
extern const IconArt ic_jupiter_list; /* 木星小.jpeg */
extern const IconArt ic_saturn_list; /* 土星小.jpeg */
extern const IconArt ic_mars_list; /* 火星小.jpeg */
extern const IconArt ic_earth_list; /* 地球小.jpeg */
extern const IconArt ic_earth_list; /* 地球-2小.jpeg */
extern const IconArt ic_earth_icon_list; /* 地球-图标小.jpeg */
extern const IconArt ic_venus_list; /* 金星(图标)小.jpeg */
extern const IconArt ic_neptune_list; /* 海王星小.jpeg */
@ -44,6 +44,10 @@ extern const IconArt ic_satellite_detail;
extern const IconArt ic_probe_detail;
extern const IconArt ic_shuttle_detail;
extern const IconArt ic_rover_detail;
extern const IconArt ic_mode_planet_96; /* 96x96 */
extern const IconArt ic_mode_rocket_96; /* 96x96 */
extern const IconArt ic_rocket_list; /* 40x40 */
extern const IconArt ic_rocket_detail; /* 64x64 */
/** name/name_zh 小写子串命中优先,其次按 type 兜底;detail!=0 取大图 */
const IconArt *icon_for(const char *name, const char *name_zh, const char *type, int detail);

View File

@ -9,6 +9,7 @@
static DNSServer s_dns;
static WebServer s_server(80);
static bool s_saved = false;
static bool s_routed = false;
static const char *PAGE_HEAD =
"<meta name=viewport content='width=device-width,initial-scale=1'>"
@ -18,19 +19,35 @@ static const char *PAGE_HEAD =
static void handle_root()
{
char api[96] = {0};
char api[96] = {0}, saved[33] = {0};
if (!store_get_str(K_API, api, sizeof(api))) strcpy(api, "https://cosmo.unisspace.com/api");
store_get_str(K_SSID, saved, sizeof(saved));
int n = WiFi.scanNetworks();
String opts;
/* 第一项是"不动 WiFi 只改后端地址":换开发机 IP 时不必重输密码 */
String opts = "<option value=''>\xe4\xb8\x8d\xe6\x94\xb9\x20\x57\x69\x46\x69\xef\xbc\x8c\xe5\x8f\xaa\xe4\xbf\x9d\xe5\xad\x98\xe5\x90\x8e\xe7\xab\xaf\xe5\x9c\xb0\xe5\x9d\x80</option>";
for (int i = 0; i < n; i++) {
bool cur = saved[0] && WiFi.SSID(i) == saved;
opts += "<option value='";
opts += WiFi.SSID(i);
opts += "'>";
opts += "'";
if (cur) opts += " selected";
opts += ">";
opts += WiFi.SSID(i);
opts += " (";
opts += String(WiFi.RSSI(i));
opts += " dBm)</option>";
opts += " dBm)";
if (cur) opts += " \xe2\x86\x90\xe5\xbd\x93\xe5\x89\x8d";
opts += "</option>";
}
/* 一个热点都没扫到(路由器只开 5G、或 SSID 隐藏)时,
下拉框会是空的,用户就没法配网了,这时给个手填入口 */
if (n <= 0) {
opts += "<option value=''>\xe6\x9c\xaa\xe6\x89\xab\xe6\x8f\x8f\xe5\x88\xb0\x20\x32\x2e\x34\x47\x20\xe7\x83\xad\xe7\x82\xb9</option>";
/* 扫不到但存过凭据:至少让用户把原网络再选回来 */
if (saved[0]) opts += "<option value='" + String(saved) + "' selected>" + String(saved) +
" (\xe5\xbd\x93\xe5\x89\x8d\xe4\xbf\x9d\xe5\xad\x98\x29</option>";
}
String page = "<html><head><meta charset=utf-8>";
@ -38,32 +55,56 @@ static void handle_root()
page += "</head><body><h3>COSMO \xe7\xbb\x88\xe7\xab\xaf\xe9\x85\x8d\xe7\xbd\x91</h3>"; /* 终端配网 */
page += "<form method=POST action=/join>";
page += "<label>WiFi</label><select name=ssid>" + opts + "</select>";
page += "<label>\xe5\xaf\x86\xe7\xa0\x81</label><input name=pass type=text>"; /* 密码 */
/* 列表里没有想连的热点时直接填名称,填了就覆盖下拉框的选择 */
page += "<label>\xe6\x89\x8b\xe5\x8a\xa8\xe8\xbe\x93\xe5\x85\xa5 SSID\xef\xbc\x88\xe5\x8f\xaf\xe7\x95\x99\xe7\xa9\xba\xef\xbc\x89</label><input name=ssid_manual>";
page += "<label>\xe5\xaf\x86\xe7\xa0\x81\xef\xbc\x88\xe8\xbf\x9e\xe5\x9b\x9e\xe5\xbd\x93\xe5\x89\x8d\xe7\xbd\x91\xe7\xbb\x9c\xe5\x8f\xaf\xe7\x95\x99\xe7\xa9\xba\xef\xbc\x89</label><input name=pass type=text>";
page += "<label>\xe5\x90\x8e\xe7\xab\xaf\xe5\x9c\xb0\xe5\x9d\x80</label><input name=api value='"; /* 后端地址 */
page += api;
page += "'><br><button type=submit>\xe4\xbf\x9d\xe5\xad\x98</button></form>"; /* 保存 */
page += "<p style='color:#8ab;font-size:13px'>\xe4\xbf\x9d\xe5\xad\x98\xe5\x90\x8e\xe8\xae\xbe\xe5\xa4\x87\xe8\x87\xaa\xe5\x8a\xa8\xe9\x87\x8d\xe5\x90\xaf</p>";
page += "<p style='color:#8ab;font-size:13px'>\xe4\xbb\x85\xe6\x94\xaf\xe6\x8c\x81 2.4GHz\xef\xbc\x8c\xe4\xbf\x9d\xe5\xad\x98\xe5\x90\x8e\xe8\xae\xbe\xe5\xa4\x87\xe8\x87\xaa\xe5\x8a\xa8\xe9\x87\x8d\xe5\x90\xaf</p>";
page += "</body></html>";
s_server.send(200, "text/html", page);
}
static void handle_join()
{
String ssid = s_server.hasArg("ssid") ? s_server.arg("ssid") : "";
String pass = s_server.hasArg("pass") ? s_server.arg("pass") : "";
String api = s_server.hasArg("api") ? s_server.arg("api") : "";
ssid.trim(); api.trim();
if (!ssid.length()) {
s_server.send(400, "text/plain", "missing ssid");
String man = s_server.hasArg("ssid_manual") ? s_server.arg("ssid_manual") : "";
ssid.trim(); pass.trim(); api.trim(); man.trim();
if (man.length()) ssid = man;
char saved[33] = {0}, cur_api[96] = {0};
store_get_str(K_SSID, saved, sizeof(saved));
store_get_str(K_API, cur_api, sizeof(cur_api));
bool wifi_changed = ssid.length() && strcmp(ssid.c_str(), saved);
bool touched = false;
/* SSID 留空 = WiFi 一点不动,只改后端地址;
选回当前网络又没填密码 = 沿用存过的密码。
换开发机 IP 是最常见的一次改动,不该逼人把 WiFi 密码重新抄一遍。 */
if (ssid.length()) {
if (wifi_changed) { store_set_str(K_SSID, ssid.c_str()); touched = true; }
if (wifi_changed || pass.length()) { store_set_str(K_PASS, pass.c_str()); touched = true; }
}
if (api.length() && strcmp(api.c_str(), cur_api)) {
store_set_str(K_API, api.c_str());
touched = true;
}
Serial.printf("[portal] ssid=%s(%s) pass=%s api=%s\n",
ssid.length() ? ssid.c_str() : saved, wifi_changed ? "changed" : "kept",
pass.length() ? "updated" : "unchanged",
api.length() ? api.c_str() : "(kept)");
if (!touched) {
s_server.send(200, "text/html",
"<html><meta charset=utf-8><body style='font-family:system-ui;"
"background:#04121a;color:#cfe;padding:16px'>没有需要保存的改动</body></html>");
return;
}
store_set_str(K_SSID, ssid.c_str());
store_set_str(K_PASS, pass.c_str());
if (api.length()) store_set_str(K_API, api.c_str());
Serial.printf("[portal] saved ssid=%s api=%s\n", ssid.c_str(), api.c_str());
s_server.send(200, "text/html",
"<html><meta charset=utf-8><body style='font-family:system-ui'>"
"\xe5\xb7\xb2\xe4\xbf\x9d\xe5\xad\x98\xef\xbc\x8c\xe8\xae\xbe\xe5\xa4\x87\xe6\xad\xa3\xe5\x9c\xa8\xe9\x87\x8d\xe5\x90\xaf</body></html>");
"已保存,设备正在重启</body></html>");
s_saved = true;
}
@ -74,19 +115,42 @@ static void handle_captive()
s_server.send(302, "text/plain", "");
}
void portal_start(const char *ap_ssid, const char *api_default)
void portal_start(const char *ap_ssid, const char *api_default, bool keep_sta)
{
WiFi.mode(WIFI_MODE_AP);
/* keep_sta:调试用。原有 STA 连接不断,门户同时挂在局域网那一侧,
同一网段直接浏览器/curl 打开设备 IP 就能验证门户在不在服务,不用先连热点。 */
WiFi.mode(keep_sta ? WIFI_MODE_APSTA : WIFI_MODE_AP);
WiFi.softAP(ap_ssid);
s_saved = false;
s_dns.start(53, "*", WiFi.softAPIP());
s_server.on("/", HTTP_GET, handle_root);
s_server.on("/join", HTTP_POST, handle_join);
s_server.on("/generate_204", handle_captive);
s_server.on("/hotspot-detect.html", handle_captive);
s_server.on("/connecttest.txt", handle_captive);
s_server.onNotFound(handle_captive);
if (!s_routed) { /* 路由只注册一次:反复开热点会越堆越多 */
s_server.on("/", HTTP_GET, handle_root);
s_server.on("/join", HTTP_POST, handle_join);
s_server.on("/generate_204", handle_captive);
s_server.on("/hotspot-detect.html", handle_captive);
s_server.on("/connecttest.txt", handle_captive);
s_server.onNotFound(handle_captive);
s_routed = true;
}
/* begin() 每轮都要调:portal_stop() 里的 close() 只关监听,路由留给下次。
放在 if 里会让第二次及以后开的热点能连上但打不开页面(换环境时最容易踩)。 */
s_server.begin();
Serial.printf("[portal] AP=%s api=%s ip=%s\n", ap_ssid, api_default, WiFi.softAPIP().toString().c_str());
Serial.printf("[portal] AP=%s api=%s ip=%s", ap_ssid, api_default,
WiFi.softAPIP().toString().c_str());
if (keep_sta) Serial.printf(" lan=%s", WiFi.localIP().toString().c_str());
Serial.println();
}
/* 退出配网:关掉热点和 DNS,把射频交还 STA,让主循环拿 NVS 里的旧凭据再试一次。
没有这一步,误进配网页就只能重输 WiFi 密码或拔电。 */
void portal_stop()
{
Serial.println(F("[portal] hotspot closed"));
s_server.close(); /* 只停监听,路由留给下次 */
s_dns.stop();
WiFi.softAPdisconnect(true);
WiFi.mode(WIFI_MODE_STA);
s_saved = false;
}
void portal_loop()

View File

@ -2,6 +2,7 @@
#pragma once
#include <stdbool.h>
void portal_start(const char *ap_ssid, const char *api_default);
void portal_start(const char *ap_ssid, const char *api_default, bool keep_sta = false);
void portal_stop(); /* 关热点,拿旧凭据重试 */
void portal_loop();
bool portal_saved(); /* 收到表单后置位,主循环据此重启 */

View File

@ -0,0 +1,120 @@
#include <Arduino.h>
#include <esp_heap_caps.h>
#include <string.h>
#include "rocketstore.h"
#define SLOT_ART 2 /* [0]=列表 40x40 [1]=详情 64x64 */
typedef struct {
char code[24]; /* 占位的型号 code,空槽为空串 */
uint32_t ver[SLOT_ART]; /* 这张点阵对应的参数版本,0 = 还没拉到 */
uint16_t *px[SLOT_ART];
IconArt art[SLOT_ART];
} RocketSlot;
/* 一个型号一个槽,参数改过就是重新下载,不额外占内存 */
static RocketSlot s_slot[MAX_ROCKETS];
static const uint8_t s_size[SLOT_ART] = { ICON_LIST_W, ICON_DETAIL_W };
static RocketSlot *slot_find(const char *code)
{
for (int i = 0; i < MAX_ROCKETS; i++)
if (s_slot[i].code[0] && !strcmp(s_slot[i].code, code)) return &s_slot[i];
return NULL;
}
/* 后台停用一个型号之后把它的槽丢掉(缓冲区留着复用),别让它一直占着版本号 */
static void slot_prune(const RocketSnapshot *snap)
{
for (int i = 0; i < MAX_ROCKETS; i++) {
RocketSlot *s = &s_slot[i];
if (!s->code[0]) continue;
bool still_listed = false;
for (int n = 0; n < snap->count; n++)
if (!strcmp(snap->rockets[n].code, s->code)) { still_listed = true; break; }
if (!still_listed) { s->code[0] = 0; s->ver[0] = s->ver[1] = 0; }
}
}
static RocketSlot *slot_claim(const char *code)
{
RocketSlot *free_slot = NULL;
for (int i = 0; i < MAX_ROCKETS; i++) {
RocketSlot *s = &s_slot[i];
if (s->code[0] && !strcmp(s->code, code)) return s;
if (!s->code[0] && !free_slot) free_slot = s;
}
if (!free_slot) free_slot = &s_slot[0]; /* 满员(型号数超过 MAX_ROCKETS 才会)就抢占 */
strlcpy(free_slot->code, code, sizeof(free_slot->code));
free_slot->ver[0] = free_slot->ver[1] = 0;
return free_slot;
}
static bool slot_fetch(RocketSlot *s, const char *base, const char *token, int k, uint32_t ver)
{
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("[art] %s no PSRAM for %dx%d\n", s->code, s_size[k], s_size[k]); return false; }
}
int http = 0;
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;
return true;
}
static bool slot_ready(const RocketSlot *s, int k, uint32_t ver)
{
return s->px[k] && s->ver[k] == ver;
}
const IconArt *rocket_store_get(const char *code, uint32_t art_ver, int detail)
{
if (!art_ver || !code || !code[0]) return NULL;
const RocketSlot *s = slot_find(code);
if (!s) return NULL;
int k = detail ? 1 : 0;
return slot_ready(s, k, art_ver) ? &s->art[k] : NULL;
}
bool rocket_store_ensure(const char *base, const char *token,
const char *code, uint32_t art_ver, int detail)
{
if (!base || !base[0] || !token || !token[0] || !code || !code[0] || !art_ver) return false;
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;
}
void rocket_store_sync(const char *base, const char *token, const RocketSnapshot *snap)
{
if (!base || !base[0] || !token || !token[0] || !snap) return;
slot_prune(snap);
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);
}
}
void rocket_store_dump(void)
{
for (int i = 0; i < MAX_ROCKETS; i++) {
RocketSlot *s = &s_slot[i];
if (!s->code[0]) continue;
Serial.printf("art : %s v%lu %s%s\n", s->code, (unsigned long)s->ver[0],
s->px[0] ? "40" : "-", s->px[1] ? " 64" : "");
}
}

View File

@ -0,0 +1,18 @@
/** 后端按火箭参数画出来的立面图缓存(和天体图标一样放 PSRAM、叠加混合用)。
* 列表只缺 40x40,进详情才拉 64x64:型号可能很多,不做一次性全量下载。 */
#pragma once
#include "api.h"
#include "icons.h"
/** 缓存里有这个型号的图就返回它,否则返回 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);
/** 补齐某个型号的某个尺寸;进详情页时拉 64x64 用。失败返回 false,画面退回内置线稿 */
bool rocket_store_ensure(const char *base, const char *token,
const char *code, uint32_t art_ver, int detail);
/** 串口调试:逐槽打印 code / 版本 / 是否已缓存 */
void rocket_store_dump(void);

View File

@ -13,3 +13,4 @@ void store_erase(const char *key);
#define K_API "api"
#define K_TOKEN "token"
#define K_USER "user"
#define K_MODE "mode"

View File

@ -5,6 +5,7 @@
#include <ctype.h>
#include "ui.h"
#include "iconstore.h"
#include "rocketstore.h"
#include "display.h"
#include "icons.h"
#include "board_config.h"
@ -35,6 +36,85 @@ static void clip_chars(char *dst, size_t cap, const char *src, int max_chars)
if (src[n] && used + 2 < (int)cap) { dst[used++] = '.'; dst[used++] = '.'; dst[used] = 0; }
}
/* 一行放不下的发射任务名。disp_text_clipped 只保头,"Starlink Group 15-25" 会被打成
"Starlink Group ..",偏偏编号才是区分两行 Starlink 的唯一信息,所以这里反过来:
尾巴(末尾几个完整词)优先保住,".." 放到中间。 */
static void text_elided(int x, int y, int maxw, const char *s, uint16_t fg, uint16_t bg)
{
if (!s) return;
if (disp_text_width(s, 16, 1) <= maxw) { disp_text(x, y, s, 16, fg, bg); return; }
int room = maxw - disp_text_width("..", 16, 1);
if (room < 24) { disp_text(x, y, "..", 16, fg, bg); return; }
/* 头和尾之间不许留白:留白了 "..15-25" 会看起来像右边那一列日期,所以头部预算
直接吃满 room - tw,切在词中间也照切,保证 "Starlink G..15-25" 是一整串 */
int len = (int)strlen(s);
const char *ws[20], *we[20];
int nw = 0;
for (const char *p = s; *p && nw < 20; ) {
while (*p == ' ') p++;
if (!*p) break;
ws[nw] = p;
while (*p && *p != ' ') p++;
we[nw++] = p;
}
/* 尾巴先按整词收,最多半个区域;连一个词都塞不下就退到按字符收尾巴(长词/中文) */
int first = -1, tw = 0; /* first = 尾巴起始词下标 */
char tail[64];
tail[0] = 0;
for (int i = nw - 1; i >= 0; i--) {
char w[64];
int n = (int)(we[i] - ws[i]);
if (n <= 0 || n >= (int)sizeof(w)) break;
memcpy(w, ws[i], n); w[n] = 0;
int ww = disp_text_width(w, 16, 1);
if (ww > room / 2) break; /* 最后一个词本身就太宽 */
if (first >= 0 && tw + ww > room / 2) break; /* 收不下更多词了 */
char acc[64]; /* 尾巴 = 这一段原文,内部空格照抄 */
int an = (int)(we[nw - 1] - ws[i]);
if (an >= (int)sizeof(acc)) break;
memcpy(acc, ws[i], an); acc[an] = 0;
memcpy(tail, acc, an + 1);
tw = disp_text_width(tail, 16, 1);
first = i;
}
int cut = (first >= 0) ? (int)(ws[first] - s) : len;
if (first < 0) { /* 没有整词可用:从串尾往前吃字符 */
tw = 0;
for (int p = len; p > 0; ) {
int q = p - 1;
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);
if (ww > room / 2) break;
tw = ww; cut = q; p = q;
}
}
char head[64];
int hw = 0, hn = 0;
for (int i = 1; i < cut && i < (int)sizeof(head) - 1; ) {
while (i < cut && ((unsigned char)s[i] & 0xC0) == 0x80) i++; /* 不切断 UTF-8 */
if (i >= cut) break;
memcpy(head, s, i); head[i] = 0;
int w = disp_text_width(head, 16, 1);
if (w > room - tw) break;
hw = w; hn = i;
i++;
}
head[hn] = 0;
while (hn > 0 && head[hn - 1] == ' ') head[--hn] = 0; /* 尾随空格白占宽度 */
if (hn) hw = disp_text_width(head, 16, 1);
disp_text(x, y, head, 16, fg, bg);
disp_text(x + hw, y, "..", 16, fg, bg);
if (tw) disp_text(x + maxw - tw, y, tail, 16, fg, bg);
}
/* 中文名与英文名不同时才中英并列(系外行星的 name_zh 往往就是英文名) */
static void body_title(const BodyData &b, char *dst, size_t cap)
{
@ -53,9 +133,11 @@ static const IconArt *body_art(const BodyData &b, int detail)
static void status_bar(const UiState &st, const char *right)
{
if (st.wifi_up) {
char sig[24];
snprintf(sig, sizeof(sig), "NET:ONLINE RSSI:%d", st.rssi);
disp_text(4, 2, sig, 16, C_CYAN, C_BG);
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);
} else {
disp_text(4, 2, "NET:OFFLINE", 16, C_RED, C_BG);
}
@ -69,7 +151,9 @@ static void key_bar(const char *const *labels, uint8_t flash)
const int x0 = 3, gap = 2, right = LCD_WIDTH - x0;
int w[4], sum = 0;
for (int i = 0; i < 4; i++) {
w[i] = disp_text_width(labels[i][0] ? labels[i] : "KEYn XXX", 16, 1) + 14;
/* 没定义的槽位只留个窄条。按真实文字宽度等分的话,故障页这种
「两个空槽 + 两个带字」的组合会把文字挤出自己的按钮,压到隔壁上。 */
w[i] = labels[i][0] ? disp_text_width(labels[i], 16, 1) + 14 : 26;
sum += w[i];
}
int avail = (right - x0) - 3 * gap, x = x0;
@ -83,10 +167,18 @@ static void key_bar(const char *const *labels, uint8_t flash)
}
}
static const char *const KEYS_NAV[] = { "KEY0 UP", "KEY1 DN", "KEY2 OK", "KEY3 REF" };
static const char *const KEYS_NAV[] = { "KEY0 UP", "KEY1 DN", "KEY2 OK", "KEY3 MODE" };
static const char *const KEYS_MODE[] = { "KEY0 UP", "KEY1 DN", "KEY2 OK", "KEY3 SETUP" };
static const char *const KEYS_ROCKETS[] = { "KEY0 UP", "KEY1 DN", "KEY2 OK", "KEY3 MODE" };
static const char *const KEYS_ROCKET[] = { "KEY0 UP", "KEY1 DN", "KEY2 BACK", "KEY3 TAB" };
static const char *const KEYS_DETAIL[] = { "KEY0 UP", "KEY1 DN", "KEY2 BACK", "KEY3 TAB" };
static const char *const KEYS_PAIR[] = { "", "", "KEY2 INFO", "KEY3 CODE" };
static const char *const KEYS_PAIR[] = { "", "", "KEY2 SETUP", "KEY3 CODE" };
static const char *const KEYS_NET[] = { "", "", "", "KEY3 SETUP" };
static const char *const KEYS_FAULT[] = { "", "", "KEY2 SETUP", "KEY3 REF" };
static const char *const KEYS_EMPTY[] = { "", "", "", "" };
static const char *const KEYS_SETUP[] = { "", "", "", "KEY3 RETRY" };
/* 设置页只读,改东西要去配网门户(那里能同时改 WiFi 和后端地址) */
static const char *const KEYS_SETTINGS[] = { "", "", "KEY2 SETUP", "KEY3 BACK" };
static void fmt_au(char *buf, size_t cap, float v)
{
@ -124,44 +216,51 @@ static void draw_splash(const UiState &st)
static void draw_provision(const UiState &st)
{
const int px = 8, py = 26, pw = LCD_WIDTH - 16, ph = 184;
const int px = 8, py = 22, pw = LCD_WIDTH - 16, ph = 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 + 8, "NO WIFI CONFIG", 16, C_GOLD, C_PANEL);
disp_text(px + 12, py + 6, "NETWORK SETUP", 16, C_GOLD, C_PANEL);
char msg[64];
disp_text(px + 12, py + 36, "1. JOIN HOTSPOT", 16, C_DIM, C_PANEL);
snprintf(msg, sizeof(msg), "%s", st.ap_ssid);
disp_text_clipped(px + 12, py + 54, pw - 24, msg, 16, C_GOLD, C_PANEL);
disp_text(px + 12, py + 78, "2. OPEN IN BROWSER", 16, C_DIM, C_PANEL);
disp_text(px + 12, py + 96, "http://192.168.4.1", 16, C_CYAN, C_PANEL);
disp_text(px + 12, py + 120, "3. SAVE WIFI + BACKEND SETTINGS", 16, C_DIM, C_PANEL);
disp_text_wrap(px + 12, py + 138, pw - 24,
"The terminal reboots and shows a 6 digit binding code, enter it on the web site to finish.",
16, C_TEXT, C_PANEL, 2);
char msg[96];
/* 首次开机是没存凭据,跑着用是连不上,都落到这一页,原因写第一行 */
disp_text_clipped(px + 12, py + 26, pw - 24,
st.reason[0] ? st.reason : "NO SAVED WIFI CREDENTIALS", 16, C_ORANGE, C_PANEL);
snprintf(msg, sizeof(msg), "API %s", st.api);
disp_text_clipped(px + 12, py + 162, pw - 24, msg, 16, C_CYAN_DIM, C_PANEL);
disp_text_clipped(px + 12, py + 50, pw - 24, msg, 16, C_CYAN_DIM, C_PANEL);
disp_text(px + 12, py + 76, "1. JOIN THIS HOTSPOT", 16, C_DIM, C_PANEL);
snprintf(msg, sizeof(msg), "%s", st.ap_ssid);
disp_text_clipped(px + 12, py + 94, pw - 24, msg, 16, C_GOLD, C_PANEL);
disp_text(px + 12, py + 116, "2. OPEN IN BROWSER", 16, C_DIM, C_PANEL);
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);
}
static void draw_connecting(const UiState &st)
{
const int px = 40, py = 64, pw = 240, ph = 112;
const int px = 24, py = 40, pw = LCD_WIDTH - 48, ph = 158;
disp_panel(px, py, pw, ph, 10, C_PANEL, C_CYAN);
disp_text_center(px, py + 10, pw, "CONNECTING", 16, C_CYAN, C_PANEL);
disp_text_center(px, py + 6, pw, "CONNECTING", 16, C_CYAN, C_PANEL);
/* 环形进度:一圈刻度 + 随 millis 转动的指针 */
disp_ring(160, 92, 14, C_CYAN_DIM);
disp_ring(160, py + 36, 14, C_CYAN_DIM);
float a = (millis() % 1600) / 1600.0f * 2 * 3.1415926f;
disp_disc(160 + (int)(cosf(a) * 14), 92 + (int)(sinf(a) * 14), 3, C_GREEN);
disp_disc(160 + (int)(cosf(a) * 14), py + 36 + (int)(sinf(a) * 14), 3, C_GREEN);
char msg[48];
char msg[64];
uint32_t dots = (millis() / 400) % 4;
snprintf(msg, sizeof(msg), "%s%.*s", st.ssid, (int)dots, "...");
disp_text_clipped(px + 8, py + 62, pw - 16, msg, 16, C_GREEN, C_PANEL);
disp_text_clipped(px + 10, py + 62, pw - 20, msg, 16, C_GREEN, C_PANEL);
/* 连不上的话先说清楚为什么,再告诉用户它不会一直卡在这 */
if (st.reason[0])
disp_text_clipped(px + 10, py + 82, pw - 20, st.reason, 16, C_ORANGE, C_PANEL);
if (st.hint[0])
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 + 8, py + 82, pw - 16, msg, 16, C_DIM, C_PANEL);
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);
}
static void draw_pair(const UiState &st)
@ -172,7 +271,12 @@ static void draw_pair(const UiState &st)
disp_text_center(px, py + 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, 5);
/* 拿不到码多半是换了网段/后端地址填错,这一页必须给出配网出口 */
disp_text_wrap(px + 14, py + 40, pw - 28, st.message, 16, C_ORANGE, C_PANEL, 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);
return;
}
@ -247,13 +351,6 @@ static void draw_list(const UiState &st)
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);
/* 订阅状态胶囊:只读,跟随后端 is_active */
bool on = b.active;
uint16_t sc = on ? C_GOLD : C_DIM;
disp_panel(256, y + 8, 46, 20, 8, on ? C_GOLD_DK : bg, sc);
disp_disc(256 + (on ? 35 : 10), y + 18, 6, sc);
disp_text_center(252, y + 34, 54, on ? "ON" : "OFF", 16, sc, bg);
}
/* 右缘滚动条取代原来的 v+N 文字 */
@ -337,7 +434,7 @@ static void draw_detail(const UiState &st)
for (int i = 0; i < b.ev_count && i < MAX_EVENTS; i++) {
int y = py + 24 + i * 18;
char ds[8];
snprintf(ds, sizeof(ds), "%s ", (strlen(b.ev_date[i]) >= 10) ? b.ev_date[i] + 5 : b.ev_date[i]);
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);
int used = disp_text_width(ds, 16, 1);
disp_text_clipped(qx + 8 + used, y, qw - 16 - used, b.ev[i], 16,
@ -356,6 +453,217 @@ static void draw_detail(const UiState &st)
}
}
/* ================= 火箭模式 ================= */
/* 立绘优先用后端按参数画的那张(已缓存到 PSRAM);后台改过参数或还没拉下来时
退回固件内置的通用火箭,尺寸一致所以版面不用分叉 */
static const IconArt *rocket_art(const RocketData &r, int detail)
{
const IconArt *dyn = rocket_store_get(r.code, r.art_ver, detail);
if (dyn) return dyn;
return detail ? &ic_rocket_detail : &ic_rocket_list;
}
static void rocket_title(const RocketData &r, char *dst, size_t cap)
{
if (r.name_zh[0] && strcmp(r.name_zh, r.name)) snprintf(dst, cap, "%s %s", r.name_zh, r.name);
else strlcpy(dst, r.name, cap);
}
/* 入口页:两块面板,图标是 96x96 的大图(gen_assets.py 烘进固件) */
static void draw_mode(const UiState &st)
{
disp_text_center(0, TOP_Y, LCD_WIDTH, "SELECT TERMINAL MODE", 16, C_CYAN, C_BG);
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++) {
const int x = 8 + i * 154, y = 42, w = 150, h = 146;
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);
disp_panel(x, y, w, h, 10, bg, sel ? C_CYAN : C_CYAN_DIM);
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);
}
}
/* 和天体列表同一种卡片,右侧换成"还有几次发射",因为火箭没有订阅开关那种状态 */
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);
return;
}
int scroll = st.rsel;
if (scroll > s->count - LIST_ROWS) scroll = s->count - LIST_ROWS;
if (scroll < 0) scroll = 0;
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;
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);
const IconArt *ic = rocket_art(r, 0);
disp_add_bitmap(13, y + 10, 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);
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);
char nb[8];
snprintf(nb, sizeof(nb), (r.upcoming > 0) ? "%u" : "--", (unsigned)r.upcoming);
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);
}
int sbh = BOT_Y - TOP_Y + 1;
disp_fill(317, 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);
}
static void draw_rocket(const UiState &st)
{
const RocketDetail *d = st.rdet;
if (!d || !d->base.code[0]) return;
const RocketData &r = d->base;
/* 标题就是型号名(页面本身已经说明是 TARGET),右端留最近一次发射的日期 */
char title[56], next[20];
rocket_title(r, title, sizeof(title));
if (d->next_date[0] && strlen(d->next_date) >= 10)
snprintf(next, sizeof(next), "NEXT %.*s", 5, d->next_date + 5);
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);
const int pw = 156, ph = 88, by = 40;
const int lx = 3, rx = 161;
disp_panel(lx, by, pw, ph, 6, C_PANEL, C_CYAN);
disp_panel(rx, by, 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);
char v[20];
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 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);
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);
/* 右:LAUNCH / STAGE / INFO 三页,KEY3 循环 */
const int qx = 95, qw = 222;
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 };
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);
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 (st.rocket_tab == 0) {
if (!d->ev_count) {
disp_text(qx + 8, ry[0], d->event_total ? "NO NEARBY LAUNCHES" : "NO UPCOMING LAUNCHES",
16, C_DIM, C_PANEL);
return;
}
for (int i = 0; i < d->ev_count && i < MAX_ROCKET_EV; i++) {
/* 任务名是主角,占满左边;发射日期挪到行尾成一列,读起来还是"什么时候打什么" */
char ds[8];
snprintf(ds, sizeof(ds), "%.5s", (strlen(d->ev[i].date) >= 10) ? d->ev[i].date + 5 : d->ev[i].date);
int dw = disp_text_width(ds, 16, 1);
text_elided(qx + 8, ry[i], qw - 16 - dw - 8, d->ev[i].name,
(i == 0) ? C_WHITE : C_TEXT, C_PANEL);
text_right(qx + qw - 8, ry[i], ds, 16, C_CYAN_DIM, C_PANEL);
}
} else if (st.rocket_tab == 1) {
const char *lab[3] = { "S1", "S2", "BST" };
char val[3][24];
snprintf(val[0], sizeof(val[0]), (d->s1_thrust_kn > 0) ? "%.0fKN ISP%.0f x%u" : "--",
d->s1_thrust_kn, d->s1_isp, (unsigned)d->s1_engines);
snprintf(val[1], sizeof(val[1]), (d->s2_thrust_kn > 0) ? "%.0fKN ISP%.0f x%u" : "--",
d->s2_thrust_kn, d->s2_isp, (unsigned)d->s2_engines);
if (r.boosters > 0 && d->booster_thrust_kn > 0)
snprintf(val[2], sizeof(val[2]), "%.0fKN x%u", d->booster_thrust_kn, (unsigned)r.boosters);
else
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);
text_right(qx + qw - 8, ry[i], val[i], 16, C_TEXT, C_PANEL);
}
} else {
char name[56];
rocket_title(r, name, sizeof(name));
disp_text_clipped(qx + 8, ry[0], qw - 16, name, 16, C_WHITE, C_PANEL);
if (!d->desc[0]) {
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);
}
}
static void draw_error(const UiState &st)
{
const int px = 8, py = 32, pw = LCD_WIDTH - 16, ph = 168;
@ -368,12 +676,53 @@ static void draw_error(const UiState &st)
disp_text_clipped(px + 14, py + ph - 24, pw - 28, msg, 16, C_DIM, C_PANEL);
}
/* 设置页:模式页 KEY3 进来。只读地把"网络"和"后端"两件事摊开——
改的地方仍然是配网门户(KEY2),这里不再做一套输入控件。 */
static void draw_settings(const UiState &st)
{
const int pw = 304, ix = 20, ir = 300; /* 面板左右内壁 */
char val[48];
disp_panel_glow(8, 22, pw, 84, 10, C_CYAN_DIM);
disp_panel(8, 22, pw, 84, 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, 196, 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);
}
if (st.ip[0]) { snprintf(val, sizeof(val), "IP %s", st.ip); disp_text_clipped(ix, 64, 268, val, 16, C_CYAN, C_PANEL); }
else disp_text(ix, 64, "IP --", 16, C_DIM, C_PANEL);
snprintf(val, sizeof(val), "HOTSPOT %s", st.ap_ssid);
disp_text_clipped(ix, 82, 268, val, 16, C_DIM, C_PANEL);
disp_panel_glow(8, 110, pw, 102, 10, C_GOLD_DIM);
disp_panel(8, 110, pw, 102, 10, C_PANEL, C_GOLD);
disp_text(ix, 116, "SERVER", 16, C_GOLD, C_PANEL);
if (st.api_fail) text_right(ir, 116, "API FAIL", 16, C_RED, C_PANEL);
disp_text_clipped(ix, 134, 280, st.api, 16, C_CYAN, C_PANEL);
snprintf(val, sizeof(val), "USER %s", st.owner[0] ? st.owner : "--");
disp_text_clipped(ix, 152, 176, val, 16, C_TEXT, C_PANEL);
text_right(ir, 152, st.owner[0] ? "BOUND" : "NOT BOUND", 16,
st.owner[0] ? C_GREEN : C_ORANGE, C_PANEL);
snprintf(val, sizeof(val), "DEV %s", st.device_id);
disp_text_clipped(ix, 170, 280, val, 16, C_DIM, C_PANEL);
disp_text(ix, 188,
(st.mode < 0) ? "MODE NOT CHOSEN" : (st.mode ? "MODE LAUNCHER" : "MODE CELESTIAL"),
16, C_CYAN_DIM, C_PANEL);
}
void ui_draw(const UiState &st)
{
disp_bg();
const char *right = "COSMO";
if (st.screen == SC_LIST || st.screen == SC_DETAIL || st.screen == SC_LOADING) right = st.owner;
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_SETTINGS) right = st.owner;
if (st.screen != SC_SPLASH) status_bar(st, right);
switch (st.screen) {
@ -382,15 +731,26 @@ void ui_draw(const UiState &st)
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;
case SC_ROCKETS: draw_rockets(st); break;
case SC_ROCKET: draw_rocket(st); break;
case SC_ERROR: draw_error(st); break;
case SC_SETTINGS: draw_settings(st); break;
}
const char *const *keys = KEYS_EMPTY;
if (st.screen == SC_LIST) keys = KEYS_NAV;
else if (st.screen == SC_DETAIL) keys = KEYS_DETAIL;
else if (st.screen == SC_MODE) keys = KEYS_MODE;
else if (st.screen == SC_ROCKETS) keys = KEYS_ROCKETS;
else if (st.screen == SC_ROCKET) keys = KEYS_ROCKET;
else if (st.screen == SC_PAIR) keys = KEYS_PAIR;
else if (st.screen == SC_CONNECTING) keys = KEYS_NET;
else if (st.screen == SC_ERROR) keys = KEYS_FAULT;
else if (st.screen == SC_PROVISION) keys = KEYS_SETUP;
else if (st.screen == SC_SETTINGS) keys = KEYS_SETTINGS;
if (st.screen != SC_SPLASH) key_bar(keys, st.key_flash);
disp_flush();

View File

@ -8,9 +8,13 @@ enum Screen {
SC_CONNECTING, /* 正在连接 WiFi */
SC_PAIR, /* 显示 6 位配对码,等待网页端绑定 */
SC_LOADING, /* 正在拉取订阅数据 */
SC_MODE, /* 进入哪一种终端:天体 / 火箭 */
SC_LIST, /* 关注天体列表 */
SC_DETAIL, /* 单个天体的位置/速度/事件 */
SC_ERROR
SC_ROCKETS, /* 平台启用的火箭列表 */
SC_ROCKET, /* 单个火箭的参数 + 发射任务 */
SC_ERROR,
SC_SETTINGS /* WiFi 与后端地址一览,KEY2 进配网门户改 */
};
struct UiState {
@ -18,18 +22,28 @@ struct UiState {
char device_id[24] = "";
char ssid[33] = "";
char ap_ssid[33] = "";
char ip[16] = ""; /* 连上之后的局域网地址,设置页要显示 */
char api[96] = "";
char code[8] = ""; /* 配对码 */
int code_left = 0; /* 配对码剩余秒 */
int code_total = 0; /* 配对码有效期总秒数,用于倒计时条 */
char owner[24] = ""; /* 已绑定用户 */
char message[140] = "";
char reason[48] = ""; /* 连不上 WiFi 的原因,连接页/配网页都显示 */
char hint[40] = ""; /* 连接页副标题:还要试几次、几秒后自动开热点 */
const Snapshot *snap = nullptr;
int sel = 0;
const RocketSnapshot *rsnap = nullptr;
const RocketDetail *rdet = nullptr;
int mode_sel = 0; /* 模式选择页:0=天体 1=火箭 */
int mode = -1; /* 已生效的模式,设置页显示;-1=没选过 */
int sel = 0; /* 天体列表光标 */
int rsel = 0; /* 火箭列表光标:分开记,切模式不会把对方光标带乱 */
int scroll = 0;
int detail_tab = 0; /* 详情页右栏分页:0=EVENTS 1=INFO */
int detail_tab = 0; /* 天体详情页右栏分页:0=EVENTS 1=INFO */
int rocket_tab = 0; /* 火箭详情页右栏分页:0=LAUNCH 1=STAGE 2=INFO */
int rssi = 0;
bool wifi_up = false;
bool api_fail = false; /* WiFi 连着但后端取不到数据,状态栏要标出来 */
uint8_t key_flash = 0; /* 底部按键条:bit0..bit3 = 被按下的槽位(含 BOOT) */
};

View File

@ -28,6 +28,18 @@ FONT_THR = 130 # 主阈值:再低笔画就粘在一起;过密往上
LIST_SIZE = 40
DETAIL_SIZE = 64
MODE_SIZE = 96 # 入口页"天体 / 火箭"两张大图标
# 生成式图标:火箭立绘不吃源图,直接用后端那套 rocket_art 按参数画,所以终端兜底图和 Web 端 3D 模型是同一台火箭
ROCKET_CFG = {
"color": "#cfe6ff",
"height_m": 57.0,
"diameter_m": 5.0,
"stage_1": {"length_ratio": 0.62, "engine_count": 2, "recoverable": False},
"stage_2": {"length_ratio": 0.38, "engine_count": 2},
"boosters": {"count": 4, "diameter_ratio": 0.67, "length_ratio": 0.57},
"appearance": {},
}
# 图标素材:key -> 源文件名(都是 320x320 纯黑底霓虹线稿)
ART = {
@ -35,7 +47,7 @@ ART = {
"jupiter": "木星小.jpeg",
"saturn": "土星小.jpeg",
"mars": "火星小.jpeg",
"earth": "地球小.jpeg",
"earth": "地球-2小.jpeg",
"earth_icon": "地球-图标小.jpeg",
"venus": "金星(图标)小.jpeg",
"neptune": "海王星小.jpeg",
@ -94,17 +106,9 @@ def rgb565(r, g, b):
return ((r >> 3) << 11) | ((g >> 2) << 5) | (b >> 3)
def icon_pixels(path, size):
"""亮度 bbox 裁切 -> 补方 -> 缩放 -> 黑底门限 -> RGB565 列表"""
im = Image.open(path).convert("RGB")
bbox = Image.open(path).convert("L").point(lambda v: 255 if v > 40 else 0).getbbox()
if bbox:
im = im.crop(bbox)
w, h = im.size
side = max(w, h)
sq = Image.new("RGB", (side, side), (0, 0, 0))
sq.paste(im, ((side - w) // 2, (side - h) // 2))
sq = sq.resize((size, size), Image.LANCZOS)
def pack(im, size):
"""RGB 图 -> size x size 的 RGB565 列表(黑底门限,叠加混合时不落地)"""
sq = im.resize((size, size), Image.LANCZOS)
out = []
for r, g, b in sq.getdata():
if (r * 299 + g * 587 + b * 114) // 1000 <= 10:
@ -114,11 +118,41 @@ def icon_pixels(path, size):
return out
def rocket_pixels(cfg, size):
"""按参数画一枚火箭:直接 import 后端的绘图模块,保证两端长得一样"""
import sys
sys.path.insert(0, str(ROOT / "backend"))
from app.services.rocket_art import art_params, render
return pack(render(art_params(cfg), size), size)
def icon_pixels(path, size):
"""亮度 bbox 裁切 -> 补方 -> 缩放 -> 黑底门限 -> RGB565 列表"""
im = Image.open(path).convert("RGB")
bbox = Image.open(path).convert("L").point(lambda v: 255 if v > 40 else 0).getbbox()
if bbox:
im = im.crop(bbox)
w, h = im.size
side = max(w, h)
sq = Image.new("RGB", (side, side), (0, 0, 0))
sq.paste(im, ((side - w) // 2, (side - h) // 2))
return pack(sq, size)
def emit_icons():
keys = list(ART)
data = {k: {s: icon_pixels(ART_DIR / ART[k], s) for s in (LIST_SIZE, DETAIL_SIZE)}
for k in keys}
gen = {
"mode_planet_96": icon_pixels(ART_DIR / ART["planet"], MODE_SIZE),
"mode_rocket_96": rocket_pixels(ROCKET_CFG, MODE_SIZE),
"rocket_list": rocket_pixels(ROCKET_CFG, LIST_SIZE),
"rocket_detail": rocket_pixels(ROCKET_CFG, DETAIL_SIZE),
}
GEN_SIZES = [("mode_planet_96", MODE_SIZE), ("mode_rocket_96", MODE_SIZE),
("rocket_list", LIST_SIZE), ("rocket_detail", DETAIL_SIZE)]
h = ["// 由 terminal/tools/gen_assets.py 生成,请勿手改。",
"/* 天体霓虹线稿图标:无 alpha 的 RGB565,固件用叠加混合绘制(黑色不落地)。 */",
"#pragma once",
@ -135,6 +169,8 @@ def emit_icons():
h.append(f"extern const IconArt ic_{k}_list; /* {ART[k]} */")
for k in keys:
h.append(f"extern const IconArt ic_{k}_detail;")
for name, side in GEN_SIZES:
h.append(f"extern const IconArt ic_{name}; /* {side}x{side} */")
h += ["",
"/** name/name_zh 小写子串命中优先,其次按 type 兜底;detail!=0 取大图 */",
"const IconArt *icon_for(const char *name, const char *name_zh, const char *type, int detail);",
@ -152,11 +188,19 @@ def emit_icons():
for i in range(0, len(px), 16):
c.append(",".join("0x%04X" % v for v in px[i:i + 16]) + ",")
c.append("};")
for name, side in GEN_SIZES:
px = gen[name]
c.append(f"static const uint16_t px_{name}[{len(px)}] = {{")
for j in range(0, len(px), 16):
c.append(",".join("0x%04X" % v for v in px[j:j + 16]) + ",")
c.append("};")
c.append("")
for k in keys:
c.append(f"const IconArt ic_{k}_list = {{ px_{k}_list, {LIST_SIZE}, {LIST_SIZE} }};")
for k in keys:
c.append(f"const IconArt ic_{k}_detail = {{ px_{k}_detail, {DETAIL_SIZE}, {DETAIL_SIZE} }};")
for name, side in GEN_SIZES:
c.append(f"const IconArt ic_{name} = {{ px_{name}, {side}, {side} }};")
c += ["", "struct NameRule { const char *needle; const IconArt *list, *detail; };",
"struct TypeRule { const char *type; const IconArt *list, *detail; };", "",
"static const NameRule s_names[] = {"]
@ -200,8 +244,9 @@ def emit_icons():
""]
(OUT / "icons.h").write_text("\n".join(h) + "\n", encoding="utf-8")
(OUT / "icons.cpp").write_text("\n".join(c) + "\n", encoding="utf-8")
total = sum(len(v[s]) * 2 for v in data.values() for s in (LIST_SIZE, DETAIL_SIZE))
print(f"icons: {len(keys)} 张 x2 尺寸 ({LIST_SIZE}/{DETAIL_SIZE}),{total // 1024} KB flash")
total = sum(len(v) * 2 for v in list(data.values()) )
total += sum(len(v) * 2 for v in gen.values())
print(f"icons: {len(keys)} 张天体 x2 尺寸 + {len(gen)} 张生成图,{total // 1024} KB flash")
def cjk_codepoints():

View File

@ -3,8 +3,19 @@
用法: key_watch.py [监听秒数=240] [日志=/tmp/keywatch.log]
"""
import serial, sys, time
import glob, os
PORT = '/dev/cu.usbserial-210'
#: 换过 USB 口(CH340 -> 板载 USB-CDC)就别让脚本抓瞎:COSMO_PORT 优先,否则挑一个在的
def _pick_port():
env = os.environ.get('COSMO_PORT')
if env: return env
for pat in ('/dev/cu.usbserial*', '/dev/cu.usbmodem*'):
m = sorted(glob.glob(pat))
if m: return m[0]
return '/dev/cu.usbserial-210'
PORT = _pick_port()
BAUD = 115200
dur = float(sys.argv[1]) if len(sys.argv) > 1 else 240
path = sys.argv[2] if len(sys.argv) > 2 else '/tmp/keywatch.log'

View File

@ -1,7 +1,19 @@
"""发命令并按需抓屏:fbshot.py <log> "cmd|等待秒|输出png(或-)" ...
状态机保证 [FB] 标记不会被日志冲掉。"""
import serial, sys, time, os
PORT='/dev/cu.usbserial-210'; BAUD=115200; N=320*240*2
import glob
#: 换过 USB 口(CH340 -> 板载 USB-CDC)就别让脚本抓瞎:COSMO_PORT 优先,否则挑一个在的
def _pick_port():
env = os.environ.get('COSMO_PORT')
if env: return env
for pat in ('/dev/cu.usbserial*', '/dev/cu.usbmodem*'):
m = sorted(glob.glob(pat))
if m: return m[0]
return '/dev/cu.usbserial-210'
PORT = _pick_port(); BAUD=115200; N=320*240*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)
@ -10,7 +22,8 @@ def pump(dur, path=None):
"""读串口 dur 秒;path 不为空时遇到 [FB] 就抓 N 字节并渲染"""
global buf
end=time.time()+dur; f=None; got=0
while time.time()<end or f is not None:
hard=end+90 # 抓屏期间也要有终点:设备中途不发了,脚本不能永远卡在串口上
while time.time()<end or (f is not None and time.time()<hard):
d=s.read(4096)
if not d:
if f is None and time.time()>end: break
@ -36,6 +49,8 @@ def pump(dur, path=None):
'-video_size 320x240 -i %s -frames:v 1 -vf "scale=960:720:flags=neighbor" %s.png'%(path,path))
print('[fb] rendered %s.png'%(path,),flush=True)
buf=bytearray(); return True
if f is not None:
f.close(); print('[fb] TRUNCATED %d/%d bytes'%(got,N),flush=True)
if path: print('[fb] TIMEOUT',flush=True)
return False
pump(1.5)

View File

@ -1,5 +1,17 @@
import serial, sys, threading, time, os, re
PORT='/dev/cu.usbserial-210'; BAUD=115200
import glob
#: 换过 USB 口(CH340 -> 板载 USB-CDC)就别让脚本抓瞎:COSMO_PORT 优先,否则挑一个在的
def _pick_port():
env = os.environ.get('COSMO_PORT')
if env: return env
for pat in ('/dev/cu.usbserial*', '/dev/cu.usbmodem*'):
m = sorted(glob.glob(pat))
if m: return m[0]
return '/dev/cu.usbserial-210'
PORT = _pick_port(); BAUD=115200
OUT=sys.argv[1] if len(sys.argv)>2 else '/tmp/fb.raw'
N=320*240*2
s=serial.Serial(); s.port=PORT; s.baudrate=BAUD; s.timeout=0.1; s.write_timeout=5