<![CDATA[Felix Xu 日常学习实践笔记]]>https://xufelix-dailynotes-zh.hashnode.devRSS for NodeThu, 18 Jun 2026 21:53:42 GMT60<![CDATA[用交叉编译 SDK 编译、配置 STM32MP135 的 Qt 环境]]>https://xufelix-dailynotes-zh.hashnode.dev/sdk-qthttps://xufelix-dailynotes-zh.hashnode.dev/sdk-qtSat, 25 Apr 2026 12:19:09 GMT

注意，本文绝对不要无脑CV，把文字看清楚再动手！

前言

感谢 kt 老师的代笔，给原本的内容加了很多详尽的解释。我自己琢磨这个环境花了 24h+ 的时间，交叉编译还是太过于变态了，qt 的环境配置绕了很久，自己又没有经验——不过万事开头难嘛，嵌入式不就是一直跟各种奇奇怪怪的环境纠缠嘛。

5.4版本的STM32MP1-SDK内部没有适配arm32架构编译用的qt工具链，所以无法对arm32目标架构的qt代码进行编译。哪怕你配置好了gcc g++等路径的编译器，也会因为没有qt工具链出现编译失败问题。所以我们需要自己手动添加一个qt工具链，这有两种实现路径：

  1. 下载3.1版本的STM32对应的SDK，其内部有qt工具链；

  2. 手动去qt官网获取qt5版本的源码，并将其编译成可使用的qt编译链，难度较高，本文讲解的就是这个编译的过程。

环境

  • 主机系统：Win11

  • 虚拟机：VMware® Workstation Pro 25H2u1 25.0.1.25219725

  • Linux：Ubuntu 24.04.4 LTS

  • 开发板：知睿-MP135-嵌入式学习系统（STM32MP135）

  • Qt 版本：Qt 5.12.9

  • 板载系统：Openstlinux，Buildroot 2022.02.3

准备工作

系统环境准备

  • 安装旧版的gcc-9，并注册为默认编译器，因为qt5的版本比较老，用旧的编译器能减少很多问题。
sudo apt install gcc-9 g++-9
sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-9 90 --slave /usr/bin/g++ g++ /usr/bin/g++-9
sudo update-alternatives --set gcc /usr/bin/gcc-9
  • 安装好Python等基础库，这里可能没列全，缺了自己补。
sudo apt install python3
sudo apt install python-is-python3

SDK 和 sysroot

  • 按照上一课的要求完成STM32MP1-SDK的解压和安装，得到对应的 arm-ostl-linux-gnueabi-gcc 等编译器。sysroot 文件夹在 SDK 的安装路径下，也就是我们运行 SDK 安装包时指定的路径。而后续步骤中的各种 sysroot 参数，则是 SDK 路径下的 /sysroots/x86_64-ostl_sdk-linux/ 这一路径。

    • 如果之前看的是我的攻略，那这时候SDK就是在默认路径下，sysroot 就是 /opt/st/stm32mp1/3.1-openstlinux-5.4-dunfell-mp1-20-06-24/sysroots/x86_64-ostl_sdk-linux/

    • 如果之前参照了老师的文档，那SDK就是在/home/用户名/STM32MPU_workspace/STM32MP1-Ecosystem/sysroots/x86_64-ostl_sdk-linux/

这个路径可以记一下，后面会反复用到！

  • 创建软链接。这里一定要用绝对路径。下面的代码不能直接cv，要将前置路径改成自己的 sysroot。
sudo ln -sf （你的sysroot）/usr/bin/arm-ostl-linux-gnueabi/arm-ostl-linux-gnueabi-gcc /usr/bin/arm-ostl-linux-gnueabi-gcc
sudo ln -sf （你的sysroot）/usr/bin/arm-ostl-linux-gnueabi/arm-ostl-linux-gnueabi-g++ /usr/bin/arm-ostl-linux-gnueabi-g++
sudo ln -sf （你的sysroot）/usr/bin/arm-ostl-linux-gnueabi/arm-ostl-linux-gnueabi-ar /usr/bin/arm-ostl-linux-gnueabi-ar

准备好 Qt5 源码和路径

可以在板子上 ls -R / | grep libQt5*.so* 一下，查查板子有没有现成的qt库，如果版本没有差太多，可以直接找对应的版本，后面不需要把库导进板子；

/home/用户名/的路径可以简化为~/，但是本文还是按照标准展开来写。

  • 下载qt的源码，注意必须是qt5的版本，稍微早一点的版本需要挂梯子才能访问。建议解压为 /home/用户名/Qt/（版本编号）/Src，便于 Qt Creator 识别。

  • 然后创建一个用于安装qt5工具链的文件夹，比如/home/用户名/Qt/（版本编号）/arm32-gcc

编译过程

Qt 的编译过程非常麻烦，分三步，第一步用configure生成正确的编译环境，第二步正式编译，第三步把编译好的文件正确安装到路径下。如果你的板子没有Qt5的库，还要再把编译出来的库copy到板子中。

configure

  • 进入解压好的qt5源码里的文件夹，进入/qtbase/mkspecs/，复制其中的文件夹 linux-arm-gnueabi-g++ 为 linux-arm-ostl-g++（这里相当于做一次备份），然后进入刚刚复制的文件夹 linux-arm-ostl-g++，改 qmake.conf的代码如下，其中有个地方需要自己修改，将SYSROOT_PATH改成自己的sysroot。

下文中的 CFLAGS，我们可以在初始化SDK环境的脚本中找到，CC变量后面，编译器后面那一大串东西就是 FLAG 的内容，这里已经写好了。

#
# qmake configuration for building with arm-ostl-linux-gnueabi-g++
#

MAKEFILE_GENERATOR      = UNIX
CONFIG                 += incremental
QMAKE_INCREMENTAL_STYLE = sublib

include(../common/linux.conf)
include(../common/gcc-base-unix.conf)
include(../common/g++-unix.conf)

# modifications to g++.conf
QMAKE_CC                = arm-ostl-linux-gnueabi-gcc
QMAKE_CXX               = arm-ostl-linux-gnueabi-g++ 
QMAKE_LINK              = arm-ostl-linux-gnueabi-g++
QMAKE_LINK_SHLIB        = arm-ostl-linux-gnueabi-g++

# add sysroot

SYSROOT_PATH = （你的sysroot）

# set params

QMAKE_CFLAGS            += --sysroot=$$SYSROOT_PATH -mcpu=cortex-a7 -mfpu=neon-vfpv4 -mfloat-abi=hard
QMAKE_CXXFLAGS          += $$QMAKE_CFLAGS

# disable lto

QMAKE_CFLAGS_RELEASE += -fno-lto
QMAKE_CXXFLAGS_RELEASE += -fno-lto
QMAKE_LFLAGS_RELEASE += -fno-lto

# modifications to linux.conf
QMAKE_AR                = arm-ostl-linux-gnueabi-ar cqs
QMAKE_OBJCOPY           = arm-ostl-linux-gnueabi-objcopy
QMAKE_NM                = arm-ostl-linux-gnueabi-nm -P
QMAKE_STRIP             = arm-ostl-linux-gnueabi-strip
load(qt_config)
  • 接下来开始configure，进入qt5源码文件夹（注意这里进入的是qt5源码解压的文件夹，不是本次hello工程的文件夹），打开控制台，在命令行里输入以下命令，生成编译环境，配置好交叉编译参数。注意，路径需要修改，最后一行skip是我们跳过编译的组件，加回去可能编译很久或者报错。下面是我自己的命令：
./configure \
-prefix /home/felix/Qt/5.12.9/arm32-gcc \
-extprefix /home/felix/Qt/5.12.9/arm32-gcc \
-sysroot /opt/st/stm32mp1/3.1-openstlinux-5.4-dunfell-mp1-20-06-24/sysroots/cortexa7t2hf-neon-vfpv4-ostl-linux-gnueabi \
-xplatform linux-arm-ostl-g++ \
-opensource -confirm-license \
-release \
-nomake examples -nomake tests \
-skip qtwebengine -skip qt3d -skip qtlocation

如果是自己的命令行需要修改 -sysroot，-prefix，-extprefix。sysroot 输入过很多遍了，两个prefix就是我们创建好安装qt5工具链的文件夹。

./configure \
-prefix （安装文件夹） \
-extprefix （安装文件夹） \
-sysroot （你的sysroot） \
-xplatform linux-arm-ostl-g++ \
-opensource -confirm-license \
-release \
-nomake examples -nomake tests \
-skip qtwebengine -skip qt3d -skip qtlocation

这行命令敲下去后，看着他打点打满一行多，没有给出error，就是成功。

编译，安装，导入库

编译，安装qt5。参数都在前面设置过了。编译过程很久，大概需要十几二十分钟到半个多小时。

make -j$(nproc)
make install

  • 到这时候，如果没有报错，在安装路径下的bin里面就可以找到qmake了。这里我们才实现了装好一个旧版本的qt5，可以兼容STM32MPU的32位架构的旧版qt。

  • 如果最开始，我们发现目标板子中没有Qt5的库，就把安装完的qt5目录下的/lib之内的库copy到板子的/opt/qt5/lib目录下。

  • 最后收个尾，把配置成gcc-9的gcc切换回最新版本（我的Linux下是gcc-13），重复一遍先前的操作，把命令中的-9全部换掉就好，如下

sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-13 90 --slave /usr/bin/g++ g++ /usr/bin/g++-13
sudo update-alternatives --set gcc /usr/bin/gcc-13

配置 Qt Creator 与工程

配置 KIT

  • 进入 Qt Creator，打开设置，在左侧进入**构建套件（kit）**的页面，开始配置。每做完一项记得右上角 apply。

  1. 打开“编译器”模块，刷新，先确定arm-ostl-linux-gnueabi-gcc存在；

  2. 打开“Qt版本”，刷新，添加我们编译好的qt版本（5开头版本号的，不要弄错了）

  3. 打开“构建套件（Kit）”，添加一个，自己命名好：

    1. 选好编译器，qt版本；

    2. 填上你的sysroot；

    3. 接着在最底下cmake configuration里加上-DCMAKE_C_FLAGS:STRING=-mthumb -mfpu=neon-vfpv4 -mfloat-abi=hard -mcpu=cortex-a7 和 -DCMAKE_CXX_FLAGS:STRING=-mthumb -mfpu=neon-vfpv4 -mfloat-abi=hard -mcpu=cortex-a7 两行内容。 这里没有报error就没问题，因为我们就没有添加debugger。

搭建工程与验证

  • 新建工程的时候，建议在 build system 中选择兼容qt5的cmake，一方面这可以支持VSCode，一方面这可以检测qt的工具链是否配置完整。

  • 做好demo，左下角build，然后在工程文件夹中找到与工程同名的可执行文件，传到目标板。

如果一切顺利，那么你就可以亲眼看到屏幕上——

Hello Qt @ stm32mp135

总结

感谢kt的代笔，不总结了，累死了，累死了累死了累死了赶紧让老师给我发工资。。。

]]><![CDATA[搭建知睿 STM32MP135 的交叉编译环境]]>https://xufelix-dailynotes-zh.hashnode.dev/stm32mp135https://xufelix-dailynotes-zh.hashnode.dev/stm32mp135Wed, 15 Apr 2026 20:04:01 GMT前言

过程思路很简单，核心就是，先配好环境，然后做交叉编译，最后用 U 盘把编译完的文件放进文件导入到板子里面运行，但是作为新手还是稍微记录一下~

环境

  • 主机系统：Win11

  • 虚拟机：VMware® Workstation Pro 25H2u1 25.0.1.25219725

  • Linux：Ubuntu 24.04.4 LTS

  • 开发板：知睿-MP135-嵌入式学习系统 （STM32MP135）

  • 板载系统：Buildroot 2022.02.3

配置交叉编译器

准备工作

根据《知睿-MP135-嵌入式学习系统---实验指南》，先装上各种依赖库和常用工具

sudo apt update
sudo apt install gawk wget git diffstat unzip texinfo gcc-multilib chrpath socat cpio python3 python3-pip python3-pexpect libssl-dev libgmp-dev libmpc-dev lz4 zstd
sudo apt install build-essential libncurses-dev libyaml-dev libssl-dev
sudo apt install coreutils bsdmainutils sed curl bc lrzsz corkscrew cvs subversion mercurial nfs-common nfs-kernel-server libarchive-zip-perl dos2unix texi2html libxml2-utils

然后，根据文档：必须安装其他配置才能支持每个 MMC 最多 16 个分区。 默认情况下，在 Linux 系统上，MMC 上最多允许 8 个分区。 所有软件包（入门软件包等）都需要 10 个以上的分区供存储设备使用。为了将每个设备的分区数扩展到 16，必须将以下选项添加到 modprobe：

echo 'options mmc_block perdev_minors=16' > /tmp/mmc_block.conf
sudo mv /tmp/mmc_block.conf /etc/modprobe.d/mmc_block.conf

然后下载 SDK：en.SDK-x86_64-stm32mp1-openstlinux-5.4-dunfell-mp1-20-06-24.tar.xz，在 Linux 系统中解压（注意不要直接在共享文件夹解压）。

安装 SDK

解压 SDK，然后一路点进去找到脚本：st-image-weston-openstlinux-weston-stm32mp1-x86_64-toolchain-3.1-openstlinux-5.4-dunfell-mp1-20-06-24.sh，开权限，运行脚本，设定好你想要放 SDK 的路径——当然就按照他的默认路径也行（记得提前记录一下他的路径），然后等他解压。

安装成功后，进入 SDK 的安装路径，应该会看到这些文件：

environment-setup-cortexa7t2hf-neon-vfpv4-ostl-linux-gnueabi
site-config-cortexa7t2hf-neon-vfpv4-ostl-linux-gnueabi
sysroots
version-cortexa7t2hf-neon-vfpv4-ostl-linux-gnueabi

之后安装包就没用了，可以删了省空间。

配置 SDK 环境

SDK 的路径下，其中一个文件，看开头叫做 environment-setup，这就是初始化环境所需要的文件。在这个文件夹下启动命令行，开始敲命令：

source ./environment-setup-cortexa7t2hf-neon-vfpv4-ostl-linux-gnueabi

然后检查一下各个变量，看看有没有成功：

\( echo \)ARCH
arm

\( echo \)CROSS_COMPILE
arm-ostl-linux-gnueabi-

\( echo \)CC
arm-ostl-linux-gnueabi-gcc -mthumb -mfpu=neon-vfpv4 -mfloat-abi=hard -mcpu=cortex-a7 --sysroot=/opt/st/stm32mp1/3.1-openstlinux-5.4-dunfell-mp1-20-06-24/sysroots/cortexa7t2hf-neon-vfpv4-ostl-linux-gnueabi

\( \)CC --version
arm-ostl-linux-gnueabi-gcc (GCC) 9.3.0
Copyright (C) 2019 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

CC 是什么？是 Cross-Compiler，交叉编译器，记住，后面要考哦（）

这样，我们在同一个控制台中就可以编译文件了。注意，我们每次要启动交叉编译的时候，都要重复这个步骤——这么看，这个流程还是太麻烦了，也许我们可以稍微简化一下。可以用符号链接在自己平时的工作区做一个快捷方式：

语法：

ln -s [link-target] [link-name]

比如在我的工作区：

ln -s /opt/st/stm32mp1/3.1-openstlinux-5.4-dunfell-mp1-20-06-24  /home/felix/embedded/sdk-base

这样我们在上一级目录可以直接用符号链接等效地进入前面那一堆乱七八糟的路径。

还可以给那个 setup 脚本做个副本，取一个简单的名字——直接 cp 一下就好了。注意如果不是在 home，要有管理员权限：

sudo cp environment-setup-cortexa7t2hf-neon-vfpv4-ostl-linux-gnueabi setup

然后下次启动 SDK 就简单了，直接用快捷方式+简化，比如从符号链接的上一层开始：

cd sdk-base
source ./setup

就能够成功启动环境了。

交叉编译

然后我们准备一个 C 语言的 demo，比如 hello world，然后启动 SDK，按照 gcc 的语法开始编译：

$CC -g  /your/src/dir/hello.c  -o  /your/target/dir/hello

控制台没有输出，目标路径生成文件，那就是成功了，至此，SDK 中的交叉编译就已经完成了，我们有了一个可以在板子上运行的二进制可执行文件。

minicom 配置

在开启串口前，首先把 brltty 卸载掉，否则看不到我们需要的设备，然后安装 minicom：

sudo apt remove brltty
sudo apt install minicom

卸载 brltty 之后要重启一下 Linux。然后，我们把有串口的 USB 线从板子引出来，连接电脑，接入虚拟机，紧接着查一下 /dev 路径，看看有没有名称中包含 USB 的设备，检查电脑是否识别到串口：

ls /dev | grep USB

如果查到了 ttyUSB0 （或者其他数字）那就是连上了，这时候就可以管理员启动 minicom，连接板子：

sudo minicom -D /dev/ttyUSB0

默认的比特率是 115200，我在跑的时候也是115200，不用给参数就能连上，如果要换其他比特率就加上 -b 9600。

如果到这里一切正常，应该就能在串口中与板子的命令行交互了。

导入文件

U盘法

这个是我最开始尝试成功的。准备一个U盘，确定这个U盘的文件系统是 FAT32（可以在主机上查看属性，如果不是的话去问问 AI 看看对应的兼容性和命令），然后把刚才编译好的可执行文件拷贝进去，然后把U盘插进板子。

如果仔细观察板子的 /dev，能够注意到，插入U盘的时候会出现 sda，sda1 ——这就是U盘对应的设备。接下来把他挂载到系统中。

注意，接下来的操作都是通过串口在从机上操作的。

首先，创建一个拿来挂载用的路径：

mkdir -p /mnt/udisk

-p 的含义自己去查，感觉是挺有用的

然后把 sda1 挂载到刚才做好的路径下：

mount -t vfat /dev/sda1 /mnt/udisk

如果没有报错，就是成功了，接下来可以 cd 进挂载好的路径，ls 一下看看能不能读到U盘中的文件。如果一切正常，就可以试着跑一下。在嵌入式平台中，建议不用 exec 启动可执行文件，直接用文件名运行就好，比如

./hello_arm

如果一切顺利的话——

成功！

文本发送法

对于我们用来demo的这种小文件，这个方法会快很多。思路就是，把整个可执行文件变成一大串字符串，通过串口方便地发送到从机，然后再转回文件。

在主机上把编译好的可执行文件转化为 base64 编码，输出到文件中：

base64 hello > hello_base64

注意，接下来的操作都是通过串口在从机上操作的。

然后打开文件，把这堆代码复制一下，接着进入串口，把这堆文字发送到从机上。这段文字包含了换行，因此最好的方法是用 cat：

cat << EOF >> hello_base64

这个 EOF 是指定的文件末尾标记，把刚才的那一堆文字复制进来，最后一行写上 EOF，这样刚才的字符串就成功保存到从机上的文件里面了。紧接着，解码，重新生成可执行文件，给权限：

base64 -d hello_base64 > hello
chmod +x hello

然后，同上一个方法，运行即可，是激动人心的 hello world！

（补）网络 NFS 法

这个方法也非常快，但是绕了很久，而且网络协议我不了解，就做个简单的记录。

用网线连接板子和电脑，然后先去 VMWare 的 Edit - Virtual Network Editor，进入编辑，然后把桥接的那一个选项删掉（比如 VMnet0），重新建立，在直连的对象中找到疑似网口的选项，选中保存，然后去虚拟机设置里面也把桥接设置好，当然可以多开一个 NAT 保证联网。

然后去串口中查一下板子的 IP：

ip addr

然后，进入虚拟机，进入到网络的设置界面。我的 Ubuntu 可以建立多个预设，因此新建一个预设，把 IP 设置成和板子前三位相同的固定值，比如 192.168.1.66，子网掩码照常 255.255.255.0，网关和IP前三个数字相同，最后一位是1，比如 192.168.1.1。

这些设置完成后，插上网线，如果系统显示正常，就可以用从机 ping 一下虚拟机了。

接着，在主机上确定 NFS 共享的文件夹。首先安装 nfs-kernel-server，然后创建好文件夹，开777权限，然后去 /etc/exports 里面加一句 /dir/to/folder *(rw,sync,no_root_squash,no_subtree_check)，具体怎么设置权限自行查命令。

然后加载配置，重启服务，exportfs 应该能查到你刚才的设置项：

sudo exportfs -arv
sudo systemctl restart nfs-kernel-server

然后，关掉防火墙，如果一股脑全关掉就是 sudo ufw disable，想要细化可以以后再说。

接着，去 /etc/nfs.conf 中解除掉这句注释：

[nfsd]
...
vers4=y

到这步之后，上位机的权限就放开了，进行一轮重启：

sudo systemctl restart rpcbind
sudo systemctl restart rpc-statd
sudo systemctl restart nfs-server

然后去下位机创建好文件夹，跑命令：

mount -t nfs -o vers=4 192.168.1.66:/home/felix/embedded/board /mnt/nfs

正常的话，这里应该就可以完成文件夹的共享了。由于我进行了大量的回档，因此这些记录可能不全面，仅做记录。

总结

思路很清晰，配置交叉编译环境，与下位机建立通讯，把文件发送过去，能这么轻松，从机上自己的标准化 Linux 环境还是立了大功的。

流程挺长的，但是上板子毕竟还是和在模拟空间里面跑不一样，更有乐趣了，毕竟这样就可以在板子里面大闹天宫了嘛（bushi

]]><![CDATA[记录在 Linux 中搭建 Arm 嵌入式仿真平台]]>https://xufelix-dailynotes-zh.hashnode.dev/linux-armhttps://xufelix-dailynotes-zh.hashnode.dev/linux-armWed, 25 Mar 2026 19:08:11 GMT前言

主要是参考了老师给的文档，因为很多细节还需要自己去琢磨琢磨——既然自己琢磨完了就记录一下叭，万一班上有同学需要呢（）

环境

  • 主机系统：Win11；

  • 虚拟机：VMware® Workstation Pro 25H2u1 25.0.1.25219725

  • Linux：Ubuntu 24.04.4 LTS

正文

准备环境

下载 Linux 源码

https://cdn.kernel.org/pub/linux/kernel/v5.x/linux-5.19.17.tar.gz

这个大版本更新到2022为止，这个小版本就其中是最新的，感觉像是靠谱的样子（）

在命令行中下载QEMU软件包

sudo apt install qemu-system-arm

可以检查一下QEMU的安装情况和支持的芯片：

qemu-system-arm -M help

安装编译器以及依赖项

总之就是缺什么装什么

sudo apt install build-essential gcc-arm-linux-gnueabi gcc-aarch64-linux-gnu systemtap flex bison build-essential libssl-dev libelf-dev

下载 Busybox 源码

官网不知道为什么一直进不去，这里我从github下载了压缩包，注意要去找到 stable 的 branch 下载，不然编译会报错，在 Linux 环境下解压，最终成功的是 1_36_stable 的 branch。

编译系统

把刚才下载好的 linux-5.19.9.tar.gz 解压，然后在解压目录下启动命令行（和 MakeFile同一级），开始编译。首先生成 .config 文件：

make vexpress_defconfig ARCH=arm O=./object

然后文档中给出了这么一句，似乎是准图形化的详细安装配置，我反正看不懂，没去动：

make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- menuconfig -j4 O=./object

然后正式开始编译：

make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- -j4 O=./object

等个几分钟，就编译完了。

编译安装 Busybox

  • 注意，代码仓库中，tc的代码是有问题的，会挂编译，我们需要去编译菜单中把tc关掉。

进入 Busybox 的工作路径，开始 CMake：

make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- menuconfig

在菜单中找到 Networking Utilities，进去，找到 tc，按空格把这个选项删掉，然后退出，保存，然后开始编译：

make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi-

然后构建 install 目录：

make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- install

最后，把 _install 目录下的文件 copy 到 Linux 根目录下的 rootfs 文件夹中。这里原本是没有 rootfs 文件夹的，要新建路径。

搭建系统架构

回到刚刚编译完的 Linux 根目录下的工作路径，开始配置：

拷贝编译器的加载器和动态库

mkdir rootfs/lib
cp /usr/arm-linux-gnueabi/lib/* rootfs/lib/ -rfp

创建设备文件

接下来，切换工作目录，进入到 ./rootfs/dev 中，开始创建各种设备：

mkdir ./rootfs/dev
cd ./rootfs/dev
sudo mknod -m 666 tty1 c 4 1
sudo mknod -m 666 tty2 c 4 2
sudo mknod -m 666 tty3 c 4 3
sudo mknod -m 666 tty4 c 4 4
sudo mknod -m 666 console c 5 1
sudo mknod -m 666 null c 1 3

制作 SD 卡文件系统镜像

创建镜像，格式化：

dd if=/dev/zero of=rootfs.ext3 bs=1M count=32
mkfs.ext3 rootfs.ext3

接下来，把这个 rootfs.ext3 挂载到主机 Linux 下，就像新的 SD 卡插入了电脑一样。这里你可以自己选择要挂载到哪里，后续挂到工作区也不是不行，但是注意要预先创建好路径：

sudo mkdir /mnt/SD_A9
sudo mount -t ext3 rootfs.ext3 /mnt/SD_A9 -o loop

然后把 rootfs 文件夹下的内容复制进 SD 卡，复制完后就弹出。注意到，我们要拷贝整个 rootfs 文件下的文件，因此工作路径要回到小 Linux 的根目录下，所以开头先来两次 cd ..：

cd ..
cd ..
sudo cp -rf rootfs/* /mnt/SD_A9
sudo umount /mnt/SD_A9

验证！

在 Linux 镜像的根目录下，启动 QEMU：

qemu-system-arm -M vexpress-a9 \
-m 512M \
-kernel ./object/arch/arm/boot/zImage \
-dtb ./object/arch/arm/boot/dts/vexpress-v2p-ca9.dtb \
-nographic -append "root=/dev/mmcblk0 rw console=ttyAMA0" \
-sd ./rootfs/dev/rootfs.ext3

如果一切顺利的话——

Hello World!

总结

大胆猜想，严谨求证，谨慎操作，这一趟装机下来能学到不少东西哇！

]]><![CDATA[TI Driverlib 标准输出完整重定向的改进方案]]> STAT & UART_STAT_TXFF_MA...]]>https://xufelix-dailynotes-zh.hashnode.dev/ti-driverlib-stdo-redirecthttps://xufelix-dailynotes-zh.hashnode.dev/ti-driverlib-stdo-redirectMon, 10 Nov 2025 16:07:28 GMTMCU：MSPM0G3507

前段时间在课内做实验的时候碰到了比较丰富的交互需求，遂打开UART，#include "stdio.h"，然后开始重定向。虽然网上有广为流传的重定向方案，但是常年玩STM32的我有点迷惑：为什么TI Driverlib的重定向需要定义三个函数呢？

Trial

按照 STM32 重定向的方法，先对fputc进行重定向：

int fputc(int _c, FILE *_fp) {
    while((UART0 -> STAT & UART_STAT_TXFF_MASK));
    UART0 -> TXDATA = _c;
    return _c;
}

观察到，在这种重定向的方案下，printf函数可以输出常字符串，但是无法进行变量的格式化输出。

根据网络上的方案，补充fputs和puts函数，稍作修改：

int fputs(const char *restrict s, FILE *restrict stream) {
    uint16_t i, len;
    len = strlen(s);
    for (i = 0; i < len; i++) {
        fputc(s[i], stream);
    }
    return len;
}

int puts(const char *s) {
    int count = fputs(s, stdout);
    count += fputs("\n", stdout);
    return count;
}

在这种重定向方法下，printf成功实现了完整的重定向，可以进行变量的格式化输出——但是，sprintf依然无法工作，为什么呢？

观察三个函数的输入参数，其中两个都包含了一个FILE*输入变量，但是我们在使用的时候却完全没用到。找到FILE的定义：

struct __sFILE {
    int fd;                    /* File descriptor */
    unsigned char* buf;        /* Pointer to start of buffer */
    unsigned char* pos;        /* Position in buffer */
    unsigned char* bufend;     /* Pointer to end of buffer */
    unsigned char* buff_stop;  /* Pointer to last read char in buffer */
    unsigned int   flags;      /* File status flags (see below) */
};

typedef struct __sFILE FILE;

可见，在TI的库中，FILE类型并没有被简单地改为简单的存储指针，而是依然保留了“数据流”的形式。再结合debug中断点的触发情况，以及函数之间的调用关系，尝试对FILE*指针进行写入。若调用了puts，认为上层的标准输出走的是printf()，就向下传递空指针，将输出导向 UART。如果stream不是自己设定的空指针，就去编辑stream指向的缓冲区。

Result

对重定向的三个函数进行如下修改：

int fputc(int _c, FILE *_fp) {
    if(!(_fp)) {
        while((UART0 -> STAT & UART_STAT_TXFF_MASK));
        UART0 -> TXDATA = _c;
    }
    else
        *(_fp->pos) = _c;
    return _c;
}

int fputs(const char* restrict s, FILE* restrict stream) {
    uint16_t i, len;
    len = strlen(s);
    for(unsigned int i=0; i < len; i++) {
        fputc(s[i], stream);
        if(stream) stream->pos++;
    }
    return len;
}

int puts(const char *_ptr) {
    int count = fputs(_ptr,NULL);
    count += fputs("\n",NULL);
    return count;
}

重定向成功，sprintf和printf均可以正常工作！

More…

那个结构体我还没用完，估计在重定向输入流的时候会用到更多的元素。但是知道这些已经足够了，可以搞点花招，比如把UARTx → TXDATA直接丢到stream里面去，当然FIFO只有一个入口，不需要地址偏移，这么看也是有点麻烦；或者直接把自己的指定buffer设为默认输出区域，等等，虽然更复杂了，但是相对于仅仅把FILE作为一个独立指针，还是更加灵活有趣的！

实力尚浅，还请多多指教！

]]>