#!/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。

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

流式传输和帧传输有区别。

流式传输不适合用pingpong。

在USB CDC 中用了pingpong缓冲。

我没想到的是256字节会分为4包每包64字节传输（因为USB 的断点大小最多64的关系）

这个就导致了，CPU占用率低的时候，中间能来得及触发Read，看上去没有什么问题。

占用率搞的时候，多包中间没Read。直接数据丢失。

dcoker解决了什么问题？

不同的软件需要不同的依赖，某些依赖会互相干扰。

---

1. 安装 Docker 和 Compose 插件

sudo apt update
sudo apt install docker.io docker-compose-v2 -y

2. 验证 Docker 是否安装成功

输入：

sudo docker ps

如果终端没有报错，而是打印出了 CONTAINER ID IMAGE COMMAND... 这样的表头，说明 Docker 已经运行

---

4. 安装HA

既然 Docker 好了，我们现在就把 Home Assistant 和 MQTT 的配置文件写好，把它们跑起来。

依次输入：

# 创建一个文件夹专门放智能家居的配置
mkdir ~/smarthome
cd ~/smarthome

# 使用 nano 编辑器创建 docker-compose.yml 文件
nano docker-compose.yml

编写完对应的配置后，敲下启动命令：

docker compose up -d

它会自动去拉取 HA 和 Mosquitto 的镜像。由于 HA 镜像比较大（大概1个多G），这里可能需要耐心等上几分钟到十几分钟，具体取决于你的网速。

国内给docker换源

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": [
    "https://docker.m.daocloud.io",
    "https://docker.nju.edu.cn",
    "https://dockerproxy.com",
    "https://hub-mirror.c.163.com"
  ]
}
EOF// 代码

换好后重启

sudo systemctl daemon-reload
sudo systemctl restart docker

1. 下载 Miniconda 安装脚本

打开你的终端，根据你当前的设备选择对应的下载命令：

如果你现在是在泰山派 (RK3576) 的板子上操作 (ARM64 架构)：

wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-aarch64.sh -O miniconda.sh

如果你现在是在 Windows 的 WSL2 或纯粹的 PC 虚拟机里操作 (x86_64 架构)：

wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -O miniconda.sh

2. 运行安装程序

下载完成后，执行以下命令开始安装：

bash miniconda.sh

安装过程中的关键交互提示（按顺序）：

1. Please, press ENTER to continue -> 按下回车键。
2. 此时会显示长篇的许可协议。按住键盘上的空格键快速翻页，直到最底部。
3. Do you accept the license terms? [yes|no] -> 输入 yes 并回车。
4. Miniconda3 will now be installed into this location... -> 提示安装路径（默认是 ~/miniconda3），直接按回车键确认。
5. 等待进度条走完进行解压安装。
6. ⚠️ 最关键的一步：Do you wish the installer to initialize Miniconda3 by running conda init? [yes|no] -> 务必输入 yes 并回车。这会自动配置你的环境变量。

3. 使环境变量生效

安装完成后，刚才的配置需要你重新加载一下终端才能生效。你可以关掉终端重新打开，或者直接输入：

source ~/.bashrc

4. 验证安装

如果在命令行的最前面出现了一个 (base) 字样，说明 Conda 已经成功接管了。 你可以输入以下命令确认：

conda --version

如果打印出版本号（例如 conda 24.x.x），就说明安装大功告成。

--- Miniconda 默认会在你每次打开终端时，自动进入 (base) 虚拟环境。 但是，作为搞硬件和底层开发的人，我们经常需要编译 C/C++ 代码（比如使用 make、cmake 或者交叉编译工具链）。Conda 的默认环境有时会拦截掉系统的自带编译器或者库，导致莫名其妙的编译报错。

为了保证系统环境的干净，强烈建议关闭 Conda 的开机自启：

conda config --set auto_activate_base false

执行完之后，下次打开终端就不会再看到默认的 (base) 了。当你想写 Python 代码或启动网关服务时，再手动激活即可。

🚀 日常使用速查手册

准备好之后，你就可以随时为不同的项目创建独立的“无菌室”了。比如你要开发那个蓝牙网关：

• 创建新环境（例如指定 Python 3.10 版本）：

  conda create -n ble_gateway python=3.10

• 进入该环境： bash conda activate ble_gateway 此时终端前缀会变成 (ble_gateway)
• 退出当前环境，回到系统原生环境： bash conda deactivate
• 查看你创建了哪些环境： bash conda env list

驱动方式：定时器+DMA

现象：手一摸会闪烁

解决方法：IO设置为软件下拉

今天调试一个继电器电机。用了24年写的电机业务逻辑的代码框架。

回头看之前自己写的代码框架，感慨写的真TM好！真TM解耦合。

把它抽象出了inc，dec，stop而不关心底层电机类型。route_curr行程获取不关心旋变、磁编还是霍尔。

用的时候和大脑按摩一样，太顺滑了。

回头看目前用AI写的驱动，例如WB2812B，因为AI写的速度太快了，我很多代码没完全阅读过。明明是我让AI写的，但是里面的辅助函数我却看不懂什么意思了。再也没有那种对代码随心所欲掌控的感觉了。

古法编程的代码一去不复返了。