每天一个生活小妙招

“力矩”的定义是相对于“点”的，而不是“轴”。这暗示了力矩的方向并不总是沿着转轴。比如 $(1,0,1)$ 处有一个质量为1的质点，绕 z轴 逆时针旋转，则其相对于原点的力矩为 $\alpha(-1, 0, 1)$，可以看到除了轴向，还有一个 $-x$ 方向的分量。反作用力说明原点在此刻有一个向右的力矩，如果转轴和地面（不会动，可以提供任意力）在原点处通过一个铰链连接，启动时（从0加速）会看到轴杆向 $-y$ 偏转。但如果轴杆在 $(0,0,1)$ 处通过铰链和地面连接，铰链点算出来就只有轴向力矩，所以不会偏转。虽然也会受到向 $+x$ 的力，但这个力过轴，无力矩。

这个不沿着轴向的力矩的朝向和物体的位置有关，而轴向的力矩始终沿着转轴——这就是电机要提供的力矩。所以计算电机的理论输出只需要考虑轴向的力矩，即投影到轴向。可以先算出总的力矩，再投影到轴向（更通用的方法）；也可以算的时候就只在投影平面上算（高中物竞的做法）。

做物理仿真需要计算力矩，但是算力矩需要的转动惯量和质量分布、参考点的位置都有关。一方面质量分布没法存，另一方面每次根据质量分布算转动惯量也很麻烦。有没有什么解决方法？那就是转动惯量张量 $I$。它是一个3x3的矩阵，描述了物体在各个方向上的转动惯量。以前学物理时算转动惯量只算了沿着某个轴的，这里拓展到相对于某个点、任意方向。具体推导如下：

• 角加速度和线加速度的关系：$\vec{a} = \vec{\alpha} \times \vec{r}$
• 力矩 $\vec{\tau} = \vec{r} \times \vec{F} = \vec{r} \times m \vec{a} = m \cdot (\vec{r} \times \alpha \times \vec{r})$ （如果先投影后算，这里的 $\vec{r}$ 就是转轴到质点的位移；否则就是参考点到质点的位移）
• 带入计算：$\vec{r} \times \alpha \times \vec{r} = \begin{bmatrix} r_y^2 + r_z^2 & -r_x r_y & -r_x r_z \\ -r_x r_y & r_x^2 + r_z^2 & -r_y r_z \\ -r_x r_z & -r_y r_z & r_x^2 + r_y^2 \end{bmatrix} \begin{bmatrix} \alpha_x \\ \alpha_y \\ \alpha_z \end{bmatrix} = (\vec{r}^T\vec{r}E-\vec{r}\vec{r}^T)\vec{\alpha}$
• 记上面这个矩阵为 $M$，定义转动惯性张量 $I = \int M dm$

可以看到 $I$ 的取值和坐标系有关。已知一种坐标系下的 $I$，如何推理出任意坐标系下的 $I$ 呢？坐标系变换可以视为先旋转再平移（不考虑空间变形）：

• 旋转：即坐标乘以一个 旋转矩阵 $R$，则 $\vec{r}' = R\vec{r}$，所以
  $I' = \int (R\vec{r})^T(R\vec{r})E - (R\vec{r})(R\vec{r})^T dm = R \int \vec{r}^T\vec{r}E - \vec{r}\vec{r}^T dm R^T = RIR^T$
• 平移：即坐标加上一个平移向量 $\vec{d}$，则 $\vec{r}' = \vec{r} + \vec{d}$，所以
  $I' = \int (\vec{r} + \vec{d})^T(\vec{r} + \vec{d})E - (\vec{r} + \vec{d})(\vec{r} + \vec{d})^T dm = I + m(\vec{d}^T\vec{d}E - \vec{d}\vec{d}^T)$

已知某坐标系下物体的 $I_0$，要求绕某个点的力矩，更实际的做法为：

1. 在 $I_0$ 的定义坐标系下，直接平移算转动惯量，然后算出力矩（向量）
2. 将力矩进行旋转对齐到观察坐标系（不要理解为 $I$ 的旋转；仅仅是力矩的坐标变换）

mujoco 中就是用 <inertial> 定义了 $I$。值得注意的是 diaginertia 可以只写对角线；这意味着其他位置都是0。由于 $I$ 是对称矩阵，进行特征分解后一定长这样：$I = R^T diag(\lambda_1, \lambda_2, \lambda_3) R$，其中 $R$ 是旋转矩阵。根据上面的旋转变换公式，相当于只要进行旋转就可以得到一个只有对角线的 $I'$。此时的方向叫做惯性主轴，三个值叫做惯性主轴转动惯量。

• nginx 的一个重要作用是 将域名变为端口（转发），比如 domain/api 变为 127.0.0.1:8000，屏蔽了端口号
• 80 443 这种特殊端口的作用也是免去端口号

天哪今天才发现之前我对 KV cache 的理解不对。原来推理的时候也有因果掩码，第i个token进行自注意力时只能看到前面i个token。这意味着新生成的token加入输入端后不会影响前面token的注意力结果，进而不会影响到整个流程的计算结果，所以可以缓存。

推理分为 prefill 和 decode 两个阶段，而只有prefill阶段attention的开销是 $O(N^2)$，之后只需要计算新token和之前的注意力就好了，开销是 $O(N)$ 。由于只有最后一个改变，因此预测下一个token的概率分布时，也只要取最后一个token输入lm_head。

全连起来了，泪目。

1. 预编译。宏定义展开，注释删除，行号保留（供后续编译信息输出）
2. 编译，得到汇编语言
3. 汇编，得到二进制 .o 文件
4. 链接，由链接器 ld 完成。

gcc -L -l -I

• -L 增加要链接的库所在的位置，精确到文件夹。其实是加入搜索的文件夹列表中。链接和运行时的链接都有固定的搜索顺序：
  • 链接时（ld 负责搜索）：
    1. 通过 -L 增加的文件夹
    2. LIBRARY_PATH 环境变量，但仅在链接时有效
    3. 默认文件夹如 /usr/lib /lib
  • 运行时：
    0. DT_RPATH (已废弃但仍有用)：如果在链接时使用了 -Wl,-rpath,/some/path (且没有同时使用 --enable-new-dtags)，这个路径会被写入可执行文件的 DT_RPATH 条目。
    1. LD_LIBRARY_PATH 这个环境变量里的文件夹
    2. DT_RUNPATH 这是写在程序里的，见下面说的“可执行程序中内置”。如果在链接时使用了 -Wl,-rpath,/some/path 并且 链接器启用了 --enable-new-dtags (现代 gcc 默认通常启用)，路径会被写入 DT_RUNPATH。
    3. /etc/ld.so.conf 系统缓存
    4. 基础目录如 /usr/lib /lib
       通过 -L 增加的路径不会固化到最终程序，所以即使编译通过，在运行时这个目录没有出现在搜索路径列表中，也会运行失败。
       想要在可执行程序中内置这个路径，需要用别的置零如 -Wl,-rpath。
• -l 要链接的库的名称，只有名称，会被记录到可执行文件中，没用到的不记录
• -I 头文件的目录，可以使用相对路径。出现问题：“找不到头文件”的时候用

具体链接的方法：程序刚拿到main会得到一堆找不到定义的东西，比如只有头文件没有具体实现。然后会在给出的目录中搜索指定的链接库，找到一个就填补一些“undefined”，最终如果全部补完了就成功，没补完就报错。

诸如 stdio 这样的也是链接库，不过编译器自动添加这些路径和文件名

选ucrt的，是高版本、长期维护（不要选msvcrt）
64 位 MinGW 只能用 SEH（32位可选Dwarf）

Mask RCNN 实现实例分隔而不是语义分割：靠的是定位后进行语义分割。也就是先定位，然后在框内生成精确到边界的 MASK。
视频讲解

首先用 Faster RCNN 的方法获取候选区域。那 Faster RCNN 的候选区域怎么获取？用预设的锚框（不错的思路！是首创）
每个特征图的每个像素点上预设多个锚框，每个锚框预测：正负例概率和偏移。
然后是训练时特有的：和GT框比IoU，进行框的选择（用于训练的框，只选择IoU够大/够小的）和正负例的判断（正负例概率的GT）

接着进行ROIPooling，也就是将不同大小的框对应的特征缩放到统一大小的特征。做法是强行均分取每个格子的max。这一步在Mask RCNN 中有改进，用双线性插值代替了。
ROIPooling 的一般做法：先获取到原图感兴趣的区域，然后从特征图里抽取。由于特征图尺寸和原图一般不一样，因此可能原图感兴趣区域在特征图对应位置并不在格点上，此时就会四舍五入造成数据损失。但是其实不需要进行位置的量化，直接在里面重采样出几个点（论文里是2*2个点），对这几个点进行 maxpooling 即可。重采样的方式是双线性插值，此方法叫做ROIAlign。
最后只要对每个小框进行更加细致的分配/边框修正即可！

总结一下流程：

1. 用锚框技术得到感兴趣的框
2. 对每个框提取ROI特征，此时不同大小的框拥有相同的特征大小
3. 对提取的特诊预测 MASK 或者 类别 或者 更精准的框（分支间独立）
4. 后处理，如 MASK 重新缩放回原大小

DINO：自监督监督图像特征提取。自监督用的是自蒸馏：一个老师一个学生。
对同一个图像进行两次平行的裁剪(或者说增强)，得到P1和P2，老师和学生都进行特征提取得到T1T2和S1S2，然后让S1靠近T2、S2靠近T1（用交叉熵）（交叉靠近才有自监督的意义）。学生BP，老师用自己和学生的权值的加权和更新权值，以避免“模式崩塌”（也就是多种输入映射到一种特征），这叫动量更新（EMA）。
最后用老师。

VIT注意力可视化原理：最后一层的token（比如14*14个），每个token和CLS求相似度，然后重新拼成图像，上采样得到和原图一样的热力图。

安装intel xpu torch。https://pytorch-extension.intel.com/
跟着要求更新驱动，新建一个conda环境运行给出的pip指令

查看版本

Get-WmiObject Win32_VideoController | Where-Object {$_.Name -like "*Arc*"} | Select-Object Name, DriverVersion

• 单样本比例检验
  假设某变量服从二项分布 $B(1,p)$（抽一个），现在抽了一批样本（容量为n），1的比例为 $\hat{p}$，请问假设合理吗
  其实就是求 $P(\hat{p}|n,p)$ 。但是求二项分布太麻烦了还有组合数，于是用中心极限定理用正态分布近似，$N(np,np(1-p))$
  要求的是 $\hat{p}$ 的分布，所以除以n得到 $\hat{p} \sim N(p, \frac{p(1-p)}{n})$，然后看看在不在95%置信区间内
• 卡方检测
  其实就是相对MSE，因为MSE有平方，且误差假设为正态分布，所以叫卡方
  独立性检验的期望怎么算？实际为$P(A \cap B)$，假设独立则变为$P(A) P(B)$，所以用右侧算期望

DQN目标网络的作用是计算 $r+k*Q(s,a)$，这个是确定性大一些的，所以是目标
当前网络直接得到Q，这个更加不确定。为了让不确定的当前网络逼近确定的目标网络，需要多轮更新当前网络。之所以要多轮，因为学习率小，用batch+epoch更新才能向目标稳步前进，即所谓“训练稳定”。
当前网络的上限就是“知道下一步Q的”目标网络，所以逼近了一会就要用更好的当前网络去更新目标网络。

那很早之前的经验，可以在后面用吗？不推荐。因为很早之前的经验 $(s_t, a_t, r_t, s_{t+1})$ 中的a_t和s_{t+1}是在那时的policy中得到的。比如现在这种经验几乎不会被遇到，但用这个训练相当于让模型更侧重这一点，导致更应该被关注的路径被忽略，进而训练缓慢甚至顾此失彼。

这和offline RL有关。下面从深度学习的角度解释一下数据分布和训练的关系。
假设训练数据服从N(n,p)，实际数据服从N(m,q)，训练的目标其实是所有数据的损失最小（损失期望最小就是有限情况下的总和最小）。然而神经网络只是逼近，不可能处处损失为0。所以得到的模型应该是最小化了n附近的输入的损失，因为数量多。而实际分布最多的却是m附近的，导致实际损失期望比训练集上损失期望大。
再从泛化性上讲。密集的数据可以让模型在那一片区域上更接近实际映射，而稀疏的地方容易过拟合到仅有的数据点上。如果实际数据分布的疏密与训练集恰好相反，那就会在过拟合的地方密集采样，造成较大误差。这也就是遇到新数据时的泛化性问题，如果新数据容易出现在密集训练的地方，就会被泛化到。
迁移到offline强化学习上，学着学着我的决策分布就和示例的不一样了，这相当于实际分布，可以套用上面两点。

同理，用别人的经验训练DQN也有分布飘逸的问题。

时序差分（TD）：不可导变的奖励如何用于训练

• 从 Qlearning 到 Actor Critic: Qlearning中 $r_t + \gamma \max Q(a_t, s_t)$，TD算的都是 Q(act, state) 的差分(有max)；而 Actor Critic 算的是 V(state)，V是Q对action的期望，相当于把 Qlearning 的 max换成期望
• Critic: $r_t + \gamma V(s_t)$
• GEA 就是 gamma-return 减去V。gamma-return就是用多步TD的指数平均代替单步TD

Transformers 库

1. pipleline 函数：传入任务名称，下载默认的模型到本地，并推理
2. Dataset 类：底层是pyarrow，二维数组但列优先，可以行列取值

https://0809zheng.github.io/2021/08/11/reformer.html

share QK
也就是Q和K的投影矩阵为同一个，所以要禁自相关。在LSH attention中share了才能求hash

LSH attention
随机投影哈希：$h(x) = argmax [xR; -xR]$
其中 $R \in R^{d \times b/2}$，$x \in R^d$，$xR \in R^1={b/2}$，分号为matlab的拼合，即最终是 $R^b$
argmax取的是最大元素的序号，$h(x) \in [1, b]$
用论文里bucket的说法：
记R的第i列为向量 $\vec{r}_i$，其和 $-\vec{r}_i$ 的法平面将空间分为两部分。
矩阵相乘为内积，相当于x和每一组 $\{\vec{r}_i, -\vec{r}_i\}$ 做内积，取argmax意为看看更靠近谁。
其实理解为和第几个向量更靠近就好了。所以x一定要模长归一化。
这样就得到了空间中相近的点了：buckets[h(x)].append(x)，这些点是softmax后较大的元素
实际应用时，进行多轮LSH，对相同buckets的取并集。
如果几乎都在一个bucket中，此时LSH就没用，所以强行分块，取几个进行attention。

RevNet
已经不是resnet了，魔改了结构也不知道全貌下怎么用。

微调：加全连接训练最好不冻结原模型参数，而是端到端直接全部调整。数据量很小还是只训练加的层好了

使用huggingface一系列库，进行大模型微调:

1. AutoModelForSequenceClassification等：对encoder结构可以自动加linear改变输出形状。
2. Lora: 用peft库。lora节省的显存主要是中间梯度不需要存下来，而是用完即弃。反向传播计算量不会减少。
3. Trainer: 训练的封装类，要更换损失函数需要重载，或者model.forward返回值有loss字段

为什么Decoder-only大行其道？

1. 为什么Encoder-only不行：
   1. Encoder-only的训练方式MLM（即BERT预测遮住的token）难以scaling(意为模型变大收益增长慢)
   2. 生成式必须有Decoder的迭代过程
2. 为什么Encoder-Decoder不行：
   1. 注意力矩阵的秩：双向的Attention矩阵（Encoder使用）来自n*d和d*n的乘积，秩一定小于等于d；而单项的由于有掩码强制变为三角矩阵，所以满秩。理论上满秩信息量更大。

hugging face 模型文件：

• tokenizer.json: HF的新格式，包括下面两条的内容
• vocab.json: 老格式/第三方实现
• merges.txt: 老格式。包含了vocab中length>1的token的组合方式

分词器介绍：
tokenizer的目标不是找到词边界？而是类似霍夫曼编码，找到代价最下表示原文的最小集合
tokenizer训练其实就是基于统计的编码算法，训练的目的是得到词表
为什么不用HMM分词？因为HMM没有明确的词表，不能编码

• ASGI：Asynchronous Server Gateway Interface，ASGI继承自WSGI，面向的是异步Python领域，是WSGI的超集。ASGI应用程序是一个单一的、异步的可调用对象，包含三个参数：
  • scope：包含了连接信息的字典
  • send：允许应用程序向客户端发送事件消息的异步可调用对象
  • recive：允许应用程序从客户端接收事件消息的异步可调用对象
• Uvicorn: 按照ASGI要求实现的服务器：uvicorn.run(app, host="0.0.0.0", port=8000)。每次收到一个请求都会调用一次app函数，app函数的参数为ASGI要求的三个参数。Uvicorn做的就是后台进行消息解析、管理与分发。代码中用if处理各种情况。
• fastAPI：把手写app省了。基本用法：

  1
  @app.put("/items/{item_id}")
  2
  def update_item(item_id: int, item: Item):
  3
      return {"item_name": item.name, "item_id": item_id}

  这里形参名称item_id要和上面一致，原理是**kwargs解包字典传参。
  此外还会自动生成调用文档。

进powershell不进入base（加快速度）：

conda config --set auto_activate_base false

获取了ipv6但外网无法用ipv6访问：光猫的Ipv6Spi关掉
开的端口无法被外部ipv6访问：防火墙增加入站规则，开放端口

关于typst和latex，函数与宏：

• latex用宏实现自定义功能，所谓宏就是C的#define，预处理时展开作为代码的一部分，因此往往有“副作用”（写C语言也饱受宏的折磨啊！），而且代码展开后非常复杂。宏之所以有用是因为在C中没有template，所以为了兼容各种类型而不是定义一堆函数，宏就很有用了。
• typst用的是函数，也是C++推崇的，由于有作用域的限制，因此里面的代码不会影响到后面的。但是函数是运行时。

让cmd开启ANSI 转义序列（颜色）的支持：用管理员运行

reg add HKCU\Console /v VirtualTerminalLevel /t REG_DWORD /d 1 /f

关于LLM的结构

• KV缓存：因为推理时要根据之前的所有输出，而之前的编码是不会变的，所以可以缓存下来。

绝对位置编码为什么用cos和sin？有人说就像整数的二进制表示，每个位置表示为d位的整数，每一位在位置维度上看就是有周期性的，且位越低变化越快。三角函数与此类似。然后为什么用cos和sin，实际上把两个看成一组，内积值就之和位置差距有关。
相对位置编码RoPE
如何理解Transformer论文中的positional encoding，和三角函数有什么关系？ - warmup的回答 - 知乎

tokenizer就是切词，常见的是BPE，原理是合并常见组合为新“词”，分词策略是贪心，升级一下就是WordPiece。最后得到的是一个双向映射表，一个“词”对应一个数字
然后查表，输入是数字，输出是向量，称为Embedding。这是和后面的Transformer一起训练的：https://www.zhihu.com/question/663835334
模型输出的直接就是数字，然后差token的表还原为句子。原始输出是所有token的概率，选topk，然后按概率选择，以有一定的随机性。所以对相同LLM使用相同的prompt有不同的结果。

LLM的训练分为如下阶段：

1. 预训练，就是预测下一个token，为了保持因果，所以要用mask遮住训练集当前预测位置之后的。模型就可以续写了。
2. 指令微调（Supervised Fine-Tuning, SFT）。为了让模型理解指令而不是续写指令。训练数据是“问题-回答”
3. 强化学习机制。SFT后的模型可以输出多个回答，然后人工排序，用这些数据训练一个评估结果好坏的“奖励模型”，然后反过来优化SFT后的模型。用奖励模型相当于生成了更多人工标注。

LLM的输出是一个N维的向量，其中N是词典大小，用交叉熵训练。

进一步微调：在Q和V的投影矩阵上加LoRA，即并行一个两次线性变换

Deepseek的思维链疑似是数据集带来的。
在deepseek的api中这两部分是两个字段，但是在开源版本，思考过程是放在<think>中的（疑似prompt要求）。

• https://zhuanlan.zhihu.com/p/21706980653
• https://help.apiyi.com/deepseek-reasoner-api-thinking-process-guide.html
• https://www.jianshu.com/p/f8e239d81a67

Python修饰器是语法糖：

1
def x(param):
2
    def wrap():
3
        dosometing_before()
4
        x = param()
5
        dosometing_after()
6
        return x
7
    return wrap
8

9
@x
10
# 定义一个callable的东西，比如函数，比如重载了__call__的类
11
def y():

修饰器的作用相当于：

1
def y()
2
y = x(y)

LLM每次请求都是无记忆的，那记忆只能土法加入：将历史和当前请求“拼”在一起输入LLM。大模型记忆机制

RAG就是把知识库建立向量数据库，然后根据输入的prompt查询相似的，再提取出这些内容，和prompt整合给LLM。查询是为了解决LLM限制输入长度的，一般用topk，相当于先进行了一次简单的注意力。
总之无论是“记忆”还是“拓展知识”，最后都是prompt的组合，并不是LLM本身的功能。

LLM反正就是文字交流，所以一些框架也就做些边角工作，比如langchain我看主要作用：

• prompt模板，感觉没用，一些字符串的干活
• 输入格式要求自动添加
• 输出解析

现有的mingw（还是版本10）用debug编译stringstream会报错，寻思换一个更新的GCC（最新版14）。从GitHub下载，解压，配置环境变量——结果cout都会segment fault！（插一嘴，路径中不能有中文）
找了半天在stackoverflow发现了线索：

The problem was a Julia libstdc++-6.dll file that was being loaded before the mingw64 one. If you have a similar problem, make sure to comb through your PATH variables. The Visual Studio Code debug console also tells you what files are being loaded.

然而我的Julia路径在mingw后面，都在用户变量中。最后一句话让我想到去查看编译细节，用C++插件编译时可以看到链接dll的信息，赫然发现一个Qt的libstdc++，而Qt的mingw的path在我的系统变量中。
关于PATH：Windows会将用户变量的PATH添加到系统变量PATH的后面，所以系统环境变量优先（但是变量是用户覆盖系统）。于是把Qt的path删了（或移到后面），一切恢复正常！
之前的mingw是RedPandaDev自带的，观察了其编译指令：

• Debug

  g++.exe "绝对位置/file.cpp" -o "绝对位置/file.exe" -finput-charset=UTF-8 fexec-charset=UTF-8 -Ofast -Wall -Wextra -g3 -pipe

• Release:

  g++.exe "绝对位置/file.cpp" -o "绝对位置/file.exe" -finput-charset=UTF-8 fexec-charset=UTF-8 -O2 -pipe -s -static

删除远程仓库的最新提交

1
git log # 能看到最新的提交
2
git reset --soft HEAD~
3
git log # 此时应该没有最新的提交了
4
git push origin main --force # 大功告成！

大文件建议提交到release

bat语法：

• echo on: 开启回显（默认），回显就是命令输出在cmd中，下一行出现运行结果
• @: @置于语句前则该条语句不会回显（无视echo on）
• echo off: 执行改语句后关闭回显，如果之前是echo on那么这句话也会回显
• @echo off: 这样就一句话都不会显示了，一般写在第一句
• 管道符: ‘|’
• 转义符号: ‘^’。如果管道命令在字符串中就要用^|，不然|会被当做转义字符而不是字符串中的一个字符
• title 设置标题，指cmd窗口名
• goto: 先写一个“:label”，再“goto label”
• %变量名%: 引用
• set 变量=值。中间不要有空格。注意延迟赋值问题：

1
::输出为1
2
@echo off
3
set a=1
4
set a=2 & echo %a%

问题的原因是整句话一起被解析。
如果要输出为2，要么分两行写，要么用开启延时赋值和!变量名!：

1
::输出为2
2
@echo off&setlocal enabledelayedexpansion
3
set a=1
4
set a=2 & echo !a!

• if: if 条件 () else () 注意整个if即使换行（括号处）也会被视为一行语句，所以要用上面的延时赋值。
  关系符号：equ gtr geq lss leq neq
  • 与：用两个if
  • 或：使用if嵌套，或者使用额外变量标记结果，再判断该变量
  • 非：条件前加not
• for %%i in (elements) do command2
  elements用空格键、跳格键、逗号、分号或等号分隔，类似列表
  如果填路径就是遍历，但是要加/d：for /d %%i in (路径) do command
  也可以是(*)，代表bat文件所在目录
  for /l %%i in (start,step,end) do command 类似range

关于for：还是处理“列表”的方法：

1
for /f "tokens=2-5 delims=:" %%a in ('ipconfig ^| findstr "IPv6"') do (
2
    echo %%a:%%b:%%c:%%d
3
)

命名的话%%后面只能接一个ascii字符，且后面的按照ascii递增赋值。对于”z”，下一个就是”{”:

1
for /f "tokens=2,* delims=:" %%z in ('ipconfig ^| findstr "IPv6"') do (
2
    echo %%z:%%{
3
)

终于知道怎么从ipconfig中提取ipv6:

1
@echo off
2
setlocal enabledelayedexpansion
3

4
for /f "tokens=2,* delims=:" %%a in ('ipconfig ^| findstr "IPv6"') do (
5
    set IPV6=%%a:%%b
6
    @rem 去除开头空格，delims只能指定一个字符，不然用“: ”了
7
    set IPV6=!IPV6:~1!
8
    @rem 选择第一项 只能循环里面break实现
9
    goto firstmatch
10
)
11

12
:firstmatch
13
echo %IPV6%

总之写好了：

1
:: 一定不能用utf-8编码!
2
@echo off
3
setlocal enabledelayedexpansion
4
title DDNS
5

6
set DOMAIN=gg.6v7.top
7

8
@REM :loop
9
@rem 取消了循环，改为在taskschd.msc中设置定时任务。大写REM就是注释的循环任务
10

11
@rem 获取本纪当前ipv6地址
12
set IPV6=0
13
@rem ipv6地址中都是冒号，所以用冒号分割后要取后面所有
14
for /f "tokens=2,* delims=:" %%a in ('ipconfig ^| findstr "IPv6"') do (
15
    @rem findstr返回每一行，/f将其解析为一行一行，每一行再经过delims分割，取第二项后后面所有
16
    @rem 两个百分号后面的变量名只能是一个ascii字符，且变量名递增顺延分配tokens的每一项。
17
    set IPV6=%%a:%%b
18
    @rem 去除开头空格，delims只能指定一个字符，不然用“: ”了
19
    set IPV6=!IPV6:~1!
20
    @rem 选择第一项，只能循环里面break实现，findstr没有只匹配第一个的选项
21
    goto firstmatchipv6
22
)
23

24
:firstmatchipv6
25

26
@rem 找到dns当前的ipv6地址
27
set find=0
28
set dnsip=1
29
for /f "tokens=2 delims= " %%a in ('nslookup %DOMAIN% dns1.hichina.com') do (
30
    set "dnsip=%%a"
31
    if "%find%" == "1" goto foundcurrent
32
    if "!dnsip!" == "%DOMAIN%" (
33
        set find=1
34
    )
35
)
36

37
:founddnsip
38

39
@rem 更新dns
40
if "%find%" == "1" if "%dnsip%" == "%IPV6%" goto nextloop
41
echo %date% %time%
42
echo Updating dnsIP: %dnsip% to currentIP:%IPV6%
43
curl -X POST https://dyn.6v7.top:9443/ddns -H "Content-Type: application/json" -d "{\"name\":\"gg\",\"token\":\"TOKENTOKEN\",\"type\":\"AAAA\",\"value\":\"%IPV6%\"}"
44

45
if %errorlevel% == 0 (
46
    echo Successs!
47
) else (
48
    echo NetworkError
49
)
50

51
:nextloop
52
echo updated
53
@rem 休眠5分钟
54
@REM timeout /t 300 /nobreak
55
@REM goto loop

pytorch的初始化是每个层的构造函数中写的，叫reset_parameters()，

关于编码：先用GBK写一个中文txt，然后用UTF-8打开，是菱形问号。虽然此时并不提示文件未保存，但如果这个时候保存文件，UTF-8会把解析失败的替换成特定内容，从而改变了原始内容，再用GBK读取就会有问题。

试图在琴房RX580的电脑上配置GPU环境。结论：失败。
AMD的深度学习环境是ROCm，ROCm只有linux有，所以准备在WSL上配置。首先下载了Ubuntu24.02，配置好了一切准备装ROCm才发现只支持Ubuntu22.04。这才想起来先看官方文档。RX580不支持，但是网上有成功的案例，我猜其实是可以的（后来才发现跑的是tensorflow）。于是重来，驱动装好了，告诉我硬件不支持。
试着去找找魔改版？ROCm 3.5.1之后AMD就放弃了对RX580的支持，但是pytorch的ROCm从6.1开始（也许不是一个东西）。不过懒得折腾了（花了一下午）。

tauri android 配置还得回到 android 的项目文件夹，比如:

无标题无状态栏#

修改 res/values/themes，变成：

1
<resources xmlns:tools="http://schemas.android.com/tools">
2
    <!-- Base application theme. -->
3
    <style name="Theme.freqintime" parent="Theme.MaterialComponents.DayNight.NoActionBar">
4
        <!-- Customize your theme here. -->
5
        <item name="android:windowFullscreen">true</item>
6
        <item name="android:windowNoTitle">true</item>
7
    </style>
8
</resources>

横屏#

修改 src-tauri/gen/android/app/src/main/AndroidManifest.xml：
activity中加android:screenOrientation="landscape"

权限#

网页调用了麦克风，还是得在manifest中授权：

1
<uses-permission android:name="android.permission.RECORD_AUDIO" />
2
<uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />

关闭 Android SplashScreen（闪屏）

navigator.mediaDevices.getUserMedia 竟然在手机上用不了？明明MDN都写了是baseline。后来发现手机浏览器必须https才能用，不管是LiveServer还是 python -m http.server 8888 都是http协议。

windows开https：

1. 安装 openssl：https://slproweb.com/products/Win32OpenSSL.html，需要添加环境变量
2. 安装npm的http-server(python的http.server疑似有些弱小)：

1
npm install --global http-server
2
http-server -S -C cert.pem

3. 生成证书：

openssl req -new -x509 -keyout key.pem -out cert.pem -days 365 -nodes

有要填的东西全部回车跳过
4. 启动服务

http-server -S -C cert.pem

于是手机上终于用起来了。

musescore4还没做插件开发的面板，所以要调试只能用文件。

1
import FileIO 3.0
2
MuseScore {
3
    ...
4
    FileIO {
5
        id: outfile
6
        source: "D:/Desktop/log.log"
7
        onError: console.log(msg)
8
    }
9
    onRun: {
10
        outfile.write("Hello World!\n");
11
    }
12
    ...
13
}

rust编译为wasm不需要额外的编译器！C/C++编译为wasm需要emcc！

补aaencode的原理。有了颜色就知道原理了。

1
// "/.../"是正则表达式的语法糖。和"new RegExp(...)"等价。正则表达式本质还是Object，后面的['_']取了一个不存在的键值对，所以变量ﾟωﾟﾉ=undefined
2
ﾟωﾟﾉ= /｀ｍ´）ﾉ ~┻━┻ //*´∇｀*/ ['_'];
3
// o和ﾟｰﾟ和_都是变量名，值为3
4
o=(ﾟｰﾟ) =_=3;
5
// c和ﾟΘﾟ都是变量名，值为0
6
c=(ﾟΘﾟ) =(ﾟｰﾟ)-(ﾟｰﾟ);
7
// (ﾟДﾟ是变量名，o^_^o运算结果是3，所以(ﾟДﾟ和ﾟΘﾟ值为3
8
(ﾟДﾟ) =(ﾟΘﾟ)= (o^_^o)/ (o^_^o);
9
/* 对象(ﾟДﾟ):{
10
    ﾟΘﾟ: "_",
11
    ﾟωﾟﾉ: "a",
12
    ﾟДﾟﾉ: "e",
13
    ﾟｰﾟﾉ: "d",
14
    1: "f",
15
    c: "c",
16
    o: "o"
17
}*/
18
(ﾟДﾟ)={ﾟΘﾟ: '_' ,ﾟωﾟﾉ : ((ﾟωﾟﾉ==3) +'_') [ﾟΘﾟ] ,ﾟｰﾟﾉ :(ﾟωﾟﾉ+ '_')[o^_^o -(ﾟΘﾟ)] ,ﾟДﾟﾉ:((ﾟｰﾟ==3) +'_')[ﾟｰﾟ] };
19
(ﾟДﾟ) [ﾟΘﾟ] =((ﾟωﾟﾉ==3) +'_') [c^_^o];
20
(ﾟДﾟ) ['c'] = ((ﾟДﾟ)+'_') [ (ﾟｰﾟ)+(ﾟｰﾟ)-(ﾟΘﾟ) ];
21
(ﾟДﾟ) ['o'] = ((ﾟДﾟ)+'_') [ﾟΘﾟ];
22
// c o n s t r u c t o r
23
(ﾟoﾟ)=(ﾟДﾟ) ['c']+(ﾟДﾟ) ['o']+(ﾟωﾟﾉ +'_')[ﾟΘﾟ]+ ((ﾟωﾟﾉ==3) +'_') [ﾟｰﾟ] + ((ﾟДﾟ) +'_') [(ﾟｰﾟ)+(ﾟｰﾟ)]+ ((ﾟｰﾟ==3) +'_') [ﾟΘﾟ]+((ﾟｰﾟ==3) +'_') [(ﾟｰﾟ) - (ﾟΘﾟ)]+(ﾟДﾟ) ['c']+((ﾟДﾟ)+'_') [(ﾟｰﾟ)+(ﾟｰﾟ)]+ (ﾟДﾟ) ['o']+((ﾟｰﾟ==3) +'_') [ﾟΘﾟ];
24
// 赋值 3['constructor']['constructor']，得到的是函数的构造函数，下面记为F
25
(ﾟДﾟ) ['_'] =(o^_^o) [ﾟoﾟ] [ﾟoﾟ];
26
// r e t u r n
27
(ﾟεﾟ)=((ﾟｰﾟ==3) +'_') [ﾟΘﾟ]+ (ﾟДﾟ) .ﾟДﾟﾉ+((ﾟДﾟ)+'_') [(ﾟｰﾟ) + (ﾟｰﾟ)]+((ﾟｰﾟ==3) +'_') [o^_^o -ﾟΘﾟ]+((ﾟｰﾟ==3) +'_') [ﾟΘﾟ]+ (ﾟωﾟﾉ +'_') [ﾟΘﾟ];
28
// 这里是嵌套了两层，其实就是F( F('return "console.log("rock")"') (1)) ('_');套了两层，可能是为了增加复杂度。直接写F("代码")即可
29
(ﾟｰﾟ)+=(ﾟΘﾟ);
30
(ﾟДﾟ)[ﾟεﾟ]='\\'; (ﾟДﾟ).ﾟΘﾟﾉ=(ﾟДﾟ+ ﾟｰﾟ)[o^_^o -(ﾟΘﾟ)];
31
(oﾟｰﾟo)=(ﾟωﾟﾉ +'_')[c^_^o];(ﾟДﾟ) [ﾟoﾟ]='\"';
32
(ﾟДﾟ) ['_'] ( (ﾟДﾟ) ['_'] (ﾟεﾟ+(ﾟДﾟ)[ﾟoﾟ]+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟｰﾟ)+ (o^_^o)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ ((ﾟｰﾟ) + (o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ ((o^_^o) +(o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((o^_^o) +(o^_^o))+ (o^_^o)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ ((ﾟｰﾟ) + (o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟｰﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟｰﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+((ﾟｰﾟ) + (ﾟΘﾟ))+ ((o^_^o) +(o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟｰﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ ((ﾟｰﾟ) + (o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟｰﾟ)+ ((ﾟｰﾟ) + (o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+((ﾟｰﾟ) + (ﾟΘﾟ))+ (c^_^o)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟｰﾟ)+ ((o^_^o) - (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((o^_^o) +(o^_^o))+ ((o^_^o) - (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ ((ﾟｰﾟ) + (o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟｰﾟ)+ (o^_^o)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ (o^_^o)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟｰﾟ)+ ((o^_^o) - (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟΘﾟ)+ (ﾟДﾟ)[ﾟoﾟ]) (ﾟΘﾟ)) ('_');

浏览器为了安全考虑，不允许直接运行eval一类的东西。
new Function() 和 Function() 等价，传入字符串返回函数。eval是传入字符串直接运行，都是运行字符串的方法。setTimeout的第一个参数传入字符串也能运行

vscode配置verilog格式化，直接在设置里面搜 verilog fromat，然后下载https://github.com/0qinghao/istyle-verilog-formatter，配置好exe的位置即可。`—style=kr` 是我喜欢的类型

Zotero使用：

• 按shift再拖动就可以移位置，而不是复制
• 右栏设置标签，左下角分配颜色后才会显示标签列中

wx.canvasToTempFilePath 在PC上有问题。
设置导出范围为canvas或者ctx的大小时，只截取一部分保存，结果是一样的。
canvas.width 为 800，但是经过 css 的缩放，在屏幕上看起来是和框一样宽的。手机上保存正常。电脑上保存，如果设置 destWidth=undefined，则导出的只有599，且内容对应于800像素中的599大小。如果设置 destWidth 为 canvas.width ，则导出的有1158（不同图片的缩放大小不同），但内容不变。
PC上屏幕宽度为414，pixelRatio=1.4479。于是发现导出的图片的宽度和 canvas.width 的比例为 pixelRatio 。所以有以下调整：

1
let dstW = canvas.width;
2
let dstH = canvas.height;
3
// PC系统要单独处理
4
if (wx.getDeviceInfo().system.toLowerCase().startsWith("windows")) {
5
    // 保证输出的尺寸正确
6
    const pixR = wx.getWindowInfo().pixelRatio;
7
    dstW /= pixR;
8
    dstH /= pixR;
9
}

这下输出的尺寸正确了，但是截取的尺寸还是不对。怎么办呢？
我试着改变截取的宽度和高度，小了确实在截取，大了（即使超过画布大小）则锁定截取599像素。那不同的电脑输出的是否相同呢？如果相同，只要缩放画布内容即可；如果不同，那关系是什么？
结果是：不同。另一台电脑上，只截取517像素。于是发现了关系：414(屏幕宽度)*1.4479(像素比)=599(实际截取的宽度)，这就是实际可以导出的画布的最大宽度。

cqhttp实现了OneBot协议，而Nonebot是一个基于OneBot协议的机器人框架。
go-cqhttp不行了，因为官方的围追堵截。但是官方提出了一套接口。
LiteLoaderQQNT就是用NTQQ内核的，支持各种插件，其中有个插件叫做LLOneBot，实现了onebot的标准，即充当了cqhttp的角色。
NapCat基于LLOneBot，但是可以无头（不用electron），适用于小内存。用的是xvfb-run

那NapCat和LLOneBot有什么关系？https://www.xiaojiaozi.top/2024/07/21/ntQQ/，人机合一就是机器人运行时人可以在同一台电脑上用

原来VSCODE在写C/CPP时说

检测到 #include 错误。请更新 includePath。

是因为C++拓展配置的是 cl.exe，而不是我的mingw没配置好

wsl突然pip网络寄了（无法使用主机代理），查了半天发现clash没开LAN
在微信小程序上使用tensorflow，分为以下步骤：

1. 将onnx转为tfjs：
   采用回答的方法，除了回答中install的指令，实际运行时还缺少tensorflow2.15.0+以及其他库，遇到问题就pip install即可。在onnx2t中有如何将onnx转为tfjs的指令。
   tfjs转成的有两个文件，一个是json表明了结构，还有一个类似’group1-shard1of1.bin’的文件保存了权值，但是loadGraphModel只填了json的路径，如何加载权值呢？其实json中有一个值：weightsManifest，其中记录了权值文件名。所以要修改权值文件名一定要修改json文件！在官方的loadGraphModel文档也提到：“weightPathPrefix (string) Path prefix for weight files, by default this is calculated from the path of the model JSON file.”所以只要loadGraphModel(json文件的路径)就好了
2. 配置tfjs环境。参考tfjs-wechat中的做法。👉可以参考的第三方链接。简要总结一下：
   小程序添加tensorflowJS插件(tfjsPlugin)。在微信开放平台中。然后再app.json添加插件，添加方法见github项目页，记得把版本号改成最新的。
   项目中：

   1
   npm install @tensorflow/tfjs-core
   2
   npm install @tensorflow/tfjs-converter
   3
   npm install @tensorflow/tfjs-backend-webgl
   4
   npm install @tensorflow/tfjs-backend-cpu
   5
   npm install fetch-wechat

   然后小程序内构建npm，忽略警告。

1. 下载pop_os的iso并且用rufus写入U盘。提示：您选择了一个ISOHybrid镜像文件，但此文件与ISO/File复制模式不兼容。因此强制使用DD镜像写入模式。——不管，继续写。
2. 电脑调整至boot（三星的笔记本在开机的时候按F2），关闭security boot，选择最长的模式，关闭fast boot，然后选择启动盘。
3. 用于老电脑的系统，所以直接clean install。不要选择全盘加密！不然每次都要解开，没必要。全盘加密与否只在安装时可选，要更改只能重装。
4. 没有独立显卡，所以Hybrid Graphics就不调了。
5. setting-firmware升级
6. 换源。用可视化的方式：

sudo nautilus

打开文件管理器，然后找到/etc/apt/source.list，复制清华源ubuntu的内容，保存后sudo apt update、sudo apt upgrade
7. 摄像机：sudo apt install guvcview或者Cheese
8. Settings -> Power -> enable Show battery percentage
9. 安装QQ linux 3（直接搜到的是2，不能用）

1
"""
2
codes
3
#"""

只要注释第一行，就可以启用注释里的代码！

搜索区域->右侧其他日期、时间和区域设置->更改日期、时间或数字格式->管理->更改系统区域设置->beta版
为什么有这个问题？在vscode中，尽管设置了set PYTHONIOENCODING=utf-8 && python -u，但还是有中文乱码问题：

1
print("中文")   # 可以正常输出
2
import os
3
os.system("ipconfig")   # 中文不正常

可知是cmd的编码问题。换成utf-8就都正常了。
后记：

• PVZ的窗口变成乱码了
• 插入的U盘的中文名变成乱码了
• 思源黑体变得很奇怪

nbmerge a.ipynb b.ipynb -o c.ipynb

网上大部分用的是”>“，会有编码问题

word公式换行对齐：https://zhuanlan.zhihu.com/p/439988361
在unicode模式下（这点很重要！不然直接卡死），公式末尾输入#，就可以换行了
在要对齐的等号后面输入&就能对齐

算术移位和逻辑移位的比较（均为补码操作）：
当一个【有效的】左移最高位和数据最高位一致时，算术左移和逻辑左移一样，均为右补0，不一致时，算术左移溢出，无意义！
什么是“有效”：对于有符号数，左移之后符号位和之前一样
逻辑右移很简单，只要将二进制数整体右移，左边补0即可 ，算术右移，左侧均补符号位，即正数补0，负数补1。
对verilog的有符号数操作：
只有算式右边全为有符号数，运算才会自动补齐所需的bit数，n+n=n+1（加法需要多一位），n*n=2n
reg类型被作为无符号数看待？在verilog2001之后就不是了

1
reg signed [7:0] a, b;
2
reg signed [3:0] c;
3
reg signed [7:0] sum1, sum4;
4
. . .
5
// same width. can be applied to signed and unsigned(常规无符号数加法器)
6
sum1 = a + b;
7
// automatic sign extension（c被自动扩展符号位到8位）
8
sum4 = a + c;

只有当所有右手边的变量具有signed数据类型属性的时候，扩展符号位才被执行。否则，所有的变量都只扩展0

有关宏定义

1
#define ABS(x) ((x) > 0 ? (x) : (-x))
2
int32_t y0 = 128;
3
int32_t y1 = 64;
4
int32_t dy = -ABS(y1 - y0);

单片机上得到的结果是dy=192，在电脑上跑结果是正确的。
因为展开后变成了“:(-y1-y0)”。正确写法：

#define ABS(x) ((x) > 0 ? (x) : -(x))

为什么在电脑上跑是对的？因为单片机上其实有两个ABS的定义：

1
// main.h中
2
#define ABS(x) ((x) > 0 ? (x) : (-x))
3
// 出问题的文件中
4
#ifndef ABS
5
#define ABS(x) ((x) > 0 ? (x) : -(x))
6
#endif

于是正确的写法被pass了……而复制到电脑上运行只复制了出问题的文件

关于keil在vscode中的配置”未定义的标识符”：在.vscode文件中新建settings.json，内容为：

1
{
2
    "C_Cpp.intelliSenseEngine": "Tag Parser"
3
}

这样会导致无法解析变量。所以正常项目还是用default好

ADC的速度由2个参数决定，它是采样时间和转换时间之和：
即：TCONV = 采样时间 +12.5个ADC时钟周期
在STM32中，ADC的采样时间是由用户程序在一组预定的数值中选择，按照ADC的时钟周期计算，共有8种选择：
1.5、7.5、13.5、28.5、41.5、55.5、71.5和239.5
按最小的1.5个时钟周期的采样时间计算，最短的TCONV等于14个时钟周期，如果ADC的时钟频率是14MHz，则ADC的速度为每秒100万次。

FOC程序流程：硬件上，PWM设置为上升下降的三角模式，同时设置在达到顶点和底点的触发更新事件（RCR=0），且更新事件绑定TRGO，触发两路ADC采样。I2C由于怕出问题，同时为了提高速度，使用非阻塞、中断模式，中断优先级最高。
注入组ADC使用：需要等待转换完成。这样做是不是太浪费性能了？
https://github.com/chenzt2020/foc_learning/blob/main/drive_1.pwm%2Badc/current.h
HAL_ADCEx_InjectedPollForConversion等待注入组ACD结束

两个思路：

1. 全部放到更新中断中。优点是只要设置优先级高于串口，就不会被串口打断。缺点是这个中断似乎优点久了。
2. 全部放到main函数中，不管计时器，全部用软件触发。不行，因为PWM的更新时刻是离散的，得保持同步。所以是全部放到main中，adc1和adc2和as5600用中断置标志位。优点和缺点与1相反。

用方案1吧。采用C with class，将main.c改为main.cpp，就可以了。
PWM设置为模式1，即CNT小于CMP为高电平，这样CMP和占空比就是正比关系了。

总结下keil使用C++#

• 关于main之外可以执行什么：只能执行全局变量的定义与声明。但是这些语句执行的顺序是不定的。可以用“构造函数”的方法让语句执行在main之前。
• C++类的静态量一定要在类外初始化，且只能一次。
• 将main.c换成main.cpp，编译器改成version6，去掉microLIB的勾选，选择C++11，就可以使用了！
• 去掉了microLIB就不能对printf重定向了，所以有必要了解一下sprintf()和strlen：
  • sprintf(char* 存到哪, “格式化字符串”, [其他参数])
  • strlen(存到哪)获取字符串长度，需include string.h。如果用sizeof则返回数组总长度而不是到\0的长度。
  • 串口换行是\r\n，两个char
• 我喜欢用hpp文件，注意类型要选择Text Document File(同.h的类型)，不能选C++ Source，因为这个决定怎么被编译。选择source file就和include .c一样了，会出现重定义。比如类的静态量定义在source file类型的hpp文件中。

根据博客 https://www.cnblogs.com/ningmeng484/p/12056935.html，输出就是对输入的功率跟随。
传统使用推挽实现功率输出，需要配置两路幅值相反的PWM，以上桥臂为例，如果是高电平，则下桥臂是低电平，输出为有驱动能力的高电平；如果上桥臂为低电平，则下桥臂是高电平，输出为有驱动能力的低电平。只看上桥臂和输出，则输出是有驱动能力的上桥臂电压。同时还有一些细节，比如死区控制。这些可以在STM32高级定时器中完成配置。
DRV8313所起的作用就是省去了下桥臂和死区等繁杂的细节。只需要给出没有驱动能力的上桥臂状态，就可以输出有驱动能力的跟随电压，无需关心死区等。其内部就是三组推挽电路，根据输入的上桥臂生成下桥臂和死区管理，所以使用DRV8313还是要注意SVPWM的时序控制，减少内部MOS管的翻转次数。

七段式SVPWM的优点：谐波分量小。https://www.zhihu.com/tardis/zm/art/412521405?source_id=1005

关于“静态成员变量”：

• C++ 中可以从实例和类访问 static 声明的变量，前提是没有同名的动态成员变量。如果有同名的非静态成员变量，在用实例访问的时候编译器会优先匹配动态的，而若没有则编译为用类名访问的。
• js 中直接取消了从实例访问 static 的方式，从实例不能直接访问 static。

关于C++的大括号：https://www.cnblogs.com/zyk1113/p/13452493.html （C++很怪啊很怪）
见到 int y{10} 不要吃惊，省略了等号

关于复制构造#

太久没用C++了……复制构造都忘了。以下是一个复制构造的例子：

1
class Myclass {
2
public:
3
  Myclass() {
4
    cout<<"construct\n";
5
  }
6
  Myclass(Myclass &o) {
7
    cout<<"copy construct\n";
8
  }
9
};
10

11
Myclass temp(Myclass obj) {
12
  cout<<"temp\n";
13
  return obj;
14
}
15

16
int main(){
17
    Myclass myobj;  // 输出construct
18
    temp(myobj);
19
    /* 再输出
20
    copy construct
21
    temp
22
    copy construct
23
    */
24
    return 0;
25
}

写这个例子的时候我想到了一种写法（匿名对象），但是报错：

temp(Myclass());    // [错误] cannot bind non-const lvalue reference of type 'Myclass&' to an rvalue of type 'Myclass'

这个错误是由于函数参数的类型不匹配导致的。报错报的是复制构造函数，相当于要执行 Myclass obj = Myclass()。
函数传参(Myclass& obj) 表示参数 obj 是一个非常量左值引用（non-const lvalue reference）类型的对象。这意味着函数期望接受一个可以被修改的左值作为参数。
当使用 temp(Myclass()) 调用函数时，Myclass() 表达式创建了一个临时的右值对象（rvalue），而非左值。右值是一个临时的、不可修改的值，不能直接绑定到非常量左值引用。

解决方法：改成常量左值引用，使之能接受常量左值、非常量左值和右值作为参数。具体来说是复制构造函数传参写成 (const Myclass&)：

1
class Myclass {
2
public:
3
  Myclass() {
4
    cout << "construct\n";
5
  }
6
  Myclass(const Myclass& o) {     // 修改了这里！
7
    cout << "const copy construct\n";
8
  }
9
};
10
Myclass temp(Myclass obj) {
11
  cout << "temp\n";
12
  return obj;
13
}
14
int main() {
15
  temp(Myclass());
16
  return 0;
17
}
18
/* 输出
19
construct
20
temp
21
const copy construct
22
*/

少了传参的一次复制构造，为什么？——编译器进行了另一种优化，称为复制消除（Copy Elision），允许编译器在某些情况下避免不必要的复制构造函数调用。根据C++标准的规定，编译器可以进行复制消除，即使代码中存在显式的复制构造函数调用。

复制构造就应该写const！！！

但是一旦用const修饰了Myclass& obj，那便不能修改obj的任何属性。如果要调用obj的函数，为了保证这一点（指不修改属性），需要将函数也用const修饰，具体表现为在大括号前面加const。用const修饰的函数内部不能改变this的属性。那我非要修改值怎么办？比如计数被复制了几次。——可以在成员变量前加上“mutable”。

如果只将temp的传参改为const Myclass& 不行，问题出在返回时的复制构造。只改temp需要改成：const Myclass& temp(const Myclass&)

如果不用const，还有一种改法，思路是绕开复制构造：

左值和右值：#

左值就是写在赋值左边的。右值分为两种：纯右值(prvalue)和将亡值(xvalue)。将亡值比如temp函数的返回值，是马上会被销毁的东西。右值不能取地址，也就不能引用。但是C++11给出了右值引用(T&&)，让将亡值将继续存活。

1
Myclass& x = Myclass(); // 不行，必须写成const Myclass&
2
Myclass&& x = std::move(Myclass()); // 使用右值引用
3
Myclass&& x = Myclass();// 右值给右值引用可以不显式调用move
4

5
Myclass temp;
6
Myclass&& x = std::move(temp);      // 左值赋值给右值引用必须调用move

在此基础上就有了以下操作：

1
Myclass temp(Myclass&& obj) {
2
    // 函数内obj就是左值，调用重载函数触发的是传参为(&)的而非(&&)的
3
  cout<<"temp\n";
4
  return obj;
5
}
6
int main(){
7
  temp(Myclass());    // 对下文进行补充：编译器会执行std::move(Myclass())。传给temp的是右值引用
8
  return 0;
9
}
10
/* 这样就能编译了。结果是：
11
construct
12
temp
13
copy construct
14
*/

编译器会自动对临时对象应用所谓的移动语义（std::move）。移动语义是一种优化技术，它允许在不进行任何内存复制的情况下将资源从一个对象转移到另一个对象。
move函数所做的只是拿到一个左值或右值，然后都将其返回为右值引用，以不触发任何拷贝函数。
右值引用可以像左值引用一样操作，相比常量左值引用，可以修改属性。右值引用变量的属性会被编译器识别成左值。
注意，右值赋值给右值引用是可以直接做的，不用显式调用 std::move；而左值给右值引用必须调用。

小总结：左右值的关系#

常量左值引用（const T&）适用于需要传递参数并且不需要修改被引用对象的情况，而右值引用（T&&）主要用于实现移动语义和完美转发，可用于修改、移动或操纵被引用的对象。常量左值引用可以绑定到左值和右值，而右值引用只能绑定到右值（但是用move就可以绑定左值了）。
补充：当使用右值引用类型初始化左值引用时，右值引用会被折叠为左值引用：

1
int&& x = 9;
2
int& y = x;

万能引用#

传参为右值引用的函数写成模板：

1
template<typename T>
2
void test(T && v);

这样就能直接传参左值了(当然右值本来就可以传)：

1
Myclass c;
2
test(c);

为什么？实际上T被识别为C&，所以v的类型是C&&&，根据引用折叠，变成C&。在这个机制下，左右值可以直接传入test函数，左值不需要用std::move。

引用折叠：& &&会变为&；&& &&会变为&&。

当然也能用auto&&实现模版的功能。

完美转发#

万能引用带来一个问题：传入的右值引用在函数内部其实已经是左值了（因为在内存有了位置），这意味着在函数内部我不知道传入的到底是左值还是右值。
解决办法是在test中用 std::forward<T>(v)。如果test的传参是左值，forward之后就是左值；否则右值。

杂项#

cpp的函数声明可以在函数之中，这样就是局部可用。为了避免二义性，Myclass myclass(); 最好不要出现，因为不知道是函数声明还是实例化。

无感foc和有感foc: 指的是传感器。做有感的好

参考资料：#

1. https://vq8wu6s7px.feishu.cn/docx/CrKrdOtekoFoLVx3dG4ckJLancd

FOC硬件：#

1. 供电：用XC6206：3.3V输出，最大200mA，最大输入为6V。很适合 STM32F103C8T6 和 ESP 的运行电流
   同类型：
   • PW6206：最大电流仅有100mV，但耐压范围超大，如果有12V转的需求可以用
   • AMS1117：SRM32最小系统板多用。但是输入电压需要高些
   • ME6206：比XC便宜一点点，但是找不到贴近200mA的型号

不对，还要给as5600供电，总输入设置为12V。还是用AMS1117，最大18V输入，1A输出

2. 磁编码器：AS5600，貌似配套的径向磁铁都是6mm直径。买3个。https://blog.csdn.net/xiaoyuanwuhui/article/details/118970127。100mA
3. 电机：买不到便宜的，估计要拆限位。暂定8元的电机，b站有拆限位教程。买3个。还要m2螺丝
4. MCU：用stm32f103C8T6。发现平替：gb32？买一个试试。3.3V
5. 电机驱动：DRV8313。但是用这个方法不会测量电流。用的是电压控制，近似的。https://www.zhihu.com/question/429826103 https://blog.csdn.net/jdhfusk/article/details/120646346 所以没有电流环就是开环控制 8-65V，最大3A。用12V的输入
   替代品：AT8313
6. 通信：先做USART的，成功了再学can。关于和AS5600通信，使用软件i2c。这样看来用C6T6就行了。如果GB32能用，就用硬件i2c
7. 晶振。8M，因为用HSI达不到稳定的72M。三脚陶瓷谐振器CSTCE8M00G52-R0内置了负载电容，可以不用再接电容
8. 电流采样：INA240A1: 20倍；偏置采样电阻：0.05Ω，则3.3V对应电流：1.65A。足够带动电机了。

html中设置select的选中项，有三种方法：

1. html中设置option为selected
2. js中设置select.value = option的value【设置value只能在js中完成】
3. js中设置option.selected = true;

css变量

1
.your-element {
2
  top: var(--your-variable); /* 使用 CSS 变量 */
3
}

element.style.setProperty('--your-variable', value); // 设置 CSS 变量的值

自定义属性

1
.your-element {
2
  top: attr(data-my-variable); /* 使用 CSS 变量 */
3
}

1
element.setAttribute('data-my-variable', 'new value');  // 名字可以任意 但不能和已有的冲突
2
element.dataset.myVariable = 'new value';   // dataset属性只能用于访问和修改以 data- 开头的自定义属性。

attr() 函数在 CSS 中通常用于在伪元素的 content 属性中获取元素的属性值。然而，目前大多数浏览器并不支持在其他 CSS 属性（如 border-color）中使用 attr() 函数来获取元素的属性值。
伪类::before/::after的conent却用attr，因为用var不起作用

报错：[Intervention] Slow network is detected. See https://www.chromestatus.com/feature/5636954674692096 for more details. Fallback font will be used while loading……
解决：给@font-face加上font-display: auto;

Web Audio API:
connect的对象可以是AudioNode，也可以是属性，表示该属性受输入的幅度的控制

performace.now()#

performance.now()和Date.now()是JavaScript中用于获取时间的两个方法，它们之间有一些重要的区别。

1. 时间精度：performance.now()方法返回的是一个高精度的时间戳，通常是以毫秒为单位，但可以具有更高的精度。这个时间戳基于浏览器的性能计时器，它提供了一个相对于导航开始的时间值。它的精度比Date.now()更高。
2. 相对性：performance.now()返回的时间戳是相对于导航开始的，即页面加载开始的时间点，而不是相对于1970年1月1日的UTC时间。这使得它在测量性能和计时操作时非常有用。
3. 兼容性：performance.now()方法是HTML5的一部分，所以它在现代浏览器中得到广泛支持。但是，它在旧版本的浏览器中可能不被支持，特别是在Internet Explorer 9及以下版本。
   相比之下，Date.now()方法返回的是一个表示当前时间的时间戳，以毫秒为单位，相对于1970年1月1日的UTC时间。它是基于系统时钟的，并且在所有主流浏览器中都得到支持，包括较旧的浏览器版本。
   综上所述，如果你需要高精度的时间戳，并且在现代浏览器中运行，可以使用performance.now()方法。如果你只需要获取当前时间的时间戳，并且在各种浏览器中都能正常工作，可以使用Date.now()方法。

• html中可以直接用id索引。如果js中定义了同名变量则会覆盖
• dialog已经可以在绝大多数新浏览器中使用了

1
<button id="btn" onclick="dialog.show()"></button>
2
<dialog id="dialog">
3
    <div>hhhh</div>
4
</dialog>

大多数情况下，制造商为电机使用4位数字的标准命名方案。例如，一个名为2205的电动机，其中前两位数字代表定子的直径（以毫米为单位），后两位数字代表高度（以毫米为单位）。
3205小米云台电机
2804无刷电机
PM3510
4010

Keil使用C++#

https://blog.csdn.net/DP29syM41zyGndVF/article/details/115300868
参考

• V5

1. 首先打开MDK软件，去掉use microlib 勾选，这个一个C的依赖库，但比标准的库小，它可以减少C代码的大小。CubeMX生成的文件默认选择此项。因为这个精简库不支持C++，所以我们需要去掉此项功能。
2. Options for Target 再点C/C++ 在下边的Misc Controls 中输入—cpp
3. 去掉C99 mode选项

• V6
  直接就可以用
  V6的注意点：
  以下代码在 ARM Compiler 5 中，正常执行，但在 ARM Compiler 6 中，只要不是-O0级别，整个函数因为空循环问题，都被优化掉。也就是延时没有起作用。

1
void delay_us (uint32_t ul_time)
2
{
3
    ul_time *= 30;
4
  while(--ul_time != 0);
5
}

关于数组指针和存储：#

1
uint16_t a = 0x1123;
2
uint8_t* b = (uint8_t*)(&a);
3
cout<<(int)(*b)<<'\n'<<(int)(*(b+1));

输出是35\n17，即0x23和0x11，说明是小端存储

想做轮腿平衡车。首先是电机控制。
电机区别：https://blog.csdn.net/zhuguanlin121/article/details/120099439

• 步进电机：开环；步进转动靠的是定子线圈绕组不同相位的电流以及定子和转子上齿槽产生的转矩。
• 伺服电机：闭环；把控制电路放到了电机之外，里面的电机部分就是标准的直流电机或交流感应电机。
• 交流感应电机（ACIM）：是定子生成旋转磁场，转子切割磁感线产生电流，从而生成安培力驱动转子转动。定子和转子的转速是不同步的，并且定子的磁场转速必须大于转子的转速才能切割磁感线。三相交流电驱动，不含永磁体。
• 无刷直流电机（BLDC）（Brushless Direct Current Motor）：六步换相控制，电子换向，所以是梯形输入
• 永磁同步电机（PMSM）：将交流感应电机的转子换成永磁体，可以将其转变为永磁同步电机。这时磁场转速就和转子转速一样了，所以“同步”。关系图：https://pic3.zhimg.com/80/v2-cccfe53358428869b2f90c5fe152c1a2_1440w.webp。所以控制是正弦波的三相旋转交流电
  BLDC和PMSM区别：原理结构都很相似(一样)，绕组方式：BLDC与PMSM电机的区别(构造、原理与控制)？有没有较好的电机与控制的资料或书籍推荐？ - 此用户叫小明的回答 - 知乎
  https://www.zhihu.com/question/268255121/answer/3226583157

阅读tune.js看到的基频提取算法：

1
function autoCorrelate( buf, sampleRate ) {
2
  // Implements the ACF2+ algorithm
3
  var SIZE = buf.length;
4
  var rms = 0;
5

6
  for ( var i=0; i < SIZE; i++ ) {
7
    var val = buf[i]; rms += val * val;
8
  }
9
  rms = Math.sqrt(rms/SIZE);
10

11
  if ( rms < 0.01 ) { // not enough signal
12
    return -1;
13
  }
14
  var r1 = 0, r2 = SIZE - 1, thres = 0.2;
15
  for (var i=0; i<SIZE/2; i++){ if ( Math.abs(buf[i])      < thres ) { r1=i;      break; } }
16
  for (var i=1; i<SIZE/2; i++){ if ( Math.abs(buf[SIZE-i]) < thres ) { r2=SIZE-i; break; } }
17

18
  buf = buf.slice(r1,r2);
19
  SIZE = buf.length;
20

21
  var c = new Array(SIZE).fill(0);
22
  for ( var i = 0; i < SIZE; i++ ){
23
     for (var j=0; j<SIZE-i; j++){
24
       c[i] = c[i] + buf[j] * buf[j+i];
25
     }
26
  }
27
  var d=0; while (c[d]>c[d+1]) d++;
28
  var maxval=-1, maxpos=-1;
29
  for (var i=d; i<SIZE; i++) {
30
    if (c[i] > maxval) { maxval = c[i]; maxpos = i; }
31
  }
32
  var T0 = maxpos;
33

34
  var x1 = c[T0-1], x2 = c[T0], x3 = c[T0+1];
35
  a = (x1 + x3 - 2 * x2) / 2;
36
  b = (x3 - x1) / 2;
37
  if (a) { T0 = T0 - b/(2*a); }
38

39
  return sampleRate/T0;
40
}

这段JavaScript代码定义了一个名为autoCorrelate的函数，该函数实现了ACF2+算法（自相关函数）来分析音频信号的基频。
以下是该函数的主要步骤：

1. 计算输入缓冲区（buf）的均方根（RMS）。如果RMS小于0.01，函数返回-1，表示信号不足。
2. 找到缓冲区中的第一个和最后一个绝对值大于阈值（0.2）的元素，然后将缓冲区裁剪到这两个元素之间。
3. 计算新缓冲区的自相关函数，并存储在数组c中。
4. 找到数组c中的第一个局部最大值，然后找到全局最大值及其位置。
5. 使用这三个值（x1，x2，x3）来通过抛物线插值精确计算基频的位置。
6. 最后，函数返回基频的估计值，即采样率除以T0。
   这个函数通常用于音乐和语音处理中的音高检测。buf是时域数据

FFT（快速傅里叶变换）和ACF（自相关函数）都是音频信号分析中常用的方法，但它们各有优劣。
FFT的优点：

1. 计算效率高：FFT是一种高效的算法，可以快速计算大量数据的频谱。
2. 频谱分辨率高：FFT可以提供详细的频谱信息，包括各个频率成分的幅度和相位。
   FFT的缺点：
3. 对于音高检测，FFT可能不如ACF准确。因为FFT是基于频谱的，而人类对音高的感知是基于周期性的，这两者并不完全相同。
4. FFT对于非稳态信号（如音乐和语音）的分析可能会有困难。
   ACF的优点：
5. 对于音高检测，ACF可能比FFT更准确。ACF是基于信号的自相关性，可以直接检测信号的周期性，这更接近人类对音高的感知方式。
6. ACF可以处理非稳态信号，适合用于音乐和语音的分析。
   ACF的缺点：
7. 计算效率可能不如FFT高。
8. ACF可能需要更多的前期处理，如窗函数和预白化。
   总的来说，选择FFT还是ACF，取决于你的具体需求。如果你需要快速计算大量数据的频谱，或者需要详细的频谱信息，那么FFT可能是更好的选择。如果你需要准确地检测音高，或者处理非稳态信号，那么ACF可能是更好的选择。

https://zhuanlan.zhihu.com/p/269107205
常数Q变换！constant Q transform！似乎能解决音乐分析的问题！
但是复杂度太高了……比DFT还高，扒谱用不上啊（2025：用上了，真香）

canvas调整width和height之后，canvas的状态（包括当前的strokeStyle、fillStyle、lineWidth等）会被重置为默认值。默认的strokeStyle是黑色。

关于费时函数与进度条，以下是可行的：

1
var i = 0;
2
async function r() {
3
    const d = document.getElementById('progress');
4
    let ii = 0;
5
    while (1) {
6
        i++;
7
        if (i == 50) {
8
            i = 0;
9
            ii++;
10
            d.style.width = `${ii}px`;
11
            if (ii == 100) {
12
                break;  // 不要break则then永远不会被执行
13
                ii = 0;
14
            }
15
        }
16
        await new Promise(resolve => setTimeout(resolve, 0));
17
    }
18
}
19
r().then(()=>{
20
    console.log("over");
21
});
22
console.log(i); // 输出是1

await那一句执行setTimeout会拖到下一个时钟周期，所以有时间给dom更新。
用了async也不一定是异步。例子：

1
var i  = 0;
2
async function r() {
3
    const d = document.getElementById('progress');
4
    let ii = 0;
5
    while (1) {
6
        i++;
7
        if (i == 52) {
8
            ii++;
9
            d.style.width = `${ii}px`;
10
            if (ii == 100) {
11
                ii = 0;
12
            }
13
            await new Promise(resolve => setTimeout(resolve, 0));
14
            i = 0;
15
        }
16
    }
17
}
18
r();
19
console.log(i);
20
for(let i = 0; i< 5000;i++) {
21
    console.log(' ');
22
}

输出是52。说明是第一次到await的时候才结束了这一轮，在下一轮得以执行下一步。且后面循环5000次的看起来是和r函数同步在做。
以下的情况展示了同步被异步打断，实际只输出了1000次空格：

1
var i  = 0;
2
async function r() {
3
    const d = document.getElementById('progress');
4
    let ii = 0;
5
    await new Promise(resolve => setTimeout(resolve, 0));
6
    while (1) {
7
        i++;
8
        if (i == 52) {
9
            ii++;
10
            console.log("!");
11
            d.style.width = `${ii}px`;
12
            if (ii == 100) {
13
                ii = 0;
14
            }
15
            i = 0;
16
        }
17
    }
18
}
19
r();
20
console.log(i);
21
for(let i = 0; i< 5000;i++) {
22
    console.log(' ');
23
}

不用async的版本：

1
function r() {
2
    const d = document.getElementById('progress');
3
    let i = 0;
4
    let ii = 0;
5
    function loop() {
6
        i++;
7
        if (i == 50) {
8
            i = 0;
9
            ii++;
10
            d.style.width = `${ii}px`;
11
            if (ii == 100) {
12
                ii = 0;
13
            }
14
        }
15
        setTimeout(loop, 0);
16
    }
17
    loop();
18
}

以下是不行的：直接将费时的函数用promise或async包装。

js ()=>{} 的 this 不会改变！一旦定义了就不会再变

1
function createArrowFunction() {
2
    return () => {
3
        console.log(this);
4
    };
5
}
6

7
let obj = {
8
    name: 'My Object',
9
    arrowFunction: null,
10
};
11

12
obj.arrowFunction = createArrowFunction();
13
obj.arrowFunction();  // 输出：Window
14
obj.arrowFunction = createArrowFunction.call(obj);
15
obj.arrowFunction();  // 输出：{ name: 'My Object', arrowFunction: [Function] }

html鼠标右击无法通过onclick事件触发。因为被右键菜单拦截。如果禁用右键菜单：

1
document.oncontextmenu = function (e) {
2
    // 或者：e.preventDefault();
3
    return false;
4
}

右击还是无法触发onclick事件。可以改成在oncontextmenu中触发，或者用onmousedown触发。后者与右键菜单独立。

var blen=this.actx.sampleRate*.5|0;

| 的作用是向下取整
卷积来实现混响

关于振荡器使用自定义周期波：

1
function osc(f=440,zeros=0) {
2
    var real = new Float32Array([0,...Array.from({length: zeros}, ()=>0), 1]);
3
    var imag = new Float32Array([0,...Array.from({length: zeros}, ()=>0), 0]);
4
    var ac = new AudioContext();
5
    var osc = ac.createOscillator();
6
    osc.frequency.value = f;
7

8
    var wave = ac.createPeriodicWave(real, imag, { disableNormalization: true });
9

10
    osc.setPeriodicWave(wave);
11

12
    osc.connect(ac.destination);
13

14
    osc.start();
15
    osc.stop(2);
16
}

传参的两个数组是归一化傅里叶变换的结果（实部和虚部），频率增量是振荡器的频率。如果只有real，则是纯正的余弦波的叠加；如果只有imag则是纯正弦波。
所以：osc(440,0)和osc(220,1)的效果是一样的。

相比于周期波（使用频域信息创建），可以用时域数据：

1
function createSource() {
2
    audioCtx = new AudioContext();
3
    myAudioBuffer = audioCtx.createBuffer(1, 2048 * 100, audioCtx.sampleRate);
4
    var newBuffering = myAudioBuffer.getChannelData(0);
5

6
    let T = parseInt(audioCtx.sampleRate / 220);
7
    for (let i = 0; i < newBuffering.length; i++) {
8
        // newBuffering[i] = (i % T > T / 2) ? 1 : -1;  // 方波
9
        newBuffering[i] = Math.cos(6.283 / T * i)   // 正弦波
10
    }
11

12
    source = audioCtx.createBufferSource();
13
    source.buffer = myAudioBuffer;
14
    analyser = audioCtx.createAnalyser();
15
    analyser.smoothingTimeConstant = 0;
16
    source.connect(analyser);
17
    analyser.connect(audioCtx.destination);
18
}