ESP32 Captive Portal 自动弹出原理

1. 功能概述

手机连接 ESP32 的 SoftAP 后，Android 或 iOS 会自动弹出配网页面。

这个页面并不是 ESP32 主动命令手机打开的，而是手机操作系统检测到当前 Wi-Fi 存在 Captive Portal 后，主动打开系统配网窗口。

当前实现结合了以下三种机制：

1. DHCP Option 114 声明配网页面地址。
2. DNS 劫持将所有域名解析到 ESP32。
3. HTTP Server 将未知路径重定向到配网页面。

2. 手机连接 Wi-Fi 后的行为

手机连接 Wi-Fi 后，通过 DHCP 获取以下网络参数：

• IP 地址
• 子网掩码
• 默认网关
• DNS Server
• Captive Portal 地址

ESP32 SoftAP 通常分配：

手机地址：192.168.4.2
网关地址：192.168.4.1
DNS 地址：192.168.4.1

ESP32 还通过 DHCP Option 114 告诉手机：

Captive Portal URL = http://192.168.4.1/

支持 DHCP Option 114 的操作系统可以直接知道配网页面的地址。

3. 操作系统联网检测

手机连接 Wi-Fi 后，会主动访问操作系统预设的 HTTP 地址，判断当前网络是否能够访问互联网。

常见检测地址如下：

Android:
http://connectivitycheck.gstatic.com/generate_204

iOS:
http://captive.apple.com/hotspot-detect.html

Windows:
http://www.msftconnecttest.com/connecttest.txt

操作系统期望收到特定响应：

如果收到预期响应，系统认为网络可以正常访问互联网。

如果收到重定向、配网页面或其他内容，系统会认为当前网络需要进行网页登录认证。

4. DNS 劫持

ESP32 在 UDP 53 端口运行 DNS Server。

DNS Server 会将客户端发来的所有 IPv4 A 记录查询都解析为 SoftAP 地址：

任意域名 -> 192.168.4.1

例如手机查询：

connectivitycheck.gstatic.com

ESP32 返回：

connectivitycheck.gstatic.com -> 192.168.4.1

因此手机原本发往互联网的联网检测请求，最终会发送到 ESP32 的 HTTP Server。

5. HTTP 重定向

手机可能访问以下路径：

/generate_204
/hotspot-detect.html
/connecttest.txt

ESP32 当前只提供根路径：

/

当 HTTP Server 收到未注册的路径时，返回：

HTTP/1.1 303 See Other
Location: /

手机随后访问：

http://192.168.4.1/

ESP32 返回完整的配网页面。

6. 完整流程

手机连接 ESP32 SoftAP
        |
        v
通过 DHCP 获取 IP、网关和 DNS
        |
        v
DHCP Option 114 声明配网页面地址
        |
        v
手机发起系统联网检测
        |
        v
查询 connectivitycheck.gstatic.com 等域名
        |
        v
ESP32 DNS 返回 192.168.4.1
        |
        v
联网检测请求到达 ESP32 HTTP Server
        |
        v
未知路径返回 HTTP 303
        |
        v
重定向到根路径 /
        |
        v
ESP32 返回配网页面
        |
        v
系统判断当前 Wi-Fi 存在 Captive Portal
        |
        v
Android/iOS 自动弹出系统配网窗口

7. 各模块职责

DHCP Server

负责向客户端分配网络参数，并通过 Option 114 声明配网页面：

http://192.168.4.1/

Captive DNS Server

监听 UDP 53 端口，将所有 A 记录查询解析为：

192.168.4.1

HTTP Server

负责：

• 返回配网页面。
• 处理手机的联网检测请求。
• 将未知路径重定向到 /。

Android/iOS

负责：

• 主动检测网络连通性。
• 判断是否存在 Captive Portal。
• 打开系统配网窗口。
• 配网完成后重新检查互联网连接。

8. 为什么使用 HTTP 而不是 HTTPS

Captive Portal 主要依赖 HTTP 联网检测。

如果手机访问：

https://example.com

浏览器要求服务器提供与 example.com 匹配的 TLS 证书。

ESP32 无法提供任意网站的合法证书，因此 HTTPS 请求会产生证书错误，不能透明重定向到配网页面。

因此可以认为：

普通 HTTP 请求可以被引导到配网页面。
HTTPS 请求不能可靠劫持和重定向。

9. 配网页面不一定始终自动弹出

是否自动弹出最终由手机操作系统决定，以下情况可能影响弹窗：

• 手机启用了 Private DNS、DoH 或 DoT。
• 手机缓存了之前的 DNS 结果。
• 手机自动切换到蜂窝网络。
• 操作系统厂商修改了联网检测机制。
• 手机已经记住了该 Wi-Fi 的检测结果。
• 浏览器访问的是 HTTPS 或启用了 HSTS 的网站。

即使系统没有自动弹窗，用户仍然可以手动访问：

http://192.168.4.1/

进入配网页面。

10. 当前实现总结

当前 ESP32 Captive Portal 使用：

SoftAP
+ DHCP Option 114
+ 通配 DNS 解析
+ HTTP 303 重定向
+ HTML 配网页面

其本质是：

ESP32 将手机的联网检测请求引导到本地 HTTP Server，操作系统发现响应不符合互联网连通性检测要求，因此判定该 Wi-Fi 需要认证，并自动打开配网页面。

esp32上搭建http server 利用 web_server加上SoftAP进行路由配网。

httpd_register_uri_handler 这个函数可以用于注册http方法。

此函数入参为代表了HTTP_GET这个方法就会进入handler这个函数

static const httpd_uri_t s_root_uri = {
    .uri = "/",
    .method = HTTP_GET,
    .handler = http_server_root_get_handler,
    .user_ctx = NULL,
};

在这个函数的resp中返回html格式的应答。

html可以 通过CmakeLists中EMBED_FILES添加：

idf_component_register(
    SRCS
        ...
    INCLUDE_DIRS
        ...
    EMBED_FILES
        "http/web/index.html"
)

通过这种方式可以访问：

extern const uint8_t s_index_html_start[] asm("_binary_index_html_start");
extern const uint8_t s_index_html_end[] asm("_binary_index_html_end");

更加复杂点的，可以做一个小型文件系统，放入带有目录格式的网页代码

dofc-mqtt是我开的一个containers的名称

docker logs -f --tail=100 dofc-mqtt这条命令可以查看日志

docker exec -it dofc-mqtt mosquitto_sub -h 127.0.0.1 -p 1883 -t "dofc/device/dofc-motor-3C0F02C9B78C/config/state" -v 可以查看对应topic的报文

The use of large assistive torques is particularly problematic because the residual motion created by the device can be registered as user motion thus creating an unstable oscillation. This poses safety problems to those with poor balance.

在很多篇文章里都提到了，当辅助力矩过大时，外骨骼自身的震荡被识别成使用者自身的运动，从而产生不稳定的震荡。

之前我自己鼓捣的方法，就是无法克服这个问题。

但是看论文里面很多都说自己能克服这个问题，我抄袭过两篇的做法，实际无法复现。。不知道是因为我自己的水平问题，还是说论文本身作者就有点不诚实，改了数据。

在网友帮助下，得到了一篇文章，解决了力矩如何输出的问题。这个算法在力矩大的时候仍然会震荡。但是论文上有说明，这个方法是最后是收敛的。

然后我配合了启动停止的识别，在停止时随着时间衰减力矩增益系数，解决了这个问题。

如何使用加速度传感器获取位移？

首先要先把数据从本体坐标系转换到世界坐标系

转换完毕之后，对世界加速度做处理，去掉Z轴上恒定的重力加速度得到线性加速度

静止状态下，线性加速度应该为0。

线性加速度积分得到速度，再对速度做积分得到位移。

这个过程中由于进行了二次积分，原来加速度数据中很小的残差，进行二次积分过后会导致很大的差异。此时你得到的数据，在50cm的尺子上测试，大概误差会在50%以上的误差。

这个时候假设加速度残差是恒定的，用 0.5 * v_end * T  来修正最终误差，其中v_end为末速度。

进行修正之后，误差在20%之间，也就是说移动50cm，可能是55cm，也可能是60cm。

接下来我也不知道如何去优化了，对这个结果最终不满意，不过我观察数据也不知道更准确的思路了。

#!/bin/sh
#pre-commit
set -eu

echo "Running project formatter..."

if command -v pwsh >/dev/null 2>&1; then
    pwsh -NoProfile -File "tools/format_code.ps1"
elif command -v powershell.exe >/dev/null 2>&1; then
    powershell.exe -NoProfile -ExecutionPolicy Bypass -File "tools/format_code.ps1"
elif command -v powershell >/dev/null 2>&1; then
    powershell -NoProfile -ExecutionPolicy Bypass -File "tools/format_code.ps1"
else
    echo "PowerShell was not found. Run tools/format_code.ps1 manually before committing."
    exit 1
fi

if ! git diff --quiet --; then
    echo ""
    echo "Formatting changed files or unstaged changes are present."
    echo "Review the diff, stage the formatted files, then commit again:"
    echo ""
    echo "  git diff"
    echo "  git add <files>"
    echo "  git commit"
    echo ""
    git diff --name-only --
    exit 1
fi

echo "Formatting check passed."

使用git hook可以在git操作的各个阶段进行操作。

例如我这里的pre-commit可以在commit提交之前执行脚本。

这里执行了一次clang-format，判断代码是否格式化。

在复习卷积时候用到的，已经忘记了。

等比数列的求和公式主要分为公比 $q \neq 1$ 和 $q = 1$ 两种情况。

常规求和公式（从第 1 项加到第 n 项）

假设等比数列的首项是 $a1$，公比是 $q$，前 $n$ 项的和记为 $Sn$：

当 $q \neq 1$ 时：

$Sn = \frac{a1(1 - q^n)}{1 - q}$

或者写成：

$Sn = \frac{a1 - a_n q}{1 - q}$

当 $q = 1$ 时：

$Sn = n \cdot a1$

从 $n=0$ 加到 $n=k$ 的情况

你提到的“最后是 $q^{k+1}$ 吗？”这个直觉非常准确。在最终的求和公式里确实会出现 $q^{k+1}$，但我们需要稍微区分一下“加式的最后一项”和“公式里的指数”。

假设通项公式为 $a \cdot q^n$，我们从 $n=0$ 开始累加到 $n=k$：

$S = a \cdot q^0 + a \cdot q^1 + a \cdot q^2 + \dots + a \cdot q^k$

这里有两个关键细节：

累加的最后一项： 是 $a \cdot q^k$，并不是 $q^{k+1}$。

总项数： 从 $0$ 数到 $k$，总共有 $k+1$ 项（这是一个常见的“差一错误”陷阱）。

根据等比数列的求和原理，公式中的指数代表的是总项数。将“首项为 $a$”、“项数为 $k+1$”代入求和公式中（假设 $q \neq 1$），最终结果为：

$S = \frac{a(1 - q^{k+1})}{1 - q}$

总结： 你的理解在公式推导的层面上是完全正确的！如果你从 $n=0$ 累加到 $n=k$，求和公式的分子中必然包含 $q^{k+1}$。

这是一道关于离散时间序列卷积的经典信号与系统题目。我们可以通过离散卷积的定义公式来分步求解。

已知两个序列：

$x[n] = (\frac{1}{2})^n u[n] + 2^n u[-n]$

$h[n] = u[n]$

目标是求卷积 $y[n] = x[n] * h[n]$。

1. 设立卷积和公式

根据离散时间卷积的定义：

$y[n] = \sum_{k=-\infty}^{\infty} x[k] h[n-k]$

将 $x[n]$ 和 $h[n]$ 代入公式中：

$y[n] = \sum_{k=-\infty}^{\infty} \left[ (\frac{1}{2})^k u[k] + 2^k u[-k] \right] u[n-k]$

利用求和的线性性质，我们可以将其分为两部分分别求解：

$y[n] = y1[n] + y2[n]$

其中：

$y1[n] = \sum{k=-\infty}^{\infty} (\frac{1}{2})^k u[k] u[n-k]$

$y2[n] = \sum{k=-\infty}^{\infty} 2^k u[-k] u[n-k]$

3. 求解 $y_1[n]$

分析阶跃函数确定的求和区间：

$u[k] = 1$ 要求 $k \ge 0$

$u[n-k] = 1$ 要求 $n-k \ge 0$，即 $k \le n$

因此， $y1[n]$ 的非零区间要求同时满足 $k \ge 0$ 且 $k \le n$。这说明只有当 $n \ge 0$ 时求和才有意义（此时 $0 \le k \le n$）。如果 $n < 0$，区间不重叠，$y1[n] = 0$。

当 $n \ge 0$ 时，利用等比数列求和公式：

$y1[n] = \sum{k=0}^{n} (\frac{1}{2})^k = \frac{1 - (1/2)^{n+1}}{1 - 1/2} = 2 \left[ 1 - (\frac{1}{2})^{n+1} \right] = 2 - (\frac{1}{2})^n$

所以，$y_1[n]$ 可以写为：

$y_1[n] = \left[ 2 - (\frac{1}{2})^n \right] u[n]$

4. 求解 $y_2[n]$

分析阶跃函数确定的求和区间：

$u[-k] = 1$ 要求 $-k \ge 0$，即 $k \le 0$

$u[n-k] = 1$ 要求 $n-k \ge 0$，即 $k \le n$

因此，$y_2[n]$ 的求和区间取决于 $n$ 与 $0$ 的大小关系：

情况 A：当 $n \ge 0$ 时

求和区间的上限受限于 $k \le 0$（因为 $k$ 必须同时小于等于 $0$ 且小于等于 $n$，此时 $0$ 更小）。

$y2[n] = \sum{k=-\infty}^{0} 2^k$

令 $m = -k$，则求和变为从 $0$ 到 $\infty$：

$y2[n] = \sum{m=0}^{\infty} 2^{-m} = \sum_{m=0}^{\infty} (\frac{1}{2})^m = \frac{1}{1 - 1/2} = 2$

情况 B：当 $n < 0$ 时

求和区间的上限受限于 $k \le n$（因为此时 $n$ 比 $0$ 小）。

$y2[n] = \sum{k=-\infty}^{n} 2^k$

令 $m = n-k$，当 $k=n$ 时 $m=0$；当 $k \to -\infty$ 时 $m \to \infty$。

$y2[n] = \sum{m=0}^{\infty} 2^{n-m} = 2^n \sum_{m=0}^{\infty} (\frac{1}{2})^m = 2^n \left( \frac{1}{1 - 1/2} \right) = 2^{n+1}$

综合以上两种情况，$y_2[n]$ 可以分段表示为：

$y_2[n] = \begin{cases} 2, & n \ge 0 \ 2^{n+1}, & n < 0 \end{cases}$

或者用阶跃函数写成：$y_2[n] = 2u[n] + 2^{n+1}u[-n-1]$。

5. 组合最终结果

将 $y1[n]$ 和 $y2[n]$ 相加 $y[n] = y1[n] + y2[n]$：

当 $n \ge 0$ 时：

$y[n] = \left( 2 - (\frac{1}{2})^n \right) + 2 = 4 - (\frac{1}{2})^n$

当 $n < 0$ 时：

$y[n] = 0 + 2^{n+1} = 2^{n+1}$

最终答案：

你可以将结果写成分段函数的形式：

$y[n] = \begin{cases} 4 - (\frac{1}{2})^n, & n \ge 0 \ 2^{n+1}, & n < 0 \end{cases}$

或者合并写成使用单位阶跃函数的闭式表达式：

$y[n] = \left[ 4 - (\frac{1}{2})^n \right] u[n] + 2^{n+1} u[-n-1]$

AT设备你们是如何解析的呢？笔者第一次使用at设备，是一个4G模块，大夏龙雀的L511-2。

看了新公司的同事的代码，这颗模块实现MQTT的方式，是直接用了AT+MQTT的方式来下发。

我打算换一个架构，之前学习的是socket做网络应用，我想把AT设备封装成socket接口。

这部分代码就不自己造轮子了，据我了解rtthread直接有at socket，今天就花一天时间阅读一下它的源码。

这里得分为两部分，一个是AT协议的解析框架。第二个是如何把AT指令封装成socket。

我们先来看第一个。

AT协议解析框架

底层收发接口

最底层的发送接口使用一个weak定义的函数at_utils_send实现：

rt_weak rt_size_t at_utils_send(rt_device_t dev,
                                rt_off_t    pos,
                                const void *buffer,
                                rt_size_t   size)
{
    return rt_device_write(dev, pos, buffer, size);
}

// 代码

它内部调用rt_device_write，如果我们物理接口使用的是device io框架，那么可以直接使用。

at_client 初始化

根据语义，主动的被称为Client，被动的被称为Server。在我们的应用场景中往往模块被当成Server，而调用模块的MCU当成Client。如果你是要自己做一个模块，那就是实现Server。

在rtthread的代码中，提供了at_client.c和at_server.c这样子两个文件。

作为使用模块的用户，这里启用at_client.c

它支持多实例，用单向链表管理多个client。g_at_client_list就是链表，在里面挂载了一个个节点at_client_t。

unsigned int at_client_num = rt_slist_len(&g_at_client_list);
rt_snprintf(name, RT_NAME_MAX, "%s%d", AT_CLIENT_THREAD_NAME, at_client_num);
client->parser = rt_thread_create(name,
                                      (void (*)(void *parameter))ient_parsercl,
                                      client,
                                      1024 + 512,
                                      RT_THREAD_PRIORITY_MAX / 3 - 1,
                                      5);

之前没有接触过这种写法，不同入参同样的entry，又学到了一招。

初始化函数为：int at_client_init(const char *dev_name, rt_size_t recv_bufsz, rt_size_t send_bufsz)

这里的入参有3个，第一个dev_name也就是输出物理层设备的名称。

我看到代码里的写法，应该是一个输出设备只能注册一个client。不存在一个串口，挂载多个client这种现象。我仔细想一下，好像确实是这样，这个抽象是合理的。一个串口挂载两个设备就乱套了。必须物理层和AT设备是一对一的。

整体at_client_init过程不是很复杂，完整代码我就不贴了，不然文章就太长了。

它里面，首先根据dev_name判断设备是否注册，防止重复注册。

然后malloc申请一个长度为 sizeof(struct at_client) + recv_bufsz + send_bufsz内存。

这种做法貌似在RTOS代码里面满常见的。只申请一次，其中控制句柄放在这个内存的最开始。client = rt_malloc(sizeof(struct at_client) + recv_bufsz + send_bufsz);然后再对这段内存做分配。而不是申请三次

//申请一次，后续分配这段内存
client = rt_malloc(sizeof(struct at_client) + recv_bufsz + send_bufsz);
...
client->recv_bufsz    = recv_bufsz;
client->recv_line_buf = ((char *)client) + sizeof(struct at_client);

client->send_bufsz = send_bufsz;
client->send_buf   = ((char *)client) + sizeof(struct at_client) + client->recv_bufsz;
...

最后把client添加到list里面，注册串口RX的回调之类的。 rt_device_set_rx_indicate(client->device, at_client_rx_ind);

这个回调函数在串口收到数据后会被触发，里面是发送了事件标志组，去通知解析。

rt_event_send(&client->event, at_client_rx_notice_event);

解析数据

通过at_client_rx_notice_event事件来触发读取。把读到的数据放到自己的recv_line_buff中

if (event & at_client_rx_notice_event)
{
    while (RT_EOK == at_client_getchar(client, &ch))
    {
        if (client->recv_line_len < client->recv_bufsz)
        {
            client->recv_line_buf[client->recv_line_len++] = ch;
        }
        else
        {
            is_full = RT_TRUE;
        }

        /* is newline or URC data */
        client->urc = get_urc_obj(client);
        if (client->urc != RT_NULL || (ch == '\n' && last_ch == '\r')
            || (client->end_sign != 0 && ch == client->end_sign))
        {
            if (is_full)
            {
                LOG_E("read line failed. The line data length is out of buffer size(%d)!", client->recv_bufsz);
                rt_memset(client->recv_line_buf, 0x00, client->recv_bufsz);
                client->recv_line_len = 0;
                return -RT_EFULL;
            }

            /* Since the buffer state is uncertain, we proactively clear it; the overhead is negligible. */
            rt_event_send(&client->event, at_client_rx_notice_event);
            goto __next;
        }
        last_ch = ch;
    }
}

这里判断了urc

所谓urc就是指AT指令中，模块主动给MCU上报的信息，例如发送AT+CSQ收到的应答如下：

+CSQ: 20,99
OK

这种时候就需要解析应答的内容。

因为不同模块的应答格式不同，所以这个框架中采用了注册的方法，注册一个urc_table，然后这里是收到应答后去匹配，看看是不是urc的内容。

resp是应答包。在AT协议中需要OK,ERROR,FAIL来判断发送命令的知行情况。

伪代码如下：

/**
 * Waiting for connection to external devices.
 *
 * @param client current AT client object
 * @param timeout millisecond for timeout
 *
 * @return 0 : success
 *        -2 : timeout
 *        -5 : no memory
 */
int at_client_obj_wait_connect(at_client_t client, rt_uint32_t timeout)
{
    rt_err_t      result     = RT_EOK;
    at_response_t resp       = RT_NULL;
    rt_tick_t     start_time = 0;

    if (client == RT_NULL)
    {
        LOG_E("input AT client object is NULL, please create or get AT Client object!");
        return -RT_ERROR;
    }

    resp = at_create_resp(64, 0, rt_tick_from_millisecond(300));
    if (resp == RT_NULL)
    {
        LOG_E("no memory for AT client(%s) response object.", client->device->parent.name);
        return -RT_ENOMEM;
    }

    start_time = rt_tick_get();

    while (1)
    {
        /* Check whether it is timeout */
        if (rt_tick_get() - start_time > rt_tick_from_millisecond(timeout))
        {
            LOG_E("wait AT client(%s) connect timeout(%d tick).", client->device->parent.name, timeout);
            result = -RT_ETIMEOUT;
            break;
        }

        if (at_obj_exec_cmd(client, resp, "AT") == RT_EOK)
        {
            break;
        }
    }

    at_delete_resp(resp);
    return result;
}

先是创建resp，然后调用at_obj_exec_cmd等到回复应答。

封装socket

scons --cdb build/compile_commands.json这行命令可以用来用于clangd生成智能提示的json。

scons --target=mkd5生成MDK工程。MDK工程的.c和.h文件添加通过编辑Sconsript文件实现。

RT_USING_SRIAL_V1和RT_USING_SRIAL_V2是 RT-Thread串口驱动的两个版本

定义在

https://github.com/RT-Thread/rt-thread/blob/master/components/drivers/serial/Kconfig#L7-L15

choice RT_USING_SERIAL_VERSION
    prompt "Choice Serial version"
    default RT_USING_SERIAL_V1

    config RT_USING_SERIAL_V1
        bool "RT_USING_SERIAL_V1"

    config RT_USING_SERIAL_V2
        bool "RT_USING_SERIAL_V2"
endchoice

SCons会根据这个选择不同的源码

https://github.com/RT-Thread/rt-thread/blob/master/components/drivers/serial/SConscript#L14-L17

if GetDepend(['RT_USING_SERIAL_V2']):
    src += ['dev_serial_v2.c']
else:
    src += ['dev_serial.c']

V1 和 V2 的主要区别：

BYPASS功能

这个功能是RT-Thread serial 驱动里面的一个串口数据拦截机制。

开启 bypass 之后，串口的数据在被 rt_device_read()之前，会经过bypass pipe。

这个功能可以让某些模块提前看到串口字节。