stydxm's blog 2025-11-25T21:31:43.286Z https://stydxm.com/ stydxm Hexo AOSC OS上LoongArch ROS2移植 https://stydxm.com/2025/10/01/aosc-ros2/ 2025-10-01T03:52:18.000Z 2025-11-25T21:31:43.286Z 想在机器人领域使用一下龙芯，但目前ROS2官方并未发预构建二进制包

调研时发现了loongros2，证明源码直接或小改后在龙芯上运行没有太大问题，遂决定开坑移植

2025.11.7更新：得益于AOSC的构建系统，也幸好ros2源码中没有太多架构特定的代码，ROS Jazzy desktop除Mimick相关的所有包在amd64/arm64/loongarch64/riscv64/ppc64el/mips均构建通过（但还未测试，估计也不会有人在ppc和mips这些平台上用）

准备工作

colcon

colcon是一个用于构建软件包集的命令行工具，大家都用它来编译ROS2项目。因此虽然它不属于ROS的一部分，还是先把它打包出来

colcon是完全由Python写的，不涉及到编译，也没有架构问题。虽然包的数量不少（Ubuntu的python3-colcon加上推荐依赖是二十多个），但构建也不麻烦，直接手动写一下再复制复制粘贴几次

相关PR：https://github.com/AOSC-Dev/aosc-os-abbs/pull/12771

flake8

flake8是一个代码检查工具，虽然没有直接用到，但ROS里很多Python包都依赖它，因此也要打包一下

相关PR：https://github.com/AOSC-Dev/aosc-os-abbs/pull/12817

其他包

主要涉及到mypy、lttng等一大堆东西

相关PR：https://github.com/AOSC-Dev/aosc-os-abbs/pull/12823

2025.11.7更新：由于社区反馈建议分开，就拆成了多个PR：

ROS构建目标

在所有的ROS版本中，现在还在生命周期中的正式版有三个。其中Kilted不是LTS版本，而Humble比较老，依赖版本比较低，因此选择最新的LTS版本Jazzy。查看文档中对依赖库版本的需求均能满足，决定将目标distribution定为Jazzt Jalisco

REP 2001中规定了每个版本的不同变种，Jazzy有六个，其中最低的是ROS Core，其次是ROS Base

我暂时将目标Variant定为base，如进展顺利再尝试打包更多包以达到desktop

2025.11.7更新：打包base时没有遇到太多问题，然后再花了一些时间打出了dekstop

编写脚本生成打包脚本

因为ROS的包数量大、相似度高，手工编写打包脚本远不如用脚本批量生成

个人比较熟悉Python，就用它来写了

编写软件包的类

参照AOSC的指南，编写一个Python类

1
2
3
4
5
6
7
8
class Package:
    version: str
    src: str
    name: str
    dependencies: list[str]
    build_dependencies: list[str]
    description: str
    autobuild_type: str

获取包列表

ros官方提供了一个工具rosinstall-generator，可以生成包源码的结构化数据，我们可通过提供的文档来了解它的用法

使用pip安装后，尝试获取一份包含依赖项的core级别所有包的源码

1
rosinstall_generator ros_core --rosdistro jazzy --deps

使用python解析

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import subprocess
import sys
from typing import Literal

import yaml

raw_package_type = dict[
    Literal["git"], dict[Literal["local-name", "uri", "version"], str]
]
try:
    rosinstall_generator_output = subprocess.run(
        ["rosinstall_generator", "ros_base", "--rosdistro", "jazzy", "--deps"],
        capture_output=True,
        check=True,
    )
    raw_packages_str = rosinstall_generator_output.stdout
    raw_packages_data: raw_package_type = yaml.safe_load(raw_packages_str)
except subprocess.CalledProcessError as e:
    print(f"命令执行失败: {e.returncode}", file=sys.stderr)
    print(e.stderr)
except FileNotFoundError:
    print(f"找不到命令，rosinstall-generator 未安装", file=sys.stderr)
except yaml.YAMLError as e:
    print(f"返回值解析错误: {e}", file=sys.stderr)

注意rosinstall和rosinstall-generator是两个不同的包

解析包信息

版本

读取到信息中的版本号均为x.y.z-revision的格式

按照AOSC的规定：

情形：版本号带有短横线（-）
应当采取的措施：将短横线替换为加号（+）
举例：ImageMagick 6.9.10-23 -> VER=6.9.10+23

将其进行字符串替换，改为x.y.z+revision

源码

rosinstall_generator输出的均为git仓库，因此只需要做简单拼接"git::commit=tags/{version}::{uri}"

但由于已经单独提出了VER变量，在SRC中再硬编码版本号就显得不太合适，所以稍作修改

1
2
3
4
semver = version.split("/")[-1]
self.version = semver.replace("-", "+")
version_prefix = "/".join(version.split("/")[:-1])
self.src = f"git::commit=tags/{version_prefix}/{'${VER/+/-}'}::{uri}"

这样处理后，例如ament_package这个包的生成内容就是

1
2
VER=0.16.4+1
SRCS="git::commit=tags/release/jazzy/ament_package/${VER/+/-}::https://github.com/ros2-gbp/ament_package-release.git"

更新检查

样式指南要求尽量使用anitya，但要把如此数量庞大的包都加到anitya过于麻烦，就选了使用GitHub格式

1
2
3
repo = uri[19:-4]
pattern = "/".join(version.split("/")[:-1]) + "/.*"
check_update = f"github::repo={repo};pattern={pattern}"

包名

观察发现，rosinstall_generator输出的local-name都是包所属“大包”名/包名[1]的格式，且包名一段是由下划线分割的。参考官方打包的deb包名，可推测出最终包名的格式

1
2
original_name = local_name.split("/")[-1]
package_name = "ros-jazzy-" + original_name.replace("_", "-")

由于包名是推测的，没有找到相关文档，还需要进行验证

验证过程

利用ROS官方的apt仓库，通过检查目录是否存在来判断

1
2
3
4
5
6
7
8
9
10
11
12
import requests
from tqdm import tqdm

for package in tqdm(raw_packages_data):
    local_name = package["git"]["local-name"]
    original_name = local_name.split("/")[-1]
    package_name = "ros-jazzy-" + original_name.replace("_", "-")
    resp = requests.get(
        "http://packages.ros.org/ros2/ubuntu/pool/main/r/" + package_name
    )
    if resp.status_code != 200:
        print(local_name)

结果为全部通过，证实了我的猜测

依赖

这是非常重要又很难处理的一部分，每个包都有一个package.xml文件[2]，里面记录了包的依赖情况

依赖分为两种，编译时依赖和构建时依赖，用<build_depend>（编译依赖库）/<buildtool_depend>（编译时需要的编译工具）和<depend>（构建和运行都用）/<exec_depend>（只有运行用）表示

这些依赖有都有两个来源，其他的ros包和非ros的第三方库。ros包的命名方式很简单，通过前述生成包名的方式可以很容易找到；官方获取第三方库在包管理中的包名的实现方式是维护一个大的映射表，我们使用其中的Arch作为基准，在此基础上手动进行修改：

  • AOSC中的包通常不会以-dev或者-devel结尾，因此遇到该后缀就去掉

  • AOSC打包的Python库不以python3-开头，因此遇到该前缀就去掉

  • 上面两条中有个特例是Ubuntu中的包python3-dev，匹配上两条后啥都不剩了，所以要放在最前面做特殊处理

  • AOSC打包的包名中若原来不含lib前缀的，不会加上该前缀，但本来就有的则会保留；若对比同一包在多个系统中的包名，有些带lib前缀而有些没有，就可以大胆猜测它不是原项目名的一部分，将它去除

这里用一个简单粗暴（但不一定准确）的方法来区分：含有下划线_的认为是ros包，带有横杠-的是第三方库。 两种来源的包可以通过映射表中是否存在来判断

基于以上分析内容，写出python代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

import requests
import yaml

rosdep_map: dict[str, dict] = yaml.safe_load(
    requests.get(
        "https://github.com/ros/rosdistro/raw/refs/heads/master/rosdep/base.yaml"
    ).text
)


def process_rosdep_package_list(
    rosdep_package_list: list[str] | dict[str, list[str]],
) -> str:
    system_package_name = ""
    if isinstance(rosdep_package_list, list):
        system_package_name = rosdep_package_list[0]
    else:
        for system in rosdep_package_list.keys():
            if rosdep_package_list[system]:
                system_package_name = rosdep_package_list[system][0]
    assert system_package_name
    return system_package_name


def rosdep_key_to_package_name(rosdep_key: str) -> str:
    package_name = ""
    if rosdep_key in rosdep_map.keys():
        current_package = rosdep_map[rosdep_key]
        if "arch" in current_package:
            package_name = process_rosdep_package_list(current_package["arch"])
        elif "ubuntu" in current_package:
            package_name = process_rosdep_package_list(current_package["ubuntu"])
        else:
            package_name = process_rosdep_package_list(
                current_package[list(current_package.keys())[0]]
            )
    else:
        original_name = rosdep_key.split("/")[-1]
        package_name = f"ros-{rosdistro}-" + original_name.replace("_", "-")
    if package_name == "python3-dev" or package_name == "python3":
        package_name = "python-3"
    if package_name.startswith(f"ros-{rosdistro}-python3-"):
        package_name = package_name[13 + len(rosdistro) :]
    if package_name.startswith("python3-"):
        package_name = package_name[8:]
    if package_name.endswith("-dev"):
        package_name = package_name[:-4]
    return package_name

这里还要注意有个特殊的包ros-jazzy-ros-workspace，负责提供/opt/ros/jazzy/setup.{sh,bash,zsh}等脚本，它是除了本身及其依赖外所有包的依赖项

描述

package.xml中有<description>字段包含了对包的描述；但它可能有多行，因此只取第一行

有个别包中的描述中含有反斜杠，需要注意转义

构建方式

绝大多数包都是使用CMake编译或不需要编译的Python包，我选择根据是否存在CMakeLists.txt和setup.py判断；如遇到特殊情况手动处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
repo = uri[19:-4]
file_list = requests.get(f"https://api.github.com/repos/{repo}/contents?ref={version}").json()
has_pyproject = False
has_setup_py = False
has_cmake_lists = False
for file in file_list:
    if file["name"] == "pyproject.toml":
        has_pyproject = True
    if file["name"] == "setup.py":
        has_setup_py = True
    if file["name"] == "CMakeLists.txt":
        has_cmake_lists = True
if has_cmake_lists:
    self.build_type = "cmakeninja"
elif has_pyproject:
    self.build_type = "pep517"
elif has_setup_py:
    self.build_type = "python"
else:
    self.build_type = "unknown"

若包为Python写的，还要加上NOPYTHON2和noarch声明

生成ACBS文件

通过以上步骤，整合代码，写出完整程序

这里需要注意的是，由于GitHub的风控机制，需要分多次运行或填入个人apikey

展开程序
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
import os
import subprocess
import sys
import xml.etree.ElementTree as ET

from concurrent.futures import ThreadPoolExecutor
from typing import Literal

import requests
import yaml
from tqdm import tqdm

rosdistro = "jazzy"
print("Fetching rosdep map...")
rosdep_map: dict[str, dict] = yaml.safe_load(
    requests.get(
        "https://github.com/ros/rosdistro/raw/refs/heads/master/rosdep/base.yaml"
    ).text
)


def process_rosdep_package_list(
    rosdep_package_list: list[str] | dict[str, list[str]],
) -> str:
    system_package_name = ""
    if isinstance(rosdep_package_list, list):
        system_package_name = rosdep_package_list[0]
    else:
        for system in rosdep_package_list.keys():
            if rosdep_package_list[system]:
                system_package_name = rosdep_package_list[system][0]
    assert system_package_name
    return system_package_name


def rosdep_key_to_package_name(rosdep_key: str) -> str:
    package_name = ""
    if rosdep_key in rosdep_map.keys():
        current_package = rosdep_map[rosdep_key]
        if "arch" in current_package:
            package_name = process_rosdep_package_list(current_package["arch"])
        elif "ubuntu" in current_package:
            package_name = process_rosdep_package_list(current_package["ubuntu"])
        else:
            package_name = process_rosdep_package_list(
                current_package[list(current_package.keys())[0]]
            )
    else:
        original_name = rosdep_key.split("/")[-1]
        package_name = f"ros-{rosdistro}-" + original_name.replace("_", "-")
    if package_name == "python3-dev" or package_name == "python3":
        package_name = "python-3"
    if package_name.startswith(f"ros-{rosdistro}-python3-"):
        package_name = package_name[13 + len(rosdistro) :]
    if package_name.startswith("python3-"):
        package_name = package_name[8:]
    if package_name.endswith("-dev"):
        package_name = package_name[:-4]
    return package_name


class Package:
    version: str
    src: str
    check_update: str
    name: str
    dependencies: list[str]
    build_dependencies: list[str]
    description: str
    autobuild_type: str
    file_list_url: str
    package_xml_url: str
    package_info: ET.Element
    build_type: str

    def __init__(self, local_name: str, uri: str, version: str):
        semver = version.split("/")[-1]
        self.version = semver.replace("-", "+")
        version_prefix = "/".join(version.split("/")[:-1])
        self.src = f"git::commit=tags/{version_prefix}/{'${VER/+/-}'}::{uri}"
        repo = uri[19:-4]
        pattern = "/".join(version.split("/")[:-1]) + "/.*"
        self.check_update = f"github::repo={repo};pattern={pattern}"
        self.name = rosdep_key_to_package_name(local_name)
        self.file_list_url = (
            f"https://api.github.com/repos/{repo}/contents?ref={version}"
        )
        self.package_xml_url = (
            f"{uri[:-4]}/raw/refs/tags/{version}/package.xml"
        )
        self.dependencies = [f"ros-{rosdistro}-ros-workspace"]
        self.build_dependencies = []

    def get_metadata(self):
        assert self.package_xml_url
        package_xml_string = requests.get(self.package_xml_url).text
        packge_info = ET.fromstring(package_xml_string)
        pkgdep = (
            packge_info.findall("depend")
            + packge_info.findall("exec_depend")
            + packge_info.findall("build_export_depend")
            + packge_info.findall("buildtool_export_depend")
        )
        builddep = (
            packge_info.findall("buildtool_depend")
            + packge_info.findall("build_depend")
            + packge_info.findall("test_depend")
        )
        for package in pkgdep:
            packge_name = rosdep_key_to_package_name(package)
            if packge_name not in self.dependencies:
                self.dependencies.append(packge_name)
        for package in builddep:
            package_name = rosdep_key_to_package_name(package)
            if (
                package_name not in self.dependencies
                and package_name not in self.build_dependencies
            ):
                self.build_dependencies.append(package_name)
        raw_description = packge_info.findall("description")[0].text.splitlines()
        self.description = self.name
        for line in raw_description:
            clean_line = line.strip()
            if clean_line:
                self.description = clean_line
                break
        if self.description.endswith("."):
            self.description = self.description[:-1]
        self.description = self.description.replace("`", "\\`")
        file_list = requests.get(self.file_list_url).json()
        has_pyproject = False
        has_setup_py = False
        has_cmake_lists = False
        for file in file_list:
            if file["name"] == "pyproject.toml":
                has_pyproject = True
            if file["name"] == "setup.py":
                has_setup_py = True
            if file["name"] == "CMakeLists.txt":
                has_cmake_lists = True
        if has_cmake_lists:
            self.build_type = "cmakeninja"
        elif has_pyproject:
            self.build_type = "pep517"
        elif has_setup_py:
            self.build_type = "python"
        else:
            self.build_type = "unknown"

    def generate_spec(self):
        return f"""VER={self.version}
SRCS="{self.src}"
CHKSUMS="SKIP"
CHKUPDATE="{self.check_update}"
"""

    def generate_defines(self):
        defines_content = f"""PKGNAME={self.name}
PKGSEC=ros
PKGDEP="{" ".join(self.dependencies)}"
"""
        if self.build_dependencies:
            defines_content += f'BUILDDEP="{" ".join(self.build_dependencies)}"'
        defines_content += f"""
PKGDES="{self.description}"

ABTYPE={self.build_type}
PREFIX="/opt/ros/{rosdistro}"
ABSPLITDBG=0
"""
        if self.build_type == "pep517" or self.build_type == "python":
            defines_content += """NOPYTHON2=1
ABHOST=noarch
"""
        else:
            defines_content += "NOSTATIC=0\n"
        if self.build_type == "cmakeninja":
            defines_content += f"""CMAKE_AFTER=(
    "-DCMAKE_PREFIX_PATH=/opt/ros/jazzy"
    "-DBUILD_TESTING=OFF"
)
"""
        return defines_content


def write_file(new_package: Package):
    dirname = f"runtime-ros/{new_package.name}"
    if not os.path.exists(dirname):
        try:
            new_package.get_metadata()
        except TypeError:
            print("API rate limit exceeded")
            return
        except requests.exceptions.SSLError:
            print("API rate limit exceeded")
            return
        except requests.exceptions.ConnectionError:
            print("API rate limit exceeded")
            return
        spec = new_package.generate_spec()
        defines = new_package.generate_defines()
        prepare = f"""export PYTHONPATH=/opt/ros/{rosdistro}/lib/python${{ABPY3VER}}/site-packages/
export PKG_CONFIG_PATH=/opt/ros/jazzy/lib/pkgconfig
. /opt/ros/jazzy/setup.sh
"""
        os.mkdir(dirname)
        os.mkdir(dirname + "/autobuild")
        open(dirname + "/spec", "w", encoding="utf-8").write(spec)
        open(dirname + "/autobuild/defines", "w", encoding="utf-8").write(defines)
        open(dirname + "/autobuild/prepare", "w", encoding="utf-8").write(prepare)


print("Scanning packages ...")
raw_package_type = dict[
    Literal["git"], dict[Literal["local-name", "uri", "version"], str]
]
try:
    rosinstall_generator_output = subprocess.run(
        ["rosinstall_generator", "desktop", "--rosdistro", rosdistro, "--deps"],
        capture_output=True,
        check=True,
    )
    raw_packages_str = rosinstall_generator_output.stdout
    raw_packages_data: raw_package_type = yaml.safe_load(raw_packages_str)
except subprocess.CalledProcessError as e:
    print(f"命令执行失败: {e.returncode}", file=sys.stderr)
    print(e.stderr)
except FileNotFoundError:
    print(f"找不到命令，rosinstall-generator 未安装", file=sys.stderr)
except yaml.YAMLError as e:
    print(f"返回值解析错误: {e}", file=sys.stderr)

print("Generating files...")
futures = []
if not os.path.exists("runtime-ros"):
    os.mkdir("runtime-ros")

# 多线程运行
with ThreadPoolExecutor(max_workers=10) as executor:
    for package in tqdm(raw_packages_data):
        current_data = package["git"]
        current_package = Package(
            current_data["local-name"], current_data["uri"], current_data["version"]
        )
        future = executor.submit(write_file, current_package)
        futures.append(future)
    for future in tqdm(futures):
        future.result()

手动处理依赖

虽然大多数依赖都使用脚本自动化完成了，还有一些依赖包名需要手动处理，例如eigen3-dev和eigen-3等包名不一致的，还有importlib-*等属于另一个包的一部分的情况，以及ros-jazzy-ros-workspace会产生循环依赖等等

这部分工作量不大且无法自动化，需要人工手动完成

处理架构不兼容的包

打包过程中遇到了一个特殊的包Mimick，它用于C的测试

它使用了一些汇编代码，而且只有x86和arm，甚至添加RV支持的PR几年了也没有被上游合并。即使不考虑上游，学会写这么多架构的汇编也不是一件简单的事。所幸它只是一个用于测试的mock库，可以直接在不支持的架构上不依赖它并设置-DBUILD_TESTING=OFF，顺利解决

  1. 大包是我自己的不正规的叫法，指的是如ament等需要多个组件组成的包 ↩︎

  2. 该文件有三种版本，以<package>节点的format属性判断，分别是"1"、“2”、“3”，观察发现好像版本2的比较多 ↩︎

]]> <p>想在机器人领域使用一下龙芯，但目前ROS2官方并未发预构建二进制包</p> <p>调研时发现了<a href="https://loongros.cn/">loongros2</a>，证明源码直接或小改后在龙芯上运行没有太大问题，遂决定开坑移植</p> 使用SSH作为跳板机 https://stydxm.com/2025/03/24/ssh-jumpserver/ 2025-03-24T15:36:55.000Z 2025-11-25T21:31:43.287Z 在以前，云服务商提供的国内服务器带宽都很有限或非常昂贵，前段时间阿里云发布低价的200M带宽的轻量应用服务器，使得带宽成本大大降低

一些在已有机器上的服务迁移麻烦，或者因为储存/算力的原因无法迁移，那么就自然而然地想到可以用大带宽机器中转，同时享受到大带宽和高算力/大储存

要求

首先原有服务器 A 和200M的服务器 B 要在同一可用区，这样才可以通过千兆内网传输数据

这里的A不一定是轻量应用服务器，即使没有公网IP，只要与B内网相通都可以用这个方法，比如ECS、裸金属服务器，甚至开了SSH的serverless也行

B必须要能使用SSH登陆，如果不能的话需要考虑其他方式进行端口转发

配置SSH密钥登陆

密码连接需要手动介入，为了能在脚本中自动化运行，需要使用密钥或者证书登陆

这里不写教程了，如有需要可以参考WangDoc上的教程，需要将客户端的密钥添加到A和B上

获取连接地址

打开阿里云的控制台，在基本信息的位置获取服务器A的内网地址（图中主私网IP）和服务器B的公网地址（图中公网IP）

如果有防火墙、黑白名单等需要注意，客户端需要能连接到B，同时B要能连接到A

因为到A的流量会从B中转，不经过A的公网地址，所以客户端能否连接到A并不重要

使用SSH协议的服务

对于使用SSH连接的服务，比如SSH本身，或者sftp scp rsync等，可以使用ProxyJump来将B作为跳板机连接A

在命令行中测试连接

先打开任意一个终端，输入命令测试到A的连接，注意将参数替换为自己的

1
ssh -J 用户名B@B的内网IP 用户名A@A的公网IP

如果使用的不是标准的22端口，则是

1
ssh -J 用户名B@B的内网IP:B的端口 用户名A@A的公网IP -p A的端口

如果正常的话，这时应该会进入A的终端

将连接信息写入到配置文件

在~/.ssh/config中添加如下内容（这个文件不存在就手动新建）

1
2
3
4
5
6
7
8
Host ServerB
  HostName B的公网IP
  User B的用户名

Host ServerA
  HostName A的内网IP
  User A的用户名
  ProxyJump ServerB

说明：

  • 这里的Host后面的名字是主机名，可以自己改

  • ProxyJump后面的内容也可以直接写IP的，但建议还是把B单写出来，这样在连接服务器的时候可以直接使用ssh ServerB

  • 如果端口不是标准的22，可以在对应服务器的配置下面加Port 端口号

  • 用户名与当前登陆的用户一致，就可以不写User字段，后面都同理

  • 如有需要可以“以此类推”地串联下去，如果使用命令则是ssh 用户名3@服务器3的内网IP -J 用户名1@服务器1的公网IP,用户名2@服务器2的内网IP，连接顺序是1->2->3

使用

完成配置后，在使用rsync和scp等工具时可以用ServerA（或者自己设的其他名字）来代替服务器A的地址

例如使用rsync同步本地和远程的/home/user/目录：

1
rsync -a /home/user/ ServerA:/home/user/

非SSH协议的服务

比如http等不使用SSH的协议，那么就无法通过ProxyJump的方式来连接，需要通过服务器B的SSH对A上的服务进行端口转发

注意这里的HTTP服务指控制面板等，并不适用于需要公开访问的网站，那种情况请使用Nginx等软件进行反代

其实这种方法对于SSH协议也生效，只是步入ProxyJump方便

命令行中使用

这里服务器A只需要填IP和端口，连接的其他信息如用户名等在下一步连接时提供

本地端口可以任意填，可以和服务器A上业务的端口不一样，但注意不要与本地其他服务冲突

1
ssh -L -N -f 本地端口:服务器A的内网IP:用户名A@服务器A的服务端口 用户名B@B的公网IP

如果没有写-f参数，则终端会被阻塞没有响应，这是正常的，退出则需要按Ctrl+C

连接上后，就可以使用127.0.0.1和本地端口来连接服务器A上的服务了

比如http服务，就可以在浏览器打开http://127.0.0.1:本地端口

写入配置文件

本地转发也能在写入到配置文件中 虽然不太常见

1
2
3
4
Host ServerB
  HostName B的公网IP
  User B的用户名
  LocalForward 本地端口 A的内网IP:A的端口

参考

SSH to remote hosts through a proxy or bastion with ProxyJump

SSH 端口转发

]]> <p>在以前，云服务商提供的国内服务器带宽都很有限或非常昂贵，前段时间阿里云发布低价的200M带宽的轻量应用服务器，使得带宽成本大大降低</p> <p>一些在已有机器上的服务迁移麻烦，或者因为储存/算力的原因无法迁移，那么就自然而然地想到可以用大带宽机器中转，同时享受到大带宽和高算力/大储存</p> 其他语言中的 password_hash() https://stydxm.com/2025/02/04/password-hash-in-python/ 2025-02-04T14:56:17.000Z 2025-11-25T21:31:43.287Z PHP中有“一对函数”[1]password_hash()和password_verify()，用于对密码的加密和验证

若用其他语言重写PHP后端，通常不会影响到其他数据，但密码比较特殊：它被hash了。因此重写后若想保留用户数据就需要用相同的方式来验证，而且hash算法也是不可逆的，不可能使用其他算法重新编码。所以就需要想办法在其他语言中实现这两个函数

翻一下手册可以看到，这两个函数默认使用bcrypt算法，那么就可以很轻松地在其他语言中找到第三方库的实现

语言库
Pythonbcrypt
JSnode.bcrypt.js
Gocrypto/bcrypt

  1. PHP里密码哈希相关的还有两个argon2i和argon2id，不过它需要额外编译或安装，我想应该没啥人用？ ↩︎

]]> <p>PHP中有“一对函数”<sup class="footnote-ref"><a href="#fn1" id="fnref1">[1]</a></sup><code>password_hash()</code>和<code>password_verify()</code>，用于对密码的加密和验证</p> <p>若用其他语言重写PHP后端，通常不会影响到其他数据，但密码比较特殊：它被hash了。因此重写后若想保留用户数据就需要用相同的方式来验证，而且hash算法也是不可逆的，不可能使用其他算法重新编码。所以就需要想办法在其他语言中实现这两个函数</p> 在RISC-V上使用mid360 https://stydxm.com/2025/01/28/mid360-riscv/ 2025-01-28T18:58:39.000Z 2025-11-25T21:31:43.287Z 起因

因为学习需要用了一段时间的ROS2，又因为实习工作原因在用RISC-V架构的开发板，于是自然而然的想到了在RISC-V上使用ROS2

刚巧RevyOS完成了适配，在手头的LicheePi4A上安装后发现一切都很顺利，就想尝试实际应用一下了

众所周知啊，ROS2是用于机器人相关开发的，必然要使用到很多硬件；但在此同时呢，绝大多数硬件开发时完全不可能考虑到它在rv架构的兼容性，所以恐怕都比较寄。但是呢，手头刚好有一些mid360激光雷达，它使用TCP/IP来传输数据，兼容性上不容易出问题；同时它也不像工业相机那样有很大的数据量，这块性能羸弱的开发板应该可以正常收发，于是简单尝试了一下

运行

非常出人意料的是，Livox提供的sdk的屎代码虽然使用高版本gcc无法编译[1]，但是我切换到RevyOS源中的gcc-12后就可以正常编译了，只有几个WARNING，与x86上无异

结果

然后运行[2]livox-ros-driver2，就可以在rviz中看到雷达获取的点云了

这里要吐槽一下，他家有livox_ros_driver livox_ros_driver2 livox_ros2_driver，不光代码很屎山，名字还起的这么绕

用ros2 topic hz查看点云的帧率是正常的，但在rviz中看非常卡，如果要移动视角的话更是低于1fps

这大概是因为缺少gpu驱动，这个xfce桌面没有使用图形加速；而cpu本身性能就不行，还要负担这么重的图形计算任务，结果就是非常糟糕的体验

等有了性能足够的芯片以及在图形方面足够的软件支持，或许可以尝试一下把现在做的东西迁移到risc-v上来

遇到的问题

这里也不是完全没有遇到问题，列出一些我遇到的供参考：

CMake Warning

在CMake运行Findxxx.cmake找Eigen, PCL, Python, ROS等依赖时，都会报警告Policy CMP0148 is not set，参考文档手动改一下，或者直接设参数-Wno-dev忽略即可，不会影响最终结果

rviz2报错AT-SPI

运行时可能会有AT-SPI报错

1
2
[rviz2-2] (rviz2:25390): dbind-WARNING **: 17:30:40.653: AT-SPI: Error retrieving accessibility bus address: org.freedesktop.DBus.Error.ServiceUnknown: The name org.a11y.Bus was not provided by any .service files
[ERROR] [rviz2-2]: process has died [pid 25390, exit code -11, cmd '/opt/ros/humble/lib/rviz2/rviz2 --display-config /home/debian/livox_ros_driver2/launch/../config/display_point_cloud.rviz --ros-args'].

使用apt安装at-spi2-core包即可解决

rviz2报错Segmentation fault

启动rviz2时会报错Segmentation fault，无其他报错，即使将log-level设为DEBUG也看不到更多有用的信息

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
debian@revyos-lpi4a:~/livox_ros_driver2$ rviz2 --ros-args --log-level DEBUG
[DEBUG] [1742465374.358684709] [rclcpp]: signal handler installed
[DEBUG] [1742465374.358703710] [rclcpp]: deferred_signal_handler(): waiting for SIGINT/SIGTERM or uninstall
[DEBUG] [1742465374.359187059] [rcl]: Initializing node 'rviz' in namespace ''
[DEBUG] [1742465374.359362064] [rcl]: Using domain ID of '2'
[DEBUG] [1742465374.402647462] [rcl]: Initializing publisher for topic name '/rosout'
[DEBUG] [1742465374.402933138] [rcl]: Expanded and remapped topic name '/rosout'
[DEBUG] [1742465374.410872061] [rcl]: Publisher initialized
[DEBUG] [1742465374.411102068] [rcl]: Node initialized
[DEBUG] [1742465374.411547749] [rcl]: Initializing service for service name 'rviz/get_parameters'
[DEBUG] [1742465374.411706088] [rcl]: Expanded and remapped service name '/rviz/get_parameters'
[DEBUG] [1742465374.416014894] [rmw_fastrtps_cpp]: ************ Service Details *********
[DEBUG] [1742465374.416214900] [rmw_fastrtps_cpp]: Sub Topic rq/rviz/get_parametersRequest
[DEBUG] [1742465374.416312570] [rmw_fastrtps_cpp]: Pub Topic rr/rviz/get_parametersReply
[DEBUG] [1742465374.416398239] [rmw_fastrtps_cpp]: ***********
[DEBUG] [1742465374.416825587] [rcl]: Service initialized
[DEBUG] [1742465374.417099595] [rcl]: Initializing service for service name 'rviz/get_parameter_types'
[DEBUG] [1742465374.417228266] [rcl]: Expanded and remapped service name '/rviz/get_parameter_types'
[DEBUG] [1742465374.419828684] [rmw_fastrtps_cpp]: ************ Service Details *********
[DEBUG] [1742465374.420026023] [rmw_fastrtps_cpp]: Sub Topic rq/rviz/get_parameter_typesRequest
[DEBUG] [1742465374.420121360] [rmw_fastrtps_cpp]: Pub Topic rr/rviz/get_parameter_typesReply
[DEBUG] [1742465374.420198029] [rmw_fastrtps_cpp]: ***********
[DEBUG] [1742465374.420439370] [rcl]: Service initialized
[DEBUG] [1742465374.420626043] [rcl]: Initializing service for service name 'rviz/set_parameters'
[DEBUG] [1742465374.420747713] [rcl]: Expanded and remapped service name '/rviz/set_parameters'
[DEBUG] [1742465374.423464468] [rmw_fastrtps_cpp]: ************ Service Details *********
[DEBUG] [1742465374.423708142] [rmw_fastrtps_cpp]: Sub Topic rq/rviz/set_parametersRequest
[DEBUG] [1742465374.423797145] [rmw_fastrtps_cpp]: Pub Topic rr/rviz/set_parametersReply
[DEBUG] [1742465374.423875148] [rmw_fastrtps_cpp]: ***********
[DEBUG] [1742465374.424161157] [rcl]: Service initialized
[DEBUG] [1742465374.424362830] [rcl]: Initializing service for service name 'rviz/set_parameters_atomically'
[DEBUG] [1742465374.424478500] [rcl]: Expanded and remapped service name '/rviz/set_parameters_atomically'
[DEBUG] [1742465374.427344926] [rmw_fastrtps_cpp]: ************ Service Details *********
[DEBUG] [1742465374.427545599] [rmw_fastrtps_cpp]: Sub Topic rq/rviz/set_parameters_atomicallyRequest
[DEBUG] [1742465374.427635269] [rmw_fastrtps_cpp]: Pub Topic rr/rviz/set_parameters_atomicallyReply
[DEBUG] [1742465374.427713938] [rmw_fastrtps_cpp]: ***********
[DEBUG] [1742465374.427935945] [rcl]: Service initialized
[DEBUG] [1742465374.428139619] [rcl]: Initializing service for service name 'rviz/describe_parameters'
[DEBUG] [1742465374.428292290] [rcl]: Expanded and remapped service name '/rviz/describe_parameters'
[DEBUG] [1742465374.430942709] [rmw_fastrtps_cpp]: ************ Service Details *********
[DEBUG] [1742465374.431134382] [rmw_fastrtps_cpp]: Sub Topic rq/rviz/describe_parametersRequest
[DEBUG] [1742465374.431227718] [rmw_fastrtps_cpp]: Pub Topic rr/rviz/describe_parametersReply
[DEBUG] [1742465374.431306388] [rmw_fastrtps_cpp]: ***********
[DEBUG] [1742465374.431542062] [rcl]: Service initialized
[DEBUG] [1742465374.431731401] [rcl]: Initializing service for service name 'rviz/list_parameters'
[DEBUG] [1742465374.431875073] [rcl]: Expanded and remapped service name '/rviz/list_parameters'
[DEBUG] [1742465374.434697164] [rmw_fastrtps_cpp]: ************ Service Details *********
[DEBUG] [1742465374.434888170] [rmw_fastrtps_cpp]: Sub Topic rq/rviz/list_parametersRequest
[DEBUG] [1742465374.434986173] [rmw_fastrtps_cpp]: Pub Topic rr/rviz/list_parametersReply
[DEBUG] [1742465374.435067509] [rmw_fastrtps_cpp]: ***********
[DEBUG] [1742465374.435447855] [rcl]: Service initialized
[DEBUG] [1742465374.435672529] [rcl]: Initializing publisher for topic name '/parameter_events'
[DEBUG] [1742465374.435807200] [rcl]: Expanded and remapped topic name '/parameter_events'
[DEBUG] [1742465374.442996098] [rcl]: Publisher initialized
[DEBUG] [1742465374.443965796] [rcl]: Initializing subscription for topic name '/parameter_events'
[DEBUG] [1742465374.444178803] [rcl]: Expanded and remapped topic name '/parameter_events'
[DEBUG] [1742465374.445930193] [rcl]: Subscription initialized
[DEBUG] [1742465374.593761967] [rviz2]: Load pixmap at package://rviz_common/images/splash_overlay.png
Segmentation fault

解决方案在RevyOS的文档中有写，按文档说明操作即可

使用 sudo switch-gl gl4es 再重启后使用 LIBGL_ALWAYS_SOFTWARE=true rviz2 here 启动

为了在ros2 launch时启动rviz2，我用export命令设置环境变量

rviz2帧率太低

rviz并不能支持th1520的GPU，所以要正常启动就必须将渲染模式改为软解，即设置上面提到的环境变量

因为CPU本来就很弱，使用软解只有个位数的帧率，操作体验非常难受

这里我选择使用ros2的多机通信功能，即在开发板上和另一台性能足够的电脑上设置相同的ROS_DOMAIN_ID，然后在电脑上启动rviz2，这样就能解决性能问题，流畅使用rviz2了

  1. 这是我之前就发现的问题，在x86_64也是这样的，与risc-v无关 ↩︎

  2. 这里使用的不是官方仓库的，而是一个第三方修改版，实际功能等都没有变化，只是让代码变得没有那么💩。我后来还提交了一个PR ↩︎

]]> 没想到啊，这么顺利？ 构建Text2SQL多轮对话的benchmark https://stydxm.com/2024/07/02/nl2sql-benchmark/ 2024-07-02T07:27:17.000Z 2025-11-25T21:31:43.287Z 数据集

已有数据集

经调研，目前已有的较完善的数据集有Chase[1]、SParC[2]、CoSQL[3]

其中SParC和CoSQL都是耶鲁大学与SalesForce合作的成果，Chase是西交和微软合作的成果，三个数据集中只有它是中文的

统计[4]

数据集数据量1轮2轮3轮4轮5轮6轮更多
Chase394906971858103335290
SParC3034879315516334450
CoSQL24582564874675456382
Chase\SParC
1
2
3
4
5
6
7
8
import json
data=json.load(open("train.json"))
count={}
for i in list(data):
    l=len(i["interaction"])
    count[l]=count.get(l,0)+1
for i in list(sorted(count)):
    print(i," ",count[i])
CoSQL
1
2
3
4
5
6
7
8
9
10
11
12
import json
data=json.load(open("cosql_all_info_dialogs.json"))
count={}
for i in list(data):
    i=data[i]
    l=0
    for j in i["turns"]:
        if j["isUser"]:
            l+=1
    count[l]=count.get(l,0)+1
for i in list(sorted(count)):
    print(i," ",count[i])

exact set match metrics

浏览数据集的时候发现，chase的ground truth以两种形式同时呈现

比如，这个语句SELECT name FROM department GROUP BY departmentID ORDER BY count(departmentID) DESC LIMIT 1;就会被拆分成：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
"sql": {
    "orderBy": [
        "desc", 
        [
            [
                0, 
                [
                    3, 
                    5, 
                    false
                ], 
                null
            ]
        ]
    ], 
    "from": {
        "table_units": [
            [
                "table_unit", 
                1
            ]
        ], 
        "conds": []
    }, 
    "union": null, 
    "except": null, 
    "groupBy": [
        [
            0, 
            5, 
            false
        ]
    ], 
    "limit": 1, 
    "intersect": null, 
    "where": [], 
    "having": [], 
    "select": [
        false, 
        [
            [
                0, 
                [
                    0, 
                    [
                        0, 
                        6, 
                        false
                    ], 
                    null
                ]
            ]
        ]
    ]
}

可以看出来以操作的关键字结构化地分割了，但是这样做的目的，以及对象中的数字、布尔值、空值的意义都不明确

而在SParC的论文[2:1]中提到了，这是受Spider[5]的启发

Following Yu et al. (2018c), we use the exact set match metric to compute the accuracy between gold and predicted SQL answers. Instead of simply employing string match, Yu et al. (2018c) decompose predicted queries into different SQL clauses such as SELECT, WHERE, GROUP BY, and ORDER BY and compute scores for each clause using set matching separately.

这么做的原因是为了提高打分的精确度，以及对不同操作进行更细粒度的评测

We report the following two metrics: question match, the exact set matching score over all questions, and interaction match, the exact set matching score over all interactions. The exact set matching score is 1 for each question only if all predicted SQL clauses are correct, and 1 for each interaction only if there is an exact set match for every question in the interaction.

spider也提供了一个转换脚本

构建数据集

上述Chase和SParC是已有工作中比较好的 好像也没啥别的 故采用他们提出的方法，针对项目的场景，构建自己的数据集

评测

使用耶鲁大学课题组与论文一同发布的评测代码，并在此基础上做一些小修改以适应需求

  1. Chase 1.0: A Large-Scale and Pragmatic Chinese Dataset for Cross-Database Context-Dependent Text-to-SQL ↩︎

  2. SParC 1.0: Yale & Salesforce Semantic Parsing and Text-to-SQL in Context Challenge ↩︎ ↩︎

  3. CoSQL 1.0: A Conversational Text-to-SQL Challenge Towards Cross-Domain Natural Language Interfaces to Databases ↩︎

  4. SParc中有4个“0轮”的，即该条数据的interaction键对应的数组长度为0，但因为final中储存了问题和答案，所以实际也是1轮，只是缺少了意图等数据 ↩︎

  5. Spider: A Large-Scale Human-Labeled Dataset for Complex and Cross-Domain Semantic Parsing and Text-to-SQL Task ↩︎

]]> 最近因项目需要做的一些调研，顺手记录一下了 Hi6285 https://stydxm.com/2024/03/09/hi6285/ 2024-03-09T12:56:38.000Z 2025-11-25T21:31:43.287Z 该样品和下面的Dieshot均来自于Kurnal

]]> <p>该样品和下面的Dieshot均来自于<a href="https://space.bilibili.com/427356495/">Kurnal</a></p> HGAME Week1 https://stydxm.com/2024/01/30/hgame-week1/ 2024-01-30T18:19:11.000Z 2025-11-25T21:31:43.287Z HGAME

出于一些机缘巧合，暑假里加入了Vidar-Team的新生群，逐渐开始了解CTF，八月打了一段时间的hgame-mini，一度（指大佬还没来的时候）排到了第一页
虽然加入vidar基本没有可能，但也有幸认识了一些成员，这里特别要感谢Answer和eking的无私奉献对我帮助非常大，也很感谢baimeow和potato带我加入了DN11，对计网有了点更深入的了解
开学后各种事情以及开发任务逐渐增加，同时也很难找到队友，甚至于参加省赛时三个人的队伍剩下两个人一道题都没做出来，我只能选择放弃了安全这个方向。杭电的学长们一直在提的HGAME这会儿开始了，也就在寒假里抽空随便做点吧，应该是根本不存在的生涯中最后一赛了

MISC

签到

1
hgame{welc0m3_t0_HGAME_2024}

到此一游

SignIn

![try_another_way_to_see.png]
传到手机上从不同方向看

1
hgame{WOW_GREAT_YOU_SEE_IT_WONDERFUL}

Web

ezHTTP

前半段貌似hgame-mini同款

访问靶机，返回请从vidar.club访问这个页面
设置请求Headers

1
Referer: vidar.club

返回请通过Mozilla/5.0 (Vidar; VidarOS x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36 Edg/121.0.0.0访问此页面，接着改Headers

1
User-Agent: Mozilla/5.0 (Vidar; VidarOS x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36 Edg/121.0.0.0

返回请从本地访问这个页面，设置X-Forwarded-For: 127.0.0.1，发现返回值没有变化，仔细一看返回Headers里有个Hint: Not XFF

略加思索~~（指ChatGPT）~~，把XFF改成了X-Real-IP，返回值变成了Ok, the flag has been given to you ^-^
返回Headers里有Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJGMTRnIjoiaGdhbWV7SFRUUF8hc18xbVAwclQ0bnR9In0.VKMdRQllG61JTReFhmbcfIdq7MvJDncYpjaT7zttEDc，一眼JWT的格式，base64解码之后得到flag

1
hgame{HTTP_!s_1mP0rT4nt}

Bypass it

访问靶机，弹窗提示欢迎使用用户管理系统，请先登陆，点击确定后跳转到/login.html

点击注册按钮后跳转到register_page.php，虽然会弹窗很抱歉，当前不允许注册
开始还以为题目名字的意思是SQL注入，试了好久也没成功，后来无意中发现注册页面可以看到元素

1
2
3
4
5
6
7
8
<li>
<label>用户名:</label>
<input type="text" name="username" />
</li>
<li>
<label>密　码:</label>
<input type="password" name="password" />
</li>

根据表单构造请求，返回数据

1
2
3
<script language='javascript' defer>
    alert('注册成功');top.location.href='login.html'
</script>

正常登录即可获取到flag

1
hgame{b5619c116a434cda50308d84f381ea85124d1b2e}

Select Courses

打开靶机，啊这正方教务的UI……

所有课都显示已满，点击有弹窗提示课程已满！

打开开发者工具，发现点击选课按钮的时候会POST请求/api/courses，payload为{"id":1}，返回{"full":1,"message":"课程已满"}
点右上选完了按钮会请求/api/ok并返回{message: "呜呜呜，还没选上课呢！"}
查看源码还可以发现课程列表来自GET请求/api/courses
然后……最近项目有点多，只能腾出这半小时，没时间研究了，就这样吧（

后来看wp，原来是思路完全错了，要轮询抢课

]]> <h1>HGAME</h1> <p>出于一些机缘巧合，暑假里加入了<a href="https://vidar.club/">Vidar-Team</a>的新生群，逐渐开始了解CTF 解包小米路由器固件 https://stydxm.com/2023/10/31/miwifi-firmware/ 2023-10-31T16:36:27.000Z 2023-11-07T08:48:00.000Z 看到Ljcbaby在群里说，小米路由器开ssh的那个洞在新机器可能依然存在，遂一起研究一下

本文中的操作主要在Ubuntu23.04中完成

先从小米官网上下载固件，没什么好说的（还在用http，离谱）。
这里为了对比，下了ax3000t和ac2100的固件，这两台机器都有人在用，并且后者是已知有这个洞，而前者固件修复了这个问题但据说依然有办法。
不清楚新固件有没有修，ac2100就用了2.0.722的miwifi_r2100_firmware_4b519_2.0.722.bin

解包[1]

安装工具

1
pip3 install ubi_reader

安装后

1
ubireader_extract_images miwifi_r2100_firmware_4b519_2.0.722.bin
1
UBI_File Warning: end_offset - start_offset length is not block aligned, could mean missing data.UBI_File Warning: end_offset - start_offset length is not block aligned, could mean missing data.

有警告，不过问题不大，得到img-1537728761_vol-ubi_rootfs.ubifs

1
unsquashfs img-1537728761_vol-ubi_rootfs.ubifs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
Parallel unsquashfs: Using 6 processors
2763 inodes (2453 blocks) to write


create_inode: could not create character device squashfs-root/dev/console, because you're not superuser!
[========================================================================================================================================/ ] 5215/5216  99%

created 2422 files
created 219 directories
created 339 symlinks
created 0 devices
created 0 fifos
created 0 sockets
created 1 hardlink

解压出了整个文件系统

1
ls
1
bin  data  dev  etc  lib  mnt  overlay  proc  readonly  rom  root  sbin  sys  tmp  userdisk  usr  var  www

代码在/usr/lib/lua/xiaoqiang里（好像代码层面小米路由器的代号是xiaoqiang？）
ax3000t的.bin文件可以解出img-1508723001_vol-kernel.ubifs和img-1508723001_vol-rootfs.ubifs两个文件，但kernel那个用unsquashfs解不开，应该只是系统内核，意义不大，rootfs那个里面就有目录结构了

反编译

这里用了一个github项目，简单翻了下代码在/src/unluac/，但是没看到maven或者gradle之类的配置文件
后来在actions配置（/.github/workflows/jarbuild.yml）里看到了构建方法，就是非常原始的一个个编译再拼起来

1
2
3
mkdir build
javac -d build -sourcepath src  src/unluac/*.java
jar -cfm build/unluac.jar src/META-INF/MANIFEST.MF -C build  .

得到编译产物unluac.jar，再扫两眼代码看下用法，让ChatGPT写个脚本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 创建decompiled目录（如果不存在）
mkdir -p decompiled

# 使用find命令递归查找source目录下的所有.lua文件
find source -type f -name "*.lua" -print0 | while IFS= read -r -d $'\0' file; do
    # 构造输出文件路径（替换source为decompiled）
    output_file="decompiled/$(dirname "${file/source/decompiled}")/$(basename "$file")"
    
    # 创建输出文件的目录（如果不存在）
    mkdir -p "$(dirname "$output_file")"
    
    # 使用unluac.jar工具进行反编译，将输出写入到对应的文件中
    java -jar ./unluac.jar "$file" > "$output_file"
    
    # 打印处理的文件路径
    echo "Decompiled: $file -> $output_file"
done

这是Windows的，但不知道为什么（可能是他程序的问题）子目录下的识别不到

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
@echo off
setlocal enabledelayedexpansion

REM 设置源目录和目标目录
set "sourceDir=source"
set "outputDir=decompiled"

REM 创建目标目录
mkdir %outputDir% 2>nul

REM 递归处理源目录下的所有.lua文件
for /r "%sourceDir%" %%f in (*.lua) do (
    set "sourceFile=%%f"
    set "outputFile=!sourceFile:%sourceDir%=%outputDir%!"
    java -jar unluac.jar "!sourceFile!" > "!outputFile!"
)

echo "反编译完成"
pause

至此，我们就获得了小米路由器的源码，虽然经过了混淆但还是有一定的意义，可以进行一些简单的字符串搜索或者扔给AI

2023.11.7更新
ljc看到称bug存在的那位说出了方法，就不再研究了
但是因为群是比较封闭的小群，也没问，所以就不把方法写出来了

  1. 某论坛的一个帖子 ↩︎

]]> <p>看到<a href="https://github.com/ljcbaby">Ljcbaby</a>在群里说，小米路由器开ssh的<a href="https://zhuanlan.zhihu.com/p/460949138">那个洞</a>在新机器可能依然存在，遂一起研究一下</p> Google I/O Connect 2023 https://stydxm.com/2023/09/07/google-io-connect-2023/ 2023-09-07T12:20:36.000Z 2023-11-07T08:48:00.000Z

本文图片可见相册

八月看到了谷歌发了篇推文，反正暑假也没什么事，就报了个名
报名表里有职位这么个选项，同时又觉得谷歌开发者大会的审核可能并不容易通过（而且这是io connect而不是往年的summit），刚好在朋友的空壳公司挂了虚职CTO，就写了个C-level高管 （不到二十岁，事CTO） ，于是半个多月之后……

上海，我来力


说起来其实高考完这个暑假已经来了四次上海了，一次bw一次cj，还有一次是陪来上海的外地朋友，不过世博园这里倒是从世博会之后就没来过了
当时还小，对世博会已经没什么印象了，但这个中国馆总是给我种未曾谋面但非常熟悉的感觉

混入其中

订的酒店挺便宜的，离世博园也不远，走一个红绿灯就能看到世博会中国馆了，但到世博中心还得坐一站地铁


到正面再来一张

差不多准时到的，门口排队的人不多，目测一两百人（bw cj几万十几万人排队给我整出心理阴影了），人均双肩包+黑白T恤

因为人少，没多久就排完队进场了

Google标和标志性的Google色

会场

现场有一个装饰成鼓形的屏幕，挺有意思的，在旁边背景板前有机器可以拍照，拍完之后点同意就会展示在屏幕上，并且也可以用手机扫描二维码获取照片

当时排队的人贼多，后来走之前几乎没人了就拍了几张，爆照就算了（
这就是那面背景墙



签到处


巨大的……可以叫海报吧？


结合了Google风格颜色和中国风外形的背景墙
估计是因为审核相对较严， （怎么把我放进来了） 会场上人并不多，目测最多也就四五百吧



还有苦逼的打工人，到了这还得加班

签到

签到之后领到了小礼品，一个袋子和几个徽章

这设计风格很Google

免费报名的活动还管饭，虽然标配但还是要说一声良心

Keynote


主旨演讲开始前半小时就放开了所有的区域，可以进入会场了


Google大中华区的总裁陈俊挺，但说中文听起来怪怪的
吉祥物大黄，很符合我对外企在华本地化的想象（

然后就是各路title听起来很牛逼的Google大佬



↑这位是Google Web ML的部门主管，记住他，后面还有
https://ioconnectchina.googlecnapps.cn/speakers/profile/a-jason-mayes-ai02/
以及谷歌的一些技术和计划





这张并不是Keynote，而是后面演讲时拍的
主旨演讲的内容也可以在这里看到

餐食

午餐可以凭餐券从中餐、西餐和纯素食中选一份，我这份是西餐，对于我这个不挑剔的人来说味道也还挺好的

全天都有供应零食咖啡饮料，还有一些冰柜里放着文创雪糕

展示区

在地图上可以看到展示区的内容
里面也有不少的内容，比如Google一些工具的特性前瞻和一些团队与Google合作做出来的一些有意思的项目
比如这个，给乐高加上硬件接口的项目组，就用乐高积木做了个简单的循迹小车

还有一个叫Gameface的项目，用摄像头识别人脸动作代替传统的昂贵而适用性反而更差的专用控制设备，帮助有肢体残疾和渐冻症等的残疾人玩游戏（在主旨演讲中也有提到）
至于反作弊，现场问了下确实是有被反作弊识别为外挂的情况，但我觉得做一个虚拟的控制设备就可以解决

来视察工作的陈总

AI

从现场展示区的布局和主旨演讲中的占比可以看得出来，重头还是AI

但是展示区这里的demo和技术似乎……也没有什么能让我眼前一亮的东西
比如这个跑在浏览器里的Mediapipe，但TensorFlow.js也出现好久了，这些基础的CV也不是很重的运算任务，虽然帧数确实跑得很高


看我自己设计的T恤
把palm 2集成进了Android studio，问了一下有支持别的语言的计划但并没有移植到别的IDE的计划
以及，工作人员说

Unfortunately, this is only available in the US.


你这些关键词里有几个不太对劲啊.jpg

还有一些flutter啊，passkey啊还有chrome devtools的自动填充什么的这些也没啥意思，拍照都没拍，也没去深入了解

合影

B站看到了三太子敖丙的直播

跑过去蹭了个合照

后来又看到差评君也在直播

还没去找，刚巧他就往我这走过来了，不过看这阵仗，旁边还围了几个人，也没好意思去打扰

one more thing

听完主旨演讲往展示区走的路上，看到有好多人围着一位在交流，想这肯定是个大佬，就拍了张照

没想到他看到之后招了招手，我就凑过去跟他聊了两句，顺便合了个影

后来在TensorFlow.js那里见到他了，他甚至认识我了，主动跟我打了个招呼
我看到他展台摆的也是Mediapipe（他对面的是Mediapipe但是注重的是这个模型，而他主要讲解的是在浏览器里运行这个模型），刚巧之前我也用到过这个项目，就只能尴尬地临时想了个问题，问有没有计划使模型泛用性更强，比如让它可以识别猫狗这些动物
可能是我英语不好没表达清楚，也可能是会场太吵了导致他听错了，他似乎以为我问的是如何训练针对其他动物的模型，于是跟我讲了好久you need losts of data和actually you can do this with mediapipe’s code and cats’ dataset
看他兴致勃勃地，我也不好意思打断他，听他讲完之后表示谢意就跑了
然后，突然发现他的挂牌挂绳是代表主旨演讲嘉宾的红色，瞥到一眼腰间别着的工牌上的名字，发现是Jason Mayes
对，前面提到那个Google Web ML的主管
是的……Google Web机器学习的主管，教我机器学习……

回家

再看两眼中国馆


跑路（

结尾

开始我觉得通过我的报名表只是审查中的疏漏，没有发现我这个19岁的“C-level高管”
但参与活动后我越来越觉得这更是刻意而为之
我看到了在二楼一张小桌旁围坐着开会的Google员工，他们的神情平等地投入而又专注、眼中闪烁着相同的创意和想象力；主管级的技术大牛愿意为一个几乎没有机器学习基础的准大一新生细致地讲解训练一个能够识别猫的骨骼的模型的步骤
而我在他们的眼里，会不会就是一个未来可期的年轻创业者呢？
虽然现在我不是，但我希望我在四年内会是

]]> 我就像那只混进狼群的哈士奇 Intel SoMa https://stydxm.com/2023/03/18/intel-soma/ 2023-03-18T04:04:49.000Z 2025-11-25T21:31:43.287Z 等了好久，终于拿到这几颗soma b3了


我手上的这三颗编号是1097 1739 3246
还有我之前搞到的两颗soma（编号476 2948）

虽然点不亮用不上，这每核15线程[1]的架构只是拿来收藏也挺有意思的
（不过按照结城的说法，成千上万颗+Intel FPGA这两个要求或许就注定民间无法点亮soma了）

  1. 原文，存档1，存档2 ↩︎

]]> <p>等了好久，终于拿到这几颗soma b3了</p> 高考前的第一百天 https://stydxm.com/2023/02/27/100-days-before-gaokao/ 2023-02-27T14:13:55.000Z 2025-11-25T21:31:43.286Z 今天是2023.2.27，如果我们没有数错的话离6.7的高考还有刚好100天时间
三年初中三年高中过去的这么快，体验过首考之后的我也知道一百天只会更快

首考不甚理想，离我的目标杭电计算机还有大概两百五十分差距。当然语数两门课考到这么高是不可能的，只能寄希望于另四门课有些提升吧
毕竟绝大多数人的高考只有一次，一念之间，一道数学选择题就是五分，哪怕是多了或者少了一分也有可能会极大地改变人生轨迹
不敢期望高考能有什么超常发挥，每门课都能发挥出应有的水平就是很大的幸运了

（这是晚上在操场上拍的星空）

]]> <p>今天是2023.2.27，如果我们没有数错的话离6.7的高考还有刚好100天时间<br> 三年初中三年高中过去的这么快，体验过首考之后的我也知道一百天只会更快</p> 开启阿里云的.cn域名隐私保护这么难？ https://stydxm.com/2022/12/31/enable-aliyun-privacy-protect/ 2022-12-31T11:57:17.000Z 2025-11-25T21:31:43.286Z 收到通知

前两天收到阿里云的一份邮件
指向一份公告1月1日国家顶级域名（.CN、.中国）隐私保护服务收费的公告

39一年，虽然有点贵，但为了避免实名上网还是得买 （早知道这还收费就不买cn后缀了）

寻找产品

我还以为很简单，域名隐私保护服务嘛，搜一下就是了。结果找半天，文档里也没有，产品里也没有，站内也搜不到，只能找到一篇2018年的暂停公告

给客服打电话

客服告诉我在域名控制台-管理-安全设置里可以开启，结果一看并没有，还有一条“温馨提示”，内容就是2018的那个公告

再给客服打电话

跟客服说了前个客服告诉我的和我看到的情况，结果他略带疑惑地轻声说了句“是已经暂停了呀”，我告诉他我收到的邮件之后他让我稍等（看来客服还没了解这个情况……），然后说要申请，通过短信给我发了这个链接

填表单

居然这玩意还是填表单申请，人工手动开通的……

1.4不知道能不能完成呢

2023.1.4 update

付钱

1.4打开阿里云看到了账单

居然提示消息还有模板字符串没替换的bug？

2023.1.8 update

***，退钱！

本来以为完事了，结果收到一封邮件

到后台一看，猛然发现有效期就4天

说好的39一年呢？？？怎么只有四天？？？

客服表示“反馈专员核实”，那就只能先等着了

2023.2.27 update

好像完事了

似乎早就给开了，不过没有提醒，我也不知道是什么时候修正的问题

]]> 2022的最后一天，我竟在折腾这个…… 传输巨量数据：卡车拉硬盘，还真不是个梗 https://stydxm.com/2022/11/19/migrate-massive-data/ 2022-11-19T05:56:34.000Z 2025-11-25T21:31:43.287Z 前言

Never underestimate the bandwidth of a station wagon full of tapes hurtling down the highway. – Andrew S. Tanenbaum[1]

前几天看到一张表情包，大意是可以用卡车转移数据到aws
本来以为是玩梗，没想到去搜了一下之后发现aws真的有这样的服务，叫做AWS Snowmobile

查资料的时候发现已经有人给直接移动储存介质的传输方式取了个名字——Sneakernet，中文叫球鞋网络或者跑腿网络[2]，于是就想写写关于大量数据传输的内容
在云计算时代，如果企业要从传统的机房迁移到云服务商，势必要传输大量的数据；当数据达到一定量的时候，从企业自己服务器的硬盘传到云服务商的储存中去也是很困难的事，云服务器为了方便客户迁移，也给出了各种迁移方案
查资料的时候也发现aws已经推出了很多sneakernet的服务，所以下面提到云服务商的时候主要以aws为例 我看到snowmobile才想要写这篇的

网络

通过网络传输数据是最常规、最简便的方法，对于绝大多数个人和企业的非业务数据，直接通过网络传输数据方便快捷，必然是首选
但是对于数据规模较大的情况，即使不考虑大量数据上传的网络带宽费用，即使以千兆网络的理论速率，每周也只能上传约75T的数据
这样的速率对于数据量稍大的情况来说——比如企业的数据库、科研数据等——意味着需要付出很长的时间和不小的流量开支，而且耗时太长

运输储存介质

当数据量大到网络传输数据的耗时不可接受时，就需要使用sneakernet传输数据
以aws为例，他们已经有很多[3]专门用于数据上云的服务了，其中的Snow系列就是sneakernet的应用

直接邮寄储存介质

Many years ago, professor Andy Tanenbaum wrote the following:

Never underestimate the bandwidth of a station wagon full of tapes hurtling down the highway.

Since station wagons and tapes are both on the verge of obsolescence, others have updated this nugget of wisdom to reference DVDs and Boeing 747s.[4]

AWS Import/Export

早在2009年3月，阿里云和azure都还不存在的时候，aws就推出了这个服务
客户可以把小于50磅、8U[4:1]的储存设备寄给亚马逊，亚马逊会把里面的文件导入S3
不过目前这个服务已经停止了，博客中留的产品页面现在会被重定向到snowball，大概是因为已经有其他更成熟、更细分的服务可以上云了吧
当年用来计算耗时的计算器居然现在还能用
虽然由于物理接口速度的限制（当时的USB 2.0和eSATA都还不到千兆），每周只能传输大概40-50TB的数据，现在看起来速度并不快，但对比当时的网速这并不慢，不妨是一种成功的尝试

其他

清华也运过有700TB实验数据的磁带[5]

将数据装载在专用设备中邮寄

AWS Import/Export Snowball

We launched the first-generation AWS Snowball service way back in 2009. As I wrote at the time, “Hard drives are getting bigger more rapidly than internet connections are getting faster.” I believe that remains the case today. In fact, the rapid rise in Big Data applications, the emergence of global sensor networks, and the “keep it all just in case we can extract more value later” mindset have made the situation even more dire.[6]

2015年10月亚马逊推出了Snowball，速度提升到了每周1PB[6:1]，而且有了实体的设备

这个snowball设备就是个箱子，有电源、网口和一块屏幕，我猜测内部是类似普通开发板的架构和一些硬盘，最多可以储存50TB数据[6:2]
它的使用方法变成了客户在内网里向snowball写入数据，然后寄给亚马逊，亚马逊会进行导入
做出这样改变的原因我猜测是这样标准化的设备在亚马逊的数据中心里可以自动化操作，而以前五花八门的设备显然做不到；而且manifest由程序自动生成，方便使用的同时也减少了错误
aws另外发布过Snowball Edge、Snowcone这些设备，只是介质和容量有所不同，其他也都大同小异

Azure Data Box

azure也有类似服务，叫Azure Data Box，有40TB的Data Box Disk、100TB的Data Box、1PB的Data Box Heavy三种，这里讲讲“标准款”的Data Box

它有一个电口两个光口，共三个万兆接口

Transfer Appliance

GCP也有这样的设备Transfer Appliance
Google只说了有40TB的TA40和300TB的TA300两种型号，但甚至连一张照片都没有发
属实保密程度高

上门收货

AWS Snowmobile

这就是我当时看到的那个卡车拉硬盘的服务，aws更是把卡车开到了发布会上

确切地说，snowmobile并不包含卡车，而是一个集装箱
它可以储存100PB数据，有共计1T的网络带宽，可以在几周内传输EB级的数据
钱给到位，亚马逊甚至可以给你安排发电机、安排车辆护送、安排安保人员哦

离谱方法

这里的仅供图一乐 应该没人真的会这么用吧

IPoAC

全称IP over Avian Carriers，以鸟类为载体的网际协议，来自rfc 1149，这是一个愚人节rfc

图源

并且还真的有人实践过:2001年四月，挪威卑尔根的一个用户组发了九个“包”

rfc1149甚至还有修订版，即加上了QoS的rfc2549和支持IPv6的rfc6214

  1. Tanenbaum, Andrew S. (1989). Computer Networks. New Jersey: Prentice-Hall. p. 57. ISBN 0-13-166836-6. ↩︎

  2. Sneakernet ↩︎

  3. Migration & Transfer on AWS ↩︎

  4. AWS Import/Export: Ship Us That Disk! ↩︎ ↩︎

  5. 金枪鱼之夜：空运磁带的 PB 级实验数据传输 ↩︎

  6. AWS Import/Export Snowball – Transfer 1 Petabyte Per Week Using Amazon-Owned Storage Appliances ↩︎ ↩︎ ↩︎

]]> 前几天看到一张表情包，大意是可以用卡车转移数据到aws<br>本来以为是玩梗，没想到去搜了一下之后发现aws真的有这样的服务 整活：玩游戏时，在你笑的时候使用AI自动瞄准 https://stydxm.com/2022/10/08/smile-aim/ 2022-10-08T12:56:46.000Z 2025-11-25T21:31:43.287Z 前两天同学聊天的时候发了个视频，还提了个很有趣的思路——在笑的时候自动瞄准
一看视频挺有意思的，实现应该也不难，试了一下不到一小时就做完了


思路

  • 读取摄像头输入，检测表情
  • 检测到笑了之后，开始捕捉屏幕画面
  • 在屏幕画面中识别人形，并读取坐标
  • 如果能识别到人，就将鼠标移到头的位置

实现

技术栈

识别表情

看视频里的实现方法[1]简单而且效果不差，懒得再去找更好的方案了，就直接拿来用吧

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
# 调用电脑摄像头进行实时人脸+眼睛+微笑识别，可直接复制粘贴运行
# bilibili视频教程:同济子豪兄
# 2019-5-16
import cv2

face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades+'haarcascade_frontalface_default.xml')

eye_cascade = cv2.CascadeClassifier(cv2.data.haarcascades+'haarcascade_eye.xml')

smile_cascade = cv2.CascadeClassifier(cv2.data.haarcascades+'haarcascade_smile.xml')
# 调用摄像头
cap = cv2.VideoCapture(0)

while(True):
    # 获取摄像头拍摄到的画面
    ret, frame = cap.read()
    faces = face_cascade.detectMultiScale(frame, 1.3, 2)
    img = frame
    for (x,y,w,h) in faces:
    # 画出人脸框，蓝色，画笔宽度微
        img = cv2.rectangle(img,(x,y),(x+w,y+h),(255,0,0),2)
    # 框选出人脸区域，在人脸区域而不是全图中进行人眼检测，节省计算资源
        face_area = img[y:y+h, x:x+w]
        
        ## 人眼检测
        # 用人眼级联分类器引擎在人脸区域进行人眼识别，返回的eyes为眼睛坐标列表
        eyes = eye_cascade.detectMultiScale(face_area,1.3,10)
        for (ex,ey,ew,eh) in eyes:
            #画出人眼框，绿色，画笔宽度为1
            cv2.rectangle(face_area,(ex,ey),(ex+ew,ey+eh),(0,255,0),1)
        
        ## 微笑检测
        # 用微笑级联分类器引擎在人脸区域进行人眼识别，返回的eyes为眼睛坐标列表
        smiles = smile_cascade.detectMultiScale(face_area,scaleFactor= 1.16,minNeighbors=65,minSize=(25, 25),flags=cv2.CASCADE_SCALE_IMAGE)
        for (ex,ey,ew,eh) in smiles:
            #画出微笑框，红色（BGR色彩体系），画笔宽度为1
            cv2.rectangle(face_area,(ex,ey),(ex+ew,ey+eh),(0,0,255),1)
            cv2.putText(img,'Smile',(x,y-7), 3, 1.2, (0, 0, 255), 2, cv2.LINE_AA)
        
# 实时展示效果画面
    cv2.imshow('frame2',img)
    # 每5毫秒监听一次键盘动作
    if cv2.waitKey(5) & 0xFF == ord('q'):
        break

# 最后，关闭所有窗口
cap.release()
cv2.destroyAllWindows()

识别人体和骨骼绑定

暑假里搞了几天MediaPipe，不敢说有多精通，至少是搞明白怎么用了，所以毫不犹豫地选了MediaPipe Pose

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
import cv2
import mediapipe as mp
mp_drawing = mp.solutions.drawing_utils
mp_drawing_styles = mp.solutions.drawing_styles
mp_pose = mp.solutions.pose

cap = cv2.VideoCapture(0)
with mp_pose.Pose(
    min_detection_confidence=0.5,
    min_tracking_confidence=0.5) as pose:
  while cap.isOpened():
    success, image = cap.read()
    if not success:
      print("Ignoring empty camera frame.")
      # If loading a video, use 'break' instead of 'continue'.
      continue

    # To improve performance, optionally mark the image as not writeable to
    # pass by reference.
    image.flags.writeable = False
    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
    results = pose.process(image)

    # Draw the pose annotation on the image.
    image.flags.writeable = True
    image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
    mp_drawing.draw_landmarks(
        image,
        results.pose_landmarks,
        mp_pose.POSE_CONNECTIONS,
        landmark_drawing_spec=mp_drawing_styles.get_default_pose_landmarks_style())
    # Flip the image horizontally for a selfie-view display.
    cv2.imshow('MediaPipe Pose', cv2.flip(image, 1))
    if cv2.waitKey(5) & 0xFF == 27:
      break
cap.release()

捕获屏幕

随便Google了一下，找了个叫mss的库

1
2
3
from mss import mss
sct = mss()
sct_cap = sct.grab({"top": 0, "left": 0, "width": 1920, "height": 1080})

移动鼠标

这个也没去找，视频里的代码一眼看到了PyAutoGUI

1
2
import pyautogui
pyautogui.moveTo(x, y)

代码

注释写的比较详细，基本每步都有注释

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
import cv2
import numpy as np
import mediapipe as mp
import pyautogui
from mss import mss

face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
eye_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_eye.xml')
smile_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_smile.xml')
# 调用摄像头
cap = cv2.VideoCapture(0)
# 获取屏幕
sct = mss()

while True:
    # 获取摄像头拍摄到的画面
    ret, img = cap.read()
    # 获取屏幕图像
    sct_cap = np.array(sct.grab({"top": 0, "left": 0, "width": 1920, "height": 1080}))
    faces = face_cascade.detectMultiScale(img, 1.3, 2)
    for (x, y, w, h) in faces:
        # 画出蓝色人脸框
        img = cv2.rectangle(img, (x, y), (x + w, y + h), (255, 0, 0), 2)
        # 框选出人脸区域，在人脸区域而不是全图中进行人眼检测，节省计算资源
        face_area = img[y:y + h, x:x + w]
        # 用人眼级联分类器引擎在人脸区域进行人眼识别，返回的eyes为眼睛坐标列表
        eyes = eye_cascade.detectMultiScale(face_area, 1.3, 10)
        for (ex, ey, ew, eh) in eyes:
            # 画出人眼框，绿色，画笔宽度为1
            cv2.rectangle(face_area, (ex, ey), (ex + ew, ey + eh), (0, 255, 0), 1)
        # 用微笑级联分类器引擎在人脸区域进行人眼识别，返回的eyes为眼睛坐标列表
        smiles = smile_cascade.detectMultiScale(face_area, scaleFactor=1.16, minNeighbors=65, minSize=(25, 25),
                                                flags=cv2.CASCADE_SCALE_IMAGE)
        for (ex, ey, ew, eh) in smiles:
            # 画出微笑框，红色（BGR色彩体系），画笔宽度为1
            cv2.rectangle(face_area, (ex, ey), (ex + ew, ey + eh), (0, 0, 255), 1)
            cv2.putText(img, 'Smile', (x, y - 7), 3, 1.2, (0, 0, 255), 2, cv2.LINE_AA)

        # 当摄像头画面中检测到微笑时检测屏幕图像
        if len(smiles) > 0:
            # 检测人体并获取骨骼
            pose = mp.solutions.pose.Pose(
                min_detection_confidence=0.5,
                min_tracking_confidence=0.5)
            sct_cap.flags.writeable = False
            sct_cap = cv2.cvtColor(sct_cap, cv2.COLOR_BGR2RGB)
            results = pose.process(sct_cap)
            sct_cap.flags.writeable = True
            sct_cap = cv2.cvtColor(sct_cap, cv2.COLOR_RGB2BGR)
            # 绘制骨骼
            mp.solutions.drawing_utils.draw_landmarks(
                sct_cap,
                results.pose_landmarks,
                mp.solutions.pose.POSE_CONNECTIONS,
                landmark_drawing_spec=mp.solutions.drawing_styles.get_default_pose_landmarks_style())
            # 当检测到人体时
            if results.pose_landmarks:
                # 获取0号地标
                # 地标编号参考：https://mediapipe.dev/images/mobile/pose_tracking_full_body_landmarks.png
                landmark = results.pose_landmarks.landmark[0]
                x = sct_cap.shape[1] * landmark.x
                y = sct_cap.shape[0] * landmark.y
                # 打印坐标
                print(x, y)
                cv2.circle(sct_cap, (int(x), int(y)), 10, (0, 0, 255), -1)
                # 将鼠标移到对应坐标
                pyautogui.moveTo(x, y)

    # 实时展示效果画面
    cv2.imshow('frame2', img)
    cv2.imshow('screen', sct_cap)
    # 每5毫秒监听一次键盘动作，按Q时退出
    if cv2.waitKey(5) & 0xFF == ord('q'):
        break

# 关闭所有窗口
cap.release()
cv2.destroyAllWindows()

效果

用的人脸照片是Pexels上随便找的一张

在游戏里没敢试，因为怕被反作弊识别然后号没了
识别表情、识别人体都没啥问题，也能正确地把鼠标移到屏幕里人的头上

表情

找了各种肤色、情绪的笑脸照片，都能正确识别，唯一的问题是图片放到摄像头之后要过几秒钟才能识别出微笑，不过也没什么太大问题了

人体姿态

为了模拟真实情况 谁真去用啊 ，不仅试了常规照片，玩过的几个游戏（GTA5，BF5，RDR2等）截图也试了一下，人物靠得近一点就没什么没问题了（太小的识别不到）
Steve和Alex都识别不了，差评

展望

检测微笑的卷积神经网络性能很好，至少在我的机器上完全观察不到卡顿；但mediapipe的pose模型检测1080P的画面时，在我的5800H上目测最多只有十几帧
mediapipe的模型是跑在CPU上的，我电脑上还有一块3070 mobile，所以我的想法是使用GPU加速，虽然文档里有GPU加速相关的内容[2]，但是写的是面对Linux的，可惜大多数游戏在Linux上无法运行或体验很不好
并且，mediapipe的模型是TF lite的，而TF lite主要面向移动设备，并没有计划开发windows平台的GPU加速[3]，所以未来如果要解决这个问题，我的想法是使用性能更好的模型或者有较完善GPU加速支持的模型

  1. 第十章：物体检测与人脸识别【子豪兄opencv-python教程】 ↩︎

  2. GPU support ↩︎

  3. tensorflow contributor的comment ↩︎

]]> <p>前两天同学聊天的时候发了个<a href="https://www.bilibili.com/video/BV1Kd4y1i7Nf">视频</a>，还提了个很有趣的思路——在笑的时候自动瞄准<br> 一看视频挺有意思的，实现应该也不难，试了一下不到一小时就做完了</p> 给Hexo添加脚注支持 https://stydxm.com/2022/09/23/hexo-footnote/ 2022-09-23T16:32:22.000Z 2025-11-25T21:31:43.287Z hexo有现成的不错的方案markdown-it-footnote可用，所以也不用怎么折腾，但是有几个坑

markdown-it-footnote的README写着

Install

node.js, browser:

1
2
npm install markdown-it-footnote --save
bower install markdown-it-footnote --save

但并不是装上这个库就能用脚注了 （踩坑了）

首先markdown-it-footnote是Markdown it的一个插件，所以先把hexo默认的hexo-renderer-marked渲染引擎替换成hexo-renderer-markdown-it

1
2
npm un hexo-renderer-marked --save
npm i hexo-renderer-markdown-it --save

这一步挺常规的，然后就是插件需要手动启用 没仔细看readme
在配置文件_config.yml里加入markdown这个字段，并启用脚注插件

1
2
3
markdown:
  plugins:
    - markdown-it-footnote
]]> <p>hexo有现成的不错的方案<a href="https://github.com/markdown-it/markdown-it-footnote"><code>markdown-it-footnote</code></a>可用，所以也不用怎么折腾，但是有几个坑</p> 从iPhone14看手机创新的匮乏 https://stydxm.com/2022/09/10/iphone14/ 2022-09-10T12:08:44.000Z 2025-11-25T21:31:43.287Z 刚发布的iPhone14系列看起来跟上一代几乎没有变化——除了刘海变成了长的已经不像药丸的药丸
因为这个药丸，iOS就做了“灵动岛”，在UI设计方面做了点创新
然而还是掩盖不了屏幕一个巨大挖孔的事实，甚至还强行把两个孔连起来了

于是，就有了罗老师（网传）发的这段话

诚然，这个UI设计确实做得很优秀，但也反映了手机创新的匮乏——一年的代差，区别居然只是UI上的动画。再往前看，iPhone X之后也没有什么没大的进步，只是收窄刘海和加摄像头。然后顺着这个想法来理一理近年来手机领域的 《创新》

先说结论

我认为这十多年来，自从智能手机正面屏幕、侧面按键、反面摄像头的格局定下来之后，手机形态上唯三有点创新而且能被主流市场认可的就是全面屏、折叠屏和屏下指纹了

当然并不是说没有进步，处理器的算力不断提升，摄像头越堆越多，全面屏出现后屏占比的百分之几的提升，内存、储存甚至一路提到18+1t，现在主流游戏本大多还是16+512

创新的设计难成主流

手机的设计并非真的一成不变，不同手机间的差异化也不止在纸面的数据上体现
手机销量最高的几个品牌故步自封，精力一直花在卷参数和做营销上；索尼、LG、谷歌、微软这些不差钱也不把手机当主业的厂商反而能做出一些让人眼前一亮的新设计，但不能

升降摄像头——昙花一现的妥协方案

升降摄像头里最常见的是机械升降一个摄像头模组，太多了就不举例了，那个年代的新机一眼望去全都是这样的，其中有个特例是OPPO Reno的扇形摄像头模组

升降摄像头还有一种方案是略显复古的滑盖形态，保证完整屏幕的同时减少了机身内的机械结构（手动的所以不需要电机了），减少了厚度和重量，腾出更多空间
典例：荣耀magic2、OPPO find x

正反双屏——牺牲成本的妥协方案

像nubia x, vivo NEX 双屏版这样的正反面双屏在我看来这是为了正面完整屏幕砍掉前置摄像头后，对于自拍的解决方案
少了前置摄像头，加了一块屏幕，耗电和成本上升，而且仍然是一个妥协的方案，除非手机烫手翻来翻去看

正面多屏——难成主流的效率设计

像LG Wing、LG的副屏手机壳、Surface Duo这样的单面多屏的形态在多任务处理上有着显著的优势，但多出来的结构会导致续航差、机身厚重这些问题，而且也没有手机大厂尝试这样的设计，也一直没能得到主流消费市场的认可

未量产的方案

还有诸如LG Rollable卷轴屏、MIX Alpha的环绕屏等的方案，最终都没能实现量产开售，所以说目前谈论它们还为时尚早，只能说让我们一起期望手机厂商能做出真正 有意思 的设计吧

厂商们不再热衷于真正的创新

从我开始关注数码圈开始，这几年来手机届所谓的“革新“实则却是营销，内存从3G、4G一路来到了18G，摄像头像素从1200w到了108m，无数所谓”黑科技“实则是根本没用或科技以换皮为本的概念被创造出来
手机市场早就从增量变为存量，手机的差异越来越少，外观也就是在背板和摄像头排布上做文章，翻了好几倍的纸面参数在实际体验中究竟带来了多大的提升呢？恐怕不大
灵动岛是一次有意思的尝试，是对挖孔屏交互方式的一种探索，但效果显然不如直接做成无孔的。这是创新吗？当然是；这创新有意义吗？不如研究研究怎么解决屏幕上的孔，而不是花时间研究怎么把孔做好看
苹果这么做的“成效”也显而易见。苹果在产品设计上的变化本就自带话题属性（从google trends上看得出来），从刘海到摄像头突起，从取消3.5mm耳机孔到为了所谓环保而不再赠送充电头，这些变化都少不了用户的批评，很多主流手机厂商还是照样跟进。苹果这么做顺便还做了免费宣传——但凡关注数码科技领域，谁又不知道灵动岛呢？

用户需要真正的创新

更高的参数固然好，结果带来的是软件优化越来越差，对性能要求越来越高（比如某国际游戏大厂的两款手机3A大作），用户为了其实大可不必的性能消耗而不得不购买更好的硬件，但真的是用户想看到的吗？
至少对我来说，与其花费人力物力研发被软件浪费掉的性能，我更想买到体验上有提升的设计、有意义的创新。我不是说更好的性能更高的参数没有意义，而是说应该把这些研发成本投入到更有意义的东西的研发上去

]]> <p>刚发布的iPhone14系列看起来跟上一代几乎没有变化——除了刘海变成了长的已经不像药丸的药丸<br> 因为这个药丸，iOS就做了“灵动岛”，在UI设计方面做了点创新<br> <s>然而还是掩盖不了屏幕一个巨大挖孔的事实，甚至还强行把两个孔连起来了</s></p> LG wing：未能展开的未来 https://stydxm.com/2022/08/05/lg-wing/ 2022-08-05T06:01:35.000Z 2025-11-25T21:31:43.287Z

图片较多且都未经压缩，可能加载会有点慢

2020年9月，发布会结束后，LG wing的图片着实让我惊讶，但在当时它和我没什么关系，售价1049美元且没有国行，而且LG手机一贯的垃圾佬特质 过一年就能海鲜市场半价捡 让我根本没有买它的想法

不想不到一年时间，卖了26年手机的LG宣布由于亏损而放弃了手机业务，也让这个形态独特的手机成了LG最后一款公开发售的手机 当然海鲜市场价格又低了

发布后还不到两年，即使是成色完美的机器在小黄鱼上已经不到1.5k了，自己又想换手机了，就花1.7k买了个成色完美、号称原装未拆机的LG wing。至于为啥这么贵，因为当主力机用，而且用的电信卡，买的是8+256的att版的

（LG wing有多个版本，对大陆地区的网络支持不同，二手价格也不一样。韩版的不支持三大运营商，也就是只能用WiFi上网；T版，也就是T-mobile版，只能支持移动联通的流量和电话、短信功能；V版，也就是Verizon的，支持三家的流量，但是要手动切换电信的4G和2G，据说移动联通5G也可以；att版，也就是AT&T版，支持三网5G和2G [1] ，但是我测试发现似乎不太行，应该是不能完全支持电信5G的频段，所以有人说行有人说不行，我也不太在意能不能用5G，就没再折腾）

外观和手感

手机到手给人的第一印象当然是外观和手感

手机外观我也不太在意，正面几乎全是屏，后面是玻璃后盖+三摄，觉得很漂亮了，看渲染图好像蓝色版本的更漂亮一点，不过反正戴个壳都一样

手感的话前后的曲面握起来还是比较舒服的，厚有点厚，超过1cm了，但可以捏着边框所以影响也不大

机器确实比较重，260g的质量已经接近主流折叠屏（左右翻折的那种打开较大的）的手机了，这是在买之前就了解清楚了的。到手之后还是比想象中重一点，反正对我这样三四斤的单反+镜头一拿一整天的人来说也没什么，用了两三天也没有手酸手臂痛 现在拿别的手机已经感觉轻飘飘了

屏幕

这个手机最特殊的就是那块可以旋转的主屏了，电脑一直用着多屏，手机只有一块屏幕居然不太习惯，现在终于可以一边看QQ一边看B站了

这块6.8寸的主屏是1080P60的，很多人为既没有2K也没有高刷而感到遗憾，不知道为什么我对这个并没啥感觉，反而是被曲面屏的素质惊艳到了，可惜相机并不能拍出来

而且这块屏亮度也很高，在强烈的太阳光下清晰可读，晚上也没觉得OLED有多瞎眼 不过万一晚上没拿住掉下来能砸死倒是真的


这个屏幕尺寸也让机身长度来到了16.95cm，我的手掌根到中指尖刚好也差不多，再加上机身超过半斤，单手操作再也不可能了

副屏的下巴有点大，但其实真用起来也没啥影响

有待验证的一点是两块屏幕似乎有一定的色差，不过我只见过一次，然后就没观察到过这个现象，可能是由于调节亮度或者色温的时候系统没有同步，改成自动亮度之后就好了

屏幕问题的话可能不是屏幕本身的问题（什么绕口令），而是是屏幕的转轴，当然我也不清楚问题到底是设计问题导致本身就这样，还是因为不耐用转多了导致的，还是因为贩子拆机后装回去的水平不行导致的

转轴似乎有一些突起，导致转轴上下两侧不平，而且主屏和机身中间的缝比较大，如果不是端坐着的话可能因为重力作用屏幕离机身有一段距离，点屏幕的时候会按回去，轻微碰撞发出声音，在用输入法的时候尤其明显，关了声音和振动还有哒哒哒的声音 机械软键盘了属于是

相机

相机没什么好说的，真要点拍什么我会拿相机，随手拍点记录生活的肯定够了

直男也用不着前摄，本来还用来人脸识别，换升降摄像头的手机之后连解锁都不用了，就彻底用不着前摄了，估计也就实名认证的时候用一下吧

只是我不太理解为啥要两个超广角而不是把其中一个换成长焦

刚好今天天上的积云挺漂亮的，就顺手拍两张
没开到最高像素的主摄
广角

要是有空还能想起来的话出去再拍点

展开主屏之后的稳定器模式很有创意，可惜硬件上用的是一颗1300w的成像质量很差的超广角摄像头而不是真正的云台，即使在光照充足的条件下，果冻效应和满屏噪点也让画面变得非常不可用，使不错的软件设计无法发挥出来

2022.8.11update 出去玩顺手拍了点，应该能看出来哪些是主摄哪些是广角





其他性能

这台机器为了旋转的主屏妥协了很多，比如上千美元的售价居然只用了765G，比如如此厚重的机身只有4000mAh的电池

但是作为一台2020年发布的旗舰机，除了处理器的遗憾之外该有的也都有了，玻璃后盖、无打孔的OLED曲面屏、屏幕指纹、无线充电、三摄和方向错了的4800w像素的主摄，甚至这个形态都能做到IP56的防尘防水

765G处理器性能不如855 865，在两块屏开不同应用的时候有的时候确实会卡。还好我已经多年不玩手游了，玩游戏都是用电脑，目前的性能还够用

4000mAh的电池加上两块屏确实不太耐用，亮屏时间也就四五个小时，对目前的我来说没什么问题，或许一年之后上大学就该考虑换了

最后

买之前看过几篇评测文章和几个视频，都是把它当备用机甚至玩具来玩，但我还是决定还是作为主力机用，至少目前来说我还没有后悔

作为一台满是机械结构的手机，机身厚重我能接受，但是有点担心摄像头模组和转轴的寿命问题，尤其是这独特的转轴结构全球仅此一款，还是来自一个已经不做手机的厂商；玻璃后盖和两块屏容易在意外中受损，用的时候还是要小心一点

还有一点跟机器本身没啥关系，海鲜市场的水挺深的，我这台卖家说全原未拆机，实际成色完美得不像二手，一点磕碰划痕都没有，但是边框上似乎有补过漆，所以存疑，查了下没有被硬解过，就没再深究了；挑的时候甚至还看到声称是全新一手仅拆封的，我就更不敢买了

再用一段时间之后如果有新的体会就再来更新吧


  1. 需要进行一些修改 ↩︎

]]> <blockquote> <p>图片较多且都未经压缩，可能加载会有点慢</p> </blockquote> <p>2020年9月，发布会结束后，LG wing的<a href="https://www.lg.com/global/lgwing">图片</a>着实让我惊讶，但在当时它和我没什么关系，售价1049美元且没有国行，而且LG手机一贯的垃圾佬特质 <s>过一年就能海鲜市场半价捡</s> 让我根本没有买它的想法</p> <p>不想不到一年时间，卖了26年手机的LG宣布由于亏损而放弃了手机业务，也让这个形态独特的手机成了LG最后一款公开发售的手机 <s>当然海鲜市场价格又低了</s></p> <p>发布后还不到两年，即使是成色完美的机器在小黄鱼上已经不到1.5k了，自己又想换手机了，就花1.7k买了个成色完美、<code>号称原装未拆机</code>的LG wing。至于为啥这么贵，因为当主力机用，而且用的电信卡，买的是8+256的att版的</p> Hello World https://stydxm.com/2022/07/25/hello-world/ 2022-07-25T12:27:11.000Z 2022-07-26T11:31:20.000Z 这段时间研究一些静态页面托管服务，于是也想着给自己搭一个博客。

有了想法之后，花五分钟买了个域名stydxm.com，花五分钟搭了个hexo，再花十分钟把博客放到了Cloudflare Pages上去，然后……花了好久好久挑了个主题Icarus和改域名的配置。总共花了不到一个小时把博客搭起来了，接下来就是把以前在各种地方写的一些东西搬到这里来（这也是有的文章时间比这篇还早的原因）
关于博客页面的更新也会写在这篇文章里

update

2022.7.26 把这篇文章的封面换成了必应的每日图片，API是ioliu的

]]> <p>这段时间研究一些静态页面托管服务，于是也想着给自己搭一个博客。</p> 1.18：无周目老服务器的存档之困 https://stydxm.com/2022/07/07/minecraft-server-terrain-update/ 2022-07-07T13:10:28.000Z 2022-08-21T16:49:34.000Z

本文是我做的这期视频的文稿，删除服务器相关的内容之后放到博客上来了

北京时间2020.10.4，在Minecraft Live 2020上，MOJANG宣布了下一次更新的主题：洞穴与山崖。

2020.11.4，1.17的第一个快照20w45a发布；2021.6.8，1.17的第一个正式版发布；

2021.7.13，1.18的第一个快照1.18-experimental snapshot 1发布；2021.11.30,1.18的第一个正式版发布。

洞穴与山崖更新，地形生成改变之后，更高的高度上限，更漂亮的山峰、洞穴，美西螈、荧光鱿鱼，毫无疑问会带来全新的体验。

但是，对于一些开服已经很久的老服务器来说，1.18虽然是时代的潮流，服务器的升级却变得越来越困难。从低版本一点点升级的过程带来了沉重的历史包袱。毫无疑问，这些服务器必然会在将来的某一天更新到1.18，但是这其中有些事情，可能没那么容易。

最简单的方案当然是直接升级，已经探索过的区块下方会被拓展，新的地形要到更远的地方才能见到。这种方案对于存档是伤害最小也最方便的，但是效果却不佳：明明更新了，但新的内容要到几万格之外才能找到，相当于更新了寂寞。
类似的想法还有部分升级，比如把没什么问题的空岛、大厅升级，而生存不升级。对空岛来说，新地形没什么用，因为根本看不到，而对于生存区来说还是更新了寂寞。

另一个选择是开新区，现有的生存停留在1.16，新开一个1.18的生存区。这样确实是既保留了存档，又避开了老存档升级这个棘手的问题。但如果这样的话，会消耗大量服务器资源，而且如果开了新区，同是生存区，背包得要互通吧，那把新区的东西带到老区来怎么办呢？本来生存区人就不多，开了新区之后现有的生存区占用了大量资源，玩的人却更少了，也把生存区的玩家割裂开了

最后我觉得最好的方案就是删部分区块，这个其实早就有过设想，因为很多被探索过但没有改变过的区块并没有意义，但占了不少的储存空间，我们早就想找到一个办法删除这些区块，但似乎并没有非常精准的方案，最多也就是人工看一下，这样工作量极大而且靠人看很有可能会遗漏一些地方导致误删区块，因此可行性并不高
总之，更高的版本改变了地形生成机制，使我们这样一个坚持不换周目不删档的服务器升级过程遇到了很大的麻烦。我看到的其他服务器解决方案大多是删档换周目，这样的方式虽然最简单易行，还能从根本上解决问题，但与我们的理念（注：该服务器的理念是无周目）背道而驰，因此需要理念相似、愿意合作的服务器共同探索出解决方案。

]]> <blockquote> <p>本文是我做的<a href="https://www.bilibili.com/video/BV1xU4y1m7ZC">这期视频</a>的文稿，删除服务器相关的内容之后放到博客上来了</p> </blockquote> GIF之后，再无动态图片 https://stydxm.com/2022/03/26/dynamic-images/ 2022-03-26T05:15:00.000Z 2022-07-26T06:28:00.000Z 24号看到GIF发明者去世的消息[2]，觉得GIF早已完成了它的历史使命。

但今天打开QQ空间，看到GIF的梗图，才意识到GIF仍然在被大量使用。

然后仔细一想，虽然GIF的分辨率低、帧率低、只有256色，虽然现在的web开发早已没有满屏闪烁的gif，没有雪碧图，虽然像谷歌苹果这样的巨头和各个开源组织都在不遗余力地推行更快或者更高压缩率的图形编码格式，比如webp和svg……但是，到现在除了gif，我们仍然没有第二种足够通行并且较轻量的动图格式，或许在将来较长时间里，也不会有。我们要么继续用gif，要么就只能用需要播放器的视频了。

2022.7.26 update

这篇文章原本发在B站动态和QQ空间里，今天搬到博客上的时候做了一点小修改，顺便查了一下除gif外现有的动态图片格式，然后发现了犯了个错误——Google的WebP其实是支持动图的，只是webp的动图有多少，恐怕不好说。

支持动图的格式：

APNG - Animated Portable Network Graphics

APNG is an extension of the PNG format, adding support for animated images. It is intended to be a replacement for simple animated images that have traditionally used the GIF format, while adding support for 24-bit images and 8-bit transparency. APNG is a simpler alternative to MNG, providing a spec suitable for the most common usage of animated images on the Internet.

拓展自PNG，支持24bit位深度和8bit的透明图像

兼容PNG，第一帧为普通PNG，所以也可以作为普通PNG来解析

WebP

The 14-bit dynamics for image size limit the maximum size of a WebP lossless image to 16384✕16384 pixels.

官网上说支持最高14bit，16K分辨率的动态图片

AVIF - AV1 Image File Format

基于AV1的图片格式，支持动图

支持多种色彩空间，多种压缩率，多种位深度

MNG - Multiple-image Network Graphics

和APNG一样也拓展自PNG，而且得到了PNG的官方承认，但似乎目前兼容性还不如APNG

[1]: 封面图片：Computer programmer Stephen Wilhite accepts his Webby Lifetime Achievement Award in 2013. (Webby Awards/AP)
[2]: Stephen Wilhite, computer programmer who created the GIF, dies at 74
[3]: Graphics Interchange Format

]]> <p>24号看到GIF发明者去世的消息[2]，觉得GIF早已完成了它的历史使命。</p> <p>但今天打开QQ空间，看到GIF的梗图，才意识到GIF仍然在被大量使用。</p>